[thirdparty/linux.git] / block / disk-events.c

// SPDX-License-Identifier: GPL-2.0
/*
 * Disk events - monitor disk events like media change and eject request.
 */
#include <linux/export.h>
#include <linux/moduleparam.h>
#include <linux/blkdev.h>
#include "blk.h"

struct disk_events {
	struct list_head	node;		/* all disk_event's */
	struct gendisk		*disk;		/* the associated disk */
	spinlock_t		lock;

	struct mutex		block_mutex;	/* protects blocking */
	int			block;		/* event blocking depth */
	unsigned int		pending;	/* events already sent out */
	unsigned int		clearing;	/* events being cleared */

	long			poll_msecs;	/* interval, -1 for default */
	struct delayed_work	dwork;
};

static const char *disk_events_strs[] = {
	[ilog2(DISK_EVENT_MEDIA_CHANGE)]	= "media_change",
	[ilog2(DISK_EVENT_EJECT_REQUEST)]	= "eject_request",
};

static char *disk_uevents[] = {
	[ilog2(DISK_EVENT_MEDIA_CHANGE)]	= "DISK_MEDIA_CHANGE=1",
	[ilog2(DISK_EVENT_EJECT_REQUEST)]	= "DISK_EJECT_REQUEST=1",
};

/* list of all disk_events */
static DEFINE_MUTEX(disk_events_mutex);
static LIST_HEAD(disk_events);

/* disable in-kernel polling by default */
static unsigned long disk_events_dfl_poll_msecs;

static unsigned long disk_events_poll_jiffies(struct gendisk *disk)
{
	struct disk_events *ev = disk->ev;
	long intv_msecs = 0;

	/*
	 * If device-specific poll interval is set, always use it.  If
	 * the default is being used, poll if the POLL flag is set.
	 */
	if (ev->poll_msecs >= 0)
		intv_msecs = ev->poll_msecs;
	else if (disk->event_flags & DISK_EVENT_FLAG_POLL)
		intv_msecs = disk_events_dfl_poll_msecs;

	return msecs_to_jiffies(intv_msecs);
}

/**
 * disk_block_events - block and flush disk event checking
 * @disk: disk to block events for
 *
 * On return from this function, it is guaranteed that event checking
 * isn't in progress and won't happen until unblocked by
 * disk_unblock_events().  Events blocking is counted and the actual
 * unblocking happens after the matching number of unblocks are done.
 *
 * Note that this intentionally does not block event checking from
 * disk_clear_events().
 *
 * CONTEXT:
 * Might sleep.
 */
void disk_block_events(struct gendisk *disk)
{
	struct disk_events *ev = disk->ev;
	unsigned long flags;
	bool cancel;

	if (!ev)
		return;

	/*
	 * Outer mutex ensures that the first blocker completes canceling
	 * the event work before further blockers are allowed to finish.
	 */
	mutex_lock(&ev->block_mutex);

	spin_lock_irqsave(&ev->lock, flags);
	cancel = !ev->block++;
	spin_unlock_irqrestore(&ev->lock, flags);

	if (cancel)
		cancel_delayed_work_sync(&disk->ev->dwork);

	mutex_unlock(&ev->block_mutex);
}

static void __disk_unblock_events(struct gendisk *disk, bool check_now)
{
	struct disk_events *ev = disk->ev;
	unsigned long intv;
	unsigned long flags;

	spin_lock_irqsave(&ev->lock, flags);

	if (WARN_ON_ONCE(ev->block <= 0))
		goto out_unlock;

	if (--ev->block)
		goto out_unlock;

	intv = disk_events_poll_jiffies(disk);
	if (check_now)
		queue_delayed_work(system_freezable_power_efficient_wq,
				&ev->dwork, 0);
	else if (intv)
		queue_delayed_work(system_freezable_power_efficient_wq,
				&ev->dwork, intv);
out_unlock:
	spin_unlock_irqrestore(&ev->lock, flags);
}

