ISELFInalProjectInfo

   1 #include <linux/module.h>       /* Required by all modules */
   2 #include <linux/kernel.h>       /* Required for KERN_INFO */
   3 #include <linux/init.h>         /* Required for the macros */
   4 
   5 static int __init helloworld_init(void)
   6 {
   7     printk(KERN_INFO "Hello world\n");
   8 return 0;
   9 }
  10 
  11 static void __exit helloworld_exit(void)
  12 {
  13     printk(KERN_INFO "Bye all.\n");
  14 }
  15 
  16 module_init(helloworld_init);
  17 module_exit(helloworld_exit);
  18 MODULE_LICENSE("GPL");

   1 /*
   2 indent -linux sysfs_sample.c
   3 make clean
   4 make
   5 insmod sysfs_sample.ko
   6 tail /var/log/messages
   7 cat /sys/module/sysfs_sample/sysfs_sample_attrs/first
   8 cat /sys/module/sysfs_sample/sysfs_sample_attrs/second
   9 cat /sys/module/sysfs_sample/sysfs_sample_attrs/operation
  10 echo "asdf" >  /sys/module/sysfs_sample/sysfs_sample_attrs/operation
  11 cat /sys/module/sysfs_sample/sysfs_sample_attrs/operation
  12 dmesg
  13 rmmod sysfs_sample.ko
  14 */
  15 #include <linux/module.h>
  16 #include <linux/kernel.h>
  17 #include <linux/init.h>
  18 #include <linux/fs.h>
  19 #include <linux/slab.h>
  20 /*A struct kobject represents a kernel object, maybe a device or so,
  21 such as the things that show up as directory in the sysfs filesystem.*/
  22 struct kobject *sysfs_sample_kobject;
  23 struct int_attribute {
  24         struct attribute attr;
  25         int value;
  26 };
  27 struct string_attribute {
  28         struct attribute attr;
  29         char value[64];
  30 };
  31 static struct int_attribute first_attribute = {.attr.name = "first",.attr.mode =
  32             0666,.value = 11, };
  33 static struct int_attribute second_attribute = {.attr.name =
  34             "second",.attr.mode = 0666,.value = 22, };
  35 static struct string_attribute operation_attribute = {.attr.name =
  36             "operation",.attr.mode = 0666,.value = "add", };
  37 static struct attribute *sysfs_sample_attributes[] =
  38     { &first_attribute.attr, &second_attribute.attr, &operation_attribute.attr,
  39 NULL };
  40 /*Called when a read is performed on a attribute file in sysfs */
  41 static ssize_t default_show(struct kobject *kobj, struct attribute *attr,
  42                             char *buf)
  43 {
  44         struct int_attribute *intAttr;
  45         struct string_attribute *stringAttr;
  46         printk(KERN_INFO "Show called for kobject %s\n", kobj->name);
  47         printk(KERN_INFO "Attribute name: %s\n", attr->name);
  48         /* convert to proper struct based on name */
  49         if (strcmp("operation", attr->name) != 0) {
  50                 intAttr = container_of(attr, struct int_attribute, attr);
  51                 return scnprintf(buf, PAGE_SIZE, "%d\n", intAttr->value);
  52         } else {
  53                 stringAttr = container_of(attr, struct string_attribute, attr);
  54                 return scnprintf(buf, PAGE_SIZE, "%s\n", stringAttr->value);
  55         }
  56 }
  57 
  58 /*Called when a write is performed on a attribute file in sysfs */
  59 static ssize_t default_store(struct kobject *kobj, struct attribute *attr,
  60                              const char *buf, size_t len)
  61 {
  62         struct int_attribute *intAttr;
  63         struct string_attribute *stringAttr;
  64         printk(KERN_INFO "Store called for kobject %s\n", kobj->name);
  65 
  66         if (strcmp("operation", attr->name) != 0) {
  67                 intAttr = container_of(attr, struct int_attribute, attr);
  68                 sscanf(buf, "%d", &(intAttr->value));   /*convert char to int */
  69                 return sizeof(int);
  70         } else {
  71                 stringAttr = container_of(attr, struct string_attribute, attr);
  72                 sscanf(buf, "%s", stringAttr->value);   /*convert char to char */
  73                 printk(KERN_INFO "Sizeof %d\n", sizeof(stringAttr->value));
  74                 return sizeof(stringAttr->value);
  75         }
  76 }
  77 
  78 static struct sysfs_ops sysfs_sample_operations = {.show = default_show,.store =
  79             default_store, };
  80 static struct kobj_type sysfs_sample_type = {.sysfs_ops =
  81             &sysfs_sample_operations,.default_attrs =
  82             sysfs_sample_attributes, };
  83 /*Called on module initialization */
  84 static int __init sysfsexample_module_init(void)
  85 {
  86         int err = -1;
  87         printk(KERN_INFO "sysfs_sample init called \n");
  88         sysfs_sample_kobject =
  89             kzalloc(sizeof(*sysfs_sample_kobject), GFP_KERNEL);
  90         if (sysfs_sample_kobject) {
  91                 kobject_init(sysfs_sample_kobject, &sysfs_sample_type);
  92                 // if (kobject_add(sysfs_sample_kobject, NULL, "%s", "sysfs_sample")) {
  93                 if (kobject_add
  94                     (sysfs_sample_kobject, &THIS_MODULE->mkobj.kobj, "%s",
  95                      "sysfs_sample_attrs")) {
  96                         err = -1;
  97                         printk(KERN_INFO "sysfs_sample creation failed\n");
  98                         kobject_put(sysfs_sample_kobject);
  99                         sysfs_sample_kobject = NULL;
 100                 }
 101                 err = 0;
 102         }
 103         return err;
 104 }
 105 
 106 /*Called on module exit */
 107 static void __exit sysfsexample_module_exit(void)
 108 {
 109         printk(KERN_INFO "sysfs_sample exit called \n");
 110         if (sysfs_sample_kobject) {
 111                 kobject_put(sysfs_sample_kobject);
 112                 kfree(sysfs_sample_kobject);
 113         }
 114 }
 115 
 116 module_init(sysfsexample_module_init);
 117 module_exit(sysfsexample_module_exit);
 118 MODULE_LICENSE("GPL");