《驱动学习

1.异步通知

　　前面介绍的几种按键相关：

• 　　应用程序中使用while(1)，一直去轮询查按键的状态。（这样会导致应用程序一直占用cpu资源）
• 　　使用中断的方式，在应用程序中通过read，然后进入驱动程序中，使应用程序进入休眠。然后发生中断的时候，在中断服务函数中将进程唤醒，返回按键值。（导致应用程序一直在休眠）
• 　　使用poll机制，如果在规定的时间内没用中断发生，则超时返回。

　　以上三种都是针对应用程序。

　　接下来介绍一种异步通知机制：一旦设备就绪，则主动通知应用程序，这样应用程序根本就不需要查询设备状态，是一种“信号驱动的异步I/O”。

　　信号是在软件层次上对中断机制的一种模拟，在原理上，一个进程收到一个信号与处理器收到一个中断请求可以说是一样的。信号是异步的，一个进程不必通过任何操作来等待信号的到达，事实上，进程也不知道信号到底什么时候会到达。

　　kill -9  pid是我们经常使用用来结束某个进程得命令。其实这个就是一种异步通知。

　　kill是一个进程，用作发送信号

　　9是一个信号

　　pid是另一个进程，是接收信号

　　当pid这个进程接收到9这个信号，就会调用对应得函数。默认状态就是结束进程。

　　举例：

#include <signal.h>


