Пособие по программированию модулей ядра Linux. Ч.5

$ sudo insmod sleep.ko $ cat_nonblock /proc/sleep Last input: $ tail -f /proc/sleep & Last input: Last input: Last input: Last input: Last input: Last input: Last input: tail: /proc/sleep: file truncated [1] 6540 $ cat_nonblock /proc/sleep Open would block $ kill %1 [1]+  Terminated              tail -f /proc/sleep $ cat_nonblock /proc/sleep Last input: $ /*   * sleep.c – создаем файл /proc, и если его одновременно будут пытаться   * открыть несколько процессов, все их отправляем в ожидание.   */    #include <linux/kernel.h> /* Для работы с ядром. */  #include <linux/module.h> /* Для модуля. */  #include <linux/proc_fs.h> /* Необходим для использования procfs */  #include <linux/sched.h> /* Для усыпления процессов и их пробуждения. */   #include <linux/uaccess.h> /* Для get_user и put_user. */  #include <linux/version.h>    #if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 6, 0)  #define HAVE_PROC_OPS  #endif    /* Здесь мы храним последнее полученное сообщение, подтверждая возможность   * обработки ввода.   */  #define MESSAGE_LENGTH 80  static char message[MESSAGE_LENGTH];    static struct proc_dir_entry *our_proc_file;  #define PROC_ENTRY_FILENAME "sleep"    /* Так как мы используем структуру файловых операций, то не можем   * задействовать специальную файловую систему proc и должны   * использовать стандартную функцию чтения, которой эта функция и является.   */  static ssize_t module_output(struct file *file, /* см. include/linux/fs.h   */                               char __user *buf, /* Буфер для данных                                           (в сегменте пользователя).    */                                size_t len, /* Длина буфера. */                               loff_t *offset)  {      static int finished = 0;      int i;      char output_msg[MESSAGE_LENGTH + 30];        /* Возвращаем 0, обозначая конец файла.       */      if (finished) {          finished = 0;          return 0;      }        sprintf(output_msg, "Last input:%s\n", message);      for (i = 0; i < len && output_msg[i]; i++)          put_user(output_msg[i], buf + i);        finished = 1;      return i; /* Возвращаем количество “считанных” байт. */  }    /* Эта функция получает ввод от пользователя, когда он производит запись  * в файл /proc.   */  static ssize_t module_input(struct file *file, /* Сам файл. */                              const char __user *buf, /* Буфер с вводом. */                              size_t length, /* Длина буфера. */                              loff_t *offset) /* Cмещение до файла – игнорируется.  */  {      int i;        /* Помещение ввода в Message, где позднее его сможет использовать        * module_output.       */      for (i = 0; i < MESSAGE_LENGTH - 1 && i < length; i++)          get_user(message[i], buf + i);      /* Нам нужна стандартная строка, завершающаяся нулем. */      message[i] = '\0';        /* Нужно вернуть количество использованных во вводе символов. */      return i;  }    /* 1, если файл сейчас уже кем-то открыт. */  static atomic_t already_open = ATOMIC_INIT(0);    /* Очередь процессов, ожидающих доступа к файлу. */  static DECLARE_WAIT_QUEUE_HEAD(waitq);    /* Вызывается при открытии файла /proc. */  static int module_open(struct inode *inode, struct file *file)  {      /* Если флаги при открытии файла содержат O_NONBLOCK, значит процесс       * не хочет ждать доступности этого файла. В таком случае, если файл       * уже открыт, нужно будет не блокировать процесс, который       * предпочитает оставаться открытым, а вернуть -EAGAIN, сообщив ему,       * что попытку нужно повторить позже.      */      if ((file->f_flags & O_NONBLOCK) && atomic_read(&already_open))          return -EAGAIN;        /* Это подходящее место для try_module_get(THIS_MODULE), так как,       * если процесс находится в цикле в модуле ядра, то этот модуль       * извлекать нельзя.       */      try_module_get(THIS_MODULE);        while (atomic_cmpxchg(&already_open, 0, 1)) {          int i, is_sig = 0;            /* Эта функция отправляет текущий процесс, включая любые системные           * вызовы, например наши, в ожидание. Выполнение продолжится сразу            * после вызова этой функции либо при вызове           * wake_up(&waitq) (это делает только module_close при закрытии            * файла), либо при отправке процессу сигнала вроде Ctrl+C.          */          wait_event_interruptible(waitq, !atomic_read(&already_open));            /* Если пробуждение произошло из-за получения сигнала, который не           * блокируется, вернуть -EINTR (провал системного вызова). Это              * позволяет завершать или останавливать процессы.           */          for (i = 0; i < _NSIG_WORDS && !is_sig; i++)              is_sig = current->pending.signal.sig[i] & ~current->blocked.sig[i];            if (is_sig) {              /* Важно поместить module_put(THIS_MODULE) сюда, так как              * для процессов, где окажется прервана операция open(),               * соответствующей операции close() не будет. Если не               * декрементировать счетчик использования здесь, у нас                * останется в нем положительный счет, который мы никак уже               * не приведем к нулю. В итоге у нас получится бессмертный               * модуль, для извлечения которого потребуется перезагрузка.               */              module_put(THIS_MODULE);              return -EINTR;          }      }        return 0; /* Разрешение доступа. */  }    /* Вызывается при закрытии файла /proc. */  static int module_close(struct inode *inode, struct file *file)  {      /* Устанавливаем already_open на нуль, чтобы один из процессов в waitq       * мог установить already_open обратно на один и открыть файл. В итоге       * остальные процессы при вызове будут видеть, что already_open       * равен одному, в связи с чем возвращаться в ожидание.       */      atomic_set(&already_open, 0);        /* Пробуждение всех процессов в waitq, чтобы очередной ожидающий мог       * получить доступ к файлу.       */      wake_up(&waitq);        module_put(THIS_MODULE);        return 0; /* Успех. */  }    /* Структуры для регистрации в качестве файла /proc с указателями на все   * связанные функции.   */    /* Файловые операции нашего файла /proc. Здесь размещаются указатели на  * все функции, вызываемые, когда кто-то пытается произвести действия с   * файлом. NULL означает, что мы не хотим выполнять какое-то действие.   */  #ifdef HAVE_PROC_OPS  static const struct proc_ops file_ops_4_our_proc_file = {      .proc_read = module_output, /* "Считывание" из файла. */      .proc_write = module_input, /* "Запись" в файл. */      .proc_open = module_open, /* Вызывается при открытии файла /proc */      .proc_release = module_close, /* Вызывается при его закрытии. */  };  #else  static const struct file_operations file_ops_4_our_proc_file = {      .read = module_output,      .write = module_input,      .open = module_open,      .release = module_close,  };  #endif    /* Инициализация модуля – регистрация файла /proc. */  static int __init sleep_init(void)  {      our_proc_file =          proc_create(PROC_ENTRY_FILENAME, 0644, NULL, &file_ops_4_our_proc_file);      if (our_proc_file == NULL) {          remove_proc_entry(PROC_ENTRY_FILENAME, NULL);          pr_debug("Error: Could not initialize /proc/%s\n", PROC_ENTRY_FILENAME);          return -ENOMEM;      }      proc_set_size(our_proc_file, 80);      proc_set_user(our_proc_file, GLOBAL_ROOT_UID, GLOBAL_ROOT_GID);        pr_info("/proc/%s created\n", PROC_ENTRY_FILENAME);        return 0;  }    /* Очистка – снятие регистрации файла из /proc.  Это может быть опасно,    * если в waitq еще есть ожидающие процессы, потому что они находятся   * внутри функции open(), которая будет выгружена. В 10 главе я объясняю,   * как в подобном случае избежать извлечения модуля.   */  static void __exit sleep_exit(void)  {      remove_proc_entry(PROC_ENTRY_FILENAME, NULL);      pr_debug("/proc/%s removed\n", PROC_ENTRY_FILENAME);  }    module_init(sleep_init);  module_exit(sleep_exit);  

