摘要：
一、ioctl接口 定义ioctl命令号的正确方法使用4个位段，新符号定义在type：魔数，只是一个选择数，并且使用它在整个驱动中，8位宽number：序号，它是8位宽direction：数据传送方向，如果这个特殊的命令设计数据传送。
函数原型：
int ioctl(int fd, unsigned long cmd, ...);
ioctl驱动方法有和用户空间版本不同的原型：
int (*ioctl)(struct inode *inode, struct file *filp, unsigned int cmd, unsigned long arg);
为帮助程序员创建唯一的ioctl命令代码，这些编码已被划分为几个段位，Linux的第一个版本使用16-位数：
高8位是关联这个设备的“魔”数，低8位是一个顺序号，在设备内唯一。
根据Linux内核管理来选择驱动ioctl号，在include/asm/ioctl.h和Documentation/ioctl-number.txt文件列举了在内核中使用的魔数。
定义ioctl命令号的正确方法使用4个位段，新符号定义在<linux/ioctl.h>
- type：魔数，只是一个选择数（参考ioctl-number.txt），并且使用它在整个驱动中，8位宽(_IOC_TYPEBITS)
- number：序号，它是8位(_IOC_NRBITS)宽
- direction：数据传送方向，如果这个特殊的命令设计数据传送。可能的值_IOC_NONE（没有数据传输），_IOC_READ, _IOC_WRITE, IOC_READ|_IOC_WRITE。
- size：涉及到的用户数据的大小
在<linux/ioctl.h>中包含的<asm/ioctl.h>头文件定义了一些构造命令编号的宏：
- _IO(type, nr)用于构造无参数的命令编号
- _IOR(type, nr, datatype)用于构造从驱动程序中读取数据的命令编号
- _IOW(type, nr datatype)用于写入数据的命令
- _IOWR(type, nr, datatype)用于双向传输
- type和number位字段通过参数传入，而size位字段通过对datatype参数取sizeof获取
还有头文件定义了用于解开位字段的宏：
- _IOC_DIR(nr)、_IOC_TYPE(nr)、_IOC_NR(nr)和_IOC_SIZE(nr)
scull的使用例子：
/*使用"k"作为幻数 */ #define SCULL_IOC_MAGIC 'k' /*在你自己的代码中，请使用不同的8位数字 */ #define SCULL_IOCRESET _IO(SCULL_IOC_MAGIC, 0) /** S means "Set" through a ptr, * T means "Tell" directly with the argument value * G means "Get"：reply by setting through a pointer * Q means "Query"：response is on the return value * X means "eXchange"：switch G and S atomically * H means "sHift"：switch T and Q atomically */ #define SCULL_IOCSQUANTUM _IOW(SCULL_IOC_MAGIC, 1, int) #define SCULL_IOCSQSET _IOW(SCULL_IOC_MAGIC, 2, int) #define SCULL_IOCTQUANTUM _ IO(SCULL_IOC_MAGIC, 3) #define SCULL_IOCTQSET _IO(SCULL_IOC_MAGIC, 4) #define SCULL_IOCGQUANTUM _IOR(SCULL_IOC_MAGIC, 5, int) #define SCULL_IOCGQSET _IOR(SCULL_IOC_MAGIC, 6, int) #define SCULL_IOCQQUANTUM _IO(SCULL_IOC_MAGIC, 7) #define SCULL_IOCQQSET _IO(SCULL_IOC_MAGIC, 8) #define SCULL_IOCXQUANTUM _IOWR(SCULL_IOC_MAGIC, 9, int) #define SCULL_IOCXQSET _IOWR(SCULL_IOC_MAGIC, 10, int) #define SCULL_IOCHQUANTUM _IO(SCULL_IOC_MAGIC, 11) #define SCULL_IOCHQSET _IO(SCULL_IOC_MAGIC, 12) #define SCULL_IOC_MAXNR 14
1.1 预定义的命令
- 可对任何文件发出的（常规，设备，FIFO，或者socket）的那些
- 只对常规文件发出的那些
- 对文件系统类型特殊的那些
ioctl命令是预定义给任何文件，包括设备特殊的文件：
- FIOCLEX ：设置close-on-exec标志
- FIONCLEX ：清除close-no-exec标志
- FIOQSIZE ：返回一个文件或者目录的大小
- FIONBIO ：在“阻塞和非阻塞操作”一节中描述
头文件<asm/ioctl.h>，它包含在<linux/ioctl.h>中，定义宏来帮助建立命令号。
1.2 使用ioctl参数
ioctl调用常常包含小数据项，可通过其他方法更有效的操作。地址校验由函数access_ok，在头文件<asm/uaccess.h>：
int access_ok(int type, const void *addr, unsigned long size);
第一个参数应当是VERIFY_READ或者VERIFY_WRITE
addr参数持有一个用户空间地址
size是一个字节量
头文件<asm/uaccess.h>
put_user(datum, ptr)
__put_user(datum, ptr)
get_user(local, ptr)
__get_user(local, ptr)1.3 兼容性和受限操作
在头文件中<linux/capability.h>中找到
- CAP_DAC_OVERRIDE ：这个能力来推翻在文件和目录上的存取的限制(数据存取控制, 或者 DAC).
- CAP_NET_ADMIN ：进行网络管理任务的能力, 包括那些能够影响网络接口的
- CAP_SYS_MODULE ：加载或去除内核模块的能力
- CAP_SYS_RAWIO ：进行 "raw" I/O 操作的能力. 例子包括存取设备端口或者直接和 USB 设备通讯
- CAP_SYS_ADMIN ：一个捕获-全部的能力, 提供对许多系统管理操作的存取
- CAP_SYS_TTY_CONFIG ：进行 tty 配置任务的能力
能力检查通过capable函数来进行的（定义在<linux/sched.h>）:
int capable(intcapability); 例子： if(!capable(CAP_SYS_ADMIN)) return -EPERM;
ioctl命令实现
switch(cmd) { caseSCULL_IOCRESET: scull_quantum =SCULL_QUANTUM; scull_qset =SCULL_QSET; break; case SCULL_IOSQUANTUM: /*Set: arg points to the value */ if(!capable(CAP_SYS_ADMIN)) return -EPERM; retval = __get_user(scull_quantum, (int __user *)arg); break; case SCULL_IOCTQUANTUM: /*Tell: arg is the value */ if(!capable(CAP_SYS_ADMIN)) return -EPERM; scull_quantum =arg; break; case SCULL_IOCGQUANTUM: /*Get: arg is pointer to result */retval = __put_user(scull_quantum, (int __user *)arg); break; case SCULL_IOCQQUANTUM: /*Query: return it (it's positive) */ returnscull_quantum; case SCULL_IOCXQUANTUM: /*eXchange: user arg as pointer */ if(!capable(CAP_SYS_ADMIN)) return -EPERM; tmp =scull_quantum; retval = __get_user(scull_quantum, (int __user *)arg); if(retval == 0) retval = __put_user(tmp, (int __user *)arg); break; case SCULL_IOCHQUANTUM: /*sHift: like Tell + Query */ if(!capable(CAP_SYS_ADMIN)) return -EPERM; tmp =scull_quantum; scull_qaumtum =arg; returntmp; default: return -ENOTTY; } return retval:
如何使进程睡眠并且之后再次唤醒他。一个驱动当它无法立刻满足请求应当如何响应？
程序员只希望调用read和write并且使调用返回，在必要的工作已完成后。这样，你的驱动应当（缺省地）阻塞进程，使它进入睡眠直到请求可继续。
2.1 睡眠的介绍
当一个进程被置为睡眠，它被标识为处于一个特殊的状态并且从调度器的运行队列中去除。直到发生谋陷事情改变了那个状态，这个进程将不被在任何CPU上调度，并且将不会运行。一个睡着的进程被搁置系统的一边，直到以后发生事件。
有几个规则必须记住，促使安全的方式的睡眠：
1.当你运行在原子上下文时不能睡眠，这意味着驱动持有自旋锁，seqlock或者RCU锁时不能睡眠。
2.当你进程醒来，不能关于醒后的系统状态做任何的假设，并且必须检查来确保你在等待的条件有效。
3.你的进程不能睡眠除非确信其他人，某处将唤醒它。做唤醒工作的代码必须也能够找到你的进程来做它工作。
一个等待队列由一个“等待队列头”来管理，定义在<linux/wait.h>，wait_queue_head_t类型，使用：
DECLARE_WAIT_QUEUE_HEAD(name);
或者动态的，如下：
wait_queue_head_t my_queue;
init_waitqueue_head(&my_queue);2.2 简单睡眠
Linux内核中睡眠的最简单方式是一个宏定义。称为wait_event(有几个变体)，形式是：
wait_event(queue, condition)
wait_event_interruptible(queue, condition)
wait_event_timeout(queue, condition, timeout)
wait_event_interruptible_timeout(queue, condition, timeout)queue是要用的等待队列头，条件是一个被这个宏在睡眠前后锁求值的任一的布尔表达式。
如果你使用wait_event进程被置为不可中断地睡眠
唤醒函数：
void wake_up(wait_queue_head_t *queue); void wake_up_interruptible(wait_queue_head_t *queue);
这个例子，任何试图从这个设备读取的进程都被置为睡眠。无论何时一个进程写这个设备，所有的睡眠进程被唤醒：
staticDECLARE_WAIT_QUEUE_HEAD(wq); static int flag = 0; ssize_t sleepy_read(struct file *filp, char __user *buf, size_t count, loff_t *pos) { printk(KERN_DEBUG "process %i (%s) going to sleep ", current-pid, current-comm); wait_event_interruptible(wq, flag != 0); flag = 0; printk(KERN_DEBUG "awoken %i (%s) ", current->pid, current->comm); return 0; /*EOF */} ssize_t sleepy_write(struct file *filp, const char __user *buf, size_t count, loff_t *pos) { printk(KERN_DEBUG "process %i (%s) awakening the readers... ", current->pid, current->comm); flag = 1; wake_up_interruptible(&wq); return count; /*succedd, to avoid retrial */}
注意这个例子里 flag 变量的使用. 因为 wait_event_interruptible 检查一个必须变为真的条件, 我们使用 flag 来创建那个条件。
2.3 阻塞和非阻塞操作
明确的非阻塞I/O由filp->f_flags中的O_NONBLOCK标志来指示。这个标志定义于<linux/fcntl.h>被<linux/fs.h>自动包含。
structscull_pipe { wait_queue_head_t inq, outq; /*read and write queues */ char *buffer, *end; /*begin of buf, end of buf */ int buffersize; /*used in pointer arithmetic */ char *rp, *wp; /*where to read, where to write */ int nreaders, nwriters; /*number of openings for r/w */ struct fasync_struct *async_queue; /*asynchronous readers */ struct semaphore sem; /*mutual exclusion semaphore */ struct cdev cdev; /*Char devie structure */};
read实现既管理阻塞也管理非阻塞输入：
static ssize_t scull_p_read(struct file *filp, char __user *buf, size_t count, loff_t *f_pos) { struct scull_pipe *dev = filp->private_data; if(down_interruptible(&dev->sem)) return -ERESTARTSYS; while(dev->rp == dev->wp) { /*nothing to read */up(&dev->sem); /*release the lock */ if(filp->f_flags &O_NONBLOCK) return -EAGAIN; PDEBUG(""%s" reading: going to sleep ", current->comm); if(wait_event_interruptible(dev->inq, (dev->rp != dev->wp))) return -ERESTARTSYS; /*signal: tell the fs layer to handle it */ /*otherwise loop, but first reacquire the lock */ if(down_interruptible(&dev->sem)) return -ERESTARTSYS; } /*ok, data is there, return something */ if(dev->wp > dev->rp) count = min(count, (size_t)(dev->wp - dev->rp)); else /*the write pointer has wrapped, return data up to dev->end */count = min(count, (size_t)(dev->end - dev->rp)); if(copy_to_user(buf, dev->rp, count)) { up(&dev->sem); return -EFAULT; } dev->rp +=count; if(dev->rp == dev->end) dev->rp = dev->buffer; /*wrapped */up(&dev->sem); /*finally, awake any writers and return */wake_up_interruptible(&dev->outq); PDEBUG(""%s" did read %li bytes ", current->comm, (long)count); returncount; }