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 | 75 +++++++++++++++++++++++++++++++++++----
include/linux/reboot-mode.h | 6 ++++
2 files changed, 75 insertions(+), 6 deletions(-)
diff --git a/drivers/power/reset/reboot-mode.c b/drivers/power/reset/reboot-mode.c
index fba53f638da04655e756b5f8b7d2d666d1379535..28d1fe09d685a7422027fafc9d6a3db97a6aca18 100644
--- a/drivers/power/reset/reboot-mode.c
+++ b/drivers/power/reset/reboot-mode.c
@@ -19,6 +19,39 @@ struct mode_info {
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 = dev_get_drvdata(dev);
+ if (!reboot)
+ return -ENODATA;
+
+ scoped_guard(mutex, &reboot->reboot_mode_mutex) {
+ 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 unsigned int get_reboot_mode_magic(struct reboot_mode_driver *reboot,
const char *cmd)
{
@@ -76,6 +109,15 @@ int reboot_mode_register(struct reboot_mode_driver *reboot)
size_t len = strlen(PREFIX);
int ret;
+ reboot->reboot_mode_device = device_create(&reboot_mode_class, NULL, 0,
+ (void *)reboot, reboot->driver_name);
+ if (IS_ERR(reboot->reboot_mode_device)) {
+ ret = PTR_ERR(reboot->reboot_mode_device);
+ reboot->reboot_mode_device = NULL;
+ return ret;
+ }
+
+ mutex_init(&reboot->reboot_mode_mutex);
INIT_LIST_HEAD(&reboot->head);
for_each_property_of_node(np, prop) {
@@ -107,7 +149,9 @@ int reboot_mode_register(struct reboot_mode_driver *reboot)
goto error;
}
- list_add_tail(&info->list, &reboot->head);
+ scoped_guard(mutex, &reboot->reboot_mode_mutex) {
+ list_add_tail(&info->list, &reboot->head);
+ }
}
reboot->reboot_notifier.notifier_call = reboot_mode_notify;
@@ -116,9 +160,7 @@ int reboot_mode_register(struct reboot_mode_driver *reboot)
return 0;
error:
- list_for_each_entry(info, &reboot->head, list)
- kfree_const(info->mode);
-
+ reboot_mode_unregister(reboot);
return ret;
}
EXPORT_SYMBOL_GPL(reboot_mode_register);
@@ -131,10 +173,17 @@ int reboot_mode_unregister(struct reboot_mode_driver *reboot)
{
struct mode_info *info;
+ if (!reboot->reboot_mode_device)
+ return -ENODEV;
+
unregister_reboot_notifier(&reboot->reboot_notifier);
- list_for_each_entry(info, &reboot->head, list)
- kfree_const(info->mode);
+ scoped_guard(mutex, &reboot->reboot_mode_mutex) {
+ list_for_each_entry(info, &reboot->head, list)
+ kfree_const(info->mode);
+ }
+ device_unregister(reboot->reboot_mode_device);
+ reboot->reboot_mode_device = NULL;
return 0;
}
@@ -162,6 +211,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);
@@ -199,6 +249,19 @@ void devm_reboot_mode_unregister(struct device *dev,
}
EXPORT_SYMBOL_GPL(devm_reboot_mode_unregister);
+static int __init reboot_mode_init(void)
+{
+ return class_register(&reboot_mode_class);
+}
+
+static void __exit reboot_mode_exit(void)
+{
+ class_unregister(&reboot_mode_class);
+}
+
+subsys_initcall(reboot_mode_init);
+module_exit(reboot_mode_exit);
+
MODULE_AUTHOR("Andy Yan <andy.yan@rock-chips.com>");
MODULE_DESCRIPTION("System reboot mode core library");
MODULE_LICENSE("GPL v2");
diff --git a/include/linux/reboot-mode.h b/include/linux/reboot-mode.h
index 4a2abb38d1d612ec0fdf05eb18c98b210f631b7f..d7141a1a609b62bd3185642ecc1478fdd3555037 100644
--- a/include/linux/reboot-mode.h
+++ b/include/linux/reboot-mode.h
@@ -2,9 +2,15 @@
#ifndef __REBOOT_MODE_H__
#define __REBOOT_MODE_H__
+#include <linux/mutex.h>
+
struct reboot_mode_driver {
struct device *dev;
struct list_head head;
+ const char *driver_name;
+ struct device *reboot_mode_device;
+ /* protects reboot_mode list */
+ struct mutex reboot_mode_mutex;
int (*write)(struct reboot_mode_driver *reboot, unsigned int magic);
struct notifier_block reboot_notifier;
};
--
2.34.1On Mon, Dec 22, 2025 at 4:33 AM 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>
> ---
[snip]
> +
> static unsigned int get_reboot_mode_magic(struct reboot_mode_driver *reboot,
> const char *cmd)
> {
> @@ -76,6 +109,15 @@ int reboot_mode_register(struct reboot_mode_driver *reboot)
> size_t len = strlen(PREFIX);
> int ret;
>
> + reboot->reboot_mode_device = device_create(&reboot_mode_class, NULL, 0,
> + (void *)reboot, reboot->driver_name);
You should define a separate struct in this file and pass it as
drvdata as argument 4. The main reason for using device_create() was
to not have to store any data associated with the sysfs ABI in a
separate struct, not in the public one.
> + if (IS_ERR(reboot->reboot_mode_device)) {
> + ret = PTR_ERR(reboot->reboot_mode_device);
> + reboot->reboot_mode_device = NULL;
> + return ret;
> + }
> +
> + mutex_init(&reboot->reboot_mode_mutex);
Add a corresponding mutex_destroy() please.
[snip]
> +
> MODULE_AUTHOR("Andy Yan <andy.yan@rock-chips.com>");
> MODULE_DESCRIPTION("System reboot mode core library");
> MODULE_LICENSE("GPL v2");
> diff --git a/include/linux/reboot-mode.h b/include/linux/reboot-mode.h
> index 4a2abb38d1d612ec0fdf05eb18c98b210f631b7f..d7141a1a609b62bd3185642ecc1478fdd3555037 100644
> --- a/include/linux/reboot-mode.h
> +++ b/include/linux/reboot-mode.h
> @@ -2,9 +2,15 @@
> #ifndef __REBOOT_MODE_H__
> #define __REBOOT_MODE_H__
>
> +#include <linux/mutex.h>
> +
> struct reboot_mode_driver {
> struct device *dev;
> struct list_head head;
> + const char *driver_name;
I have no idea why you're storing the name here.
As I said above: you should not need to modify this structure (if
maybe for the mutex if modifications of this struct from existing code
can race with the sysfs code). Use a separate one for sysfs data.
> + struct device *reboot_mode_device;
I think you misunderstood my comment about the renaming: what I meant
was: propose to rename the existing reboot_mode_driver structure to
reboot_mode_device because this is what it is in reality.
> + /* protects reboot_mode list */
> + struct mutex reboot_mode_mutex;
> int (*write)(struct reboot_mode_driver *reboot, unsigned int magic);
> struct notifier_block reboot_notifier;
> };
>
> --
> 2.34.1
>
Bart
On 12/22/2025 10:56 PM, Bartosz Golaszewski wrote:
> On Mon, Dec 22, 2025 at 4:33 AM 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>
>> ---
>
> [snip]
>
>> +
>> static unsigned int get_reboot_mode_magic(struct reboot_mode_driver *reboot,
>> const char *cmd)
>> {
>> @@ -76,6 +109,15 @@ int reboot_mode_register(struct reboot_mode_driver *reboot)
>> size_t len = strlen(PREFIX);
>> int ret;
>>
>> + reboot->reboot_mode_device = device_create(&reboot_mode_class, NULL, 0,
>> + (void *)reboot, reboot->driver_name);
>
> You should define a separate struct in this file and pass it as
> drvdata as argument 4. The main reason for using device_create() was
> to not have to store any data associated with the sysfs ABI in a
> separate struct, not in the public one.
Currently we directly access list head in show_modes.
We want to maintain a separate struct and copy the mode strings
there after registration is complete and then set drvdata and the same
in show_modes?
>
>> + if (IS_ERR(reboot->reboot_mode_device)) {
>> + ret = PTR_ERR(reboot->reboot_mode_device);
>> + reboot->reboot_mode_device = NULL;
>> + return ret;
>> + }
>> +
>> + mutex_init(&reboot->reboot_mode_mutex);
>
> Add a corresponding mutex_destroy() please.
Ack. thanks.
>
> [snip]
>
>> +
>> MODULE_AUTHOR("Andy Yan <andy.yan@rock-chips.com>");
>> MODULE_DESCRIPTION("System reboot mode core library");
>> MODULE_LICENSE("GPL v2");
>> diff --git a/include/linux/reboot-mode.h b/include/linux/reboot-mode.h
>> index 4a2abb38d1d612ec0fdf05eb18c98b210f631b7f..d7141a1a609b62bd3185642ecc1478fdd3555037 100644
>> --- a/include/linux/reboot-mode.h
>> +++ b/include/linux/reboot-mode.h
>> @@ -2,9 +2,15 @@
>> #ifndef __REBOOT_MODE_H__
>> #define __REBOOT_MODE_H__
>>
>> +#include <linux/mutex.h>
>> +
>> struct reboot_mode_driver {
>> struct device *dev;
>> struct list_head head;
>> + const char *driver_name;
>
> I have no idea why you're storing the name here.
>
> As I said above: you should not need to modify this structure (if
> maybe for the mutex if modifications of this struct from existing code
> can race with the sysfs code). Use a separate one for sysfs data.
>
ok. If separate data for mode strings is maintained, may be we won't
need a mutex lock as-well.
>> + struct device *reboot_mode_device;
>
> I think you misunderstood my comment about the renaming: what I meant
> was: propose to rename the existing reboot_mode_driver structure to
> reboot_mode_device because this is what it is in reality.
reboot_mode_device - this is not renamed. variable name is same as in
previous version.
thanks,
Shivendra
© 2016 - 2026 Red Hat, Inc.