Linux驱动实践：驱动程序如何发送【信号】给应用程序？

$ kill -9 <进程的 PID>

/* Signals.  */
#define  SIGINT      2  /* Interrupt (ANSI).  */
#define  SIGKILL     9  /* Kill, unblockable (POSIX).  */
#define  SIGUSR1     10 /* User-defined signal 1 (POSIX).  */
#define  SIGSEGV     11 /* Segmentation violation (ANSI).  */
#define  SIGUSR2     12 /* User-defined signal 2 (POSIX).  */
...
...
#define SIGSYS    31 /* Bad system call.  */
#define SIGUNUSED 31

#define  _NSIG    65 /* Biggest signal number + 1
               (including real-time signals).  */

/* These are the hard limits of the kernel.  These values should not be
   used directly at user level.  */
#define __SIGRTMIN   32
#define __SIGRTMAX   (_NSIG - 1)

// 文件：tmp/App/app_handle_signal/app_handle_signal.c

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <signal.h>

// 信号处理函数
static void signal_handler(int signum, siginfo_t *info, void *context)
{
    // 打印接收到的信号值
    printf("signal_handler: signum = %d \n", signum);
}

int main(void)
{
    int count = 0;
    // 注册信号处理函数
    struct sigaction sa;
    sigemptyset(&sa.sa_mask);
    sa.sa_sigaction = &signal_handler;
    sa.sa_flags = SA_SIGINFO;
    sigaction(SIGUSR1, &sa, NULL);
    sigaction(SIGUSR2, &sa, NULL);

    // 一直循环打印信息，等待接收发信号
    while (1)
    {
        printf("app_handle_signal is running...count = %d \n", ++count);
        sleep(5);
    }

    return 0;
}

$ gcc app_handle_signal.c -o app_handle_signal
$ ./app_handle_signal

$ kill -10 15428

$ cd ~/tmp/linux-4.15/drivers/
$ mkdir my_driver_signal
$ cd my_driver_signal
$ touch my_driver_signal.c

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/ctype.h>
#include <linux/device.h>
#include <linux/cdev.h>

// 新增的头文件
#include <asm/siginfo.h>
#include <linux/pid.h>
#include <linux/uaccess.h>
#include <linux/sched/signal.h>
#include <linux/pid_namespace.h>

// GPIO 硬件相关宏定义
#define MYGPIO_HW_ENABLE

// 新增部分，使用这个宏控制起来
#define MY_SIGNAL_ENABLE

// 设备名称
#define MYGPIO_NAME     "mygpio"

// 一共有４个GPIO
#define MYGPIO_NUMBER   4

// 设备类
static struct class *gpio_class;

// 用来保存设备
struct cdev gpio_cdev[MYGPIO_NUMBER];

// 用来保存设备号
int gpio_major = 0;
int gpio_minor = 0;

#ifdef MY_SIGNAL_ENABLE
// 用来保存向谁发送信号，应用程序通过 ioctl 把自己的进程 ID 设置进来。
static int g_pid = 0;
#endif

#ifdef MYGPIO_HW_ENABLE
// 硬件初始化函数，在驱动程序被加载的时候(gpio_driver_init)被调用
static void gpio_hw_init(int gpio)
{
  printk("gpio_hw_init is called: %d. \n", gpio);
}

// 硬件释放
static void gpio_hw_release(int gpio)
{
  printk("gpio_hw_release is called: %d. \n", gpio);
}

// 设置硬件GPIO的状态，在控制GPIO的时候(gpio_ioctl)被调研
static void gpio_hw_set(unsigned long gpio_no, unsigned int val)
{
  printk("gpio_hw_set is called. gpio_no = %ld, val = %d. \n", gpio_no, val);
}
#endif

#ifdef MY_SIGNAL_ENABLE
// 用来发送信号给应用程序
static void send_signal(int sig_no)
{
  int ret;
  struct siginfo info;
  struct task_struct *my_task = NULL;
  if (0 == g_pid)
  {
    // 说明应用程序没有设置自己的 PID
      printk("pid[%d] is not valid! \n", g_pid);
      return;
  }

  printk("send signal %d to pid %d \n", sig_no, g_pid);

  // 构造信号结构体
  memset(&info, 0, sizeof(struct siginfo));
  info.si_signo = sig_no;
  info.si_errno = 100;
  info.si_code = 200;

  // 获取自己的任务信息，使用的是 RCU 锁
  rcu_read_lock();
  my_task = pid_task(find_vpid(g_pid), PIDTYPE_PID);
  rcu_read_unlock();

  if (my_task == NULL)
  {
      printk("get pid_task failed! \n");
      return;
  }

  // 发送信号
  ret = send_sig_info(sig_no, &info, my_task);
  if (ret < 0) 
  {
         printk("send signal failed! \n");
  }
}
#endif

// 当应用程序打开设备的时候被调用
static int gpio_open(struct inode *inode, struct file *file)
{
  
  printk("gpio_open is called. \n");
  return 0; 
}

