root/samples/kobject/kobject-example.c

DEFINITIONS

1. foo_show
2. foo_store
3. b_show
4. b_store
5. example_init
6. example_exit

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Sample kobject implementation
   4  *
   5  * Copyright (C) 2004-2007 Greg Kroah-Hartman <greg@kroah.com>
   6  * Copyright (C) 2007 Novell Inc.
   7  */
   8 #include <linux/kobject.h>
   9 #include <linux/string.h>
  10 #include <linux/sysfs.h>
  11 #include <linux/module.h>
  12 #include <linux/init.h>
  13 
  14 /*
  15  * This module shows how to create a simple subdirectory in sysfs called
  16  * /sys/kernel/kobject-example  In that directory, 3 files are created:
  17  * "foo", "baz", and "bar".  If an integer is written to these files, it can be
  18  * later read out of it.
  19  */
  20 
  21 static int foo;
  22 static int baz;
  23 static int bar;
  24 
  25 /*
  26  * The "foo" file where a static variable is read from and written to.
  27  */
  28 static ssize_t foo_show(struct kobject *kobj, struct kobj_attribute *attr,
  29                         char *buf)
  30 {
  31         return sprintf(buf, "%d\n", foo);
  32 }
  33 
  34 static ssize_t foo_store(struct kobject *kobj, struct kobj_attribute *attr,
  35                          const char *buf, size_t count)
  36 {
  37         int ret;
  38 
  39         ret = kstrtoint(buf, 10, &foo);
  40         if (ret < 0)
  41                 return ret;
  42 
  43         return count;
  44 }
  45 
  46 /* Sysfs attributes cannot be world-writable. */
  47 static struct kobj_attribute foo_attribute =
  48         __ATTR(foo, 0664, foo_show, foo_store);
  49 
  50 /*
  51  * More complex function where we determine which variable is being accessed by
  52  * looking at the attribute for the "baz" and "bar" files.
  53  */
  54 static ssize_t b_show(struct kobject *kobj, struct kobj_attribute *attr,
  55                       char *buf)
  56 {
  57         int var;
  58 
  59         if (strcmp(attr->attr.name, "baz") == 0)
  60                 var = baz;
  61         else
  62                 var = bar;
  63         return sprintf(buf, "%d\n", var);
  64 }
  65 
  66 static ssize_t b_store(struct kobject *kobj, struct kobj_attribute *attr,
  67                        const char *buf, size_t count)
  68 {
  69         int var, ret;
  70 
  71         ret = kstrtoint(buf, 10, &var);
  72         if (ret < 0)
  73                 return ret;
  74 
  75         if (strcmp(attr->attr.name, "baz") == 0)
  76                 baz = var;
  77         else
  78                 bar = var;
  79         return count;
  80 }
  81 
  82 static struct kobj_attribute baz_attribute =
  83         __ATTR(baz, 0664, b_show, b_store);
  84 static struct kobj_attribute bar_attribute =
  85         __ATTR(bar, 0664, b_show, b_store);
  86 
  87 
  88 /*
  89  * Create a group of attributes so that we can create and destroy them all
  90  * at once.
  91  */
  92 static struct attribute *attrs[] = {
  93         &foo_attribute.attr,
  94         &baz_attribute.attr,
  95         &bar_attribute.attr,
  96         NULL,   /* need to NULL terminate the list of attributes */
  97 };
  98 
  99 /*
 100  * An unnamed attribute group will put all of the attributes directly in
 101  * the kobject directory.  If we specify a name, a subdirectory will be
 102  * created for the attributes with the directory being the name of the
 103  * attribute group.
 104  */
 105 static struct attribute_group attr_group = {
 106         .attrs = attrs,
 107 };
 108 
 109 static struct kobject *example_kobj;
 110 
 111 static int __init example_init(void)
 112 {
 113         int retval;
 114 
 115         /*
 116          * Create a simple kobject with the name of "kobject_example",
 117          * located under /sys/kernel/
 118          *
 119          * As this is a simple directory, no uevent will be sent to
 120          * userspace.  That is why this function should not be used for
 121          * any type of dynamic kobjects, where the name and number are
 122          * not known ahead of time.
 123          */
 124         example_kobj = kobject_create_and_add("kobject_example", kernel_kobj);
 125         if (!example_kobj)
 126                 return -ENOMEM;
 127 
 128         /* Create the files associated with this kobject */
 129         retval = sysfs_create_group(example_kobj, &attr_group);
 130         if (retval)
 131                 kobject_put(example_kobj);
 132 
 133         return retval;
 134 }
 135 
 136 static void __exit example_exit(void)
 137 {
 138         kobject_put(example_kobj);
 139 }
 140 
 141 module_init(example_init);
 142 module_exit(example_exit);
 143 MODULE_LICENSE("GPL v2");
 144 MODULE_AUTHOR("Greg Kroah-Hartman <greg@kroah.com>");