the-tree/block/disk-events.c

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * Disk events - monitor disk events like media change and eject request.
0004  */
0005 #include <linux/export.h>
0006 #include <linux/moduleparam.h>
0007 #include <linux/blkdev.h>
0008 #include "blk.h"
0009
0010 struct disk_events {
0011     struct list_head    node;       /* all disk_event's */
0012     struct gendisk      *disk;      /* the associated disk */
0013     spinlock_t      lock;
0014
0015     struct mutex        block_mutex;    /* protects blocking */
0016     int         block;      /* event blocking depth */
0017     unsigned int        pending;    /* events already sent out */
0018     unsigned int        clearing;   /* events being cleared */
0019
0020     long            poll_msecs; /* interval, -1 for default */
0021     struct delayed_work dwork;
0022 };
0023
0024 static const char *disk_events_strs[] = {
0025     [ilog2(DISK_EVENT_MEDIA_CHANGE)]    = "media_change",
0026     [ilog2(DISK_EVENT_EJECT_REQUEST)]   = "eject_request",
0027 };
0028
0029 static char *disk_uevents[] = {
0030     [ilog2(DISK_EVENT_MEDIA_CHANGE)]    = "DISK_MEDIA_CHANGE=1",
0031     [ilog2(DISK_EVENT_EJECT_REQUEST)]   = "DISK_EJECT_REQUEST=1",
0032 };
0033
0034 /* list of all disk_events */
0035 static DEFINE_MUTEX(disk_events_mutex);
0036 static LIST_HEAD(disk_events);
0037
0038 /* disable in-kernel polling by default */
0039 static unsigned long disk_events_dfl_poll_msecs;
0040
0041 static unsigned long disk_events_poll_jiffies(struct gendisk *disk)
0042 {
0043     struct disk_events *ev = disk->ev;
0044     long intv_msecs = 0;
0045
0046     /*
0047      * If device-specific poll interval is set, always use it.  If
0048      * the default is being used, poll if the POLL flag is set.
0049      */
0050     if (ev->poll_msecs >= 0)
0051         intv_msecs = ev->poll_msecs;
0052     else if (disk->event_flags & DISK_EVENT_FLAG_POLL)
0053         intv_msecs = disk_events_dfl_poll_msecs;
0054
0055     return msecs_to_jiffies(intv_msecs);
0056 }
0057
0058 /**
0059  * disk_block_events - block and flush disk event checking
0060  * @disk: disk to block events for
0061  *
0062  * On return from this function, it is guaranteed that event checking
0063  * isn't in progress and won't happen until unblocked by
0064  * disk_unblock_events().  Events blocking is counted and the actual
0065  * unblocking happens after the matching number of unblocks are done.
0066  *
0067  * Note that this intentionally does not block event checking from
0068  * disk_clear_events().
0069  *
0070  * CONTEXT:
0071  * Might sleep.
0072  */
0073 void disk_block_events(struct gendisk *disk)
0074 {
0075     struct disk_events *ev = disk->ev;
0076     unsigned long flags;
0077     bool cancel;
0078
0079     if (!ev)
0080         return;
0081
0082     /*
0083      * Outer mutex ensures that the first blocker completes canceling
0084      * the event work before further blockers are allowed to finish.
0085      */
0086     mutex_lock(&ev->block_mutex);
0087
0088     spin_lock_irqsave(&ev->lock, flags);
0089     cancel = !ev->block++;
0090     spin_unlock_irqrestore(&ev->lock, flags);
0091
0092     if (cancel)
0093         cancel_delayed_work_sync(&disk->ev->dwork);
0094
0095     mutex_unlock(&ev->block_mutex);
0096 }
0097
0098 static void __disk_unblock_events(struct gendisk *disk, bool check_now)
0099 {
0100     struct disk_events *ev = disk->ev;
0101     unsigned long intv;
0102     unsigned long flags;
0103
0104     spin_lock_irqsave(&ev->lock, flags);
0105
0106     if (WARN_ON_ONCE(ev->block <= 0))
0107         goto out_unlock;
0108
0109     if (--ev->block)
0110         goto out_unlock;
0111
0112     intv = disk_events_poll_jiffies(disk);
0113     if (check_now)
0114         queue_delayed_work(system_freezable_power_efficient_wq,
0115                 &ev->dwork, 0);
0116     else if (intv)
0117         queue_delayed_work(system_freezable_power_efficient_wq,
0118                 &ev->dwork, intv);
0119 out_unlock:
0120     spin_unlock_irqrestore(&ev->lock, flags);
0121 }
0122
0123 /**
0124  * disk_unblock_events - unblock disk event checking
0125  * @disk: disk to unblock events for
0126  *
0127  * Undo disk_block_events().  When the block count reaches zero, it
0128  * starts events polling if configured.
0129  *
0130  * CONTEXT:
0131  * Don't care.  Safe to call from irq context.
0132  */
0133 void disk_unblock_events(struct gendisk *disk)
0134 {
0135     if (disk->ev)
0136         __disk_unblock_events(disk, false);
0137 }
0138
0139 /**
0140  * disk_flush_events - schedule immediate event checking and flushing
0141  * @disk: disk to check and flush events for
0142  * @mask: events to flush
0143  *
0144  * Schedule immediate event checking on @disk if not blocked.  Events in
0145  * @mask are scheduled to be cleared from the driver.  Note that this
0146  * doesn't clear the events from @disk->ev.
0147  *
0148  * CONTEXT:
0149  * If @mask is non-zero must be called with disk->open_mutex held.
0150  */
0151 void disk_flush_events(struct gendisk *disk, unsigned int mask)
0152 {
0153     struct disk_events *ev = disk->ev;
0154
0155     if (!ev)
0156         return;
0157
0158     spin_lock_irq(&ev->lock);
0159     ev->clearing |= mask;
0160     if (!ev->block)
0161         mod_delayed_work(system_freezable_power_efficient_wq,
0162                 &ev->dwork, 0);
0163     spin_unlock_irq(&ev->lock);
0164 }
0165
0166 /*
0167  * Tell userland about new events.  Only the events listed in @disk->events are
0168  * reported, and only if DISK_EVENT_FLAG_UEVENT is set.  Otherwise, events are
0169  * processed internally but never get reported to userland.
0170  */
0171 static void disk_event_uevent(struct gendisk *disk, unsigned int events)
0172 {
0173     char *envp[ARRAY_SIZE(disk_uevents) + 1] = { };
0174     int nr_events = 0, i;
0175
0176     for (i = 0; i < ARRAY_SIZE(disk_uevents); i++)
0177         if (events & disk->events & (1 << i))
0178             envp[nr_events++] = disk_uevents[i];
0179
0180     if (nr_events)
0181         kobject_uevent_env(&disk_to_dev(disk)->kobj, KOBJ_CHANGE, envp);
0182 }
0183
0184 static void disk_check_events(struct disk_events *ev,
0185                   unsigned int *clearing_ptr)
0186 {
0187     struct gendisk *disk = ev->disk;
0188     unsigned int clearing = *clearing_ptr;
0189     unsigned int events;
0190     unsigned long intv;
0191
0192     /* check events */
0193     events = disk->fops->check_events(disk, clearing);
0194
0195     /* accumulate pending events and schedule next poll if necessary */
0196     spin_lock_irq(&ev->lock);
0197
0198     events &= ~ev->pending;
0199     ev->pending |= events;
0200     *clearing_ptr &= ~clearing;
0201
0202     intv = disk_events_poll_jiffies(disk);
0203     if (!ev->block && intv)
0204         queue_delayed_work(system_freezable_power_efficient_wq,
0205                 &ev->dwork, intv);
0206
0207     spin_unlock_irq(&ev->lock);
0208
0209     if (events & DISK_EVENT_MEDIA_CHANGE)
0210         inc_diskseq(disk);
0211
0212     if (disk->event_flags & DISK_EVENT_FLAG_UEVENT)
0213         disk_event_uevent(disk, events);
0214 }
0215
0216 /**
0217  * disk_clear_events - synchronously check, clear and return pending events
0218  * @disk: disk to fetch and clear events from
0219  * @mask: mask of events to be fetched and cleared
0220  *
0221  * Disk events are synchronously checked and pending events in @mask
0222  * are cleared and returned.  This ignores the block count.
0223  *
0224  * CONTEXT:
0225  * Might sleep.
0226  */
0227 static unsigned int disk_clear_events(struct gendisk *disk, unsigned int mask)
0228 {
0229     struct disk_events *ev = disk->ev;
0230     unsigned int pending;
0231     unsigned int clearing = mask;
0232
0233     if (!ev)
0234         return 0;
0235
0236     disk_block_events(disk);
0237
0238     /*
0239      * store the union of mask and ev->clearing on the stack so that the
0240      * race with disk_flush_events does not cause ambiguity (ev->clearing
0241      * can still be modified even if events are blocked).
0242      */
0243     spin_lock_irq(&ev->lock);
0244     clearing |= ev->clearing;
0245     ev->clearing = 0;
0246     spin_unlock_irq(&ev->lock);
0247
0248     disk_check_events(ev, &clearing);
0249     /*
0250      * if ev->clearing is not 0, the disk_flush_events got called in the
0251      * middle of this function, so we want to run the workfn without delay.
0252      */
0253     __disk_unblock_events(disk, ev->clearing ? true : false);
0254
0255     /* then, fetch and clear pending events */
0256     spin_lock_irq(&ev->lock);
0257     pending = ev->pending & mask;
0258     ev->pending &= ~mask;
0259     spin_unlock_irq(&ev->lock);
0260     WARN_ON_ONCE(clearing & mask);
0261
0262     return pending;
0263 }
0264
0265 /**
0266  * bdev_check_media_change - check if a removable media has been changed
0267  * @bdev: block device to check
0268  *
0269  * Check whether a removable media has been changed, and attempt to free all
0270  * dentries and inodes and invalidates all block device page cache entries in
0271  * that case.
0272  *
0273  * Returns %true if the block device changed, or %false if not.
0274  */
0275 bool bdev_check_media_change(struct block_device *bdev)
0276 {
0277     unsigned int events;
0278
0279     events = disk_clear_events(bdev->bd_disk, DISK_EVENT_MEDIA_CHANGE |
0280                    DISK_EVENT_EJECT_REQUEST);
0281     if (!(events & DISK_EVENT_MEDIA_CHANGE))
0282         return false;
0283
0284     if (__invalidate_device(bdev, true))
0285         pr_warn("VFS: busy inodes on changed media %s\n",
0286             bdev->bd_disk->disk_name);
0287     set_bit(GD_NEED_PART_SCAN, &bdev->bd_disk->state);
0288     return true;
0289 }
0290 EXPORT_SYMBOL(bdev_check_media_change);
0291
0292 /**
0293  * disk_force_media_change - force a media change event
0294  * @disk: the disk which will raise the event
0295  * @events: the events to raise
0296  *
0297  * Generate uevents for the disk. If DISK_EVENT_MEDIA_CHANGE is present,
0298  * attempt to free all dentries and inodes and invalidates all block
0299  * device page cache entries in that case.
0300  *
0301  * Returns %true if DISK_EVENT_MEDIA_CHANGE was raised, or %false if not.
0302  */
0303 bool disk_force_media_change(struct gendisk *disk, unsigned int events)
0304 {
0305     disk_event_uevent(disk, events);
0306
0307     if (!(events & DISK_EVENT_MEDIA_CHANGE))
0308         return false;
0309
0310     if (__invalidate_device(disk->part0, true))
0311         pr_warn("VFS: busy inodes on changed media %s\n",
0312             disk->disk_name);
0313     set_bit(GD_NEED_PART_SCAN, &disk->state);
0314     return true;
0315 }
0316 EXPORT_SYMBOL_GPL(disk_force_media_change);
0317
0318 /*
0319  * Separate this part out so that a different pointer for clearing_ptr can be
0320  * passed in for disk_clear_events.
0321  */
0322 static void disk_events_workfn(struct work_struct *work)
0323 {
0324     struct delayed_work *dwork = to_delayed_work(work);
0325     struct disk_events *ev = container_of(dwork, struct disk_events, dwork);
0326
0327     disk_check_events(ev, &ev->clearing);
0328 }
0329
0330 /*
0331  * A disk events enabled device has the following sysfs nodes under
0332  * its /sys/block/X/ directory.
0333  *
0334  * events       : list of all supported events
0335  * events_async     : list of events which can be detected w/o polling
0336  *            (always empty, only for backwards compatibility)
0337  * events_poll_msecs    : polling interval, 0: disable, -1: system default
0338  */
0339 static ssize_t __disk_events_show(unsigned int events, char *buf)
0340 {
0341     const char *delim = "";
0342     ssize_t pos = 0;
0343     int i;
0344
0345     for (i = 0; i < ARRAY_SIZE(disk_events_strs); i++)
0346         if (events & (1 << i)) {
0347             pos += sprintf(buf + pos, "%s%s",
0348                        delim, disk_events_strs[i]);
0349             delim = " ";
0350         }
0351     if (pos)
0352         pos += sprintf(buf + pos, "\n");
0353     return pos;
0354 }
0355
0356 static ssize_t disk_events_show(struct device *dev,
0357                 struct device_attribute *attr, char *buf)
0358 {
0359     struct gendisk *disk = dev_to_disk(dev);
0360
0361     if (!(disk->event_flags & DISK_EVENT_FLAG_UEVENT))
0362         return 0;
0363     return __disk_events_show(disk->events, buf);
0364 }
0365
0366 static ssize_t disk_events_async_show(struct device *dev,
0367                       struct device_attribute *attr, char *buf)
0368 {
0369     return 0;
0370 }
0371
0372 static ssize_t disk_events_poll_msecs_show(struct device *dev,
0373                        struct device_attribute *attr,
0374                        char *buf)
0375 {
0376     struct gendisk *disk = dev_to_disk(dev);
0377
0378     if (!disk->ev)
0379         return sprintf(buf, "-1\n");
0380     return sprintf(buf, "%ld\n", disk->ev->poll_msecs);
0381 }
0382
0383 static ssize_t disk_events_poll_msecs_store(struct device *dev,
0384                         struct device_attribute *attr,
0385                         const char *buf, size_t count)
0386 {
0387     struct gendisk *disk = dev_to_disk(dev);
0388     long intv;
0389
0390     if (!count || !sscanf(buf, "%ld", &intv))
0391         return -EINVAL;
0392
0393     if (intv < 0 && intv != -1)
0394         return -EINVAL;
0395
0396     if (!disk->ev)
0397         return -ENODEV;
0398
0399     disk_block_events(disk);
0400     disk->ev->poll_msecs = intv;
0401     __disk_unblock_events(disk, true);
0402     return count;
0403 }
0404
0405 DEVICE_ATTR(events, 0444, disk_events_show, NULL);
0406 DEVICE_ATTR(events_async, 0444, disk_events_async_show, NULL);
0407 DEVICE_ATTR(events_poll_msecs, 0644, disk_events_poll_msecs_show,
0408         disk_events_poll_msecs_store);
0409
0410 /*
0411  * The default polling interval can be specified by the kernel
0412  * parameter block.events_dfl_poll_msecs which defaults to 0
0413  * (disable).  This can also be modified runtime by writing to
0414  * /sys/module/block/parameters/events_dfl_poll_msecs.
0415  */
0416 static int disk_events_set_dfl_poll_msecs(const char *val,
0417                       const struct kernel_param *kp)
0418 {
0419     struct disk_events *ev;
0420     int ret;
0421
0422     ret = param_set_ulong(val, kp);
0423     if (ret < 0)
0424         return ret;
0425
0426     mutex_lock(&disk_events_mutex);
0427     list_for_each_entry(ev, &disk_events, node)
0428         disk_flush_events(ev->disk, 0);
0429     mutex_unlock(&disk_events_mutex);
0430     return 0;
0431 }
0432
0433 static const struct kernel_param_ops disk_events_dfl_poll_msecs_param_ops = {
0434     .set    = disk_events_set_dfl_poll_msecs,
0435     .get    = param_get_ulong,
0436 };
0437
0438 #undef MODULE_PARAM_PREFIX
0439 #define MODULE_PARAM_PREFIX "block."
0440
0441 module_param_cb(events_dfl_poll_msecs, &disk_events_dfl_poll_msecs_param_ops,
0442         &disk_events_dfl_poll_msecs, 0644);
0443
0444 /*
0445  * disk_{alloc|add|del|release}_events - initialize and destroy disk_events.
0446  */
0447 int disk_alloc_events(struct gendisk *disk)
0448 {
0449     struct disk_events *ev;
0450
0451     if (!disk->fops->check_events || !disk->events)
0452         return 0;
0453
0454     ev = kzalloc(sizeof(*ev), GFP_KERNEL);
0455     if (!ev) {
0456         pr_warn("%s: failed to initialize events\n", disk->disk_name);
0457         return -ENOMEM;
0458     }
0459
0460     INIT_LIST_HEAD(&ev->node);
0461     ev->disk = disk;
0462     spin_lock_init(&ev->lock);
0463     mutex_init(&ev->block_mutex);
0464     ev->block = 1;
0465     ev->poll_msecs = -1;
0466     INIT_DELAYED_WORK(&ev->dwork, disk_events_workfn);
0467
0468     disk->ev = ev;
0469     return 0;
0470 }
0471
0472 void disk_add_events(struct gendisk *disk)
0473 {
0474     if (!disk->ev)
0475         return;
0476
0477     mutex_lock(&disk_events_mutex);
0478     list_add_tail(&disk->ev->node, &disk_events);
0479     mutex_unlock(&disk_events_mutex);
0480
0481     /*
0482      * Block count is initialized to 1 and the following initial
0483      * unblock kicks it into action.
0484      */
0485     __disk_unblock_events(disk, true);
0486 }
0487
0488 void disk_del_events(struct gendisk *disk)
0489 {
0490     if (disk->ev) {
0491         disk_block_events(disk);
0492
0493         mutex_lock(&disk_events_mutex);
0494         list_del_init(&disk->ev->node);
0495         mutex_unlock(&disk_events_mutex);
0496     }
0497 }
0498
0499 void disk_release_events(struct gendisk *disk)
0500 {
0501     /* the block count should be 1 from disk_del_events() */
0502     WARN_ON_ONCE(disk->ev && disk->ev->block != 1);
0503     kfree(disk->ev);
0504 }