Currently, there is no standardized mechanism for userspace to discover
which reboot-modes are supported on a given platform. This limitation
forces tools and scripts to rely on hardcoded assumptions about the
supported reboot-modes.
Create a class 'reboot-mode' and a device under it to expose a sysfs
interface to show the available reboot mode arguments to userspace. Use
the driver_name field of the struct reboot_mode_driver to create the
device. For device-based drivers, configure the device driver name as
driver_name.
This results in the creation of:
/sys/class/reboot-mode/<driver>/reboot_modes
This read-only sysfs file will exposes the list of supported reboot
modes arguments provided by the driver, enabling userspace to query the
list of arguments.
Signed-off-by: Shivendra Pratap <shivendra.pratap@oss.qualcomm.com>
---
drivers/power/reset/reboot-mode.c | 72 +++++++++++++++++++++++++++++++++++++++
include/linux/reboot-mode.h | 3 ++
2 files changed, 75 insertions(+)
diff --git a/drivers/power/reset/reboot-mode.c b/drivers/power/reset/reboot-mode.c
index fba53f638da04655e756b5f8b7d2d666d1379535..062df67735c4818cfeb894941e537f19ea9d4ccb 100644
--- a/drivers/power/reset/reboot-mode.c
+++ b/drivers/power/reset/reboot-mode.c
@@ -7,18 +7,77 @@
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/module.h>
+#include <linux/mutex.h>
#include <linux/of.h>
#include <linux/reboot.h>
#include <linux/reboot-mode.h>
#define PREFIX "mode-"
+static DEFINE_MUTEX(reboot_mode_mutex);
+
struct mode_info {
const char *mode;
u32 magic;
struct list_head list;
};
+static ssize_t reboot_modes_show(struct device *dev, struct device_attribute *attr, char *buf)
+{
+ struct reboot_mode_driver *reboot;
+ struct mode_info *info;
+ ssize_t size = 0;
+
+ reboot = container_of(dev, struct reboot_mode_driver, reboot_mode_device);
+ if (!reboot)
+ return -ENODATA;
+
+ list_for_each_entry(info, &reboot->head, list)
+ size += sysfs_emit_at(buf, size, "%s ", info->mode);
+
+ if (!size)
+ return -ENODATA;
+
+ return size + sysfs_emit_at(buf, size - 1, "\n");
+}
+static DEVICE_ATTR_RO(reboot_modes);
+
+static struct attribute *reboot_mode_attrs[] = {
+ &dev_attr_reboot_modes.attr,
+ NULL,
+};
+ATTRIBUTE_GROUPS(reboot_mode);
+
+static const struct class reboot_mode_class = {
+ .name = "reboot-mode",
+ .dev_groups = reboot_mode_groups,
+};
+
+static void reboot_mode_device_release(struct device *dev)
+{
+ /* place holder to avoid warning on device_unregister. nothing to free */
+}
+
+static void reboot_mode_create_device(struct reboot_mode_driver *reboot)
+{
+ static bool is_class_registered;
+
+ reboot->reboot_mode_device_registered = false;
+
+ scoped_guard(mutex, &reboot_mode_mutex) {
+ if (!is_class_registered) {
+ if (!class_register(&reboot_mode_class))
+ is_class_registered = true;
+ }
+ }
+
+ reboot->reboot_mode_device.class = &reboot_mode_class;
+ reboot->reboot_mode_device.release = reboot_mode_device_release;
+ dev_set_name(&reboot->reboot_mode_device, reboot->driver_name);
+ if (!device_register(&reboot->reboot_mode_device))
+ reboot->reboot_mode_device_registered = true;
+}
+
static unsigned int get_reboot_mode_magic(struct reboot_mode_driver *reboot,
const char *cmd)
{
@@ -78,6 +137,8 @@ int reboot_mode_register(struct reboot_mode_driver *reboot)
INIT_LIST_HEAD(&reboot->head);
+ reboot_mode_create_device(reboot);
+
for_each_property_of_node(np, prop) {
if (strncmp(prop->name, PREFIX, len))
continue;
@@ -119,6 +180,11 @@ int reboot_mode_register(struct reboot_mode_driver *reboot)
list_for_each_entry(info, &reboot->head, list)
kfree_const(info->mode);
+ if (reboot->reboot_mode_device_registered) {
+ device_unregister(&reboot->reboot_mode_device);
+ reboot->reboot_mode_device_registered = false;
+ }
+
return ret;
}
EXPORT_SYMBOL_GPL(reboot_mode_register);
@@ -136,6 +202,11 @@ int reboot_mode_unregister(struct reboot_mode_driver *reboot)
list_for_each_entry(info, &reboot->head, list)
kfree_const(info->mode);
+ if (reboot->reboot_mode_device_registered) {
+ device_unregister(&reboot->reboot_mode_device);
+ reboot->reboot_mode_device_registered = false;
+ }
+
return 0;
}
EXPORT_SYMBOL_GPL(reboot_mode_unregister);
@@ -162,6 +233,7 @@ int devm_reboot_mode_register(struct device *dev,
if (!dr)
return -ENOMEM;
+ reboot->driver_name = reboot->dev->driver->name;
rc = reboot_mode_register(reboot);
if (rc) {
devres_free(dr);
diff --git a/include/linux/reboot-mode.h b/include/linux/reboot-mode.h
index 4a2abb38d1d612ec0fdf05eb18c98b210f631b7f..400cfde0e029aef14ff90a11b9d12d0c3ce8dee6 100644
--- a/include/linux/reboot-mode.h
+++ b/include/linux/reboot-mode.h
@@ -5,6 +5,9 @@
struct reboot_mode_driver {
struct device *dev;
struct list_head head;
+ const char *driver_name;
+ struct device reboot_mode_device;
+ bool reboot_mode_device_registered;
int (*write)(struct reboot_mode_driver *reboot, unsigned int magic);
struct notifier_block reboot_notifier;
};
--
2.34.1On Sun, 16 Nov 2025 at 16:20, Shivendra Pratap
<shivendra.pratap@oss.qualcomm.com> wrote:
>
> Currently, there is no standardized mechanism for userspace to discover
> which reboot-modes are supported on a given platform. This limitation
> forces tools and scripts to rely on hardcoded assumptions about the
> supported reboot-modes.
>
> Create a class 'reboot-mode' and a device under it to expose a sysfs
> interface to show the available reboot mode arguments to userspace. Use
> the driver_name field of the struct reboot_mode_driver to create the
> device. For device-based drivers, configure the device driver name as
> driver_name.
>
> This results in the creation of:
> /sys/class/reboot-mode/<driver>/reboot_modes
>
> This read-only sysfs file will exposes the list of supported reboot
> modes arguments provided by the driver, enabling userspace to query the
> list of arguments.
>
> Signed-off-by: Shivendra Pratap <shivendra.pratap@oss.qualcomm.com>
> ---
> drivers/power/reset/reboot-mode.c | 72 +++++++++++++++++++++++++++++++++++++++
> include/linux/reboot-mode.h | 3 ++
> 2 files changed, 75 insertions(+)
>
> diff --git a/drivers/power/reset/reboot-mode.c b/drivers/power/reset/reboot-mode.c
> index fba53f638da04655e756b5f8b7d2d666d1379535..062df67735c4818cfeb894941e537f19ea9d4ccb 100644
> --- a/drivers/power/reset/reboot-mode.c
> +++ b/drivers/power/reset/reboot-mode.c
> @@ -7,18 +7,77 @@
> #include <linux/init.h>
> #include <linux/kernel.h>
> #include <linux/module.h>
> +#include <linux/mutex.h>
> #include <linux/of.h>
> #include <linux/reboot.h>
> #include <linux/reboot-mode.h>
>
> #define PREFIX "mode-"
>
> +static DEFINE_MUTEX(reboot_mode_mutex);
> +
> struct mode_info {
> const char *mode;
> u32 magic;
> struct list_head list;
> };
>
> +static ssize_t reboot_modes_show(struct device *dev, struct device_attribute *attr, char *buf)
> +{
> + struct reboot_mode_driver *reboot;
> + struct mode_info *info;
> + ssize_t size = 0;
> +
> + reboot = container_of(dev, struct reboot_mode_driver, reboot_mode_device);
> + if (!reboot)
> + return -ENODATA;
> +
> + list_for_each_entry(info, &reboot->head, list)
> + size += sysfs_emit_at(buf, size, "%s ", info->mode);
> +
> + if (!size)
> + return -ENODATA;
> +
> + return size + sysfs_emit_at(buf, size - 1, "\n");
> +}
> +static DEVICE_ATTR_RO(reboot_modes);
> +
> +static struct attribute *reboot_mode_attrs[] = {
> + &dev_attr_reboot_modes.attr,
> + NULL,
> +};
> +ATTRIBUTE_GROUPS(reboot_mode);
> +
> +static const struct class reboot_mode_class = {
> + .name = "reboot-mode",
> + .dev_groups = reboot_mode_groups,
> +};
> +
> +static void reboot_mode_device_release(struct device *dev)
> +{
> + /* place holder to avoid warning on device_unregister. nothing to free */
> +}
> +
> +static void reboot_mode_create_device(struct reboot_mode_driver *reboot)
> +{
> + static bool is_class_registered;
> +
> + reboot->reboot_mode_device_registered = false;
> +
> + scoped_guard(mutex, &reboot_mode_mutex) {
> + if (!is_class_registered) {
> + if (!class_register(&reboot_mode_class))
> + is_class_registered = true;
> + }
> + }
This could be achieved with DO_ONCE() but you still haven't explained
why this needs to be done here. Why not in the module's
subsys_initcall()? As of now, the class will not appear in sysfs until
the first device is registered which isn't a very common behavior.
Bart
> +
> + reboot->reboot_mode_device.class = &reboot_mode_class;
> + reboot->reboot_mode_device.release = reboot_mode_device_release;
> + dev_set_name(&reboot->reboot_mode_device, reboot->driver_name);
> + if (!device_register(&reboot->reboot_mode_device))
> + reboot->reboot_mode_device_registered = true;
> +}
> +
> static unsigned int get_reboot_mode_magic(struct reboot_mode_driver *reboot,
> const char *cmd)
> {
> @@ -78,6 +137,8 @@ int reboot_mode_register(struct reboot_mode_driver *reboot)
>
> INIT_LIST_HEAD(&reboot->head);
>
> + reboot_mode_create_device(reboot);
> +
> for_each_property_of_node(np, prop) {
> if (strncmp(prop->name, PREFIX, len))
> continue;
> @@ -119,6 +180,11 @@ int reboot_mode_register(struct reboot_mode_driver *reboot)
> list_for_each_entry(info, &reboot->head, list)
> kfree_const(info->mode);
>
> + if (reboot->reboot_mode_device_registered) {
> + device_unregister(&reboot->reboot_mode_device);
> + reboot->reboot_mode_device_registered = false;
> + }
> +
> return ret;
> }
> EXPORT_SYMBOL_GPL(reboot_mode_register);
> @@ -136,6 +202,11 @@ int reboot_mode_unregister(struct reboot_mode_driver *reboot)
> list_for_each_entry(info, &reboot->head, list)
> kfree_const(info->mode);
>
> + if (reboot->reboot_mode_device_registered) {
> + device_unregister(&reboot->reboot_mode_device);
> + reboot->reboot_mode_device_registered = false;
> + }
> +
> return 0;
> }
> EXPORT_SYMBOL_GPL(reboot_mode_unregister);
> @@ -162,6 +233,7 @@ int devm_reboot_mode_register(struct device *dev,
> if (!dr)
> return -ENOMEM;
>
> + reboot->driver_name = reboot->dev->driver->name;
> rc = reboot_mode_register(reboot);
> if (rc) {
> devres_free(dr);
> diff --git a/include/linux/reboot-mode.h b/include/linux/reboot-mode.h
> index 4a2abb38d1d612ec0fdf05eb18c98b210f631b7f..400cfde0e029aef14ff90a11b9d12d0c3ce8dee6 100644
> --- a/include/linux/reboot-mode.h
> +++ b/include/linux/reboot-mode.h
> @@ -5,6 +5,9 @@
> struct reboot_mode_driver {
> struct device *dev;
> struct list_head head;
> + const char *driver_name;
> + struct device reboot_mode_device;
> + bool reboot_mode_device_registered;
> int (*write)(struct reboot_mode_driver *reboot, unsigned int magic);
> struct notifier_block reboot_notifier;
> };
>
> --
> 2.34.1
>
On 11/17/2025 6:55 PM, Bartosz Golaszewski wrote:
> On Sun, 16 Nov 2025 at 16:20, Shivendra Pratap
> <shivendra.pratap@oss.qualcomm.com> wrote:
>>
>> Currently, there is no standardized mechanism for userspace to discover
>> which reboot-modes are supported on a given platform. This limitation
>> forces tools and scripts to rely on hardcoded assumptions about the
>> supported reboot-modes.
>>
>> Create a class 'reboot-mode' and a device under it to expose a sysfs
>> interface to show the available reboot mode arguments to userspace. Use
>> the driver_name field of the struct reboot_mode_driver to create the
>> device. For device-based drivers, configure the device driver name as
>> driver_name.
>>
>> This results in the creation of:
>> /sys/class/reboot-mode/<driver>/reboot_modes
>>
>> This read-only sysfs file will exposes the list of supported reboot
>> modes arguments provided by the driver, enabling userspace to query the
>> list of arguments.
>>
>> Signed-off-by: Shivendra Pratap <shivendra.pratap@oss.qualcomm.com>
>> ---
>> drivers/power/reset/reboot-mode.c | 72 +++++++++++++++++++++++++++++++++++++++
>> include/linux/reboot-mode.h | 3 ++
>> 2 files changed, 75 insertions(+)
>>
>> diff --git a/drivers/power/reset/reboot-mode.c b/drivers/power/reset/reboot-mode.c
>> index fba53f638da04655e756b5f8b7d2d666d1379535..062df67735c4818cfeb894941e537f19ea9d4ccb 100644
>> --- a/drivers/power/reset/reboot-mode.c
>> +++ b/drivers/power/reset/reboot-mode.c
>> @@ -7,18 +7,77 @@
>> #include <linux/init.h>
>> #include <linux/kernel.h>
>> #include <linux/module.h>
>> +#include <linux/mutex.h>
>> #include <linux/of.h>
>> #include <linux/reboot.h>
>> #include <linux/reboot-mode.h>
>>
>> #define PREFIX "mode-"
>>
>> +static DEFINE_MUTEX(reboot_mode_mutex);
>> +
>> struct mode_info {
>> const char *mode;
>> u32 magic;
>> struct list_head list;
>> };
>>
>> +static ssize_t reboot_modes_show(struct device *dev, struct device_attribute *attr, char *buf)
>> +{
>> + struct reboot_mode_driver *reboot;
>> + struct mode_info *info;
>> + ssize_t size = 0;
>> +
>> + reboot = container_of(dev, struct reboot_mode_driver, reboot_mode_device);
>> + if (!reboot)
>> + return -ENODATA;
>> +
>> + list_for_each_entry(info, &reboot->head, list)
>> + size += sysfs_emit_at(buf, size, "%s ", info->mode);
>> +
>> + if (!size)
>> + return -ENODATA;
>> +
>> + return size + sysfs_emit_at(buf, size - 1, "\n");
>> +}
>> +static DEVICE_ATTR_RO(reboot_modes);
>> +
>> +static struct attribute *reboot_mode_attrs[] = {
>> + &dev_attr_reboot_modes.attr,
>> + NULL,
>> +};
>> +ATTRIBUTE_GROUPS(reboot_mode);
>> +
>> +static const struct class reboot_mode_class = {
>> + .name = "reboot-mode",
>> + .dev_groups = reboot_mode_groups,
>> +};
>> +
>> +static void reboot_mode_device_release(struct device *dev)
>> +{
>> + /* place holder to avoid warning on device_unregister. nothing to free */
>> +}
>> +
>> +static void reboot_mode_create_device(struct reboot_mode_driver *reboot)
>> +{
>> + static bool is_class_registered;
>> +
>> + reboot->reboot_mode_device_registered = false;
>> +
>> + scoped_guard(mutex, &reboot_mode_mutex) {
>> + if (!is_class_registered) {
>> + if (!class_register(&reboot_mode_class))
>> + is_class_registered = true;
>> + }
>> + }
>
> This could be achieved with DO_ONCE() but you still haven't explained
> why this needs to be done here. Why not in the module's
> subsys_initcall()? As of now, the class will not appear in sysfs until
> the first device is registered which isn't a very common behavior.
sure will add a subsys_initcall() and add it there.
thanks,
Shivendra
© 2016 - 2026 Red Hat, Inc.