examples/kerneltest/kernel_module.c

   1 #include <linux/module.h>
   2 #include <linux/kthread.h>
   3 #include <linux/fs.h>
   4 #include <linux/cdev.h>
   5 #include <asm/uaccess.h>
   6
   7 #include "TestMasterSlave.h"
   8 #include "console/console.h"
   9
  10 #define minor 0
  11
  12 MODULE_LICENSE("GPL");
  13
  14 static dev_t canftest_dev;
  15 static struct cdev *canftest_cdev;
  16 static struct task_struct *thread_start_p, *thread_stop_p;
  17 static DECLARE_MUTEX (canftest_mutex);
  18 static int canftest_stopped = 1;
  19
  20 int thread_start (void* data);
  21 int thread_stop (void* data);
  22
  23 // handler processing write() requests from user-space
  24 ssize_t canftest_write(struct file *filp, const char __user *buf, size_t count,
  25                        loff_t *f_pos)
  26 {
  27         int cmd;
  28
  29         // get integer from user-space
  30         if (get_user (cmd, buf))
  31                 return -EFAULT;
  32
  33         // process integer as command
  34         switch (cmd) {
  35                 case CMD_START:
  36                         if (!canftest_stopped) break;
  37                         thread_start_p = kthread_create (thread_start, NULL, "canftest_start");
  38
  39                         if (PTR_ERR(thread_start_p) == -ENOMEM) {
  40                                 printk(KERN_WARNING "canftest: error creating start thread\n");
  41                                 return -ENOMEM;
  42                         }
  43
  44                         wake_up_process (thread_start_p);
  45                         break;
  46
  47                 case CMD_STOP:
  48                         if (canftest_stopped) break;
  49                         thread_stop_p = kthread_create (thread_stop, NULL, "canftest_stop");
  50
  51                         if (PTR_ERR(thread_stop_p) == -ENOMEM) {
  52                                 printk(KERN_WARNING "canftest: error creating stop thread\n");
  53                                 return -ENOMEM;
  54                         }
  55
  56                         wake_up_process (thread_stop_p);
  57                         break;
  58
  59                 // ignore new line character
  60                 case 10:
  61                         break;
  62
  63                 default:
  64                         printk("canftest: bad command %d\n", cmd);
  65                         break;
  66         }
  67
  68         return count;
  69 }
  70
  71 // register write() handler
  72 static struct file_operations canftest_fops = {
  73         .owner =    THIS_MODULE,
  74         .write =    canftest_write,
  75 };
  76
  77 // start TestMasterSlave example
  78 int thread_start (void* data)
  79 {
  80         int ret=0;
  81
  82         down_interruptible (&canftest_mutex);
  83
  84         ret=TestMasterSlave_start();
  85
  86         // if started
  87         if (ret == 0) {
  88                 canftest_stopped = 0;
  89
  90                 // increment module usage count
  91                 try_module_get(THIS_MODULE);
  92         }
  93
  94         up (&canftest_mutex);
  95
  96         return ret;
  97 }
  98
  99 // finish TestMasterSlave example
 100 int thread_stop (void* data)
 101 {
 102         down_interruptible (&canftest_mutex);
 103
 104         TestMasterSlave_stop();
 105         canftest_stopped = 1;
 106
 107         // decrement usage count
 108         module_put(THIS_MODULE);
 109
 110         up (&canftest_mutex);
 111
 112         return 0;
 113 }
 114
 115 int init_module(void)
 116 {
 117         int ret, major;
 118
 119         // get major device number dynamically
 120         ret = alloc_chrdev_region(&canftest_dev, minor, 1, DEVICE_NAME);
 121         major = MAJOR(canftest_dev);
 122         if (ret < 0) {
 123                 printk(KERN_WARNING "canftest: can't get major %d\n", major);
 124                 return ret;
 125         }
 126
 127         canftest_cdev = cdev_alloc( );
 128         canftest_cdev->owner = THIS_MODULE;
 129         canftest_cdev->ops = &canftest_fops;
 130
 131         // register new character device
 132         ret = cdev_add (canftest_cdev, canftest_dev, 1);
 133         if (ret) {
 134                 printk(KERN_WARNING "canftest: error %d adding char device\n", ret);
 135                 return ret;
 136         }
 137
 138         return 0;
 139 }
 140
 141 void cleanup_module(void)
 142 {
 143         // unregister major device number and character device
 144         unregister_chrdev_region(canftest_dev, 1);
 145         cdev_del(canftest_cdev);
 146 }