void my_signal_test(int signum)
{
    static int cnt = 0;
    printf("signal = %d,%d times
",signum,++cnt);
}

int main(int argc,char **argv)
{
    signal(SIGUSR1, my_signal_test);//建立一个信号函数，接收的信号是SIGUSR1表示用户可用的信号值

    while(1)
    {
        sleep(1000);
    }
    return 0;
}

　　 signal(SIGUSR1, my_signal_test);就是如果接收到SIGUSR1信号，就会调用my_signal_test函数。然后在函数中就打印信息。

　　这样就可以在命令行中先运行./signal  &，通过ps查看signal进程得pid，然后kill   USR1   pid。就可以查看到打印信息。

2.异步通知驱动编写

static struct file_operations sencod_drv_fops = {
    .owner   =  THIS_MODULE,    /* 这是一个宏，推向编译模块时自动创建的__this_module变量 */
    .open    =  fifth_drv_open,     
    .read     =    fifth_drv_read,       
    .release =  fifth_drv_close,
    .poll    =  fifth_drv_poll,
    .fasync     =  fifth_drv_fasync,
};

　　首先在file_operations结构体中定义好，

fasync函数：

static struct fasync_struct *button_async;

static int fifth_drv_fasync (int fd, struct file *filp, int on)
{
    printk("driver: fifth_drv_fasync
");
    return fasync_helper (fd, filp, on, &button_async);
}

 　　定义一个fasync_struct结构体指针，然后通过fasync_helper对这个指针变量进行初始化。

fasync_helper函数：

int fasync_helper(int fd, struct file * filp, int on, struct fasync_struct **fapp)
{
    struct fasync_struct *new = NULL;

      if (on) {
        new = kmem_cache_alloc(fasync_cache, GFP_KERNEL);
        if (!new)
            return -ENOMEM;
    }

    if (on) {
        new->magic = FASYNC_MAGIC;
        new->fa_file = filp;
        new->fa_fd = fd;
        new->fa_next = *fapp;
        *fapp = new;
        result = 1;
    }  
}

　　可以从源码上看出，就是将button_async申请一块内存，然后进行一系列初始化。

中断服务函数：

static irqreturn_t buttons_irq(int irq, void *dev_id)
{
        /*略*/
    kill_fasync (&button_async, SIGIO, POLL_IN);
    
}

　　通过kill_fasync来发送SIGIO信号到应用程序中。

3.分析fcntl源码

　　在应用程序中调用fcntl函数，就会调用SYSCALL_DEFINE3(fcntl, unsigned int, fd, unsigned int, cmd, unsigned long, arg)。（在旧内核是sys_fcntl）

SYSCALL_DEFINE3(fcntl, unsigned int, fd, unsigned int, cmd, unsigned long, arg)
{    
    struct file *filp;
    long err = -EBADF;

    filp = fget(fd);   //通过文件描述符获得对应关联的文件指针
    if (!filp)
        goto out;
　　/*略*/
    err = do_fcntl(fd, cmd, arg, filp);   //调用do_fcntl函数

     fput(filp);
out:
    return err;
}

do_fcntl函数：

static long do_fcntl(int fd, unsigned int cmd, unsigned long arg,
        struct file *filp)
{
    long err = -EINVAL;

    switch (cmd) {
    case F_DUPFD:
    case F_DUPFD_CLOEXEC:
        if (arg >= current->signal->rlim[RLIMIT_NOFILE].rlim_cur)
            break;
        err = alloc_fd(arg, cmd == F_DUPFD_CLOEXEC ? O_CLOEXEC : 0);
        if (err >= 0) {
            get_file(filp);
            fd_install(err, filp);
        }
        break;
    case F_GETFD:
        err = get_close_on_exec(fd) ? FD_CLOEXEC : 0;
        break;
    case F_SETFD:
        err = 0;
        set_close_on_exec(fd, arg & FD_CLOEXEC);
        break;
    case F_GETFL:
        err = filp->f_flags;
        break;
    case F_SETFL:
        err = setfl(fd, filp, arg);
        break;
    case F_GETLK:
        err = fcntl_getlk(filp, (struct flock __user *) arg);
        break;
    case F_SETLK:
    case F_SETLKW:
        err = fcntl_setlk(fd, filp, cmd, (struct flock __user *) arg);
        break;
    case F_GETOWN:
        /*
         * XXX If f_owner is a process group, the
         * negative return value will get converted
         * into an error.  Oops.  If we keep the
         * current syscall conventions, the only way
         * to fix this will be in libc.
         */
        err = f_getown(filp);
        force_successful_syscall_return();
        break;
    case F_SETOWN:
        err = f_setown(filp, arg, 1);
        break;
    case F_GETOWN_EX:
        err = f_getown_ex(filp, arg);
        break;
    case F_SETOWN_EX:
        err = f_setown_ex(filp, arg);
        break;
    case F_GETSIG:
        err = filp->f_owner.signum;
        break;
    case F_SETSIG:
        /* arg == 0 restores default behaviour. */
        if (!valid_signal(arg)) {
            break;
        }
        err = 0;
        filp->f_owner.signum = arg;
        break;
    case F_GETLEASE:
        err = fcntl_getlease(filp);
        break;
    case F_SETLEASE:
        err = fcntl_setlease(fd, filp, arg);
        break;
    case F_NOTIFY:
        err = fcntl_dirnotify(fd, filp, arg);
        break;
    default:
        break;
    }
    return err;
}

　　do_fcntl函数里面就是一个switch，根据传进来的cmd执行相对应的函数。

　　其中主要注意两个F_SETOWN和F_SETFL

F_SETOWN：

最后主要调用：
static void f_modown(struct file *filp, struct pid *pid, enum pid_type type,
                     int force)
{
    write_lock_irq(&filp->f_owner.lock);
    if (force || !filp->f_owner.pid) {
        put_pid(filp->f_owner.pid);
        filp->f_owner.pid = get_pid(pid);
        filp->f_owner.pid_type = type;

        if (pid) {
            const struct cred *cred = current_cred();
            filp->f_owner.uid = cred->uid;
            filp->f_owner.euid = cred->euid;
        }
    }
    write_unlock_irq(&filp->f_owner.lock);
}

F_SETOWN被调用时对filp->f_owner赋值，此外什么也不做；

F_SETFL：

static int setfl(int fd, struct file * filp, unsigned long arg)
{  
　　　　/*略*/  
         if (((arg ^ filp->f_flags) & FASYNC) && filp->f_op &&filp->f_op->fasync) 
　　　　　{
       　　 error = filp->f_op->fasync(fd, filp, (arg & FASYNC) != 0);
       　　 if (error < 0)
            　　goto out;
        　　if (error > 0)
           　　 error = 0;
        }
    /*略*/
}                

　　在执行F_SETFL启用FASYNC时，调用驱动程序的fasync方法。只要filp->f_flags中的FASYNC标识发生了变化，就会调用该方法，以便把这个变化通知驱动程序，使其能正确响应。文件打开时，FASYNC标志被默认为是清除的。

　　Linux的这种通用方法基于一个数据结构和两个函数：

struct fasync_struct {
    int magic;
    int fa_fd;//文件描述符
    struct  fasync_struct   *fa_next; /* singly linked list *///异步通知队列
    struct  file        *fa_file;//文件指针
};

/* SMP safe fasync helpers: */
extern int fasync_helper(int, struct file *, int, struct fasync_struct **);
/* can be called from interrupts */
extern void kill_fasync(struct fasync_struct **, int, int);

　　当一个打开的文件的FASYNC标志被修改时，调用fasync_helper函数以便从相关的进程表中添加或删除文件。
　　当数据到达时，可使用kill_fasync函数通知所有的相关进程。（在UNIX语义中，kill这个词常用来向进程发送信号，而不是杀死某个进程，raise则用于向自身发送信号）。

4.应用程序的编写

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <poll.h>
#include <signal.h>
#include <sys/types.h>
#include <unistd.h>
#include <fcntl.h>

/* fifthdrvtest 
  */
int fd;

void my_signal_fun(int signum)
{
    unsigned char key_val;
    read(fd, &key_val, 1);
    printf("key_val: 0x%x
", key_val);
}

int main(int argc, char **argv)
{
    unsigned char key_val;
    int ret;
    int Oflags;

    signal(SIGIO, my_signal_fun);
    
    fd = open("/dev/buttons", O_RDWR);
    if (fd < 0)
    {
        printf("can't open!
");
    }

    fcntl(fd, F_SETOWN, getpid());
    
    Oflags = fcntl(fd, F_GETFL); 
    
    fcntl(fd, F_SETFL, Oflags | FASYNC);


    while (1)
    {
        sleep(1000);
    }
    
    return 0;
}

　　signal(SIGIO, my_signal_fun);

　　让my_signal_fun去处理SIGIO信号

　　fcntl(fd, F_SETOWN, getpid())

　　为了启动文件的异步通知机制，用户程序必须执行两个步骤。首先，她们指定一个进程作为文件的“属主（owner）”。当进程使用fcntl系统调用执行F_SETOWN命令时，属主进程的进程ID号就被保存在filp->f_owner中。这一步是必需的，目的是为了让内核知道应该通知哪个进程。

　　 Oflags = fcntl(fd, F_GETFL); 
 　　fcntl(fd, F_SETFL, Oflags | FASYNC);

　　然后为了真正启动异步通知机制，用户程序还必须在设备中设置FASYNC标志，这通过fcntl的F_SETFL命令完成的。
　　执行完这两个步骤之后，输入文件就可以在新数据到达时请求发送一个SIGIO信号。该信号被发送到存放在filp->f_owner中的进程（如果是负值就是进程组）。

 　　https://blog.csdn.net/wenqian1991/article/details/50333655