Commit | Line | Data |
---|---|---|
d5870edf CH |
1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* | |
3 | * Disk events - monitor disk events like media change and eject request. | |
4 | */ | |
5 | #include <linux/export.h> | |
6 | #include <linux/moduleparam.h> | |
322cbb50 | 7 | #include <linux/blkdev.h> |
d5870edf CH |
8 | #include "blk.h" |
9 | ||
10 | struct disk_events { | |
11 | struct list_head node; /* all disk_event's */ | |
12 | struct gendisk *disk; /* the associated disk */ | |
13 | spinlock_t lock; | |
14 | ||
15 | struct mutex block_mutex; /* protects blocking */ | |
16 | int block; /* event blocking depth */ | |
17 | unsigned int pending; /* events already sent out */ | |
18 | unsigned int clearing; /* events being cleared */ | |
19 | ||
20 | long poll_msecs; /* interval, -1 for default */ | |
21 | struct delayed_work dwork; | |
22 | }; | |
23 | ||
24 | static const char *disk_events_strs[] = { | |
25 | [ilog2(DISK_EVENT_MEDIA_CHANGE)] = "media_change", | |
26 | [ilog2(DISK_EVENT_EJECT_REQUEST)] = "eject_request", | |
27 | }; | |
28 | ||
29 | static char *disk_uevents[] = { | |
30 | [ilog2(DISK_EVENT_MEDIA_CHANGE)] = "DISK_MEDIA_CHANGE=1", | |
31 | [ilog2(DISK_EVENT_EJECT_REQUEST)] = "DISK_EJECT_REQUEST=1", | |
32 | }; | |
33 | ||
34 | /* list of all disk_events */ | |
35 | static DEFINE_MUTEX(disk_events_mutex); | |
36 | static LIST_HEAD(disk_events); | |
37 | ||
38 | /* disable in-kernel polling by default */ | |
39 | static unsigned long disk_events_dfl_poll_msecs; | |
40 | ||
41 | static unsigned long disk_events_poll_jiffies(struct gendisk *disk) | |
42 | { | |
43 | struct disk_events *ev = disk->ev; | |
44 | long intv_msecs = 0; | |
45 | ||
46 | /* | |
47 | * If device-specific poll interval is set, always use it. If | |
48 | * the default is being used, poll if the POLL flag is set. | |
49 | */ | |
50 | if (ev->poll_msecs >= 0) | |
51 | intv_msecs = ev->poll_msecs; | |
52 | else if (disk->event_flags & DISK_EVENT_FLAG_POLL) | |
53 | intv_msecs = disk_events_dfl_poll_msecs; | |
54 | ||
55 | return msecs_to_jiffies(intv_msecs); | |
56 | } | |
57 | ||
58 | /** | |
59 | * disk_block_events - block and flush disk event checking | |
60 | * @disk: disk to block events for | |
61 | * | |
62 | * On return from this function, it is guaranteed that event checking | |
63 | * isn't in progress and won't happen until unblocked by | |
64 | * disk_unblock_events(). Events blocking is counted and the actual | |
65 | * unblocking happens after the matching number of unblocks are done. | |
66 | * | |
67 | * Note that this intentionally does not block event checking from | |
68 | * disk_clear_events(). | |
69 | * | |
70 | * CONTEXT: | |
71 | * Might sleep. | |
72 | */ | |
73 | void disk_block_events(struct gendisk *disk) | |
74 | { | |
75 | struct disk_events *ev = disk->ev; | |
76 | unsigned long flags; | |
77 | bool cancel; | |
78 | ||
79 | if (!ev) | |
80 | return; | |
81 | ||
82 | /* | |
83 | * Outer mutex ensures that the first blocker completes canceling | |
84 | * the event work before further blockers are allowed to finish. | |
85 | */ | |
86 | mutex_lock(&ev->block_mutex); | |
87 | ||
88 | spin_lock_irqsave(&ev->lock, flags); | |
89 | cancel = !ev->block++; | |
90 | spin_unlock_irqrestore(&ev->lock, flags); | |
91 | ||
92 | if (cancel) | |
93 | cancel_delayed_work_sync(&disk->ev->dwork); | |
94 | ||
95 | mutex_unlock(&ev->block_mutex); | |
96 | } | |
97 | ||
98 | static void __disk_unblock_events(struct gendisk *disk, bool check_now) | |
99 | { | |
100 | struct disk_events *ev = disk->ev; | |
101 | unsigned long intv; | |
102 | unsigned long flags; | |
103 | ||
104 | spin_lock_irqsave(&ev->lock, flags); | |
105 | ||
106 | if (WARN_ON_ONCE(ev->block <= 0)) | |
107 | goto out_unlock; | |
108 | ||
109 | if (--ev->block) | |
110 | goto out_unlock; | |
111 | ||
112 | intv = disk_events_poll_jiffies(disk); | |
113 | if (check_now) | |
114 | queue_delayed_work(system_freezable_power_efficient_wq, | |
115 | &ev->dwork, 0); | |
116 | else if (intv) | |
117 | queue_delayed_work(system_freezable_power_efficient_wq, | |
118 | &ev->dwork, intv); | |
119 | out_unlock: | |
120 | spin_unlock_irqrestore(&ev->lock, flags); | |
121 | } | |
122 | ||
123 | /** | |
124 | * disk_unblock_events - unblock disk event checking | |
125 | * @disk: disk to unblock events for | |
126 | * | |
127 | * Undo disk_block_events(). When the block count reaches zero, it | |
128 | * starts events polling if configured. | |
129 | * | |
130 | * CONTEXT: | |
131 | * Don't care. Safe to call from irq context. | |
132 | */ | |
133 | void disk_unblock_events(struct gendisk *disk) | |
134 | { | |
135 | if (disk->ev) | |
136 | __disk_unblock_events(disk, false); | |
137 | } | |
138 | ||
139 | /** | |
140 | * disk_flush_events - schedule immediate event checking and flushing | |
141 | * @disk: disk to check and flush events for | |
142 | * @mask: events to flush | |
143 | * | |
144 | * Schedule immediate event checking on @disk if not blocked. Events in | |
145 | * @mask are scheduled to be cleared from the driver. Note that this | |
146 | * doesn't clear the events from @disk->ev. | |
147 | * | |
148 | * CONTEXT: | |
149 | * If @mask is non-zero must be called with disk->open_mutex held. | |
150 | */ | |
151 | void disk_flush_events(struct gendisk *disk, unsigned int mask) | |
152 | { | |
153 | struct disk_events *ev = disk->ev; | |
154 | ||
155 | if (!ev) | |
156 | return; | |
157 | ||
158 | spin_lock_irq(&ev->lock); | |
159 | ev->clearing |= mask; | |
160 | if (!ev->block) | |
161 | mod_delayed_work(system_freezable_power_efficient_wq, | |
162 | &ev->dwork, 0); | |
163 | spin_unlock_irq(&ev->lock); | |
164 | } | |
165 | ||
e6138dc1 MC |
166 | /* |
167 | * Tell userland about new events. Only the events listed in @disk->events are | |
168 | * reported, and only if DISK_EVENT_FLAG_UEVENT is set. Otherwise, events are | |
169 | * processed internally but never get reported to userland. | |
170 | */ | |
171 | static void disk_event_uevent(struct gendisk *disk, unsigned int events) | |
172 | { | |
173 | char *envp[ARRAY_SIZE(disk_uevents) + 1] = { }; | |
174 | int nr_events = 0, i; | |
175 | ||
176 | for (i = 0; i < ARRAY_SIZE(disk_uevents); i++) | |
177 | if (events & disk->events & (1 << i)) | |
178 | envp[nr_events++] = disk_uevents[i]; | |
179 | ||
180 | if (nr_events) | |
181 | kobject_uevent_env(&disk_to_dev(disk)->kobj, KOBJ_CHANGE, envp); | |
182 | } | |
183 | ||
d5870edf CH |
184 | static void disk_check_events(struct disk_events *ev, |
185 | unsigned int *clearing_ptr) | |
186 | { | |
187 | struct gendisk *disk = ev->disk; | |
d5870edf CH |
188 | unsigned int clearing = *clearing_ptr; |
189 | unsigned int events; | |
190 | unsigned long intv; | |
d5870edf CH |
191 | |
192 | /* check events */ | |
193 | events = disk->fops->check_events(disk, clearing); | |
194 | ||
195 | /* accumulate pending events and schedule next poll if necessary */ | |
196 | spin_lock_irq(&ev->lock); | |
197 | ||
198 | events &= ~ev->pending; | |
199 | ev->pending |= events; | |
200 | *clearing_ptr &= ~clearing; | |
201 | ||
202 | intv = disk_events_poll_jiffies(disk); | |
203 | if (!ev->block && intv) | |
204 | queue_delayed_work(system_freezable_power_efficient_wq, | |
205 | &ev->dwork, intv); | |
206 | ||
207 | spin_unlock_irq(&ev->lock); | |
208 | ||
cf179948 MC |
209 | if (events & DISK_EVENT_MEDIA_CHANGE) |
210 | inc_diskseq(disk); | |
211 | ||
e6138dc1 MC |
212 | if (disk->event_flags & DISK_EVENT_FLAG_UEVENT) |
213 | disk_event_uevent(disk, events); | |
d5870edf CH |
214 | } |
215 | ||
216 | /** | |
217 | * disk_clear_events - synchronously check, clear and return pending events | |
218 | * @disk: disk to fetch and clear events from | |
219 | * @mask: mask of events to be fetched and cleared | |
220 | * | |
221 | * Disk events are synchronously checked and pending events in @mask | |
222 | * are cleared and returned. This ignores the block count. | |
223 | * | |
224 | * CONTEXT: | |
225 | * Might sleep. | |
226 | */ | |
227 | static unsigned int disk_clear_events(struct gendisk *disk, unsigned int mask) | |
228 | { | |
229 | struct disk_events *ev = disk->ev; | |
230 | unsigned int pending; | |
231 | unsigned int clearing = mask; | |
232 | ||
233 | if (!ev) | |
234 | return 0; | |
235 | ||
236 | disk_block_events(disk); | |
237 | ||
238 | /* | |
239 | * store the union of mask and ev->clearing on the stack so that the | |
240 | * race with disk_flush_events does not cause ambiguity (ev->clearing | |
241 | * can still be modified even if events are blocked). | |
242 | */ | |
243 | spin_lock_irq(&ev->lock); | |
244 | clearing |= ev->clearing; | |
245 | ev->clearing = 0; | |
246 | spin_unlock_irq(&ev->lock); | |
247 | ||
248 | disk_check_events(ev, &clearing); | |
249 | /* | |
250 | * if ev->clearing is not 0, the disk_flush_events got called in the | |
251 | * middle of this function, so we want to run the workfn without delay. | |
252 | */ | |
253 | __disk_unblock_events(disk, ev->clearing ? true : false); | |
254 | ||
255 | /* then, fetch and clear pending events */ | |
256 | spin_lock_irq(&ev->lock); | |
257 | pending = ev->pending & mask; | |
258 | ev->pending &= ~mask; | |
259 | spin_unlock_irq(&ev->lock); | |
260 | WARN_ON_ONCE(clearing & mask); | |
261 | ||
262 | return pending; | |
263 | } | |
264 | ||
265 | /** | |
444aa2c5 CH |
266 | * disk_check_media_change - check if a removable media has been changed |
267 | * @disk: gendisk to check | |
d5870edf CH |
268 | * |
269 | * Check whether a removable media has been changed, and attempt to free all | |
270 | * dentries and inodes and invalidates all block device page cache entries in | |
271 | * that case. | |
272 | * | |
444aa2c5 | 273 | * Returns %true if the media has changed, or %false if not. |
d5870edf | 274 | */ |
444aa2c5 | 275 | bool disk_check_media_change(struct gendisk *disk) |
d5870edf CH |
276 | { |
277 | unsigned int events; | |
278 | ||
444aa2c5 | 279 | events = disk_clear_events(disk, DISK_EVENT_MEDIA_CHANGE | |
d5870edf CH |
280 | DISK_EVENT_EJECT_REQUEST); |
281 | if (!(events & DISK_EVENT_MEDIA_CHANGE)) | |
282 | return false; | |
283 | ||
444aa2c5 | 284 | if (__invalidate_device(disk->part0, true)) |
d5870edf | 285 | pr_warn("VFS: busy inodes on changed media %s\n", |
444aa2c5 CH |
286 | disk->disk_name); |
287 | set_bit(GD_NEED_PART_SCAN, &disk->state); | |
d5870edf CH |
288 | return true; |
289 | } | |
444aa2c5 | 290 | EXPORT_SYMBOL(disk_check_media_change); |
d5870edf | 291 | |
e6138dc1 MC |
292 | /** |
293 | * disk_force_media_change - force a media change event | |
294 | * @disk: the disk which will raise the event | |
295 | * @events: the events to raise | |
296 | * | |
297 | * Generate uevents for the disk. If DISK_EVENT_MEDIA_CHANGE is present, | |
298 | * attempt to free all dentries and inodes and invalidates all block | |
299 | * device page cache entries in that case. | |
300 | * | |
301 | * Returns %true if DISK_EVENT_MEDIA_CHANGE was raised, or %false if not. | |
302 | */ | |
303 | bool disk_force_media_change(struct gendisk *disk, unsigned int events) | |
304 | { | |
305 | disk_event_uevent(disk, events); | |
306 | ||
307 | if (!(events & DISK_EVENT_MEDIA_CHANGE)) | |
308 | return false; | |
309 | ||
b90ecc03 | 310 | inc_diskseq(disk); |
e6138dc1 MC |
311 | if (__invalidate_device(disk->part0, true)) |
312 | pr_warn("VFS: busy inodes on changed media %s\n", | |
313 | disk->disk_name); | |
314 | set_bit(GD_NEED_PART_SCAN, &disk->state); | |
315 | return true; | |
316 | } | |
317 | EXPORT_SYMBOL_GPL(disk_force_media_change); | |
318 | ||
d5870edf CH |
319 | /* |
320 | * Separate this part out so that a different pointer for clearing_ptr can be | |
321 | * passed in for disk_clear_events. | |
322 | */ | |
323 | static void disk_events_workfn(struct work_struct *work) | |
324 | { | |
325 | struct delayed_work *dwork = to_delayed_work(work); | |
326 | struct disk_events *ev = container_of(dwork, struct disk_events, dwork); | |
327 | ||
328 | disk_check_events(ev, &ev->clearing); | |
329 | } | |
330 | ||
331 | /* | |
332 | * A disk events enabled device has the following sysfs nodes under | |
333 | * its /sys/block/X/ directory. | |
334 | * | |
335 | * events : list of all supported events | |
336 | * events_async : list of events which can be detected w/o polling | |
337 | * (always empty, only for backwards compatibility) | |
338 | * events_poll_msecs : polling interval, 0: disable, -1: system default | |
339 | */ | |
340 | static ssize_t __disk_events_show(unsigned int events, char *buf) | |
341 | { | |
342 | const char *delim = ""; | |
343 | ssize_t pos = 0; | |
344 | int i; | |
345 | ||
346 | for (i = 0; i < ARRAY_SIZE(disk_events_strs); i++) | |
347 | if (events & (1 << i)) { | |
348 | pos += sprintf(buf + pos, "%s%s", | |
349 | delim, disk_events_strs[i]); | |
350 | delim = " "; | |
351 | } | |
352 | if (pos) | |
353 | pos += sprintf(buf + pos, "\n"); | |
354 | return pos; | |
355 | } | |
356 | ||
357 | static ssize_t disk_events_show(struct device *dev, | |
358 | struct device_attribute *attr, char *buf) | |
359 | { | |
360 | struct gendisk *disk = dev_to_disk(dev); | |
361 | ||
362 | if (!(disk->event_flags & DISK_EVENT_FLAG_UEVENT)) | |
363 | return 0; | |
364 | return __disk_events_show(disk->events, buf); | |
365 | } | |
366 | ||
367 | static ssize_t disk_events_async_show(struct device *dev, | |
368 | struct device_attribute *attr, char *buf) | |
369 | { | |
370 | return 0; | |
371 | } | |
372 | ||
373 | static ssize_t disk_events_poll_msecs_show(struct device *dev, | |
374 | struct device_attribute *attr, | |
375 | char *buf) | |
376 | { | |
377 | struct gendisk *disk = dev_to_disk(dev); | |
378 | ||
379 | if (!disk->ev) | |
380 | return sprintf(buf, "-1\n"); | |
381 | return sprintf(buf, "%ld\n", disk->ev->poll_msecs); | |
382 | } | |
383 | ||
384 | static ssize_t disk_events_poll_msecs_store(struct device *dev, | |
385 | struct device_attribute *attr, | |
386 | const char *buf, size_t count) | |
387 | { | |
388 | struct gendisk *disk = dev_to_disk(dev); | |
389 | long intv; | |
390 | ||
391 | if (!count || !sscanf(buf, "%ld", &intv)) | |
392 | return -EINVAL; | |
393 | ||
394 | if (intv < 0 && intv != -1) | |
395 | return -EINVAL; | |
396 | ||
397 | if (!disk->ev) | |
398 | return -ENODEV; | |
399 | ||
400 | disk_block_events(disk); | |
401 | disk->ev->poll_msecs = intv; | |
402 | __disk_unblock_events(disk, true); | |
403 | return count; | |
404 | } | |
405 | ||
2bc8cda5 CH |
406 | DEVICE_ATTR(events, 0444, disk_events_show, NULL); |
407 | DEVICE_ATTR(events_async, 0444, disk_events_async_show, NULL); | |
408 | DEVICE_ATTR(events_poll_msecs, 0644, disk_events_poll_msecs_show, | |
409 | disk_events_poll_msecs_store); | |
d5870edf CH |
410 | |
411 | /* | |
412 | * The default polling interval can be specified by the kernel | |
413 | * parameter block.events_dfl_poll_msecs which defaults to 0 | |
414 | * (disable). This can also be modified runtime by writing to | |
415 | * /sys/module/block/parameters/events_dfl_poll_msecs. | |
416 | */ | |
417 | static int disk_events_set_dfl_poll_msecs(const char *val, | |
418 | const struct kernel_param *kp) | |
419 | { | |
420 | struct disk_events *ev; | |
421 | int ret; | |
422 | ||
423 | ret = param_set_ulong(val, kp); | |
424 | if (ret < 0) | |
425 | return ret; | |
426 | ||
427 | mutex_lock(&disk_events_mutex); | |
428 | list_for_each_entry(ev, &disk_events, node) | |
429 | disk_flush_events(ev->disk, 0); | |
430 | mutex_unlock(&disk_events_mutex); | |
431 | return 0; | |
432 | } | |
433 | ||
434 | static const struct kernel_param_ops disk_events_dfl_poll_msecs_param_ops = { | |
435 | .set = disk_events_set_dfl_poll_msecs, | |
436 | .get = param_get_ulong, | |
437 | }; | |
438 | ||
439 | #undef MODULE_PARAM_PREFIX | |
440 | #define MODULE_PARAM_PREFIX "block." | |
441 | ||
442 | module_param_cb(events_dfl_poll_msecs, &disk_events_dfl_poll_msecs_param_ops, | |
443 | &disk_events_dfl_poll_msecs, 0644); | |
444 | ||
445 | /* | |
446 | * disk_{alloc|add|del|release}_events - initialize and destroy disk_events. | |
447 | */ | |
92e7755e | 448 | int disk_alloc_events(struct gendisk *disk) |
d5870edf CH |
449 | { |
450 | struct disk_events *ev; | |
451 | ||
452 | if (!disk->fops->check_events || !disk->events) | |
92e7755e | 453 | return 0; |
d5870edf CH |
454 | |
455 | ev = kzalloc(sizeof(*ev), GFP_KERNEL); | |
456 | if (!ev) { | |
457 | pr_warn("%s: failed to initialize events\n", disk->disk_name); | |
92e7755e | 458 | return -ENOMEM; |
d5870edf CH |
459 | } |
460 | ||
461 | INIT_LIST_HEAD(&ev->node); | |
462 | ev->disk = disk; | |
463 | spin_lock_init(&ev->lock); | |
464 | mutex_init(&ev->block_mutex); | |
465 | ev->block = 1; | |
466 | ev->poll_msecs = -1; | |
467 | INIT_DELAYED_WORK(&ev->dwork, disk_events_workfn); | |
468 | ||
469 | disk->ev = ev; | |
92e7755e | 470 | return 0; |
d5870edf CH |
471 | } |
472 | ||
473 | void disk_add_events(struct gendisk *disk) | |
474 | { | |
d5870edf CH |
475 | if (!disk->ev) |
476 | return; | |
477 | ||
478 | mutex_lock(&disk_events_mutex); | |
479 | list_add_tail(&disk->ev->node, &disk_events); | |
480 | mutex_unlock(&disk_events_mutex); | |
481 | ||
482 | /* | |
483 | * Block count is initialized to 1 and the following initial | |
484 | * unblock kicks it into action. | |
485 | */ | |
486 | __disk_unblock_events(disk, true); | |
487 | } | |
488 | ||
489 | void disk_del_events(struct gendisk *disk) | |
490 | { | |
491 | if (disk->ev) { | |
492 | disk_block_events(disk); | |
493 | ||
494 | mutex_lock(&disk_events_mutex); | |
495 | list_del_init(&disk->ev->node); | |
496 | mutex_unlock(&disk_events_mutex); | |
497 | } | |
d5870edf CH |
498 | } |
499 | ||
500 | void disk_release_events(struct gendisk *disk) | |
501 | { | |
502 | /* the block count should be 1 from disk_del_events() */ | |
503 | WARN_ON_ONCE(disk->ev && disk->ev->block != 1); | |
504 | kfree(disk->ev); | |
505 | } |