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");

   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 #include <stdio.h>
   2 
   3 int main()
   4 {
   5     printf("Hello cross-compiling world!\n");
   6     return 0;
   7 }

   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     return;
  15 }
  16 
  17 module_init(helloworld_init);
  18 module_exit(helloworld_exit);
  19 MODULE_LICENSE("GPL");
  20 MODULE_AUTHOR("DonaldDuck");

   1 /*
   2  cc blasExample.c -o blasExample -lgsl -lgslcblas
   3  cc blasExample.c -o blasExample -lgsl -lgslcblas -lm -static
   4 
   5  on emdebian 
   6  arm-linux-gnueabi-gcc blasExample.c -o blasExample -lgsl -lgslcblas -lm -I/usr/local/arm/include/ -L/usr/local/arm/lib/ -L/usr/arm-linux-gnueabi/lib
   7  arm-linux-gnueabi-gcc blasExample.c -o blasExample -lgsl -lgslcblas -lm -I/usr/local/arm/include/ -L/usr/local/arm/lib/ 
   8 
   9  arm-linux-gnueabi-gcc blasExample.c -o blasExample -lgsl -lgslcblas -lm -I/usr/local/arm/include/ -L/usr/local/arm/lib/ -static
  10  qemu-arm blasExample
  11 */
  12 #include <stdio.h>
  13 #include <gsl/gsl_blas.h>
  14 
  15 int
  16 main (void)
  17 {
  18   double a[] = { 0.11, 0.12, 0.13,
  19                  0.21, 0.22, 0.23 };
  20 
  21   double b[] = { 1011, 1012,
  22                  1021, 1022,
  23                  1031, 1032 };
  24 
  25   double c[] = { 0.00, 0.00,
  26                  0.00, 0.00 };
  27 
  28   gsl_matrix_view A = gsl_matrix_view_array(a, 2, 3);
  29   gsl_matrix_view B = gsl_matrix_view_array(b, 3, 2);
  30   gsl_matrix_view C = gsl_matrix_view_array(c, 2, 2);
  31 
  32   /* Compute C = A B */
  33 
  34   gsl_blas_dgemm (CblasNoTrans, CblasNoTrans,
  35                   1.0, &A.matrix, &B.matrix,
  36                   0.0, &C.matrix);
  37 
  38   printf ("[ %g, %g\n", c[0], c[1]);
  39   printf ("  %g, %g ]\n", c[2], c[3]);
  40 
  41   return 0;  
  42 }