/**
 * disk_unblock_events - unblock disk event checking
 * @disk: disk to unblock events for
 *
 * Undo disk_block_events().  When the block count reaches zero, it
 * starts events polling if configured.
 *
 * CONTEXT:
 * Don't care.  Safe to call from irq context.
 */
void disk_unblock_events(struct gendisk *disk)
{
	if (disk->ev)
		__disk_unblock_events(disk, false);
}

/**
 * disk_flush_events - schedule immediate event checking and flushing
 * @disk: disk to check and flush events for
 * @mask: events to flush
 *
 * Schedule immediate event checking on @disk if not blocked.  Events in
 * @mask are scheduled to be cleared from the driver.  Note that this
 * doesn't clear the events from @disk->ev.
 *
 * CONTEXT:
 * If @mask is non-zero must be called with disk->open_mutex held.
 */
void disk_flush_events(struct gendisk *disk, unsigned int mask)
{
	struct disk_events *ev = disk->ev;

	if (!ev)
		return;

	spin_lock_irq(&ev->lock);
	ev->clearing |= mask;
	if (!ev->block)
		mod_delayed_work(system_freezable_power_efficient_wq,
				&ev->dwork, 0);
	spin_unlock_irq(&ev->lock);
}

/*
 * Tell userland about new events.  Only the events listed in @disk->events are
 * reported, and only if DISK_EVENT_FLAG_UEVENT is set.  Otherwise, events are
 * processed internally but never get reported to userland.
 */
static void disk_event_uevent(struct gendisk *disk, unsigned int events)
{
	char *envp[ARRAY_SIZE(disk_uevents) + 1] = { };
	int nr_events = 0, i;

	for (i = 0; i < ARRAY_SIZE(disk_uevents); i++)
		if (events & disk->events & (1 << i))
			envp[nr_events++] = disk_uevents[i];

	if (nr_events)
		kobject_uevent_env(&disk_to_dev(disk)->kobj, KOBJ_CHANGE, envp);
}

static void disk_check_events(struct disk_events *ev,
			      unsigned int *clearing_ptr)
{
	struct gendisk *disk = ev->disk;
	unsigned int clearing = *clearing_ptr;
	unsigned int events;
	unsigned long intv;

	/* check events */
	events = disk->fops->check_events(disk, clearing);

	/* accumulate pending events and schedule next poll if necessary */
	spin_lock_irq(&ev->lock);

	events &= ~ev->pending;
	ev->pending |= events;
	*clearing_ptr &= ~clearing;

	intv = disk_events_poll_jiffies(disk);
	if (!ev->block && intv)
		queue_delayed_work(system_freezable_power_efficient_wq,
				&ev->dwork, intv);

	spin_unlock_irq(&ev->lock);

	if (events & DISK_EVENT_MEDIA_CHANGE)
		inc_diskseq(disk);

	if (disk->event_flags & DISK_EVENT_FLAG_UEVENT)
		disk_event_uevent(disk, events);
}

/**
 * disk_clear_events - synchronously check, clear and return pending events
 * @disk: disk to fetch and clear events from
 * @mask: mask of events to be fetched and cleared
 *
 * Disk events are synchronously checked and pending events in @mask
 * are cleared and returned.  This ignores the block count.
 *
 * CONTEXT:
 * Might sleep.
 */
static unsigned int disk_clear_events(struct gendisk *disk, unsigned int mask)
{
	struct disk_events *ev = disk->ev;
	unsigned int pending;
	unsigned int clearing = mask;

	if (!ev)
		return 0;

	disk_block_events(disk);

	/*
	 * store the union of mask and ev->clearing on the stack so that the
	 * race with disk_flush_events does not cause ambiguity (ev->clearing
	 * can still be modified even if events are blocked).
	 */
	spin_lock_irq(&ev->lock);
	clearing |= ev->clearing;
	ev->clearing = 0;
	spin_unlock_irq(&ev->lock);

	disk_check_events(ev, &clearing);
	/*
	 * if ev->clearing is not 0, the disk_flush_events got called in the
	 * middle of this function, so we want to run the workfn without delay.
	 */
	__disk_unblock_events(disk, ev->clearing ? true : false);

	/* then, fetch and clear pending events */
	spin_lock_irq(&ev->lock);
	pending = ev->pending & mask;
	ev->pending &= ~mask;
	spin_unlock_irq(&ev->lock);
	WARN_ON_ONCE(clearing & mask);

	return pending;
}

