/***********************************************************************************
 *                    
 *               Makefile,open,read,write,lseek,poll,ioctl,fasync
 *
 * 声明:
 *      1. 本系列文档是在vim下编辑,请尽量是用vim来阅读,在其它编辑器下可能会
 *         不对齐,从而影响阅读.
 *
 *
 *                                          2015-3-9 阴 深圳 尚观 Var 曾剑锋
 **********************************************************************************/

                        \\\\\\\\\\\\\\--*目录*--//////////////
                        |  一. Makefile大致写法:             
                        |  二. 获取进程task_struct的方法:    
                        |  三. open 大致写法:                
                        |  四. read 大致写法:                
                        |  五. write 大致写法:               
                        |  六. lseek 大致写法:               
                        |  七. poll 大致写法:                
                        |  八. ioctl 大致写法:               
                        |  九. close 大致写法:               
                        |  十. fasync 大致写法:              
                        |  十一. 等待队列API:                
                        |  十二. 驱动wait_queue poll fasync: 
                        |  十三. 应用wait_queue poll fasync: 
                        \\\\\\\\\\\\\\\\\\\///////////////////

一. Makefile大致写法:
    ...
    # 定义一个CC变量,赋值为arm-linux-
    CC = arm-linux-         
    # .c文件依赖的.h文件存放的目录,这里是:当前目录下include文件夹
    INCLUDE_DIRS = include

    # 如果变量objs在此之前未声明定义,那么就声明定义,并赋值objs为hello.o
    # 如果变量objs在此之前已声明定义,那么把hello.o放在objs字符串后面
    objs += hello.o         
    
    # 1. hello : 下面命令要生成的目标,当然也有可能是伪指令;
    # 2. $(objs) : 依赖文件,只有依赖文件都存在的情况下才会执行下面的指令;
    # 3. $(CC)gcc $< -o $@ : 编译依赖文件产生目标文件;
    #    1. $(CC) : 取CC变量里的值;
    #    2. $<    : 依赖文件($(objs))
    #    3. $@    : 目标文件(hello)
    hello : $(objs) 
        $(CC)gcc $< -o $@
    
    # 1. 生成的目标文件简写,将当前文件下所有的.c编译成对应的.o文件;
    # 2. -I$(INCLUDE_DIRS) : .c编译时需要的头文件所在的目录
    %.o : %.c 
        $(CC)gcc -c $< -o $@ -I$(INCLUDE_DIRS)
    
    # 伪命令声明,这样即使存在clean文件,也会把clean当命令使用
    .PHONY:clean
    clean:
        rm *.o hello
    ...

二. 获取进程task_struct的方法:
    ...
    int ret;
    struct thread_info *info;
    struct task_struct *task;
    
    /** 
     * 获取当前进程的进程描述符(PCB)算法,主要是因为thread_info里有task_struct指针,
     * 而thread_info放在了内核线程栈的起始地方,而内核线程栈是8k对齐,
     * 所以thread_finfo的首地址是: ((unsigned int)&ret & ~(0x2000 - 1))
     */
    info = (void *)((unsigned int)&ret & ~(0x2000 - 1));
    task = info->task;
    printk("pid = %d, [%s]\n", task->pid, task->comm); /* task->comm 运行的程序名 */
    
    // current 当前进程的PCB指针,系统自带提供的全局变量
    printk("pid = %d, [%s]\n", current->pid, current->comm);
    ...

三. open 大致写法:
    1. int (*open) (struct inode *, struct file *);
    2. 代码模型:
        static int test_open(struct inode *inode, struct file *file) 
        { 
            /**
             * 一般open函数里面都要把私有数据绑定到file->private_data上
             */
            test_t *p; 
            p = container_of(file->f_op, test_t, fops); 
            file->private_data = p; 
         
            //声明当前设备不支持llseek方法调整读写位置 
            //nonseekable_open(inode, file);
            return 0; 
        } 

