ioctl操作实现

?ioctl，避免使用三个全局变量，因此写进一个结构体里面

?ioctl对文件属性进行操作

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <asm/uaccess.h>

#define BUF_LEN 100
int major = 11;//主设备号
int minor =0;//次设备号
int mychar_num = 1;//次设备数量
//ioctrl
struct mychar_dev
{
struct cdev mydev;
char mydev_buf[BUF_LEN];
int curlen;//100个字节中已经存有的数据
};

struct mychar_dev gmydev;

int mychar_open(struct inode *pnode,struct file *pfile)
{//inode * pnode 中有一个成员 i_rdev存放这mydev的地址，现在用struct成员的地址求出结构体的地址
     //求出gmydev的地址
	pfile->private_data = (void *)container_of(pnode->i_cdev,struct mychar_dev,mydev);
	printk("mychar_open is called\n");
	return 0;
}

int mychar_close(struct inode *pnode,struct file *pfile)
{
	printk("mychar_close is called\n");
	return 0;
}
ssize_t mychar_read(struct file *pfile,char __user *puser,size_t count,loff_t *p_pos)
{//内核空间mydev_buf  向   用户空间puser  进行copy
	struct mychar_dev *pmydev = (struct mychar_dev *)pfile->private_data;
	//定义一个指针pmydev
 int size = 0;
 int ret = 0;
 if(count >pmydev->curlen)//如果期望读取的数据大小大于了原本数据大小
 {
   size = pmydev->curlen;//读取的数据为被读取数据的大小
 }
 else
 {
    size = count;//被读取的数据大小为期望读取的数据大小

 }
ret = copy_to_user(puser,pmydev->mydev_buf,size);
  if(ret)//
  {
	  printk("copy_to_user failed\n");
	  return -1;
  }
  //将没被读取的数据拷贝到初始读取的位置.
  memcpy(pmydev->mydev_buf,pmydev->mydev_buf + size,pmydev->curlen - size);
  pmydev->curlen =pmydev-> curlen -size;//被读取后剩余这么多字节
  return size;

}

ssize_t mychar_write(struct file *pfile,const char __user *puser,size_t count,loff_t *p_pos)
{//用户空间puser  向 内核空间mydev_buf  copy
	int ret=0;
	int size = 0;
	struct mychar_dev *pmydev = (struct mychar_dev *)pfile->private_data;
    if(count>BUF_LEN - pmydev->curlen)//如果期望写入的数据大小大于100个字节剩余的空间
	{
		size = BUF_LEN - pmydev->curlen;
	}
	else 
	{
		size = count;
	}
	ret = copy_from_user(pmydev->mydev_buf,puser,size);
	//将用户空间puser中 size大小的数据写入到内核空间mydev_buf为始的地址中去
	if(ret)
	{
		printk("copy_from_user is failed\n");
		return -1;
	}
	pmydev->curlen = pmydev->curlen +size;
	//mydev_buf中存在的数据大小
	return size;

}
struct file_operations myops = {

	.owner = THIS_MODULE,
	.open = mychar_open,
     .release = mychar_close,
	 .read = mychar_read,
	 .write = mychar_write,
};

int __init mychar_init(void)
{
   int ret = 0;
   dev_t devno = MKDEV(major,minor);//组合成完整的设备号
   /*申请设备号*/
   ret = register_chrdev_region(devno,mychar_num,"mychar");
if(ret)//ret非0，表示失败
{
  ret = alloc_chrdev_region(&devno,minor,mychar_num,"mychar");
//此设备号申请后填写到devno地址中去，从minor开始申请mychar_num个
    if(ret)
	{
		printk("get devno failed\n");
		return -1;
	}
	major = MAJOR(devno);//获取新的设备号,不要遗漏
     //次设备号都是0，所以不用再次提取
}
    //给struct_cdev对象制定操作函数集
	 cdev_init(&gmydev.mydev,&myops);    
    //将struct_cdev对象添加到内核对应的数据结构里
	gmydev.mydev.owner = THIS_MODULE;
    cdev_add(&gmydev.mydev,devno,1);

	return 0;
}

void __exit mychar_exit(void)
{
	dev_t devno = MKDEV(major,minor);
    cdev_del(&gmydev.mydev);

    unregister_chrdev_region(devno,mychar_num);

}


MODULE_LICENSE("GPL");

module_init(mychar_init);
module_exit(mychar_exit);

一、ioctl操作实现

已知成员的地址获得所在结构体变量的地址：container_of(成员地址,结构体类型名，成员在结构体中的名称)

long xxx_ioctl (struct file *filp, unsigned int cmd, unsigned long arg);
功能：对相应设备做指定的控制操作（各种属性的设置获取等等）
参数：
    filp：指向open产生的struct file类型的对象，表示本次ioctl对应的那次open
    cmd：用来表示做的是哪一个操作
 ?  arg：和cmd配合用的参数