/**
 * disk_check_media_change - check if a removable media has been changed
 * @disk: gendisk to check
 *
 * Check whether a removable media has been changed, and attempt to free all
 * dentries and inodes and invalidates all block device page cache entries in
 * that case.
 *
 * Returns %true if the media has changed, or %false if not.
 */
bool disk_check_media_change(struct gendisk *disk)
{
	unsigned int events;

	events = disk_clear_events(disk, DISK_EVENT_MEDIA_CHANGE |
				   DISK_EVENT_EJECT_REQUEST);
	if (!(events & DISK_EVENT_MEDIA_CHANGE))
		return false;

	bdev_mark_dead(disk->part0, true);
	set_bit(GD_NEED_PART_SCAN, &disk->state);
	return true;
}
EXPORT_SYMBOL(disk_check_media_change);

/**
 * disk_force_media_change - force a media change event
 * @disk: the disk which will raise the event
 * @events: the events to raise
 *
 * Should be called when the media changes for @disk.  Generates a uevent
 * and attempts to free all dentries and inodes and invalidates all block
 * device page cache entries in that case.
 */
void disk_force_media_change(struct gendisk *disk)
{
	disk_event_uevent(disk, DISK_EVENT_MEDIA_CHANGE);
	inc_diskseq(disk);
	bdev_mark_dead(disk->part0, true);
	set_bit(GD_NEED_PART_SCAN, &disk->state);
}
EXPORT_SYMBOL_GPL(disk_force_media_change);

/*
 * Separate this part out so that a different pointer for clearing_ptr can be
 * passed in for disk_clear_events.
 */
static void disk_events_workfn(struct work_struct *work)
{
	struct delayed_work *dwork = to_delayed_work(work);
	struct disk_events *ev = container_of(dwork, struct disk_events, dwork);

	disk_check_events(ev, &ev->clearing);
}

/*
 * A disk events enabled device has the following sysfs nodes under
 * its /sys/block/X/ directory.
 *
 * events		: list of all supported events
 * events_async		: list of events which can be detected w/o polling
 *			  (always empty, only for backwards compatibility)
 * events_poll_msecs	: polling interval, 0: disable, -1: system default
 */
static ssize_t __disk_events_show(unsigned int events, char *buf)
{
	const char *delim = "";
	ssize_t pos = 0;
	int i;

	for (i = 0; i < ARRAY_SIZE(disk_events_strs); i++)
		if (events & (1 << i)) {
			pos += sprintf(buf + pos, "%s%s",
				       delim, disk_events_strs[i]);
			delim = " ";
		}
	if (pos)
		pos += sprintf(buf + pos, "\n");
	return pos;
}

static ssize_t disk_events_show(struct device *dev,
				struct device_attribute *attr, char *buf)
{
	struct gendisk *disk = dev_to_disk(dev);

	if (!(disk->event_flags & DISK_EVENT_FLAG_UEVENT))
		return 0;
	return __disk_events_show(disk->events, buf);
}

static ssize_t disk_events_async_show(struct device *dev,
				      struct device_attribute *attr, char *buf)
{
	return 0;
}

static ssize_t disk_events_poll_msecs_show(struct device *dev,
					   struct device_attribute *attr,
					   char *buf)
{
	struct gendisk *disk = dev_to_disk(dev);

	if (!disk->ev)
		return sprintf(buf, "-1\n");
	return sprintf(buf, "%ld\n", disk->ev->poll_msecs);
}