MODULE_LICENSE("GPL"); /*   *  cat_nonblock.c – открывает файл и отображает содержимое, но в случае   *  необходимости ожидания ввода выходит.   */  #include <errno.h> /* Для errno. */  #include <fcntl.h> /* Для открытия. */  #include <stdio.h> /* Стандартный ввод-вывод. */  #include <stdlib.h> /* Для выхода. */  #include <unistd.h> /* Для считывания.*/    #define MAX_BYTES 1024 * 4    int main(int argc, char *argv[])  {      int fd; /* Дескриптор считываемого файла. */      size_t bytes; /* Количество считываемых байт. */      char buffer[MAX_BYTES]; /* Буфер для этих байт. */        /* Использование. */      if (argc != 2) {          printf("Usage: %s <filename>\n", argv[0]);          puts("Reads the content of a file, but doesn't wait for input");          exit(-1);      }        /* Открытие файла для считывания в неблокирующемся режиме. */      fd = open(argv[1], O_RDONLY | O_NONBLOCK);        /* Если открытие провалилось. */      if (fd == -1) {          puts(errno == EAGAIN ? "Open would block" : "Open failed");          exit(-1);      }        /* Считывание файла и вывод его содержимого. */      do {          /* Считывание символов из файла. */          bytes = read(fd, buffer, MAX_BYTES);            /* В случае ошибки сообщить о ней и завершиться. */          if (bytes == -1) {              if (errno == EAGAIN)                  puts("Normally I'd block, but you told me not to");              else                  puts("Another read error");              exit(-1);          }            /* Вывод символов. */          if (bytes > 0) {              for (int i = 0; i < bytes; i++)                  putchar(buffer[i]);          }            /* Пока нет ошибок, и файл не закончился. */      } while (bytes > 0);        return 0;  }

