290 lines · c
1// SPDX-License-Identifier: GPL-2.02/*3 * Sample kset and ktype implementation4 *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/slab.h>12#include <linux/module.h>13#include <linux/init.h>14 15/*16 * This module shows how to create a kset in sysfs called17 * /sys/kernel/kset-example18 * Then tree kobjects are created and assigned to this kset, "foo", "baz",19 * and "bar". In those kobjects, attributes of the same name are also20 * created and if an integer is written to these files, it can be later21 * read out of it.22 */23 24 25/*26 * This is our "object" that we will create a few of and register them with27 * sysfs.28 */29struct foo_obj {30 struct kobject kobj;31 int foo;32 int baz;33 int bar;34};35#define to_foo_obj(x) container_of(x, struct foo_obj, kobj)36 37/* a custom attribute that works just for a struct foo_obj. */38struct foo_attribute {39 struct attribute attr;40 ssize_t (*show)(struct foo_obj *foo, struct foo_attribute *attr, char *buf);41 ssize_t (*store)(struct foo_obj *foo, struct foo_attribute *attr, const char *buf, size_t count);42};43#define to_foo_attr(x) container_of(x, struct foo_attribute, attr)44 45/*46 * The default show function that must be passed to sysfs. This will be47 * called by sysfs for whenever a show function is called by the user on a48 * sysfs file associated with the kobjects we have registered. We need to49 * transpose back from a "default" kobject to our custom struct foo_obj and50 * then call the show function for that specific object.51 */52static ssize_t foo_attr_show(struct kobject *kobj,53 struct attribute *attr,54 char *buf)55{56 struct foo_attribute *attribute;57 struct foo_obj *foo;58 59 attribute = to_foo_attr(attr);60 foo = to_foo_obj(kobj);61 62 if (!attribute->show)63 return -EIO;64 65 return attribute->show(foo, attribute, buf);66}67 68/*69 * Just like the default show function above, but this one is for when the70 * sysfs "store" is requested (when a value is written to a file.)71 */72static ssize_t foo_attr_store(struct kobject *kobj,73 struct attribute *attr,74 const char *buf, size_t len)75{76 struct foo_attribute *attribute;77 struct foo_obj *foo;78 79 attribute = to_foo_attr(attr);80 foo = to_foo_obj(kobj);81 82 if (!attribute->store)83 return -EIO;84 85 return attribute->store(foo, attribute, buf, len);86}87 88/* Our custom sysfs_ops that we will associate with our ktype later on */89static const struct sysfs_ops foo_sysfs_ops = {90 .show = foo_attr_show,91 .store = foo_attr_store,92};93 94/*95 * The release function for our object. This is REQUIRED by the kernel to96 * have. We free the memory held in our object here.97 *98 * NEVER try to get away with just a "blank" release function to try to be99 * smarter than the kernel. Turns out, no one ever is...100 */101static void foo_release(struct kobject *kobj)102{103 struct foo_obj *foo;104 105 foo = to_foo_obj(kobj);106 kfree(foo);107}108 109/*110 * The "foo" file where the .foo variable is read from and written to.111 */112static ssize_t foo_show(struct foo_obj *foo_obj, struct foo_attribute *attr,113 char *buf)114{115 return sysfs_emit(buf, "%d\n", foo_obj->foo);116}117 118static ssize_t foo_store(struct foo_obj *foo_obj, struct foo_attribute *attr,119 const char *buf, size_t count)120{121 int ret;122 123 ret = kstrtoint(buf, 10, &foo_obj->foo);124 if (ret < 0)125 return ret;126 127 return count;128}129 130/* Sysfs attributes cannot be world-writable. */131static struct foo_attribute foo_attribute =132 __ATTR(foo, 0664, foo_show, foo_store);133 134/*135 * More complex function where we determine which variable is being accessed by136 * looking at the attribute for the "baz" and "bar" files.137 */138static ssize_t b_show(struct foo_obj *foo_obj, struct foo_attribute *attr,139 char *buf)140{141 int var;142 143 if (strcmp(attr->attr.name, "baz") == 0)144 var = foo_obj->baz;145 else146 var = foo_obj->bar;147 return sysfs_emit(buf, "%d\n", var);148}149 150static ssize_t b_store(struct foo_obj *foo_obj, struct foo_attribute *attr,151 const char *buf, size_t count)152{153 int var, ret;154 155 ret = kstrtoint(buf, 10, &var);156 if (ret < 0)157 return ret;158 159 if (strcmp(attr->attr.name, "baz") == 0)160 foo_obj->baz = var;161 else162 foo_obj->bar = var;163 return count;164}165 166static struct foo_attribute baz_attribute =167 __ATTR(baz, 0664, b_show, b_store);168static struct foo_attribute bar_attribute =169 __ATTR(bar, 0664, b_show, b_store);170 171/*172 * Create a group of attributes so that we can create and destroy them all173 * at once.174 */175static struct attribute *foo_default_attrs[] = {176 &foo_attribute.attr,177 &baz_attribute.attr,178 &bar_attribute.attr,179 NULL, /* need to NULL terminate the list of attributes */180};181ATTRIBUTE_GROUPS(foo_default);182 183/*184 * Our own ktype for our kobjects. Here we specify our sysfs ops, the185 * release function, and the set of default attributes we want created186 * whenever a kobject of this type is registered with the kernel.187 */188static const struct kobj_type foo_ktype = {189 .sysfs_ops = &foo_sysfs_ops,190 .release = foo_release,191 .default_groups = foo_default_groups,192};193 194static struct kset *example_kset;195static struct foo_obj *foo_obj;196static struct foo_obj *bar_obj;197static struct foo_obj *baz_obj;198 199static struct foo_obj *create_foo_obj(const char *name)200{201 struct foo_obj *foo;202 int retval;203 204 /* allocate the memory for the whole object */205 foo = kzalloc(sizeof(*foo), GFP_KERNEL);206 if (!foo)207 return NULL;208 209 /*210 * As we have a kset for this kobject, we need to set it before calling211 * the kobject core.212 */213 foo->kobj.kset = example_kset;214 215 /*216 * Initialize and add the kobject to the kernel. All the default files217 * will be created here. As we have already specified a kset for this218 * kobject, we don't have to set a parent for the kobject, the kobject219 * will be placed beneath that kset automatically.220 */221 retval = kobject_init_and_add(&foo->kobj, &foo_ktype, NULL, "%s", name);222 if (retval) {223 kobject_put(&foo->kobj);224 return NULL;225 }226 227 /*228 * We are always responsible for sending the uevent that the kobject229 * was added to the system.230 */231 kobject_uevent(&foo->kobj, KOBJ_ADD);232 233 return foo;234}235 236static void destroy_foo_obj(struct foo_obj *foo)237{238 kobject_put(&foo->kobj);239}240 241static int __init example_init(void)242{243 /*244 * Create a kset with the name of "kset_example",245 * located under /sys/kernel/246 */247 example_kset = kset_create_and_add("kset_example", NULL, kernel_kobj);248 if (!example_kset)249 return -ENOMEM;250 251 /*252 * Create three objects and register them with our kset253 */254 foo_obj = create_foo_obj("foo");255 if (!foo_obj)256 goto foo_error;257 258 bar_obj = create_foo_obj("bar");259 if (!bar_obj)260 goto bar_error;261 262 baz_obj = create_foo_obj("baz");263 if (!baz_obj)264 goto baz_error;265 266 return 0;267 268baz_error:269 destroy_foo_obj(bar_obj);270bar_error:271 destroy_foo_obj(foo_obj);272foo_error:273 kset_unregister(example_kset);274 return -EINVAL;275}276 277static void __exit example_exit(void)278{279 destroy_foo_obj(baz_obj);280 destroy_foo_obj(bar_obj);281 destroy_foo_obj(foo_obj);282 kset_unregister(example_kset);283}284 285module_init(example_init);286module_exit(example_exit);287MODULE_DESCRIPTION("Sample kset and ktype implementation");288MODULE_LICENSE("GPL v2");289MODULE_AUTHOR("Greg Kroah-Hartman <greg@kroah.com>");290