static ssize_t disk_events_poll_msecs_store(struct device *dev,
					    struct device_attribute *attr,
					    const char *buf, size_t count)
{
	struct gendisk *disk = dev_to_disk(dev);
	long intv;

	if (!count || !sscanf(buf, "%ld", &intv))
		return -EINVAL;

	if (intv < 0 && intv != -1)
		return -EINVAL;

	if (!disk->ev)
		return -ENODEV;

	disk_block_events(disk);
	disk->ev->poll_msecs = intv;
	__disk_unblock_events(disk, true);
	return count;
}

DEVICE_ATTR(events, 0444, disk_events_show, NULL);
DEVICE_ATTR(events_async, 0444, disk_events_async_show, NULL);
DEVICE_ATTR(events_poll_msecs, 0644, disk_events_poll_msecs_show,
	    disk_events_poll_msecs_store);

/*
 * The default polling interval can be specified by the kernel
 * parameter block.events_dfl_poll_msecs which defaults to 0
 * (disable).  This can also be modified runtime by writing to
 * /sys/module/block/parameters/events_dfl_poll_msecs.
 */
static int disk_events_set_dfl_poll_msecs(const char *val,
					  const struct kernel_param *kp)
{
	struct disk_events *ev;
	int ret;

	ret = param_set_ulong(val, kp);
	if (ret < 0)
		return ret;

	mutex_lock(&disk_events_mutex);
	list_for_each_entry(ev, &disk_events, node)
		disk_flush_events(ev->disk, 0);
	mutex_unlock(&disk_events_mutex);
	return 0;
}

static const struct kernel_param_ops disk_events_dfl_poll_msecs_param_ops = {
	.set	= disk_events_set_dfl_poll_msecs,
	.get	= param_get_ulong,
};

#undef MODULE_PARAM_PREFIX
#define MODULE_PARAM_PREFIX	"block."

module_param_cb(events_dfl_poll_msecs, &disk_events_dfl_poll_msecs_param_ops,
		&disk_events_dfl_poll_msecs, 0644);

/*
 * disk_{alloc|add|del|release}_events - initialize and destroy disk_events.
 */
int disk_alloc_events(struct gendisk *disk)
{
	struct disk_events *ev;

	if (!disk->fops->check_events || !disk->events)
		return 0;

	ev = kzalloc(sizeof(*ev), GFP_KERNEL);
	if (!ev) {
		pr_warn("%s: failed to initialize events\n", disk->disk_name);
		return -ENOMEM;
	}

	INIT_LIST_HEAD(&ev->node);
	ev->disk = disk;
	spin_lock_init(&ev->lock);
	mutex_init(&ev->block_mutex);
	ev->block = 1;
	ev->poll_msecs = -1;
	INIT_DELAYED_WORK(&ev->dwork, disk_events_workfn);

	disk->ev = ev;
	return 0;
}

void disk_add_events(struct gendisk *disk)
{
	if (!disk->ev)
		return;

	mutex_lock(&disk_events_mutex);
	list_add_tail(&disk->ev->node, &disk_events);
	mutex_unlock(&disk_events_mutex);

	/*
	 * Block count is initialized to 1 and the following initial
	 * unblock kicks it into action.
	 */
	__disk_unblock_events(disk, true);
}

void disk_del_events(struct gendisk *disk)
{
	if (disk->ev) {
		disk_block_events(disk);

		mutex_lock(&disk_events_mutex);
		list_del_init(&disk->ev->node);
		mutex_unlock(&disk_events_mutex);
	}
}

