Changes from v3:
================
* Use blkdev_get_by_path() to "resolve" block devices
(struct block_device). With this change, there are now no changes
required to the block subsystem, so there are only 2 patches in this
series.
* link_device and unlink_device attributes now take paths to block device
special files (e.g. /dev/sda), rather than kernel names. Symbolic
links also work.
If the path written to the attribute doesn't exist (-ENOENT), we re-try
with /dev/ prepended, so "simple" names like sda will still work as long
as the corresponding special file exists in /dev.
* Fixed a bug that could cause "phantom" blinks because of old device
activity that was not recognized at the correct time.
* (Slightly) more detailed commit message for the patch that adds the
trigger code. As with v3, the real details are found in the comments
in the source file.
Changes from v2:
================
* Allow LEDs to be "linked" to partitions, as well as whole devices.
Internally, the trigger now works with block_device structs, rather
than gendisk structs.
(Investigating the lifecycle of block_device structs led me to
discover the device resource API, so ...)
* Use the device resource API to manage the trigger's per-block device
data structure (struct led_bdev_bdi). The trigger now uses a release
function to remove references to block devices that have been removed.
Because the release function is automatically called by the driver core,
there is no longer any need for the block layer to explictly call the
trigger's cleanup function.
* Since there is no need to provide a built-in "stub" cleanup function
when the trigger is built as a module, I have removed the always
built-in "core" portion of the trigger.
* Without a built-in component, the module does need access to the
block_class symbol. The second patch in this series exports the symbol
to the LEDTRIG_BLKDEV namespace and explains the reason for doing so.
* Changed the interval sysfs attribute from a device attribute to a class
attribute. It's single value that applies to all LEDs, so it didn't
make sense as a device atribute.
* As requested, I am posting the trigger code (ledtrig-blkdev.c) as a
single patch. This eliminates the commit messages that would otherwise
describe sections of the code, so I have added fairly extensive comments
to each function.
Changes from v1:
================
* Use correct address for LKML.
* Renamed the sysfs attributes used to manage and view the set of block
devices associated ("linked") with an LED.
- /sys/class/leds/<LED>/link_device to create associations
- /sys/class/leds/<LED>/unlink_device to remove associations
- /sys/class/leds/<LED>/linked_devices/ contains symlinks to all block
devices associated with the LED
- /sys/block/<DEVICE>/linked_leds (which only exists when the device is
associated with at least one LED) contains symlinks to all LEDs with
which the device is associated
link_device and unlink_device are write-only attributes, each of which
represents a single action, rather than any state. (The current state
is shown by the symbolic links in the <LED>/linked_devices/ and
<DEVICE>/linked_leds/ directories.)
* Simplified sysfs attribute store functions. link_device and
unlink_device no longer accept multiple devices at once, but this was
really just an artifact of the way that sysfs repeatedly calls the
store function when it doesn't "consume" all of its input, and it
seemed to be confusing and unpopular anyway.
* Use DEVICE_ATTR_* macros (rather than __ATTR) for the sysfs attributes.
* Removed all pr_info() "system administrator error" messages.
* Different minimum values for LED blink time (10 ms) and activity check
interval (25 ms).
v1 summary:
===========
This patch series adds a new "blkdev" LED trigger for disk (or other block
device) activity LEDs.
It has the following functionality.
* Supports all types of block devices, including virtual devices
(unlike the existing disk trigger which only works with ATA devices).
* LEDs can be configured to show read activity, write activity, or both.
* Supports multiple devices and multiple LEDs in arbitrary many-to-many
configurations. For example, it is possible to configure multiple
devices with device-specific read activity LEDs and a shared write
activity LED. (See Documentation/leds/ledtrig-blkdev.rst in the first
patch.)
* Doesn't add any overhead in the I/O path. Like the netdev LED trigger,
it periodically checks the configured devices for activity and blinks
its LEDs as appropriate.
* Blink duration (per LED) and interval between activity checks (global)
are configurable.
* Requires minimal changes to the block subsystem.
- Adds 1 pointer to struct gendisk,
- Adds (inline function) call in device_add_disk() to ensure that the
pointer is initialized to NULL (as protection against any drivers
that allocate a gendisk themselves and don't use kzalloc()), and
- Adds call in del_gendisk() to remove a device from the trigger when
that device is being removed.
These changes are all in patch #4, "block: Add block device LED trigger
integrations."
* The trigger can be mostly built as a module.
When the trigger is modular, a small portion is built in to provide a
"stub" function which can be called from del_gendisk(). The stub calls
into the modular code via a function pointer when needed. The trigger
also needs the ability to find gendisk's by name, which requires access
to the un-exported block_class and disk_type symbols.
Ian Pilcher (2):
docs: Add block device (blkdev) LED trigger documentation
leds: trigger: Add block device LED trigger
Documentation/ABI/testing/sysfs-block | 9 +
.../testing/sysfs-class-led-trigger-blkdev | 50 +
Documentation/leds/index.rst | 1 +
Documentation/leds/ledtrig-blkdev.rst | 149 +++
drivers/leds/trigger/Kconfig | 9 +
drivers/leds/trigger/Makefile | 1 +
drivers/leds/trigger/ledtrig-blkdev.c | 981 ++++++++++++++++++
7 files changed, 1200 insertions(+)
create mode 100644 Documentation/ABI/testing/sysfs-class-led-trigger-blkdev
create mode 100644 Documentation/leds/ledtrig-blkdev.rst
create mode 100644 drivers/leds/trigger/ledtrig-blkdev.c
base-commit: ff1ffd71d5f0612cf194f5705c671d6b64bf5f91
--
2.31.1
Add Documentation/ABI/testing/sysfs-class-led-trigger-blkdev to
document:
* /sys/class/leds/<led>/blink_time
* /sys/class/leds/<led>/mode
* /sys/class/leds/<led>/link_device
* /sys/class/leds/<led>/unlink_device
* /sys/class/leds/<led>/linked_devices
* /sys/class/ledtrig_blkdev/interval
Add /sys/block/<disk>/linked_leds to
Documentation/ABI/testing/sysfs-block.
Add overview in Documentation/leds/ledtrig-blkdev.rst.
Signed-off-by: Ian Pilcher <[email protected]>
---
Documentation/ABI/testing/sysfs-block | 9 ++
.../testing/sysfs-class-led-trigger-blkdev | 50 ++++++
Documentation/leds/index.rst | 1 +
Documentation/leds/ledtrig-blkdev.rst | 149 ++++++++++++++++++
4 files changed, 209 insertions(+)
create mode 100644 Documentation/ABI/testing/sysfs-class-led-trigger-blkdev
create mode 100644 Documentation/leds/ledtrig-blkdev.rst
diff --git a/Documentation/ABI/testing/sysfs-block b/Documentation/ABI/testing/sysfs-block
index a0ed87386639..80d4becc4e6d 100644
--- a/Documentation/ABI/testing/sysfs-block
+++ b/Documentation/ABI/testing/sysfs-block
@@ -328,3 +328,12 @@ Description:
does not complete in this time then the block driver timeout
handler is invoked. That timeout handler can decide to retry
the request, to fail it or to start a device recovery strategy.
+
+What: /sys/block/<disk>/linked_leds
+Date: September 2021
+Contact: Ian Pilcher <[email protected]>
+Description:
+ Directory containing links to all LEDs that are associated
+ with this block device through the blkdev LED trigger. Only
+ present when at least one LED is associated. (See
+ Documentation/leds/ledtrig-blkdev.rst.)
diff --git a/Documentation/ABI/testing/sysfs-class-led-trigger-blkdev b/Documentation/ABI/testing/sysfs-class-led-trigger-blkdev
new file mode 100644
index 000000000000..b8730d450dbf
--- /dev/null
+++ b/Documentation/ABI/testing/sysfs-class-led-trigger-blkdev
@@ -0,0 +1,50 @@
+What: /sys/class/leds/<led>/blink_time
+Date: September 2021
+Contact: Ian Pilcher <[email protected]>
+Description:
+ Time (in milliseconds) that the LED will be on during a single
+ "blink".
+
+What: /sys/class/leds/<led>/mode
+Date: September 2021
+Contact: Ian Pilcher <[email protected]>
+Description:
+ Type of events for which LED will blink - read, write,
+ or rw (both). Note that any activity that changes the state of
+ the device's non-volatile storage (including discards and cache
+ flushes) is considered to be a write.
+
+What: /sys/class/leds/<led>/link_device
+Date: September 2021
+Contact: Ian Pilcher <[email protected]>
+Description:
+ Associate a block device with this LED by writing the path to
+ the device special file (e.g. /dev/sda) to this attribute.
+ Symbolic links are followed. Optionally, the leading "/dev/"
+ may be omitted.
+
+What: /sys/class/leds/<led>/unlink_device
+Date: September 2021
+Contact: Ian Pilcher <[email protected]>
+Description:
+ Remove the association between this LED and a block device by
+ writing the path to the device special file (e.g. /dev/sda) to
+ this attribute. Symbolic links are followed. Optionally, the
+ leading "/dev/" may be omitted.
+
+What: /sys/class/leds/<led>/linked_devices
+Date: September 2021
+Contact: Ian Pilcher <[email protected]>
+Description:
+ Directory containing links to all block devices that are
+ associated with this LED. (Note that the names of the
+ symbolic links in this directory are *kernel* names, which
+ may not match the device special file paths written to
+ link_device and unlink_device.)
+
+What: /sys/class/ledtrig_blkdev/interval
+Date: September 2021
+Contact: Ian Pilcher <[email protected]>
+Description:
+ Frequency (in milliseconds) with which block devices associated
+ with the blkdev LED trigger will be checked for activity.
diff --git a/Documentation/leds/index.rst b/Documentation/leds/index.rst
index e5d63b940045..e3c24e468cbc 100644
--- a/Documentation/leds/index.rst
+++ b/Documentation/leds/index.rst
@@ -10,6 +10,7 @@ LEDs
leds-class
leds-class-flash
leds-class-multicolor
+ ledtrig-blkdev
ledtrig-oneshot
ledtrig-transient
ledtrig-usbport
diff --git a/Documentation/leds/ledtrig-blkdev.rst b/Documentation/leds/ledtrig-blkdev.rst
new file mode 100644
index 000000000000..af319125ab25
--- /dev/null
+++ b/Documentation/leds/ledtrig-blkdev.rst
@@ -0,0 +1,149 @@
+.. SPDX-License-Identifier: GPL-2.0
+
+=================================
+Block Device (blkdev) LED Trigger
+=================================
+
+Available when ``CONFIG_LEDS_TRIGGER_BLKDEV=y`` or
+``CONFIG_LEDS_TRIGGER_BLKDEV=m``.
+
+See also:
+
+* ``Documentation/ABI/testing/sysfs-class-led-trigger-blkdev``
+* ``Documentation/ABI/testing/sysfs-block`` (``/sys/block/<disk>/linked_leds``)
+
+Overview
+========
+
+.. note::
+ The examples below use ``<LED>`` to refer to the name of a
+ system-specific LED. If no suitable LED is available on a test
+ system (in a virtual machine, for example), it is possible to
+ use a userspace LED. (See ``Documentation/leds/uleds.rst``.)
+
+Verify that the ``blkdev`` LED trigger is available::
+
+ # grep blkdev /sys/class/leds/<LED>/trigger
+ ... rfkill-none blkdev
+
+(If the previous command produces no output, you may need to load the trigger
+module - ``modprobe ledtrig_blkdev``. If the module is not available, check
+the value of ``CONFIG_LEDS_TRIGGER_BLKDEV`` in your kernel configuration.)
+
+Associate the LED with the ``blkdev`` LED trigger::
+
+ # echo blkdev > /sys/class/leds/<LED>/trigger
+
+ # cat /sys/class/leds/<LED>/trigger
+ ... rfkill-none [blkdev]
+
+Note that several new device attributes are available in the
+``/sys/class/leds/<LED>`` directory.
+
+* ``link_device`` and ``unlink_device`` are used to manage the set of block
+ devices associated with this LED. The LED will blink in response to read or
+ write activity on its linked devices.
+
+* ``mode`` is used to control the type of device activity that will cause this
+ LED to blink - read activity, write activity, or both. (Note that any
+ activity that changes the state of a device's non-volatile storage is
+ considered to be a write. This includes discard and cache flush requests.)
+
+* ``blink_time`` is the duration (in milliseconds) of each blink of this LED.
+ (The minimum value is 10 milliseconds.)
+
+* The ``linked_devices`` directory will contain a symbolic link to every device
+ that is associated with this LED.
+
+Link a block device to the LED::
+
+ # echo sda > /sys/class/leds/<LED>/link_device
+
+ # ls /sys/class/leds/<LED>/linked_devices
+ sda
+
+(The value written to ``link_device`` must be the path of the device special
+file, such as ``/dev/sda``, that represents the block device - or the path of a
+symbolic link to such a device special file. The example above works because it
+is possible to omit the leading ``/dev``.)
+
+Read and write activity on the device should cause the LED to blink. The
+duration of each blink (in milliseconds) can be adjusted by setting
+``/sys/class/leds/<LED>/blink_time``. (But see **interval and blink_time**
+below.)
+
+Associate a second device with the LED::
+
+ # echo sdb > /sys/class/leds/<LED>/link_device
+
+ # ls /sys/class/leds/<LED>/linked_devices
+ sda sdb
+
+When a block device is linked to one or more LEDs, the LEDs are linked from
+the device's ``linked_leds`` directory::
+
+ # ls /sys/class/block/sd{a,b}/linked_leds
+ /sys/class/block/sda/linked_leds:
+ <LED>
+
+ /sys/class/block/sdb/linked_leds:
+ <LED>
+
+(The ``linked_leds`` directory only exists when the block device is linked to
+at least one LED.)
+
+``interval`` and ``blink_time``
+===============================
+
+* By default, linked block devices are checked for activity every 100
+ milliseconds. This frequency can be changed via the
+ ``/sys/class/ledtrig_blkdev/interval`` attribute. (The minimum value is 25
+ milliseconds.)
+
+* All associated devices are checked for activity every ``interval``
+ milliseconds, and a blink is triggered on appropriate LEDs. The duration
+ of an LED's blink is determined by its ``blink_time`` attribute. Thus
+ (assuming that activity of the relevant type has occurred on one of an LED's
+ linked devices), the LED will be on for ``blink_time`` milliseconds and off
+ for ``interval - blink_time`` milliseconds.
+
+* The LED subsystem ignores new blink requests for an LED that is already in
+ in the process of blinking, so setting a ``blink_time`` greater than or equal
+ to ``interval`` will cause some blinks to be missed.
+
+* Because of processing times, scheduling latencies, etc., avoiding missed
+ blinks actually requires a difference of at least a few milliseconds between
+ the ``blink_time`` and ``interval``. The required difference is likely to
+ vary from system to system. As a reference, a Thecus N5550 NAS requires a
+ difference of 7 milliseconds (``interval == 100``, ``blink_time == 93``).
+
+* The default values (``interval == 100``, ``blink_time == 75``) cause the LED
+ associated with a continuously active device to blink rapidly. For a more
+ "always on" effect, increase the ``blink_time`` (but not too much; see the
+ previous bullet).
+
+Other Notes
+===========
+
+* Many (possibly all) types of block devices work with this trigger, including:
+
+ * SCSI (including SATA and USB) hard disk drives and SSDs
+ * SCSI (including SATA and USB) optical drives
+ * NVMe SSDs
+ * SD cards
+ * loopback block devices (``/dev/loop*``)
+ * device mapper devices, such as LVM logical volumes
+ * MD RAID devices
+ * zRAM compressed RAM-disks
+ * partitions on block devics that support them
+
+* The names of the symbolic links in ``/sys/class/leds/<LED>/linked_devices``
+ are **kernel** names, which may not match the paths used for
+ ``link_device`` and ``unlink_device``. This is most likely when a symbolic
+ link is used to refer to the device (as is common with logical volumes), but
+ it can be true for any device, because nothing prevents the creation of
+ device special files with arbitrary names (``sudo mknod /foo b 8 0``).
+
+* The ``blkdev`` LED trigger supports many-to-many device/LED associations.
+ A device can be associated with multiple LEDs, and an LED can be associated
+ with multiple devices.
--
2.31.1
Add "blkdev" LED trigger to blink LEDs in response to block device
activity.
Add LEDS_TRIGGER_BLKDEV (tristate) config option to control building of
the trigger.
Signed-off-by: Ian Pilcher <[email protected]>
---
drivers/leds/trigger/Kconfig | 9 +
drivers/leds/trigger/Makefile | 1 +
drivers/leds/trigger/ledtrig-blkdev.c | 981 ++++++++++++++++++++++++++
3 files changed, 991 insertions(+)
create mode 100644 drivers/leds/trigger/ledtrig-blkdev.c
diff --git a/drivers/leds/trigger/Kconfig b/drivers/leds/trigger/Kconfig
index 1f1d57288085..219d15c046d7 100644
--- a/drivers/leds/trigger/Kconfig
+++ b/drivers/leds/trigger/Kconfig
@@ -153,4 +153,13 @@ config LEDS_TRIGGER_TTY
When build as a module this driver will be called ledtrig-tty.
+config LEDS_TRIGGER_BLKDEV
+ tristate "LED Trigger for block devices"
+ depends on BLOCK
+ help
+ The blkdev LED trigger allows LEDs to be controlled by block device
+ activity (reads and writes).
+
+ See Documentation/leds/ledtrig-blkdev.rst.
+
endif # LEDS_TRIGGERS
diff --git a/drivers/leds/trigger/Makefile b/drivers/leds/trigger/Makefile
index 25c4db97cdd4..d53bab5d93f1 100644
--- a/drivers/leds/trigger/Makefile
+++ b/drivers/leds/trigger/Makefile
@@ -16,3 +16,4 @@ obj-$(CONFIG_LEDS_TRIGGER_NETDEV) += ledtrig-netdev.o
obj-$(CONFIG_LEDS_TRIGGER_PATTERN) += ledtrig-pattern.o
obj-$(CONFIG_LEDS_TRIGGER_AUDIO) += ledtrig-audio.o
obj-$(CONFIG_LEDS_TRIGGER_TTY) += ledtrig-tty.o
+obj-$(CONFIG_LEDS_TRIGGER_BLKDEV) += ledtrig-blkdev.o
diff --git a/drivers/leds/trigger/ledtrig-blkdev.c b/drivers/leds/trigger/ledtrig-blkdev.c
new file mode 100644
index 000000000000..8cb0d3b1e7ed
--- /dev/null
+++ b/drivers/leds/trigger/ledtrig-blkdev.c
@@ -0,0 +1,981 @@
+// SPDX-License-Identifier: GPL-2.0-only
+
+/*
+ * Block device LED trigger
+ *
+ * Copyright 2021 Ian Pilcher <[email protected]>
+ */
+
+#include <linux/blkdev.h>
+#include <linux/leds.h>
+#include <linux/module.h>
+#include <linux/part_stat.h>
+
+/* Default blink time & check interval (milliseconds) */
+#define LED_BDEV_BLINK_MSEC 75
+#define LED_BDEV_INTERVAL 100
+
+/* Minimum blink time & check interval (milliseconds) */
+#define LED_BDEV_MIN_BLINK 10
+#define LED_BDEV_MIN_INT 25
+
+/* Device activity type that will make LED blink */
+enum led_bdev_mode {
+ LED_BDEV_MODE_RO = 0,
+ LED_BDEV_MODE_WO = 1,
+ LED_BDEV_MODE_RW = 2
+};
+
+/* Block device information (BDI) - 1 per blkdev linked to at least 1 LED */
+struct led_bdev_bdi {
+ struct block_device *bdev;
+ struct hlist_head leds;
+ unsigned long read_ios;
+ unsigned long write_ios;
+ unsigned int generation;
+ bool read_act;
+ bool write_act;
+};
+
+/* For many-to-many relationships between block devices and LEDs */
+struct led_bdev_link {
+ struct hlist_node bdi_leds_node;
+ struct hlist_node led_bdis_node;
+ struct led_bdev_bdi *bdi;
+ struct led_bdev_led *led;
+};
+
+/* Every LED associated with the blkdev trigger gets one of these */
+struct led_bdev_led {
+ struct led_classdev *led_cdev;
+ unsigned int blink_msec;
+ struct hlist_head bdis;
+ struct hlist_node leds_node;
+ enum led_bdev_mode mode;
+};
+
+/* Forward declarations to make this file compile in a reasonable order */
+static void led_bdev_process(struct work_struct *work);
+static struct led_bdev_bdi *led_bdev_get_bdi(const char *buf, size_t size);
+static struct block_device *led_bdev_get(const char *buf, size_t size,
+ fmode_t mode);
+static int led_bdev_link(struct led_bdev_led *led, struct led_bdev_bdi *bdi);
+static void led_bdev_put_bdi(struct led_bdev_bdi *bdi);
+static void led_bdev_bdi_release(struct device *dev, void *res);
+static void led_bdev_unlink(struct led_bdev_led *led,
+ struct led_bdev_link *link,
+ struct led_bdev_bdi *bdi, bool releasing);
+static void led_bdev_update_bdi(struct led_bdev_bdi *bdi);
+static bool led_bdev_blink(const struct led_bdev_led *led,
+ const struct led_bdev_bdi *bdi);
+
+/* Protects everything except atomic sysfs attributes */
+static DEFINE_MUTEX(led_bdev_mutex);
+
+/* All LEDs associated with the trigger */
+static HLIST_HEAD(led_bdev_leds);
+
+/* sysfs class for "global" trigger attributes (interval) */
+static struct class *led_bdev_class;
+
+/* Delayed work to periodically check for activity & blink LEDs */
+static DECLARE_DELAYED_WORK(led_bdev_work, led_bdev_process);
+
+/* How often to run the delayed work - in jiffies */
+static unsigned int led_bdev_interval;
+
+/* Incremented every time the delayed work runs */
+static unsigned int led_bdev_generation;
+
+/* Total number of device-to-LED associations (links) */
+static unsigned int led_bdev_link_count;
+
+/* Empty attribute list for the linked_leds & linked_devices "groups" */
+static struct attribute *led_bdev_attrs_empty[] = { NULL };
+
+/* linked_leds sysfs directory for block devs linked to 1 or more LEDs */
+static const struct attribute_group led_bdev_linked_leds = {
+ .name = "linked_leds",
+ .attrs = led_bdev_attrs_empty,
+};
+
+/* linked_devices sysfs directory for each LED associated with the trigger */
+static const struct attribute_group led_bdev_linked_devs = {
+ .name = "linked_devices",
+ .attrs = led_bdev_attrs_empty,
+};
+
+/**
+ * led_bdev_activate() - Called when an LED is associated with the trigger.
+ * @led_cdev: The LED
+ *
+ * Allocates & initializes the @led_bdev_led structure, adds it to the
+ * @led_bdev_leds list, and sets the LED's trigger data.
+ *
+ * Context: Process context. Takes and releases @led_bdev_mutex.
+ * Return: ``0`` on success, ``-errno`` on error.
+ */
+static int led_bdev_activate(struct led_classdev *const led_cdev)
+{
+ struct led_bdev_led *led;
+ int ret;
+
+ led = kmalloc(sizeof(*led), GFP_KERNEL);
+ if (led == NULL) {
+ ret = -ENOMEM;
+ goto exit_return;
+ }
+
+ led->led_cdev = led_cdev;
+ led->blink_msec = LED_BDEV_BLINK_MSEC;
+ led->mode = LED_BDEV_MODE_RW;
+ INIT_HLIST_HEAD(&led->bdis);
+
+ ret = mutex_lock_interruptible(&led_bdev_mutex);
+ if (ret != 0)
+ goto exit_free;
+
+ hlist_add_head(&led->leds_node, &led_bdev_leds);
+ led_set_trigger_data(led_cdev, led);
+
+ mutex_unlock(&led_bdev_mutex);
+
+exit_free:
+ if (ret != 0)
+ kfree(led);
+exit_return:
+ return ret;
+}
+
+/**
+ * link_device_store() - ``link_device`` device attribute store function.
+ * @dev: The LED device
+ * @attr: The ``link_device`` attribute (@dev_attr_link_device)
+ * @buf: The value written to the attribute, which should be the path to
+ * the special file that represents the block device to be linked
+ * to the LED (e.g. /dev/sda)
+ * @count: The number of characters in @buf
+ *
+ * Calls led_bdev_get_bdi() to find or create the BDI for the block device,
+ * checks that the device isn't already linked to this LED, and calls
+ * led_bdev_link() to create the link.
+ *
+ * Context: Process context. Takes and releases @led_bdev_mutex.
+ * Return: @count on success, ``-errno`` on error.
+ */
+static ssize_t link_device_store(struct device *const dev,
+ struct device_attribute *const attr,
+ const char *const buf, const size_t count)
+{
+ struct led_bdev_led *const led = led_trigger_get_drvdata(dev);
+ const struct led_bdev_link *link;
+ struct led_bdev_bdi *bdi;
+ int ret;
+
+ ret = mutex_lock_interruptible(&led_bdev_mutex);
+ if (ret != 0)
+ goto exit_return;
+
+ bdi = led_bdev_get_bdi(buf, count);
+ if (IS_ERR(bdi)) {
+ ret = PTR_ERR(bdi);
+ goto exit_unlock;
+ }
+
+ hlist_for_each_entry (link, &bdi->leds, bdi_leds_node) {
+ if (link->led == led) {
+ ret = -EEXIST;
+ goto exit_put_bdi;
+ }
+ }
+
+ ret = led_bdev_link(led, bdi);
+
+exit_put_bdi:
+ if (ret != 0)
+ led_bdev_put_bdi(bdi);
+exit_unlock:
+ mutex_unlock(&led_bdev_mutex);
+exit_return:
+ return (ret == 0) ? count : ret;
+}
+
+/**
+ * led_bdev_get_bdi() - Find or create the BDI for a block device.
+ * @buf: The value written to the ``link_device`` attribute, which should
+ * be the path to a special file that represents a block device
+ * @count: The number of characters in @buf
+ *
+ * Calls led_bdev_get() to get the block device represented by the path in @buf.
+ * If the device already has a BDI (because it is already linked to an LED),
+ * simply returns the existing BDI.
+ *
+ * Otherwise, allocates a new BDI (as a device resource), creates the block
+ * device's ``linked_leds`` directory (attribute group), calls
+ * led_bdev_update_bdi() to set the BDI's activity counters, and adds the BDI
+ * resource to the block device.
+ *
+ * Context: Process context. Caller must hold @led_bdev_mutex.
+ * Return: Pointer to the BDI, error pointer on error.
+ */
+static struct led_bdev_bdi *led_bdev_get_bdi(const char *const buf,
+ const size_t count)
+{
+ struct block_device *bdev;
+ struct led_bdev_bdi *bdi;
+ struct device *dev;
+ int ret;
+
+ bdev = led_bdev_get(buf, count, 0);
+ if (IS_ERR(bdev)) {
+ ret = PTR_ERR(bdev);
+ goto exit_return;
+ }
+
+ dev = &bdev->bd_device;
+
+ bdi = devres_find(dev, led_bdev_bdi_release, NULL, NULL);
+ if (bdi != NULL) {
+ ret = 0;
+ goto exit_put_bdev;
+ }
+
+ bdi = devres_alloc(led_bdev_bdi_release, sizeof(*bdi), GFP_KERNEL);
+ if (bdi == NULL) {
+ ret = -ENOMEM;
+ goto exit_put_bdev;
+ }
+
+ ret = sysfs_create_group(&dev->kobj, &led_bdev_linked_leds);
+ if (ret != 0)
+ goto exit_free_bdi;
+
+ bdi->bdev = bdev;
+ INIT_HLIST_HEAD(&bdi->leds);
+
+ /* Ensure that led_bdev_update_bdi() updates BDI */
+ bdi->generation = led_bdev_generation - 1;
+ led_bdev_update_bdi(bdi);
+ /* Don't blink for activity that may have happened long ago */
+ bdi->read_act = false;
+ bdi->write_act = false;
+
+ devres_add(dev, bdi);
+
+exit_free_bdi:
+ if (ret != 0)
+ devres_free(bdi);
+exit_put_bdev:
+ blkdev_put(bdev, 0); /* Allow the device to be released */
+exit_return:
+ return (ret == 0) ? bdi : ERR_PTR(ret);
+}
+
+/**
+ * led_bdev_update_bdi() - Update a BDI's activity counters for the current
+ * generation
+ * @bdi: The BDI
+ *
+ * Does nothing if the BDI has already been updated during this generation.
+ *
+ * Otherwise, updates the BDI's activity counters (@read_ios & @write_ios) and
+ * @generation, and sets @read_act and/or @write_act if the corresponding
+ * counters have changed.
+ *
+ * Context: Process context. Caller must hold @led_bdev_mutex.
+ */
+static void led_bdev_update_bdi(struct led_bdev_bdi *const bdi)
+{
+ unsigned long read_ios, write_ios;
+
+ if (bdi->generation != led_bdev_generation) {
+
+ read_ios = part_stat_read(bdi->bdev, ios[STAT_READ]);
+
+ write_ios = part_stat_read(bdi->bdev, ios[STAT_WRITE])
+ + part_stat_read(bdi->bdev, ios[STAT_DISCARD])
+ + part_stat_read(bdi->bdev, ios[STAT_FLUSH]);
+
+ if (bdi->read_ios != read_ios) {
+ bdi->read_act = true;
+ bdi->read_ios = read_ios;
+ } else {
+ bdi->read_act = false;
+ }
+
+ if (bdi->write_ios != write_ios) {
+ bdi->write_act = true;
+ bdi->write_ios = write_ios;
+ } else {
+ bdi->write_act = false;
+ }
+
+ bdi->generation = led_bdev_generation;
+ }
+}
+
+/**
+ * led_bdev_get_bdev() - Get a block device by path, prepending "/dev/" if
+ * needed.
+ * @buf: The value written to the ``link_device`` or ``unlink_device``
+ * attribute, which should be the path to a special file that
+ * represents a block device
+ * @count: The number of characters in @buf (not including its terminating
+ * null)
+ *
+ * This function is a wrapper around blkdev_get_by_path(). It first tries the
+ * path that was written to the sysfs attribute (after removing trailing
+ * whitespace). If the first attempt returns -ENOENT, it tries again with
+ * "/dev/" prepended to the path.
+ *
+ * The caller must call blkdev_put() when finished with the device.
+ *
+ * Context: Process context.
+ * Return: The block device, or an error pointer.
+ */
+static struct block_device *led_bdev_get(const char *const buf,
+ const size_t count, fmode_t mode)
+{
+ static const char dev[] = "/dev/";
+ struct block_device *bdev;
+ char *dev_path, *path;
+
+ /* sizeof(dev) includes terminating null */
+ dev_path = kmalloc(sizeof(dev) + count, GFP_KERNEL);
+ if (dev_path == NULL)
+ return ERR_PTR(-ENOMEM);
+
+ /* sizeof(dev) - 1 is compile-time equivalent of strlen(dev) */
+ memcpy(dev_path, dev, sizeof(dev) - 1);
+ path = dev_path + sizeof(dev) - 1;
+ memcpy(path, buf, count + 1); /* include terminating null */
+ strim(path);
+
+try_blkdev_get:
+ bdev = blkdev_get_by_path(path, mode, THIS_MODULE);
+ if (IS_ERR(bdev) && PTR_ERR(bdev) == -ENOENT && path != dev_path) {
+ path = dev_path;
+ goto try_blkdev_get;
+ }
+
+ kfree(dev_path);
+ return bdev;
+}
+
+/**
+ * led_bdev_link() - "Link" a block device to an LED.
+ * @led: The LED
+ * @bdi: The block device
+ *
+ * Called from link_device_store() to create the link between an LED and a
+ * block device.
+ *
+ * * Allocates & initializes link structure.
+ * * Adds block device symlink to LED's ``linked_devices`` directory.
+ * * Adds LED symlink to block devices's ``linked_leds`` directory.
+ * * Adds link to LED's list of block devices and device's list of LEDs.
+ *
+ * If the new link is the only one (i.e. no other block device/LED links
+ * already exist), schedule delayed work to periodically check for block
+ * device activity and blink LEDs.
+ *
+ * Context: Process context. Caller must hold @led_bdev_mutex.
+ * Return: 0 on success, ``-errno`` on error.
+ */
+static int led_bdev_link(struct led_bdev_led *const led,
+ struct led_bdev_bdi *const bdi)
+{
+ struct led_bdev_link *link;
+ unsigned long delay;
+ int ret;
+
+ link = kmalloc(sizeof(*link), GFP_KERNEL);
+ if (link == NULL) {
+ ret = -ENOMEM;
+ goto error_return;
+ }
+
+ /* /sys/class/block/<bdev>/linked_leds/<led> */
+ ret = sysfs_add_link_to_group(bdev_kobj(bdi->bdev),
+ led_bdev_linked_leds.name,
+ &led->led_cdev->dev->kobj,
+ led->led_cdev->name);
+ if (ret != 0)
+ goto error_free_link;
+
+ /* /sys/class/leds/<led>/linked_devices/<bdev> */
+ ret = sysfs_add_link_to_group(&led->led_cdev->dev->kobj,
+ led_bdev_linked_devs.name,
+ bdev_kobj(bdi->bdev),
+ dev_name(&bdi->bdev->bd_device));
+ if (ret != 0)
+ goto error_remove_symlink;
+
+ link->bdi = bdi;
+ link->led = led;
+ hlist_add_head(&link->led_bdis_node, &led->bdis);
+ hlist_add_head(&link->bdi_leds_node, &bdi->leds);
+
+ if (led_bdev_link_count == 0) {
+ delay = READ_ONCE(led_bdev_interval);
+ WARN_ON(!schedule_delayed_work(&led_bdev_work, delay));
+ }
+
+ ++led_bdev_link_count;
+
+ return 0;
+
+error_remove_symlink:
+ sysfs_remove_link_from_group(bdev_kobj(bdi->bdev),
+ led_bdev_linked_leds.name,
+ led->led_cdev->name);
+error_free_link:
+ kfree(link);
+error_return:
+ return ret;
+}
+
+/**
+ * unlink_device_store() - ``unlink_device`` device attribute store function.
+ * @dev: The LED device
+ * @attr: The ``unlink_device`` attribute (@dev_attr_unlink_device)
+ * @buf: The value written to the attribute, which should be the path to
+ * the special file that represents the block device to be unlinked
+ * from the LED (e.g. /dev/sda)
+ * @count: The number of characters in @buf
+ *
+ * Block device name is written to the attribute to "unlink" the block device
+ * from the LED. I.e. the LED will no longer blink to show activity on that
+ * block device.
+ *
+ * Calls led_bdev_get() to get the block device represented by the path in @buf.
+ * If the device has a BDI, searches the BDI's list of LEDs for a link to this
+ * LED and (if found) calls led_bdev_unlink() to destroy the link.
+ *
+ * Context: Process context. Takes and releases @led_bdev_mutex.
+ * Return: @count on success, ``-errno`` on error.
+ */
+static ssize_t unlink_device_store(struct device *const dev,
+ struct device_attribute *const attr,
+ const char *buf, const size_t count)
+{
+ struct led_bdev_led *const led = led_trigger_get_drvdata(dev);
+ struct block_device *bdev;
+ struct led_bdev_bdi *bdi;
+ struct led_bdev_link *link;
+ int ret;
+
+ bdev = led_bdev_get(buf, count, 0);
+ if (IS_ERR(bdev)) {
+ ret = PTR_ERR(bdev);
+ goto exit_return;
+ }
+
+ bdi = devres_find(&bdev->bd_device, led_bdev_bdi_release, NULL, NULL);
+ if (bdi == NULL) {
+ ret = -EUNATCH;
+ goto exit_put_bdev;
+ }
+
+ ret = mutex_lock_interruptible(&led_bdev_mutex);
+ if (ret != 0)
+ goto exit_put_bdev;
+
+ hlist_for_each_entry(link, &bdi->leds, bdi_leds_node) {
+
+ if (link->led == led) {
+ led_bdev_unlink(led, link, bdi, false);
+ goto exit_unlock;
+ }
+ }
+
+ ret = -EUNATCH;
+
+exit_unlock:
+ mutex_unlock(&led_bdev_mutex);
+exit_put_bdev:
+ blkdev_put(bdev, 0);
+exit_return:
+ return (ret == 0) ? count : ret;
+}
+
+/**
+ * led_bdev_unlink() - "Unlink" a block device from an LED.
+ * @led: The LED
+ * @link: The existing link between the LED and the block device
+ * @bdi: The block device
+ * @releasing: Indicates whether the BDI is being released (because the
+ * block device has been removed)
+ *
+ * Removes and frees the link between an LED and a block device.
+ *
+ * * Removes the link from the LED's list of block devices and the
+ * device's list of LEDs.
+ * * Frees the link structure.
+ * * Removes the block device symlink from the LED's ``linked_devices``
+ * directory.
+ *
+ * If the block device is **not** being released:
+ *
+ * * Removes the LED symlink from the block device's ``linked_leds``
+ * directory.
+ * * Calls led_bdev_put_bdi() to clean up the BDI, if required.
+ *
+ * If the removed link was the only one (i.e. there are no existing block
+ * device/LED links after its removal), cancels the periodic delayed work
+ * which checks for device activity.
+ *
+ * This function is called from multiple locations.
+ *
+ * * unlink_device_store() calls this function (with @releasing == ``false``)
+ * when a block device is unlinked from an LED via the ``unlink_device``
+ * sysfs attribute.
+ * * led_bdev_deactivate() calls this function (with @releasing == ``false``)
+ * for each block device linked to an LED that is being deactivated
+ * (disassociated from the trigger).
+ * * led_bdev_bdi_release() calls this function (with @releasing == ``true``)
+ * for each LED link to a block device that has been removed from the
+ * system.
+ *
+ * Context: Process context. Caller must hold @led_bdev_mutex.
+ */
+static void led_bdev_unlink(struct led_bdev_led *const led,
+ struct led_bdev_link *const link,
+ struct led_bdev_bdi *const bdi,
+ const bool releasing)
+{
+ --led_bdev_link_count;
+
+ if (led_bdev_link_count == 0)
+ WARN_ON(!cancel_delayed_work_sync(&led_bdev_work));
+
+ hlist_del(&link->led_bdis_node);
+ hlist_del(&link->bdi_leds_node);
+ kfree(link);
+
+ /* /sys/class/leds/<led>/linked_devices/<bdev> */
+ sysfs_remove_link_from_group(&led->led_cdev->dev->kobj,
+ led_bdev_linked_devs.name,
+ dev_name(&bdi->bdev->bd_device));
+
+ /*
+ * If the BDI is being released, the device's attribute groups have
+ * already been removed, and the BDI will be freed automatically.
+ */
+ if (!releasing) {
+
+ /* /sys/class/block/<bdev>/linked_leds/<led> */
+ sysfs_remove_link_from_group(bdev_kobj(bdi->bdev),
+ led_bdev_linked_leds.name,
+ led->led_cdev->name);
+ led_bdev_put_bdi(bdi);
+ }
+}
+
+/**
+ * led_bdev_put_bdi() - Remove and free a BDI, if it is no longer needed.
+ * @bdi: The BDI
+ *
+ * Does nothing if the BDI (block device) is still linked to at least one LED.
+ *
+ * If the BDI is no longer linked to any LEDs, removes the block device's
+ * ``linked_leds`` directory (attribute group), removes the BDI from the
+ * block device's resource list, and frees the BDI.
+ *
+ * Called from led_bdev_unlink() (and in the link_device_store() error path).
+ *
+ * Context: Process context. Caller must hold @led_bdev_mutex.
+ */
+static void led_bdev_put_bdi(struct led_bdev_bdi *const bdi)
+{
+ struct block_device *const bdev = bdi->bdev;
+ int ret;
+
+ if (hlist_empty(&bdi->leds)) {
+
+ sysfs_remove_group(bdev_kobj(bdev), &led_bdev_linked_leds);
+ ret = devres_destroy(&bdev->bd_device, led_bdev_bdi_release,
+ NULL, NULL);
+ WARN_ON(ret != 0);
+ }
+}
+
+/**
+ * led_bdev_deactivate() - Called when an LED is disassociated from the
+ * trigger.
+ * @led_cdev: The LED
+ *
+ * Calls led_bdev_unlink() for each block device linked to the LED, removes
+ * the LED from the @led_bdev_leds list, and frees the @led_bdev_led structure.
+ *
+ * Context: Process context. Takes and releases @led_bdev_mutex.
+ */
+static void led_bdev_deactivate(struct led_classdev *const led_cdev)
+{
+ struct led_bdev_led *const led = led_get_trigger_data(led_cdev);
+ struct led_bdev_link *link;
+ struct hlist_node *next;
+
+ mutex_lock(&led_bdev_mutex);
+
+ hlist_for_each_entry_safe (link, next, &led->bdis, led_bdis_node)
+ led_bdev_unlink(led, link, link->bdi, false);
+
+ hlist_del(&led->leds_node);
+ kfree(led);
+
+ mutex_unlock(&led_bdev_mutex);
+}
+
+/**
+ * led_bdev_bdi_release() - BDI device resource release function.
+ * @dev: The block device
+ * @res: The BDI
+ *
+ * Called by the driver core when a block device with a BDI is removed from the
+ * system. Calls led_bdev_unlink() for each LED linked to the block device.
+ *
+ * Context: Process context. Takes and releases @led_bdev_mutex.
+ */
+static void led_bdev_bdi_release(struct device *const dev, void *const res)
+{
+ struct led_bdev_bdi *const bdi = res;
+ struct led_bdev_link *link;
+ struct hlist_node *next;
+
+ mutex_lock(&led_bdev_mutex);
+
+ hlist_for_each_entry_safe (link, next, &bdi->leds, bdi_leds_node)
+ led_bdev_unlink(link->led, link, bdi, true);
+
+ mutex_unlock(&led_bdev_mutex);
+}
+
+/**
+ * led_bdev_process() - Check linked devices for activity and blink LEDs.
+ * @work: Delayed work (@led_bdev_work)
+ *
+ * Iterates through block devices linked to LEDs and calls led_bdev_update_bdi()
+ * to update the BDI's activity counters. If a particular LED hasn't already
+ * been blinked, calls led_bdev_blink() to blink the LED if appropriate for that
+ * device's activity.
+ *
+ * When finished, schedules itself to run again after @led_bdev_interval
+ * jiffies.
+ *
+ * Context: Process context. Takes and releases @led_bdev_mutex.
+ */
+static void led_bdev_process(struct work_struct *const work)
+{
+ struct led_bdev_led *led;
+ struct led_bdev_link *link;
+ unsigned long delay;
+
+ if (!mutex_trylock(&led_bdev_mutex))
+ goto exit_reschedule;
+
+ hlist_for_each_entry (led, &led_bdev_leds, leds_node) {
+
+ bool blinked = false;
+
+ hlist_for_each_entry (link, &led->bdis, led_bdis_node) {
+
+ led_bdev_update_bdi(link->bdi);
+ if (!blinked)
+ blinked = led_bdev_blink(led, link->bdi);
+ }
+ }
+
+ ++led_bdev_generation;
+
+ mutex_unlock(&led_bdev_mutex);
+
+exit_reschedule:
+ delay = READ_ONCE(led_bdev_interval);
+ WARN_ON_ONCE(!schedule_delayed_work(&led_bdev_work, delay));
+}
+
+/**
+ * led_bdev_blink() - Blink an LED, if the correct type of activity has occurred
+ * on the block device.
+ * @led: The LED
+ * @bdi: The block device
+ *
+ * Context: Process context. Caller must hold @led_bdev_mutex.
+ * Return: ``true`` if the LED is blinked, ``false`` if not.
+ */
+static bool led_bdev_blink(const struct led_bdev_led *const led,
+ const struct led_bdev_bdi *const bdi)
+{
+ unsigned long delay_on, delay_off;
+
+ if ((bdi->read_act && led->mode != LED_BDEV_MODE_WO)
+ || (bdi->write_act && led->mode != LED_BDEV_MODE_RO)) {
+
+ delay_on = READ_ONCE(led->blink_msec);
+ delay_off = 1; /* 0 leaves LED turned on */
+
+ led_blink_set_oneshot(led->led_cdev, &delay_on, &delay_off, 0);
+ return true;
+ }
+
+ return false;
+}
+
+/**
+ * blink_time_show() - ``blink_time`` device attribute show function.
+ * @dev: The LED device
+ * @attr: The ``blink_time`` attribute (@dev_attr_blink_time)
+ * @buf: Output buffer
+ *
+ * Writes the current value of the LED's @blink_msec to @buf.
+ *
+ * Context: Process context.
+ * Return: The number of characters written to @buf.
+ */
+static ssize_t blink_time_show(struct device *const dev,
+ struct device_attribute *const attr,
+ char *const buf)
+{
+ const struct led_bdev_led *const led = led_trigger_get_drvdata(dev);
+
+ return sprintf(buf, "%u\n", READ_ONCE(led->blink_msec));
+}
+
+/**
+ * blink_time_store() - ``blink_time`` device attribute store function.
+ * @dev: The LED device
+ * @attr: The ``blink_time`` attribute (@dev_attr_blink_time)
+ * @buf: The new value (as written to the sysfs attribute)
+ * @count: The number of characters in @buf
+ *
+ * Sets the LED's @blink_msec (the duration in milliseconds of one blink).
+ *
+ * Context: Process context.
+ * Return: @count on success, ``-errno`` on error.
+ */
+static ssize_t blink_time_store(struct device *const dev,
+ struct device_attribute *const attr,
+ const char *const buf, const size_t count)
+{
+ struct led_bdev_led *const led = led_trigger_get_drvdata(dev);
+ unsigned int value;
+ int ret;
+
+ ret = kstrtouint(buf, 0, &value);
+ if (ret != 0)
+ return ret;
+
+ if (value < LED_BDEV_MIN_BLINK)
+ return -ERANGE;
+
+ WRITE_ONCE(led->blink_msec, value);
+ return count;
+}
+
+/* Data for mode_show() & mode_store() */
+static const struct {
+ char name[sizeof("write")]; /* longest name */
+ char show[sizeof("[read] write rw\n")]; /* all the same size */
+} led_bdev_modes[] = {
+ [LED_BDEV_MODE_RO] = {
+ .name = "read",
+ .show = "[read] write rw\n",
+ },
+ [LED_BDEV_MODE_WO] = {
+ .name = "write",
+ .show = "read [write] rw\n",
+ },
+ [LED_BDEV_MODE_RW] = {
+ .name = "rw",
+ .show = "read write [rw]\n",
+ },
+};
+
+/**
+ * mode_show() - ``mode`` device attribute show function.
+ * @dev: The LED device
+ * @attr: The ``mode`` attribute (@dev_attr_mode)
+ * @buf: Output buffer
+ *
+ * Writes the current value of the LED's @mode to @buf.
+ *
+ * Context: Process context.
+ * Return: The number of characters written to @buf.
+ */
+static ssize_t mode_show(struct device *const dev,
+ struct device_attribute *const attr, char *const buf)
+{
+ const struct led_bdev_led *const led = led_trigger_get_drvdata(dev);
+
+ return sprintf(buf, led_bdev_modes[READ_ONCE(led->mode)].show);
+}
+
+/**
+ * mode_store() - ``mode`` device attribute store function.
+ * @dev: The LED device
+ * @attr: The ``mode`` attribute (@dev_attr_mode)
+ * @buf: The new value (as written to the sysfs attribute)
+ * @count: The number of characters in @buf
+ *
+ * Sets the LED's @mode (``read``, ``write``, or ``rw``).
+ *
+ * Context: Process context.
+ * Return: @count on success, ``-errno`` on error.
+ */
+static ssize_t mode_store(struct device *const dev,
+ struct device_attribute *const attr,
+ const char *const buf, const size_t count)
+{
+ struct led_bdev_led *const led = led_trigger_get_drvdata(dev);
+ enum led_bdev_mode mode;
+
+ for (mode = LED_BDEV_MODE_RO; mode <= LED_BDEV_MODE_RW; ++mode) {
+
+ if (sysfs_streq(led_bdev_modes[mode].name, buf)) {
+ WRITE_ONCE(led->mode, mode);
+ return count;
+ }
+ }
+
+ return -EINVAL;
+}
+
+/**
+ * interval_show() - ``interval`` class attribute show function.
+ * @class: The ``ledtrig_blkdev`` class (@led_bdev_class)
+ * @attr: The ``interval`` attribute (@class_attr_interval)
+ * @buf: Output buffer
+ *
+ * Writes the current value of @led_bdev_interval to @buf.
+ *
+ * Context: Process context.
+ * Return: The number of characters written to @buf.
+ */
+static ssize_t interval_show(struct class *const class,
+ struct class_attribute *const attr,
+ char *const buf)
+{
+ return sprintf(buf, "%u\n",
+ jiffies_to_msecs(READ_ONCE(led_bdev_interval)));
+}
+
+/**
+ * interval_store() - ``interval`` class attribute store function
+ * @class: The ``ledtrig_blkdev`` class (@led_bdev_class)
+ * @attr: The ``interval`` attribute (@class_attr_interval)
+ * @buf: The new value (as written to the sysfs attribute)
+ * @count: The number of characters in @buf
+ *
+ * Sets @led_bdev_interval (after converting to jiffies).
+ *
+ * Context: Process context.
+ * Return: @count on success, ``-errno`` on error.
+ */
+static ssize_t interval_store(struct class *const class,
+ struct class_attribute *const attr,
+ const char *const buf, const size_t count)
+{
+ unsigned int value;
+ int ret;
+
+ ret = kstrtouint(buf, 0, &value);
+ if (ret != 0)
+ return ret;
+
+ if (value < LED_BDEV_MIN_INT)
+ return -ERANGE;
+
+ WRITE_ONCE(led_bdev_interval, msecs_to_jiffies(value));
+
+ return count;
+}
+
+/* Device and class attributes */
+static DEVICE_ATTR_WO(link_device);
+static DEVICE_ATTR_WO(unlink_device);
+static DEVICE_ATTR_RW(blink_time);
+static DEVICE_ATTR_RW(mode);
+static CLASS_ATTR_RW(interval);
+
+/* Device attributes in LED directory (/sys/class/leds/<led>/...) */
+static struct attribute *led_bdev_attrs[] = {
+ &dev_attr_link_device.attr,
+ &dev_attr_unlink_device.attr,
+ &dev_attr_blink_time.attr,
+ &dev_attr_mode.attr,
+ NULL
+};
+
+/* Unnamed attribute group == no subdirectory */
+static const struct attribute_group led_bdev_attr_group = {
+ .attrs = led_bdev_attrs,
+};
+
+/* Attribute groups for the trigger */
+static const struct attribute_group *led_bdev_attr_groups[] = {
+ &led_bdev_attr_group, /* /sys/class/leds/<led>/... */
+ &led_bdev_linked_devs, /* /sys/class/leds/<led>/linked_devices/ */
+ NULL
+};
+
+/* Trigger registration data */
+static struct led_trigger led_bdev_trigger = {
+ .name = "blkdev",
+ .activate = led_bdev_activate,
+ .deactivate = led_bdev_deactivate,
+ .groups = led_bdev_attr_groups,
+};
+
+/**
+ * led_bdev_init() - Block device LED trigger initialization.
+ *
+ * Converts default @led_bdev_interval from milliseconds to jiffies, creates
+ * the ``/sys/class/ledtrig_blkdev/interval`` attribute, and registers the LED
+ * trigger.
+ *
+ * Return: 0 on success, ``-errno`` on failure.
+ */
+static int __init led_bdev_init(void)
+{
+ int ret;
+
+ WRITE_ONCE(led_bdev_interval,
+ msecs_to_jiffies(LED_BDEV_INTERVAL));
+
+ led_bdev_class = class_create(THIS_MODULE, "ledtrig_blkdev");
+ if (IS_ERR(led_bdev_class)) {
+ ret = PTR_ERR(led_bdev_class);
+ goto exit_return;
+ }
+
+ ret = class_create_file(led_bdev_class, &class_attr_interval);
+ if (ret != 0)
+ goto exit_destroy_class;
+
+ ret = led_trigger_register(&led_bdev_trigger);
+
+exit_destroy_class:
+ if (ret != 0)
+ class_destroy(led_bdev_class); /* removes the attribute file */
+exit_return:
+ return ret;
+}
+module_init(led_bdev_init);
+
+/**
+ * led_bdev_exit() - Block device LED trigger module exit.
+ *
+ * Unregisters the LED trigger and removes the
+ * ``/sys/class/ledtrig_blkdev/interval`` attribute.
+ */
+static void __exit led_bdev_exit(void)
+{
+ led_trigger_unregister(&led_bdev_trigger);
+ class_destroy(led_bdev_class);
+}
+module_exit(led_bdev_exit);
+
+MODULE_DESCRIPTION("Block device LED trigger");
+MODULE_AUTHOR("Ian Pilcher <[email protected]>");
+MODULE_LICENSE("GPL v2");
--
2.31.1
On Thu, Sep 16, 2021 at 03:21:26PM -0500, Ian Pilcher wrote:
> +What: /sys/class/leds/<led>/link_device
> +Date: September 2021
> +Contact: Ian Pilcher <[email protected]>
> +Description:
> + Associate a block device with this LED by writing the path to
> + the device special file (e.g. /dev/sda) to this attribute.
> + Symbolic links are followed. Optionally, the leading "/dev/"
> + may be omitted.
No, please don't follow symlinks, stick with kernel names here,
otherwise you have a mismatch between that and the list of devices in
this file:
> +What: /sys/class/leds/<led>/linked_devices
thanks,
greg k-h
On Thu, Sep 16, 2021 at 03:21:27PM -0500, Ian Pilcher wrote:
> +/* Block device information (BDI) - 1 per blkdev linked to at least 1 LED */
> +struct led_bdev_bdi {
It might be a good idea to pick a differene name. BDI is a commonly
used shortcut for the backing device information used all over the block
layer and writeback code.
> +/* For many-to-many relationships between block devices and LEDs */
> +struct led_bdev_link {
> + struct hlist_node bdi_leds_node;
> + struct hlist_node led_bdis_node;
> + struct led_bdev_bdi *bdi;
> + struct led_bdev_led *led;
> +};
Why not just use a xarray to link them which due to the non-invasive
nature gets you n:m links "for free".
> +/* Forward declarations to make this file compile in a reasonable order */
> +static void led_bdev_process(struct work_struct *work);
> +static struct led_bdev_bdi *led_bdev_get_bdi(const char *buf, size_t size);
> +static struct block_device *led_bdev_get(const char *buf, size_t size,
> + fmode_t mode);
> +static int led_bdev_link(struct led_bdev_led *led, struct led_bdev_bdi *bdi);
> +static void led_bdev_put_bdi(struct led_bdev_bdi *bdi);
> +static void led_bdev_bdi_release(struct device *dev, void *res);
> +static void led_bdev_unlink(struct led_bdev_led *led,
> + struct led_bdev_link *link,
> + struct led_bdev_bdi *bdi, bool releasing);
> +static void led_bdev_update_bdi(struct led_bdev_bdi *bdi);
> +static bool led_bdev_blink(const struct led_bdev_led *led,
> + const struct led_bdev_bdi *bdi);
I seriously question the "reasonable" above if you need that many
forward declarations in brand new code.
> +static struct block_device *led_bdev_get(const char *const buf,
> + const size_t count, fmode_t mode)
> +{
> + static const char dev[] = "/dev/";
> + struct block_device *bdev;
> + char *dev_path, *path;
> +
> + /* sizeof(dev) includes terminating null */
> + dev_path = kmalloc(sizeof(dev) + count, GFP_KERNEL);
> + if (dev_path == NULL)
> + return ERR_PTR(-ENOMEM);
> +
> + /* sizeof(dev) - 1 is compile-time equivalent of strlen(dev) */
> + memcpy(dev_path, dev, sizeof(dev) - 1);
> + path = dev_path + sizeof(dev) - 1;
> + memcpy(path, buf, count + 1); /* include terminating null */
> + strim(path);
> +
> +try_blkdev_get:
> + bdev = blkdev_get_by_path(path, mode, THIS_MODULE);
> + if (IS_ERR(bdev) && PTR_ERR(bdev) == -ENOENT && path != dev_path) {
> + path = dev_path;
> + goto try_blkdev_get;
> + }
> +
> + kfree(dev_path);
> + return bdev;
Please just required the user to put in the whole path and remove all
this garbage. There is no need to build your own broken wrappers around
the VFS path resolution.
Combining 2 related threads ...
On 9/17/21 01:19, Greg KH wrote:
> On Thu, Sep 16, 2021 at 03:21:26PM -0500, Ian Pilcher wrote:
>> +What: /sys/class/leds/<led>/link_device
>> +Date: September 2021
>> +Contact: Ian Pilcher <[email protected]>
>> +Description:
>> + Associate a block device with this LED by writing the path to
>> + the device special file (e.g. /dev/sda) to this attribute.
>> + Symbolic links are followed. Optionally, the leading "/dev/"
>> + may be omitted.
>
> No, please don't follow symlinks, stick with kernel names here,
> otherwise you have a mismatch between that and the list of devices in
> this file:
>
>> +What: /sys/class/leds/<led>/linked_devices
I did update the documentation to mention that fact.
Following symlinks is the behavior of blkdev_get_by_path(), not some-
thing that my code is doing.
As far as using kernel names, that would be my preference, but I simply
don't know of any way to do so with the existing block API. To my
knowledge, there simply isn't anything like a blkdev_get_by_name() API.
This the reason that I added the "retry" logic to led_bdev_get(). It
doesn't prevent the system administrator from using a symbolic link (or
an oddly named special file), but it does make an unqualified name like
"sda" work if the expected special file exists in /dev.
However ...
On 9/17/21 00:53, Christoph Hellwig wrote:
> On Thu, Sep 16, 2021 at 03:21:27PM -0500, Ian Pilcher wrote:
>> +static struct block_device *led_bdev_get(const char *const buf,
>> + const size_t count, fmode_t mode)
>> +{
>> + static const char dev[] = "/dev/";
>> + struct block_device *bdev;
>> + char *dev_path, *path;
>> +
>> + /* sizeof(dev) includes terminating null */
>> + dev_path = kmalloc(sizeof(dev) + count, GFP_KERNEL);
>> + if (dev_path == NULL)
>> + return ERR_PTR(-ENOMEM);
>> +
>> + /* sizeof(dev) - 1 is compile-time equivalent of strlen(dev) */
>> + memcpy(dev_path, dev, sizeof(dev) - 1);
>> + path = dev_path + sizeof(dev) - 1;
>> + memcpy(path, buf, count + 1); /* include terminating null */
>> + strim(path);
>> +
>> +try_blkdev_get:
>> + bdev = blkdev_get_by_path(path, mode, THIS_MODULE);
>> + if (IS_ERR(bdev) && PTR_ERR(bdev) == -ENOENT && path != dev_path) {
>> + path = dev_path;
>> + goto try_blkdev_get;
>> + }
>> +
>> + kfree(dev_path);
>> + return bdev;
>
> Please just required the user to put in the whole path and remove all
> this garbage. There is no need to build your own broken wrappers around
> the VFS path resolution.
Please be specific about what is broken.
If you see an actual bug in the code, please tell me what it is.
If (as I suspect) you disagree with the basic idea of retrying with
"/dev/" prepended to the supplied path, please say that.
Honestly, I wasn't particularly enthusiastic about it in the first
place; it feels like something that should be done in user space. I
wouldn't have included it if I didn't have to make a writable copy of
the buffer anyway, in order to trim a trailing newline.
I can certainly remove the re-check logic. The end result will be an
API that is slightly less "user friendly" in return for saving a bit of
pointer arithmetic and a 5-byte memcpy().
--
========================================================================
In Soviet Russia, Google searches you!
========================================================================
On Fri, Sep 17, 2021 at 03:46:55PM -0500, Ian Pilcher wrote:
> Combining 2 related threads ...
>
> On 9/17/21 01:19, Greg KH wrote:
> > On Thu, Sep 16, 2021 at 03:21:26PM -0500, Ian Pilcher wrote:
> > > +What: /sys/class/leds/<led>/link_device
> > > +Date: September 2021
> > > +Contact: Ian Pilcher <[email protected]>
> > > +Description:
> > > + Associate a block device with this LED by writing the path to
> > > + the device special file (e.g. /dev/sda) to this attribute.
> > > + Symbolic links are followed. Optionally, the leading "/dev/"
> > > + may be omitted.
> >
> > No, please don't follow symlinks, stick with kernel names here,
> > otherwise you have a mismatch between that and the list of devices in
> > this file:
> >
> > > +What: /sys/class/leds/<led>/linked_devices
>
> I did update the documentation to mention that fact.
>
> Following symlinks is the behavior of blkdev_get_by_path(), not some-
> thing that my code is doing.
>
> As far as using kernel names, that would be my preference, but I simply
> don't know of any way to do so with the existing block API. To my
> knowledge, there simply isn't anything like a blkdev_get_by_name() API.
>
> This the reason that I added the "retry" logic to led_bdev_get(). It
> doesn't prevent the system administrator from using a symbolic link (or
> an oddly named special file), but it does make an unqualified name like
> "sda" work if the expected special file exists in /dev.
>
> However ...
>
> On 9/17/21 00:53, Christoph Hellwig wrote:
> > On Thu, Sep 16, 2021 at 03:21:27PM -0500, Ian Pilcher wrote:
> > > +static struct block_device *led_bdev_get(const char *const buf,
> > > + const size_t count, fmode_t mode)
> > > +{
> > > + static const char dev[] = "/dev/";
> > > + struct block_device *bdev;
> > > + char *dev_path, *path;
> > > +
> > > + /* sizeof(dev) includes terminating null */
> > > + dev_path = kmalloc(sizeof(dev) + count, GFP_KERNEL);
> > > + if (dev_path == NULL)
> > > + return ERR_PTR(-ENOMEM);
> > > +
> > > + /* sizeof(dev) - 1 is compile-time equivalent of strlen(dev) */
> > > + memcpy(dev_path, dev, sizeof(dev) - 1);
> > > + path = dev_path + sizeof(dev) - 1;
> > > + memcpy(path, buf, count + 1); /* include terminating null */
> > > + strim(path);
> > > +
> > > +try_blkdev_get:
> > > + bdev = blkdev_get_by_path(path, mode, THIS_MODULE);
> > > + if (IS_ERR(bdev) && PTR_ERR(bdev) == -ENOENT && path != dev_path) {
> > > + path = dev_path;
> > > + goto try_blkdev_get;
> > > + }
> > > +
> > > + kfree(dev_path);
> > > + return bdev;
> >
> > Please just required the user to put in the whole path and remove all
> > this garbage. There is no need to build your own broken wrappers around
> > the VFS path resolution.
>
> Please be specific about what is broken.
>
> If you see an actual bug in the code, please tell me what it is.
>
> If (as I suspect) you disagree with the basic idea of retrying with
> "/dev/" prepended to the supplied path, please say that.
>
> Honestly, I wasn't particularly enthusiastic about it in the first
> place; it feels like something that should be done in user space. I
> wouldn't have included it if I didn't have to make a writable copy of
> the buffer anyway, in order to trim a trailing newline.
>
> I can certainly remove the re-check logic. The end result will be an
> API that is slightly less "user friendly" in return for saving a bit of
> pointer arithmetic and a 5-byte memcpy().
Just use the kernel block device name and that way you do not have to
parse anything as it is unique and no paths are having to be followed.
That's the way that other LED apis are working, right?
thanks,
greg k-h
On 9/18/21 02:07, Greg KH wrote:
> On Fri, Sep 17, 2021 at 03:46:55PM -0500, Ian Pilcher wrote:
>> As far as using kernel names, that would be my preference, but I simply
>> don't know of any way to do so with the existing block API. To my
>> knowledge, there simply isn't anything like a blkdev_get_by_name() API.
...
> Just use the kernel block device name and that way you do not have to
> parse anything as it is unique and no paths are having to be followed.
>
> That's the way that other LED apis are working, right?
Greg -
There are 2 existing LED triggers that have similar functionality (i.e.
they allow LEDs to be "associated" with devices by name), and they both
use subsystem-specific APIs to "resolve" those names to the actual
kernel objects on which they operate.
* The *netdev* trigger uses dev_get_by_name(), which is specific to
network devices (despite its name).
* The *tty* trigger uses tty_dev_name_to_number() and
tty_kopen_shared().
As I've been saying, I simply don't know of any similar API for block
devices. The block API provides blkdev_get_by_path(), which I am using,
and blkdev_get_by_dev(), which takes the device number (dev_t).
If you know of an API that will allow me to resolve a block device (or
dev_t) by its kernel name, please share that information.
Thanks!
--
========================================================================
In Soviet Russia, Google searches you!
========================================================================
On Sat, Sep 18, 2021 at 09:07:54AM +0200, Greg KH wrote:
> > Honestly, I wasn't particularly enthusiastic about it in the first
> > place; it feels like something that should be done in user space. I
> > wouldn't have included it if I didn't have to make a writable copy of
> > the buffer anyway, in order to trim a trailing newline.
> >
> > I can certainly remove the re-check logic. The end result will be an
> > API that is slightly less "user friendly" in return for saving a bit of
> > pointer arithmetic and a 5-byte memcpy().
>
> Just use the kernel block device name and that way you do not have to
> parse anything as it is unique and no paths are having to be followed.
>
> That's the way that other LED apis are working, right?
The "kernel block device name" is the a block device special path
that a normal VFS path lookup is done on. This is the preferred block
device API used by everyone. And yes, this includes resolving symlinks.
The only other API is by dev_t, but it is highly discouraged and should
really not grow any new users.
On Mon, 20 Sep 2021 07:43:52 +0100
Christoph Hellwig <[email protected]> wrote:
> On Sat, Sep 18, 2021 at 09:07:54AM +0200, Greg KH wrote:
> > > Honestly, I wasn't particularly enthusiastic about it in the first
> > > place; it feels like something that should be done in user space.
> > > I wouldn't have included it if I didn't have to make a writable
> > > copy of the buffer anyway, in order to trim a trailing newline.
> > >
> > > I can certainly remove the re-check logic. The end result will
> > > be an API that is slightly less "user friendly" in return for
> > > saving a bit of pointer arithmetic and a 5-byte memcpy().
> >
> > Just use the kernel block device name and that way you do not have
> > to parse anything as it is unique and no paths are having to be
> > followed.
> >
> > That's the way that other LED apis are working, right?
>
> The "kernel block device name" is the a block device special path
> that a normal VFS path lookup is done on. This is the preferred block
> device API used by everyone. And yes, this includes resolving
> symlinks. The only other API is by dev_t, but it is highly
> discouraged and should really not grow any new users.
Christoph,
/sys/class/block lists block devices' kernel object names.
I don't understand why can't blk API provide a function returns a block
device given such name as seen in /sys/class/block directory.
Can you elaborate on this?
It seems really strange to me to not be able to do
cd /sys/class/leds/<LED>
echo blkdev >trigger
echo sda1 >block_device
and instead having to do (as the last command)
echo /dev/sda1 >block_device
And whas should we show when /dev/sda1 is paried to the trigger, and
userspace reads the block_device sysfs file? Should we show the full
path which was given when pairing, even if it may not be valid anymore?
(Such as when the device file is removed from /dev.)
Marek