四. read 大致写法:
    1. ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
    2. 代码模型:
        static ssize_t test_read(struct file *file, char __user *buf, size_t count, loff_t *pos)
        {
            int ret;
            test_t *p = file->private_data;
            
            /**
             * 检查可读数据是否足够
             */
            if(count > BUF_SIZE - *pos)
                count = BUF_SIZE - *pos;
            
            ret = copy_to_user(buf, p->buf + *pos, count);
            if(ret)
                return -EFAULT;
            
            *pos += count;
        
            return count; //返回读到的数据个数
        }


五. write 大致写法:
    1. ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
    2. 代码模型:
        static ssize_t test_read(struct file *file, char __user *buf, size_t count, loff_t *pos)
        {
            test_t *p = file->private_data;
        
            if(p->is_empty)
            {
                /* 进入深度睡眠其中方法中的一种 */
                current->state = TASK_UNINTERRUPTIBLE;
                schedule();
            }
            return count;
        }

六. lseek 大致写法:
    1. loff_t (*llseek) (struct file *, loff_t, int);
    2. 2.6版本内核不实现该方法的话,使用内核默认的llseek函数,当前版本必须实现该方法;
    3. 代码模型:
        static loff_t test_llseek(struct file *file, loff_t offset, int whence)
        {                       
            loff_t pos = file->f_pos;
        
            switch(whence)
            {
                case SEEK_SET:
                    pos = offset;
                    break;
                case SEEK_CUR:
                    pos += offset;
                    break;
                case SEEK_END:
                    pos = BUF_SIZE + offset;
                    break;
                default:
                    return -EINVAL; //参数非法
            }
        
            file->f_pos = pos;
        
            //返回lseek之后的文件读写位置(相对文件开始处)
            return pos;
        }

七. poll 大致写法:
    1. poll,epoll,select系统调用的后端,都用作查询对一个或多个文件描述符的读写是否阻塞
    2. unsigned int (*poll) (struct file *, struct poll_table_struct *);
    3. 代码模型:
        static unsigned int test_poll(struct file *file, struct poll_table_struct *table)
        {
            unsigned int poll = 0;
            test_t *p = file->private_data;
            /*printk("In test_poll.\n");*/
        
            //功能: 在设备状态变化,等待队列被唤醒时,唤醒select
            poll_wait(file, &p->wq, table);
        
            //如果可读
            if(!p->is_empty)
                poll |= POLLIN | POLLRDNORM;
        
            return poll;
        }


八. ioctl 大致写法: 
    1. long (*unlocked_ioctl) (struct file *, unsigned int cmd, unsigned long);
    2. cmd的格式:
        ---------------------------------------
        | dir 2 | size 14   |  type 8  |  nr 8 |
        ----------------------------------------
    3. 创建ioctl命令的宏:
        #define _IO(type,nr)                _IOC(_IOC_NONE,(type),(nr),0)
        #define _IOR(type,nr,datatype)     _IOC(_IOC_READ,(type),(nr),(_IOC_TYPECHECK(datatype)))
        #define _IOW(type,nr,datatype)     _IOC(_IOC_WRITE,(type),(nr),(_IOC_TYPECHECK(datatype)))
        #define _IOWR(type,nr,datatype)    _IOC(_IOC_READ|_IOC_WRITE,(type),(nr),(_IOC_TYPECHECK(datatype)))
    4. 代码模型:
        #define __SET_GET_FOO__
        #ifndef __SET_GET_FOO__
            #define SET_FOO _IOW(TYPE, NR, int)
            #define GET_FOO _IOR(TYPE, NR, int)
        #else
            #define SET_FOO _IOC(_IOC_WRITE, TYPE, NR, sizeof(int))
            #define GET_FOO _IOC(_IOC_READ, TYPE, NR, sizeof(int))
        #endif
        
        static long test_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
        {
            int ret;
        
            switch(cmd)
            {
                case SET_FOO:
                    ret = copy_from_user(&num, (void *)arg, sizeof(int));
                    if(ret)
                        return -EFAULT;
                    break;
                case GET_FOO:
                    ret = copy_to_user((void *)arg, &num, sizeof(int));
                    if(ret)
                        return -EFAULT;
                    break;
                default:
                    return -EINVAL;
            }
        
            return 0;
        }