/*   * completions.c   */  #include <linux/completion.h>  #include <linux/init.h>  #include <linux/kernel.h>  #include <linux/kthread.h>  #include <linux/module.h>    static struct {      struct completion crank_comp;      struct completion flywheel_comp;  } machine;    static int machine_crank_thread(void *arg)  {      pr_info("Turn the crank\n");        complete_all(&machine.crank_comp);      complete_and_exit(&machine.crank_comp, 0);  }    static int machine_flywheel_spinup_thread(void *arg)  {      wait_for_completion(&machine.crank_comp);        pr_info("Flywheel spins up\n");        complete_all(&machine.flywheel_comp);      complete_and_exit(&machine.flywheel_comp, 0);  }    static int completions_init(void)  {      struct task_struct *crank_thread;      struct task_struct *flywheel_thread;        pr_info("completions example\n");        init_completion(&machine.crank_comp);      init_completion(&machine.flywheel_comp);        crank_thread = kthread_create(machine_crank_thread, NULL, "KThread Crank");      if (IS_ERR(crank_thread))          goto ERROR_THREAD_1;        flywheel_thread = kthread_create(machine_flywheel_spinup_thread, NULL,                                       "KThread Flywheel");      if (IS_ERR(flywheel_thread))          goto ERROR_THREAD_2;        wake_up_process(flywheel_thread);      wake_up_process(crank_thread);        return 0;    ERROR_THREAD_2:      kthread_stop(crank_thread);  ERROR_THREAD_1:        return -1;  }    static void completions_exit(void)  {      wait_for_completion(&machine.crank_comp);      wait_for_completion(&machine.flywheel_comp);        pr_info("completions exit\n");  }    module_init(completions_init);  module_exit(completions_exit);    MODULE_DESCRIPTION("Completions example");  MODULE_LICENSE("GPL");

/*   * example_mutex.c   */  #include <linux/init.h>  #include <linux/kernel.h>  #include <linux/module.h>  #include <linux/mutex.h>    static DEFINE_MUTEX(mymutex);    static int example_mutex_init(void)  {      int ret;        pr_info("example_mutex init\n");        ret = mutex_trylock(&mymutex);      if (ret != 0) {          pr_info("mutex is locked\n");            if (mutex_is_locked(&mymutex) == 0)              pr_info("The mutex failed to lock!\n");            mutex_unlock(&mymutex);          pr_info("mutex is unlocked\n");      } else          pr_info("Failed to lock\n");        return 0;  }    static void example_mutex_exit(void)  {      pr_info("example_mutex exit\n");  }    module_init(example_mutex_init);  module_exit(example_mutex_exit);    MODULE_DESCRIPTION("Mutex example");  MODULE_LICENSE("GPL");

/*   * example_spinlock.c   */  #include <linux/init.h>  #include <linux/interrupt.h>  #include <linux/kernel.h>  #include <linux/module.h>  #include <linux/spinlock.h>    static DEFINE_SPINLOCK(sl_static);  static spinlock_t sl_dynamic;    static void example_spinlock_static(void)  {      unsigned long flags;        spin_lock_irqsave(&sl_static, flags);      pr_info("Locked static spinlock\n");        /* Безопасное выполнение задачи. Поскольку задействуется 100% ЦПУ,        * выполнение кода должно занимать не более нескольких миллисекунд.       */        spin_unlock_irqrestore(&sl_static, flags);      pr_info("Unlocked static spinlock\n");  }    static void example_spinlock_dynamic(void)  {      unsigned long flags;        spin_lock_init(&sl_dynamic);      spin_lock_irqsave(&sl_dynamic, flags);      pr_info("Locked dynamic spinlock\n");        /* Безопасное выполнение задачи. Поскольку задействуется 100% ЦПУ,       * выполнение кода должно занимать не более нескольких миллисекунд.       */        spin_unlock_irqrestore(&sl_dynamic, flags);      pr_info("Unlocked dynamic spinlock\n");  }    static int example_spinlock_init(void)  {      pr_info("example spinlock started\n");        example_spinlock_static();      example_spinlock_dynamic();        return 0;  }    static void example_spinlock_exit(void)  {      pr_info("example spinlock exit\n");  }    module_init(example_spinlock_init);  module_exit(example_spinlock_exit);    MODULE_DESCRIPTION("Spinlock example");  MODULE_LICENSE("GPL");