返回值：成功为0，失败-1

cmd组成

1. dir（direction），ioctl 命令访问模式（属性数据传输方向），占据 2 bit，可以为 IOC_NONE、IOC_READ、IOC_WRITE、IOC_READ | _IOC_WRITE，分别指示了四种访问模式：无数据、读数据、写数据、读写数据；

2. type（device type），设备类型，占据 8 bit，在一些文献中翻译为 “幻数” 或者 “魔数”，可以为任意 char 型字符，例如 ‘a’、’b’、’c’ 等等，其主要作用是使 ioctl 命令有唯一的设备标识；

3. nr（number），命令编号/序数，占据 8 bit，可以为任意 unsigned char 型数据，取值范围 0~255，如果定义了多个 ioctl 命令，通常从 0 开始编号递增；

4. size，涉及到 ioctl 函数 第三个参数 arg ，占据 13bit 或者 14bit（体系相关，arm 架构一般为 14 位），指定了 arg 的数据类型及长度，如果在驱动的 ioctl 实现中不检查，通常可以忽略该参数；

#define _IOC(dir,type,nr,size) (((dir)<<_IOC_DIRSHIFT)| \
 ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ((type)<<_IOC_TYPESHIFT)| \
 ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ((nr)<<_IOC_NRSHIFT)| \
 ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ((size)<<_IOC_SIZESHIFT))
/* used to create numbers */
?
// 定义不带参数的 ioctl 命令
#define _IO(type,nr) ? _IOC(_IOC_NONE,(type),(nr),0)
?
//定义带读参数的ioctl命令（copy_to_user） size为类型名
#define _IOR(type,nr,size)  _IOC(_IOC_READ,(type),(nr),(_IOC_TYPECHECK(size)))
?
//定义带写参数的 ioctl 命令（copy_from_user） size为类型名
#define _IOW(type,nr,size)  _IOC(_IOC_WRITE,(type),(nr),(_IOC_TYPECHECK(size)))
?
//定义带读写参数的 ioctl 命令 size为类型名
#define _IOWR(type,nr,size) _IOC(_IOC_READ|_IOC_WRITE,(type),(nr),(_IOC_TYPECHECK(size)))
?
/* used to decode ioctl numbers */
#define _IOC_DIR(nr) ? ? ?  (((nr) >> _IOC_DIRSHIFT) & _IOC_DIRMASK)
#define _IOC_TYPE(nr) ? ? ? (((nr) >> _IOC_TYPESHIFT) & _IOC_TYPEMASK)
#define _IOC_NR(nr) ? ? (((nr) >> _IOC_NRSHIFT) & _IOC_NRMASK)
#define _IOC_SIZE(nr) ? ?  (((nr) >> _IOC_SIZESHIFT) & _IOC_SIZEMASK)

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <asm/uaccess.h>
#include "mychar.h"

#define BUF_LEN 100
int major = 11;//主设备号
int minor =0;//次设备号
int mychar_num = 1;//次设备数量
//ioctrl
struct mychar_dev
{
struct cdev mydev;
char mydev_buf[BUF_LEN];
int curlen;//100个字节中已经存有的数据
};

struct mychar_dev gmydev;

int mychar_open(struct inode *pnode,struct file *pfile)
{//inode * pnode 中有一个成员 i_rdev存放这mydev的地址，现在用struct成员的地址求出结构体的地址
     //求出gmydev的地址
	pfile->private_data = (void *)container_of(pnode->i_cdev,struct mychar_dev,mydev);
	printk("mychar_open is called\n");
	return 0;
}

int mychar_close(struct inode *pnode,struct file *pfile)
{
	printk("mychar_close is called\n");
	return 0;
}
ssize_t mychar_read(struct file *pfile,char __user *puser,size_t count,loff_t *p_pos)
{//内核空间mydev_buf  向   用户空间puser  进行copy
	struct mychar_dev *pmydev = (struct mychar_dev *)pfile->private_data;
	//定义一个指针pmydev
 int size = 0;
 int ret = 0;
 if(count >pmydev->curlen)//如果期望读取的数据大小大于了原本数据大小
 {
   size = pmydev->curlen;//读取的数据为被读取数据的大小
 }
 else
 {
    size = count;//被读取的数据大小为期望读取的数据大小

 }
ret = copy_to_user(puser,pmydev->mydev_buf,size);
  if(ret)//
  {
	  printk("copy_to_user failed\n");
	  return -1;
  }
  //将没被读取的数据拷贝到初始读取的位置.
  memcpy(pmydev->mydev_buf,pmydev->mydev_buf + size,pmydev->curlen - size);
  pmydev->curlen =pmydev-> curlen -size;//被读取后剩余这么多字节
  return size;

}