九. close 大致写法:
    1. int (*release) (struct inode *, struct file *);
    2. 代码模型:
        static int test_close(struct inode *inode, struct file *file)
        {
            return 0;
        }

十. fasync 大致写法:
   1. int (*fasync) (int, struct file *, int);
   2. 前提条件:
       1. 应用层(app)设置fd的owner: fcntl(fd, F_SETOWN, getpid()); //设置fd的owner
       2. fcntl(fd, F_SETFL, fcntl(fd, F_GETFL) | O_ASYNC);        //设置O_ASYNC标志
   3. 当使用fcntl()设置O_ASYNC时,会调用fasync()函数.
   4. 代码模型:
       static int test_fasync(int fd, struct file *file, int on)
       {
           test_t *p = file->private_data;
           printk("In test_fasync: fd = %d, on = %d\n", fd, on);
       
           // fasync_helper自己会去申请结构体struct fasync_struct的空间,并赋值
           // 所以在这里我们只需要传入指向这个结构体的指针就行了
           return fasync_helper(fd, file, on, &p->fa);
       }
    5. 在设备状态变化时发送信号给使用异步通知的进程: kill_fasync(&p->fa, SIGIO, POLL_IN);

 
十一. 等待队列API: 
    1. 定义: wait_queue_head_t wq; 
    2. 初始化: init_waitqueue_head(&wq); 
    3. 两种把当前进程加入到等待队列睡眠: 
        1. wait_event(wq, cond);               //深度睡眠,top命令下状态标志: D 
        2. wait_event_interruptible(wq, cond); //可被信号中断睡眠,top命令下状态标志: S 
    4. 两种唤醒等待队列:
        1. wake_up(&wq);               //唤醒深度睡眠,普通睡眠:D,S 
        2. wake_up_interruptible(&wq); //唤醒普通睡眠:S 