void disk_release_events(struct gendisk *disk)
{
	/* the block count should be 1 from disk_del_events() */
	WARN_ON_ONCE(disk->ev && disk->ev->block != 1);
	kfree(disk->ev);
}
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)
e6138dc1 MC	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
444aa2c5 CH	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
560e20e4	284	bdev_mark_dead(disk->part0, true);
444aa2c5	285	set_bit(GD_NEED_PART_SCAN, &disk->state);
d5870edf CH	286	return true;
d5870edf CH	287	}
444aa2c5	288	EXPORT_SYMBOL(disk_check_media_change);
d5870edf	289
e6138dc1 MC	290	/**
	291	* disk_force_media_change - force a media change event
	292	* @disk: the disk which will raise the event
	293	* @events: the events to raise
	294	*
ab6860f6 CH	295	* Should be called when the media changes for @disk. Generates a uevent
ab6860f6 CH	296	* and attempts to free all dentries and inodes and invalidates all block
e6138dc1	297	* device page cache entries in that case.
e6138dc1	298	*/
ab6860f6	299	void disk_force_media_change(struct gendisk *disk)
e6138dc1	300	{
ab6860f6	301	disk_event_uevent(disk, DISK_EVENT_MEDIA_CHANGE);
b90ecc03	302	inc_diskseq(disk);
560e20e4	303	bdev_mark_dead(disk->part0, true);
e6138dc1	304	set_bit(GD_NEED_PART_SCAN, &disk->state);
e6138dc1 MC	305	}
	306	EXPORT_SYMBOL_GPL(disk_force_media_change);
	307
d5870edf CH	308	/*
	309	* Separate this part out so that a different pointer for clearing_ptr can be
	310	* passed in for disk_clear_events.
	311	*/
	312	static void disk_events_workfn(struct work_struct *work)
	313	{
	314	struct delayed_work *dwork = to_delayed_work(work);
	315	struct disk_events *ev = container_of(dwork, struct disk_events, dwork);
	316
	317	disk_check_events(ev, &ev->clearing);
	318	}
	319
	320	/*
	321	* A disk events enabled device has the following sysfs nodes under
	322	* its /sys/block/X/ directory.
	323	*
	324	* events : list of all supported events
	325	* events_async : list of events which can be detected w/o polling
	326	* (always empty, only for backwards compatibility)
	327	* events_poll_msecs : polling interval, 0: disable, -1: system default
	328	*/
	329	static ssize_t __disk_events_show(unsigned int events, char *buf)
	330	{
	331	const char *delim = "";
	332	ssize_t pos = 0;
	333	int i;
	334
	335	for (i = 0; i < ARRAY_SIZE(disk_events_strs); i++)
	336	if (events & (1 << i)) {
	337	pos += sprintf(buf + pos, "%s%s",
	338	delim, disk_events_strs[i]);
	339	delim = " ";
	340	}
	341	if (pos)
	342	pos += sprintf(buf + pos, "\n");
	343	return pos;
	344	}
	345
	346	static ssize_t disk_events_show(struct device *dev,
	347	struct device_attribute attr, char buf)
	348	{
	349	struct gendisk *disk = dev_to_disk(dev);
	350
	351	if (!(disk->event_flags & DISK_EVENT_FLAG_UEVENT))
	352	return 0;
	353	return __disk_events_show(disk->events, buf);
	354	}
	355
	356	static ssize_t disk_events_async_show(struct device *dev,
	357	struct device_attribute attr, char buf)
	358	{
	359	return 0;
	360	}
	361
	362	static ssize_t disk_events_poll_msecs_show(struct device *dev,
	363	struct device_attribute *attr,
	364	char *buf)
	365	{
	366	struct gendisk *disk = dev_to_disk(dev);
	367
	368	if (!disk->ev)
	369	return sprintf(buf, "-1\n");
	370	return sprintf(buf, "%ld\n", disk->ev->poll_msecs);
	371	}
372
373	static ssize_t disk_events_poll_msecs_store(struct device *dev,
374	struct device_attribute *attr,
375	const char *buf, size_t count)
376	{
377	struct gendisk *disk = dev_to_disk(dev);
378	long intv;
379
380	if (!count \|\| !sscanf(buf, "%ld", &intv))
381	return -EINVAL;
382
383	if (intv < 0 && intv != -1)
384	return -EINVAL;
385
386	if (!disk->ev)
387	return -ENODEV;
388
389	disk_block_events(disk);
390	disk->ev->poll_msecs = intv;
391	__disk_unblock_events(disk, true);
392	return count;
393	}
394
2bc8cda5 CH	395	DEVICE_ATTR(events, 0444, disk_events_show, NULL);
	396	DEVICE_ATTR(events_async, 0444, disk_events_async_show, NULL);
	397	DEVICE_ATTR(events_poll_msecs, 0644, disk_events_poll_msecs_show,
	398	disk_events_poll_msecs_store);