/*   * example_rwlock.c   */  #include <linux/interrupt.h>  #include <linux/kernel.h>  #include <linux/module.h>    static DEFINE_RWLOCK(myrwlock);    static void example_read_lock(void)  {      unsigned long flags;        read_lock_irqsave(&myrwlock, flags);      pr_info("Read Locked\n");       /* Считывание. */        read_unlock_irqrestore(&myrwlock, flags);      pr_info("Read Unlocked\n");  }    static void example_write_lock(void)  {      unsigned long flags;        write_lock_irqsave(&myrwlock, flags);      pr_info("Write Locked\n");        /* Запись. */        write_unlock_irqrestore(&myrwlock, flags);      pr_info("Write Unlocked\n");  }    static int example_rwlock_init(void)  {      pr_info("example_rwlock started\n");        example_read_lock();      example_write_lock();        return 0;  }    static void example_rwlock_exit(void)  {      pr_info("example_rwlock exit\n");  }    module_init(example_rwlock_init);  module_exit(example_rwlock_exit);    MODULE_DESCRIPTION("Read/Write locks example");  MODULE_LICENSE("GPL");

/*   * example_atomic.c   */  #include <linux/interrupt.h>  #include <linux/kernel.h>  #include <linux/module.h>    #define BYTE_TO_BINARY_PATTERN "%c%c%c%c%c%c%c%c"  #define BYTE_TO_BINARY(byte)                                                   \      ((byte & 0x80) ? '1' : '0'), ((byte & 0x40) ? '1' : '0'),                  \          ((byte & 0x20) ? '1' : '0'), ((byte & 0x10) ? '1' : '0'),              \          ((byte & 0x08) ? '1' : '0'), ((byte & 0x04) ? '1' : '0'),              \          ((byte & 0x02) ? '1' : '0'), ((byte & 0x01) ? '1' : '0')    static void atomic_add_subtract(void)  {      atomic_t debbie;      atomic_t chris = ATOMIC_INIT(50);        atomic_set(&debbie, 45);        /* Вычитание единицы. */      atomic_dec(&debbie);        atomic_add(7, &debbie);        /* Прибавление единицы. */      atomic_inc(&debbie);        pr_info("chris: %d, debbie: %d\n", atomic_read(&chris),              atomic_read(&debbie));  }    static void atomic_bitwise(void)  {      unsigned long word = 0;        pr_info("Bits 0: " BYTE_TO_BINARY_PATTERN, BYTE_TO_BINARY(word));      set_bit(3, &word);      set_bit(5, &word);      pr_info("Bits 1: " BYTE_TO_BINARY_PATTERN, BYTE_TO_BINARY(word));      clear_bit(5, &word);      pr_info("Bits 2: " BYTE_TO_BINARY_PATTERN, BYTE_TO_BINARY(word));      change_bit(3, &word);        pr_info("Bits 3: " BYTE_TO_BINARY_PATTERN, BYTE_TO_BINARY(word));      if (test_and_set_bit(3, &word))          pr_info("wrong\n");      pr_info("Bits 4: " BYTE_TO_BINARY_PATTERN, BYTE_TO_BINARY(word));        word = 255;      pr_info("Bits 5: " BYTE_TO_BINARY_PATTERN, BYTE_TO_BINARY(word));  }    static int example_atomic_init(void)  {      pr_info("example_atomic started\n");        atomic_add_subtract();      atomic_bitwise();        return 0;  }    static void example_atomic_exit(void)  {      pr_info("example_atomic exit\n");  }    module_init(example_atomic_init);  module_exit(example_atomic_exit);    MODULE_DESCRIPTION("Atomic operations example");  MODULE_LICENSE("GPL");