十二. 驱动wait_queue poll fasync:
    cat > test.c << EOF
        #include <linux/module.h>
        #include <linux/fs.h>
        #include <linux/uaccess.h>
        #include <linux/sched.h>
        #include <linux/poll.h>

        //设备名,可以通过命令: cat /proc/devices
        #define DEV_NAME    "test"    
        
        struct test_s {
            struct file_operations fops;
            wait_queue_head_t wq;
            struct fasync_struct *fa;
            int major;
            bool is_empty;
        };
        typedef struct test_s test_t;
        
        static int test_open(struct inode *inode, struct file *file)
        {
            //把驱动私有数据放到file的private_data中
            test_t *p;
            p = container_of(file->f_op, test_t, fops); 
            file->private_data = p;
        
            return 0;
        }
        
        static int test_close(struct inode *inode, struct file *file)
        {
            return 0;
        }
        
        static ssize_t test_read(struct file *file, char __user *buf, size_t count, loff_t *pos)
        {
            test_t *p = file->private_data;
            
            /**
             * 修正能够输出的数据长度,在本Demo中没有用到.
             * if(count > BUF_SIZE - *pos)
             *     count = BUF_SIZE - *pos;
             */
        
            while(p->is_empty)
            {
                //判断当前打开文件方式是不是非阻塞方式打开的
                if(file->f_flags & O_NONBLOCK)
                    return -EAGAIN;
        
                //如果没有数据,那么就进入睡眠状态,等待被唤醒,同时要求条件为真: !p->is_empty
                if(wait_event_interruptible(p->wq, !p->is_empty))
                    return -ERESTARTSYS;
            }
        
            printk("Read data.\n");
            
            p->is_empty = true; //数据读完,重新置为空
                
            return count; //返回数据的个数
        }
        
        /**
         * 调用这个方法请使用命令: echo 123456 > /dev/test0
         */
        static ssize_t test_write(struct file *file, const char __user *buf, size_t count, loff_t *pos)
        {
            test_t *p = file->private_data;
        
            p->is_empty = false;    //将状态置为有数据
            printk("Write data.\n");
        
            /**
             * 因为下面的kill_fasync()能唤醒可中断睡眠,所以可以不需要这行代码
             */
            //wake_up_interruptible(&p->wq);     //唤醒等待队列中的进程

            kill_fasync(&p->fa, SIGIO, POLL_IN); //发送SIGIO信号量,并且表示数据可读
        
            return count;
        }
        
        
        static unsigned int test_poll(struct file *file, struct poll_table_struct *table)
        {
            unsigned int poll = 0;
            test_t *p = file->private_data;
            /*printk("In test_poll.\n");*/
        
            /**
             * 功能: 在设备状态变化,等待队列被唤醒时,唤醒select
             * poll()可被调用多次,也导致poll_wait()被注册多次,不过没事,正常现象
             */
            poll_wait(file, &p->wq, table);
        
            //如果可读,将状态返回
            if(!p->is_empty)
                poll |= POLLIN | POLLRDNORM;
        
            return poll;
        }
        
        static int test_fasync(int fd, struct file *file, int on)
        {
            test_t *p = file->private_data;
            printk("In test_fasync: fd = %d, on = %d\n", fd, on);
        
            //注册异步事件
            return fasync_helper(fd, file, on, &p->fa);
        }
        
        struct test_s test = {
            .fops = {
                .owner      = THIS_MODULE,
                .open       = test_open,
                .release    = test_close,
                .read       = test_read,
                .write      = test_write,
                .poll       = test_poll,
                .fasync     = test_fasync,
            },
            .major = 0,
            .is_empty = true,
        };
        
        int __init test_init(void)
        {
            int ret;
        
            // 初始化等待队列
            init_waitqueue_head(&test.wq);
        
            // 注册字符设备驱动
            ret = register_chrdev(test.major, DEV_NAME, &test.fops);
            if(ret > 0)
            {
                test.major = ret;
                printk("major = %d\n", test.major);
                ret = 0;
            }
        
            return ret;
        }
        
        
        void __exit test_exit(void)
        {
            // 卸载字符设备驱动
            unregister_chrdev(test.major, DEV_NAME);
        }
        
        module_init(test_init);
        module_exit(test_exit);
        
        MODULE_LICENSE("GPL");
    EOF

十三. 应用wait_queue poll fasync:
    cat > app.c << EOF
        #include <stdio.h>
        #include <string.h>
        #include <stdlib.h>
        #include <unistd.h>
        #include <fcntl.h>
        #include <signal.h>
        
        int fd;
        
        void sig_handler(int sig)
        {
            int ret;
            char buf[1024];
            if(sig == SIGIO)
                printf("got a signal SIGIO\n");
        
            /**
             * ret = read(fd, buf, sizeof(buf));
             * if(-1 == ret)
             *     perror("read");
             */
        }
        
        int main(int argc, char **argv)
        {
            int ret;
            fd_set fds;
            char buf[1024] = "hello";
        
            signal(SIGIO, sig_handler);
        
            fd = open(argv[1], O_RDWR);
            if(-1 == fd)
            {
                perror("open");
                exit(1);
            }
            
            fcntl(fd, F_SETOWN, getpid());                    //设置fd的owner
            fcntl(fd, F_SETFL, fcntl(fd, F_GETFL) | O_ASYNC); //设置O_ASYNC标志
        
            while(1)
            {
                ret = read(fd, buf, 1024);
                if (-1 == ret ) {
                    perror("read");
                }
            }
        
            close(fd);
            return 0;
        }
    EOF