d5870edf CH	399
	400	/*
	401	* The default polling interval can be specified by the kernel
	402	* parameter block.events_dfl_poll_msecs which defaults to 0
	403	* (disable). This can also be modified runtime by writing to
	404	* /sys/module/block/parameters/events_dfl_poll_msecs.
	405	*/
	406	static int disk_events_set_dfl_poll_msecs(const char *val,
	407	const struct kernel_param *kp)
	408	{
	409	struct disk_events *ev;
	410	int ret;
	411
	412	ret = param_set_ulong(val, kp);
	413	if (ret < 0)
	414	return ret;
	415
	416	mutex_lock(&disk_events_mutex);
	417	list_for_each_entry(ev, &disk_events, node)
	418	disk_flush_events(ev->disk, 0);
	419	mutex_unlock(&disk_events_mutex);
	420	return 0;
	421	}
	422
	423	static const struct kernel_param_ops disk_events_dfl_poll_msecs_param_ops = {
	424	.set = disk_events_set_dfl_poll_msecs,
	425	.get = param_get_ulong,
	426	};
	427
	428	#undef MODULE_PARAM_PREFIX
	429	#define MODULE_PARAM_PREFIX "block."
	430
	431	module_param_cb(events_dfl_poll_msecs, &disk_events_dfl_poll_msecs_param_ops,
	432	&disk_events_dfl_poll_msecs, 0644);
	433
	434	/*
	435	* disk_{alloc\|add\|del\|release}_events - initialize and destroy disk_events.
	436	*/
92e7755e	437	int disk_alloc_events(struct gendisk *disk)
d5870edf CH	438	{
	439	struct disk_events *ev;
	440
	441	if (!disk->fops->check_events \|\| !disk->events)
92e7755e	442	return 0;
d5870edf CH	443
	444	ev = kzalloc(sizeof(*ev), GFP_KERNEL);
	445	if (!ev) {
	446	pr_warn("%s: failed to initialize events\n", disk->disk_name);
92e7755e	447	return -ENOMEM;
d5870edf CH	448	}
	449
	450	INIT_LIST_HEAD(&ev->node);
	451	ev->disk = disk;
	452	spin_lock_init(&ev->lock);
	453	mutex_init(&ev->block_mutex);
	454	ev->block = 1;
	455	ev->poll_msecs = -1;
	456	INIT_DELAYED_WORK(&ev->dwork, disk_events_workfn);
	457
	458	disk->ev = ev;
92e7755e	459	return 0;
d5870edf CH	460	}
	461
	462	void disk_add_events(struct gendisk *disk)
	463	{
d5870edf CH	464	if (!disk->ev)
	465	return;
	466
	467	mutex_lock(&disk_events_mutex);
	468	list_add_tail(&disk->ev->node, &disk_events);
	469	mutex_unlock(&disk_events_mutex);
	470
	471	/*
	472	* Block count is initialized to 1 and the following initial
	473	* unblock kicks it into action.
	474	*/
	475	__disk_unblock_events(disk, true);
	476	}
	477
	478	void disk_del_events(struct gendisk *disk)
	479	{
	480	if (disk->ev) {
	481	disk_block_events(disk);
	482
	483	mutex_lock(&disk_events_mutex);
	484	list_del_init(&disk->ev->node);
	485	mutex_unlock(&disk_events_mutex);
	486	}
d5870edf CH	487	}
	488
	489	void disk_release_events(struct gendisk *disk)
	490	{
	491	/* the block count should be 1 from disk_del_events() */
	492	WARN_ON_ONCE(disk->ev && disk->ev->block != 1);
	493	kfree(disk->ev);
	494	}