#ifdef MY_SIGNAL_ENABLE
static long gpio_ioctl(struct file* file, unsigned int cmd, unsigned long arg)
{
  void __user *pArg;
  printk("gpio_ioctl is called. cmd = %d \n", cmd);
  if (100 == cmd)
  {
    // 说明应用程序设置进程的 PID 
    pArg = (void *)arg;
    if (!access_ok(VERIFY_READ, pArg, sizeof(int)))
    {
        printk("access failed! \n");
        return -EACCES;
    }

    // 把用户空间的数据复制到内核空间
    if (copy_from_user(&g_pid, pArg, sizeof(int)))
    {
        printk("copy_from_user failed! \n");
        return -EFAULT;
    }

    printk("save g_pid success: %d \n", g_pid); 
    if (g_pid > 0)
    {
      // 发送信号
      send_signal(SIGUSR1);
      send_signal(SIGUSR2);
    }
  }

  return 0;
}
#else
// 当应用程序控制GPIO的时候被调用
static long gpio_ioctl(struct file* file, unsigned int val, unsigned long gpio_no)
{
  printk("gpio_ioctl is called. \n");
  
  if (0 != val && 1 != val)
  {
    printk("val is NOT valid! \n");
    return 0;
  }

  if (gpio_no >= MYGPIO_NUMBER)
  {
    printk("dev_no is invalid! \n");
    return 0;
  }

  printk("set GPIO: %ld to %d. \n", gpio_no, val);

#ifdef MYGPIO_HW_ENABLE
  gpio_hw_set(gpio_no, val);
#endif

  return 0;
}
#endif

static const struct file_operations gpio_ops={
  .owner = THIS_MODULE,
  .open  = gpio_open,
  .unlocked_ioctl = gpio_ioctl
};

static int __init gpio_driver_init(void)
{
  int i, devno;
  dev_t num_dev;

  printk("gpio_driver_init is called. \n");

  // 动态申请设备号(严谨点的话，应该检查函数返回值)
  alloc_chrdev_region(&num_dev, gpio_minor, MYGPIO_NUMBER, MYGPIO_NAME);

  // 获取主设备号
  gpio_major = MAJOR(num_dev);
  printk("gpio_major = %d. \n", gpio_major);

  // 创建设备类
  gpio_class = class_create(THIS_MODULE, MYGPIO_NAME);

  // 创建设备节点
  for (i = 0; i < MYGPIO_NUMBER; ++i)
  {
    // 设备号
    devno = MKDEV(gpio_major, gpio_minor + i);
    
    // 初始化cdev结构
    cdev_init(&gpio_cdev[i], &gpio_ops);

    // 注册字符设备
    cdev_add(&gpio_cdev[i], devno, 1);

    // 创建设备节点
    device_create(gpio_class, NULL, devno, NULL, MYGPIO_NAME"%d", i);
  }

#ifdef MYGPIO_HW_ENABLE
  for (i = 0; i < MYGPIO_NUMBER; ++i)
  {
    // 初始硬件GPIO
    gpio_hw_init(i);
  }
#endif

  return 0;
}

static void __exit gpio_driver_exit(void)
{
  int i;
  printk("gpio_driver_exit is called. \n");

  // 删除设备节点
  for (i = 0; i < MYGPIO_NUMBER; ++i)
  {
    cdev_del(&gpio_cdev[i]);
    device_destroy(gpio_class, MKDEV(gpio_major, gpio_minor + i));
  }

  // 释放设备类
  class_destroy(gpio_class);

#ifdef MYGPIO_HW_ENABLE
  for (i = 0; i < MYGPIO_NUMBER; ++i)
  {
    gpio_hw_release(i);
  }
#endif

  // 注销设备号
  unregister_chrdev_region(MKDEV(gpio_major, gpio_minor), MYGPIO_NUMBER);
}

MODULE_LICENSE("GPL");
module_init(gpio_driver_init);
module_exit(gpio_driver_exit);

$ touch Makefile

ifneq ($(KERNELRELEASE),)
  obj-m := my_driver_signal.o
else
  KERNELDIR ?= /lib/modules/$(shell uname -r)/build
  PWD := $(shell pwd)
default:
  $(MAKE) -C $(KERNELDIR) M=$(PWD) modules
clean:
  $(MAKE) -C $(KERNEL_PATH) M=$(PWD) clean
endif

$ make

$ sudo insmod my_driver_signal.ko

$ mkdir ~/tmp/App/app_mysignal
$ cd ~/tmp/App/app_mysignal
$ touch mysignal.c

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <assert.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <signal.h>

#define MY_GPIO_NUMBER      4

char gpio_name[MY_GPIO_NUMBER][16] = {
    "/dev/mygpio0",
    "/dev/mygpio1",
    "/dev/mygpio2",
    "/dev/mygpio3"
};

// 信号处理函数
static void signal_handler(int signum, siginfo_t *info, void *context)
{
    // 打印接收到的信号值
    printf("signal_handler: signum = %d \n", signum);
    printf("signo = %d, code = %d, errno = %d \n",
             info->si_signo,
             info->si_code, 
             info->si_errno);
}

int main(int argc, char *argv[])
{
    int fd, count = 0;
    int pid = getpid();

    // 打开GPIO
    if((fd = open("/dev/mygpio0", O_RDWR | O_NDELAY)) < 0){
        printf("open dev failed! \n");
        return -1;
    }

    printf("open dev success! \n");
    
    // 注册信号处理函数
    struct sigaction sa;
    sigemptyset(&sa.sa_mask);
    sa.sa_sigaction = &signal_handler;
    sa.sa_flags = SA_SIGINFO;
    
    sigaction(SIGUSR1, &sa, NULL);
    sigaction(SIGUSR2, &sa, NULL);

    // set PID 
    printf("call ioctl. pid = %d \n", pid);
    ioctl(fd, 100, &pid);

    // 休眠1秒，等待接收信号
    sleep(1);

    // 关闭设备
    close(fd);
}

$ gcc mysignal.c -o mysignal

$ sudo ./mysignal