What You Will Learn

Prerequisites

What Is Sysfs?

Sysfs is a virtual, in-memory filesystem that the Linux kernel exposes at /sys. It lets kernel objects (devices, drivers, subsystems) publish their properties to user space as ordinary files. A user space program simply reads or writes a file under /sys instead of calling a special system call.

The Sysfs One Value Per File Rule

The kernel documentation is strict about one thing: each sysfs attribute file must represent exactly one value. A file should not hold a comma-separated list, a multi-line dump, or a mix of unrelated fields.

Because of this rule, sysfs is excellent for reporting sensor readings, toggles, and simple settings — but it is a poor fit for verbose debugging output. That limitation is exactly why the kernel offers a second, more relaxed interface: debugfs, which we cover in the next lesson.

Why Does This Rule Exist?

Sysfs is treated as a stable user space ABI. If a file mixed multiple values together, any change to that internal format would silently break scripts and tools that parse it. Keeping one value per file means each attribute can evolve independently, and existing consumers of other attributes are never affected.

Writing Sysfs Attributes on a Modern 6.x Kernel

Older code (and older books) commonly used snprintf() inside a sysfs show() callback. On current kernels this is discouraged. The recommended helper today is sysfs_emit(), introduced to guarantee the output never exceeds the fixed PAGE_SIZE buffer that sysfs hands to a show callback, and to catch a class of bugs that plagued the old snprintf-based pattern.

#include <linux/sysfs.h>
#include <linux/mutex.h>

static unsigned int demo_value;
static DEFINE_MUTEX(demo_mtx);

static ssize_t demo_value_show(struct device *dev,
                                struct device_attribute *attr,
                                char *buf)
{
    unsigned int val;

    mutex_lock(&demo_mtx);
    val = demo_value;
    mutex_unlock(&demo_mtx);

    /* sysfs_emit() is the modern, safe replacement for snprintf() here */
    return sysfs_emit(buf, "%u\n", val);
}

static ssize_t demo_value_store(struct device *dev,
                                 struct device_attribute *attr,
                                 const char *buf, size_t count)
{
    unsigned int val;

    if (kstrtouint(buf, 10, &val))
        return -EINVAL;

    mutex_lock(&demo_mtx);
    demo_value = val;
    mutex_unlock(&demo_mtx);

    return count;
}

static DEVICE_ATTR_RW(demo_value);

Notice how this single attribute exposes exactly one value: demo_value. If you needed to expose a second property, the correct approach is to add a second DEVICE_ATTR and a second file — never to pack both values into one buffer.

Common Mistakes With Sysfs Attributes

Best Practices for Sysfs Attribute Design

Security Considerations

Sysfs files are reachable by any process with the right file permissions, so a store() callback must never trust its input blindly. Always validate the parsed value’s range, and never use a sysfs attribute to accept a raw pointer, buffer length, or anything that could be used to influence kernel memory operations without strict bounds checking.

Summary / Key Takeaways

Frequently Asked Questions

Conclusion

The sysfs one value per file rule looks like a small detail, but it is the reason sysfs has stayed a dependable, stable interface for over two decades of kernel development. As you continue this free Linux kernel programming course, keep this rule in mind every time you design a new device attribute — and remember that debugfs is there for the cases sysfs was never meant to handle.