ssize_t mychar_write(struct file *pfile,const char __user *puser,size_t count,loff_t *p_pos)
{//用户空间puser  向 内核空间mydev_buf  copy
	int ret=0;
	int size = 0;
	struct mychar_dev *pmydev = (struct mychar_dev *)pfile->private_data;
    if(count>BUF_LEN - pmydev->curlen)//如果期望写入的数据大小大于100个字节剩余的空间
	{
		size = BUF_LEN - pmydev->curlen;
	}
	else 
	{
		size = count;
	}
	ret = copy_from_user(pmydev->mydev_buf,puser,size);
	//将用户空间puser中 size大小的数据写入到内核空间mydev_buf为始的地址中去
	if(ret)
	{
		printk("copy_from_user is failed\n");
		return -1;
	}
	pmydev->curlen = pmydev->curlen +size;
	//mydev_buf中存在的数据大小
	return size;

}
//实现ioctl
long mychar_ioctl(struct file *pfile,unsigned int cmd,unsigned long arg)
{

	int __user *pret = (int *)arg;
   int maxlen = BUF_LEN;
   int ret = 0;
	struct mychar_dev *pmydev = (struct mychar_dev *)pfile->private_data;
   switch(cmd)
   {
   case MYCHAR_IOCTL_GET_MAXLEN:
		//把最大值copy到用户空间去
		ret = copy_to_user(pret,&maxlen,sizeof(int));
		if(ret)
		{
           printk("copy_to_user maxlen failed\n ");
			return -1;
		}
		break;
	case MYCHAR_IOCTL_GET_CURLEN:
		//把当前值copy到用户空间去
		ret = copy_to_user(pret,&pmydev->curlen,sizeof(int));
		if(ret)
		{
           printk("copy_to_user curlen failed\n ");
			return -1;
		}
		break;
	default:
		printk("the cmd is unknow\n");
		return -1;
   }
   return 0;
}
struct file_operations myops = {
	.owner = THIS_MODULE,
	.open = mychar_open,
     .release = mychar_close,
	 .read = mychar_read,
	 .write = mychar_write,
	 .unlocked_ioctl = mychar_ioctl,
};

int __init mychar_init(void)
{
   int ret = 0;
   dev_t devno = MKDEV(major,minor);//组合成完整的设备号
   /*申请设备号*/
   ret = register_chrdev_region(devno,mychar_num,"mychar");
if(ret)//ret非0，表示失败
{
  ret = alloc_chrdev_region(&devno,minor,mychar_num,"mychar");
//此设备号申请后填写到devno地址中去，从minor开始申请mychar_num个
    if(ret)
	{
		printk("get devno failed\n");
		return -1;
	}
	major = MAJOR(devno);//获取新的设备号,不要遗漏
     //次设备号都是0，所以不用再次提取
}
    //给struct_cdev对象制定操作函数集
	 cdev_init(&gmydev.mydev,&myops);    
    //将struct_cdev对象添加到内核对应的数据结构里
	gmydev.mydev.owner = THIS_MODULE;
    cdev_add(&gmydev.mydev,devno,1);

	return 0;
}

void __exit mychar_exit(void)
{
	dev_t devno = MKDEV(major,minor);
    cdev_del(&gmydev.mydev);

    unregister_chrdev_region(devno,mychar_num);

}


MODULE_LICENSE("GPL");

module_init(mychar_init);
module_exit(mychar_exit);

二、printk

//日志级别
#define KERN_EMERG  "<0>"   /* system is unusable           */
#define KERN_ALERT  "<1>"   /* action must be taken immediately */
#define KERN_CRIT   "<2>"   /* critical conditions          */
#define KERN_ERR    "<3>"   /* error conditions         */
?
#define KERN_WARNING    "<4>"   /* warning conditions           */
?
#define KERN_NOTICE "<5>"   /* normal but significant condition */
#define KERN_INFO   "<6>"   /* informational            */
#define KERN_DEBUG  "<7>"   /* debug-level messages         */
?
用法：printk(KERN_INFO"....",....)
 ? ?
 ? ?printk(KERN_INFO"Hello World"); =====> printk("<6>""Hello World") ====> printk("<6>Hello World")
 ?

dmesg --level=emerg,alert,crit,err,warn,notice,info,debug

#define HELLO_DEBUG
#undef PDEBUG
#ifdef HELLO_DEBUG
#define PDEBUG(fmt, args...) printk(KERN_DEBUG fmt, ##args)
#else
#define PDEBUG(fmt, args...)
#endif
?

三、多个次设备的支持

每一个具体设备（次设备不一样的设备），必须有一个struct cdev来代表它

cdev_init

cdev.owner赋值

cdev_add

以上三个操作对每个具体设备都要进行