Kernel

Kernel Git Source Tree

Root/block/genhd.c

1	/*
2	* gendisk handling
3	*/
4
5	#include <linux/module.h>
6	#include <linux/fs.h>
7	#include <linux/genhd.h>
8	#include <linux/kdev_t.h>
9	#include <linux/kernel.h>
10	#include <linux/blkdev.h>
11	#include <linux/init.h>
12	#include <linux/spinlock.h>
13	#include <linux/proc_fs.h>
14	#include <linux/seq_file.h>
15	#include <linux/slab.h>
16	#include <linux/kmod.h>
17	#include <linux/kobj_map.h>
18	#include <linux/mutex.h>
19	#include <linux/idr.h>
20	#include <linux/log2.h>
21	#include <linux/pm_runtime.h>
22
23	#include "blk.h"
24
25	static DEFINE_MUTEX(block_class_lock);
26	struct kobject *block_depr;
27
28	/* for extended dynamic devt allocation, currently only one major is used */
29	#define NR_EXT_DEVT (1 << MINORBITS)
30
31	/* For extended devt allocation. ext_devt_mutex prevents look up
32	* results from going away underneath its user.
33	*/
34	static DEFINE_MUTEX(ext_devt_mutex);
35	static DEFINE_IDR(ext_devt_idr);
36
37	static struct device_type disk_type;
38
39	static void disk_check_events(struct disk_events *ev,
40	unsigned int *clearing_ptr);
41	static void disk_alloc_events(struct gendisk *disk);
42	static void disk_add_events(struct gendisk *disk);
43	static void disk_del_events(struct gendisk *disk);
44	static void disk_release_events(struct gendisk *disk);
45
46	/**
47	* disk_get_part - get partition
48	* @disk: disk to look partition from
49	* @partno: partition number
50	*
51	* Look for partition @partno from @disk. If found, increment
52	* reference count and return it.
53	*
54	* CONTEXT:
55	* Don't care.
56	*
57	* RETURNS:
58	* Pointer to the found partition on success, NULL if not found.
59	*/
60	struct hd_struct disk_get_part(struct gendisk disk, int partno)
61	{
62	struct hd_struct *part = NULL;
63	struct disk_part_tbl *ptbl;
64
65	if (unlikely(partno < 0))
66	return NULL;
67
68	rcu_read_lock();
69
70	ptbl = rcu_dereference(disk->part_tbl);
71	if (likely(partno < ptbl->len)) {
72	part = rcu_dereference(ptbl->part[partno]);
73	if (part)
74	get_device(part_to_dev(part));
75	}
76
77	rcu_read_unlock();
78
79	return part;
80	}
81	EXPORT_SYMBOL_GPL(disk_get_part);
82
83	/**
84	* disk_part_iter_init - initialize partition iterator
85	* @piter: iterator to initialize
86	* @disk: disk to iterate over
87	* @flags: DISK_PITER_* flags
88	*
89	* Initialize @piter so that it iterates over partitions of @disk.
90	*
91	* CONTEXT:
92	* Don't care.
93	*/
94	void disk_part_iter_init(struct disk_part_iter piter, struct gendisk disk,
95	unsigned int flags)
96	{
97	struct disk_part_tbl *ptbl;
98
99	rcu_read_lock();
100	ptbl = rcu_dereference(disk->part_tbl);
101
102	piter->disk = disk;
103	piter->part = NULL;
104
105	if (flags & DISK_PITER_REVERSE)
106	piter->idx = ptbl->len - 1;
107	else if (flags & (DISK_PITER_INCL_PART0 \| DISK_PITER_INCL_EMPTY_PART0))
108	piter->idx = 0;
109	else
110	piter->idx = 1;
111
112	piter->flags = flags;
113
114	rcu_read_unlock();
115	}
116	EXPORT_SYMBOL_GPL(disk_part_iter_init);
117
118	/**
119	* disk_part_iter_next - proceed iterator to the next partition and return it
120	* @piter: iterator of interest
121	*
122	* Proceed @piter to the next partition and return it.
123	*
124	* CONTEXT:
125	* Don't care.
126	*/
127	struct hd_struct disk_part_iter_next(struct disk_part_iter piter)
128	{
129	struct disk_part_tbl *ptbl;
130	int inc, end;
131
132	/* put the last partition */
133	disk_put_part(piter->part);
134	piter->part = NULL;
135
136	/* get part_tbl */
137	rcu_read_lock();
138	ptbl = rcu_dereference(piter->disk->part_tbl);
139
140	/* determine iteration parameters */
141	if (piter->flags & DISK_PITER_REVERSE) {
142	inc = -1;
143	if (piter->flags & (DISK_PITER_INCL_PART0 \|
144	DISK_PITER_INCL_EMPTY_PART0))
145	end = -1;
146	else
147	end = 0;
148	} else {
149	inc = 1;
150	end = ptbl->len;
151	}
152
153	/* iterate to the next partition */
154	for (; piter->idx != end; piter->idx += inc) {
155	struct hd_struct *part;
156
157	part = rcu_dereference(ptbl->part[piter->idx]);
158	if (!part)
159	continue;
160	if (!part_nr_sects_read(part) &&
161	!(piter->flags & DISK_PITER_INCL_EMPTY) &&
162	!(piter->flags & DISK_PITER_INCL_EMPTY_PART0 &&
163	piter->idx == 0))
164	continue;
165
166	get_device(part_to_dev(part));
167	piter->part = part;
168	piter->idx += inc;
169	break;
170	}
171
172	rcu_read_unlock();
173
174	return piter->part;
175	}
176	EXPORT_SYMBOL_GPL(disk_part_iter_next);
177
178	/**
179	* disk_part_iter_exit - finish up partition iteration
180	* @piter: iter of interest
181	*
182	* Called when iteration is over. Cleans up @piter.
183	*
184	* CONTEXT:
185	* Don't care.
186	*/
187	void disk_part_iter_exit(struct disk_part_iter *piter)
188	{
189	disk_put_part(piter->part);
190	piter->part = NULL;
191	}
192	EXPORT_SYMBOL_GPL(disk_part_iter_exit);
193
194	static inline int sector_in_part(struct hd_struct *part, sector_t sector)
195	{
196	return part->start_sect <= sector &&
197	sector < part->start_sect + part_nr_sects_read(part);
198	}
199
200	/**
201	* disk_map_sector_rcu - map sector to partition
202	* @disk: gendisk of interest
203	* @sector: sector to map
204	*
205	* Find out which partition @sector maps to on @disk. This is
206	* primarily used for stats accounting.
207	*
208	* CONTEXT:
209	* RCU read locked. The returned partition pointer is valid only
210	* while preemption is disabled.
211	*
212	* RETURNS:
213	* Found partition on success, part0 is returned if no partition matches
214	*/
215	struct hd_struct disk_map_sector_rcu(struct gendisk disk, sector_t sector)
216	{
217	struct disk_part_tbl *ptbl;
218	struct hd_struct *part;
219	int i;
220
221	ptbl = rcu_dereference(disk->part_tbl);
222
223	part = rcu_dereference(ptbl->last_lookup);
224	if (part && sector_in_part(part, sector))
225	return part;
226
227	for (i = 1; i < ptbl->len; i++) {
228	part = rcu_dereference(ptbl->part[i]);
229
230	if (part && sector_in_part(part, sector)) {
231	rcu_assign_pointer(ptbl->last_lookup, part);
232	return part;
233	}
234	}
235	return &disk->part0;
236	}
237	EXPORT_SYMBOL_GPL(disk_map_sector_rcu);
238
239	/*
240	* Can be deleted altogether. Later.
241	*
242	*/
243	static struct blk_major_name {
244	struct blk_major_name *next;
245	int major;
246	char name[16];
247	} *major_names[BLKDEV_MAJOR_HASH_SIZE];
248
249	/* index in the above - for now: assume no multimajor ranges */
250	static inline int major_to_index(unsigned major)
251	{
252	return major % BLKDEV_MAJOR_HASH_SIZE;
253	}
254
255	#ifdef CONFIG_PROC_FS
256	void blkdev_show(struct seq_file *seqf, off_t offset)
257	{
258	struct blk_major_name *dp;
259
260	if (offset < BLKDEV_MAJOR_HASH_SIZE) {
261	mutex_lock(&block_class_lock);
262	for (dp = major_names[offset]; dp; dp = dp->next)
263	seq_printf(seqf, "%3d %s\n", dp->major, dp->name);
264	mutex_unlock(&block_class_lock);
265	}
266	}
267	#endif /* CONFIG_PROC_FS */
268
269	/**
270	* register_blkdev - register a new block device
271	*
272	* @major: the requested major device number [1..255]. If @major=0, try to
273	* allocate any unused major number.
274	* @name: the name of the new block device as a zero terminated string
275	*
276	* The @name must be unique within the system.
277	*
278	* The return value depends on the @major input parameter.
279	* - if a major device number was requested in range [1..255] then the
280	* function returns zero on success, or a negative error code
281	* - if any unused major number was requested with @major=0 parameter
282	* then the return value is the allocated major number in range
283	* [1..255] or a negative error code otherwise
284	*/
285	int register_blkdev(unsigned int major, const char *name)
286	{
287	struct blk_major_name *n, p;
288	int index, ret = 0;
289
290	mutex_lock(&block_class_lock);
291
292	/* temporary */
293	if (major == 0) {
294	for (index = ARRAY_SIZE(major_names)-1; index > 0; index--) {
295	if (major_names[index] == NULL)
296	break;
297	}
298
299	if (index == 0) {
300	printk("register_blkdev: failed to get major for %s\n",
301	name);
302	ret = -EBUSY;
303	goto out;
304	}
305	major = index;
306	ret = major;
307	}
308
309	p = kmalloc(sizeof(struct blk_major_name), GFP_KERNEL);
310	if (p == NULL) {
311	ret = -ENOMEM;
312	goto out;
313	}
314
315	p->major = major;
316	strlcpy(p->name, name, sizeof(p->name));
317	p->next = NULL;
318	index = major_to_index(major);
319
320	for (n = &major_names[index]; n; n = &(n)->next) {
321	if ((*n)->major == major)
322	break;
323	}
324	if (!*n)
325	*n = p;
326	else
327	ret = -EBUSY;
328
329	if (ret < 0) {
330	printk("register_blkdev: cannot get major %d for %s\n",
331	major, name);
332	kfree(p);
333	}
334	out:
335	mutex_unlock(&block_class_lock);
336	return ret;
337	}
338
339	EXPORT_SYMBOL(register_blkdev);
340
341	void unregister_blkdev(unsigned int major, const char *name)
342	{
343	struct blk_major_name **n;
344	struct blk_major_name *p = NULL;
345	int index = major_to_index(major);
346
347	mutex_lock(&block_class_lock);
348	for (n = &major_names[index]; n; n = &(n)->next)
349	if ((*n)->major == major)
350	break;
351	if (!n \|\| strcmp((n)->name, name)) {
352	WARN_ON(1);
353	} else {
354	p = *n;
355	*n = p->next;
356	}
357	mutex_unlock(&block_class_lock);
358	kfree(p);
359	}
360
361	EXPORT_SYMBOL(unregister_blkdev);
362
363	static struct kobj_map *bdev_map;
364
365	/**
366	* blk_mangle_minor - scatter minor numbers apart
367	* @minor: minor number to mangle
368	*
369	* Scatter consecutively allocated @minor number apart if MANGLE_DEVT
370	* is enabled. Mangling twice gives the original value.
371	*
372	* RETURNS:
373	* Mangled value.
374	*
375	* CONTEXT:
376	* Don't care.
377	*/
378	static int blk_mangle_minor(int minor)
379	{
380	#ifdef CONFIG_DEBUG_BLOCK_EXT_DEVT
381	int i;
382
383	for (i = 0; i < MINORBITS / 2; i++) {
384	int low = minor & (1 << i);
385	int high = minor & (1 << (MINORBITS - 1 - i));
386	int distance = MINORBITS - 1 - 2 * i;
387
388	minor ^= low \| high; /* clear both bits */
389	low <<= distance; /* swap the positions */
390	high >>= distance;
391	minor \|= low \| high; /* and set */
392	}
393	#endif
394	return minor;
395	}
396
397	/**
398	* blk_alloc_devt - allocate a dev_t for a partition
399	* @part: partition to allocate dev_t for
400	* @devt: out parameter for resulting dev_t
401	*
402	* Allocate a dev_t for block device.
403	*
404	* RETURNS:
405	* 0 on success, allocated dev_t is returned in *@devt. -errno on
406	* failure.
407	*
408	* CONTEXT:
409	* Might sleep.
410	*/
411	int blk_alloc_devt(struct hd_struct part, dev_t devt)
412	{
413	struct gendisk *disk = part_to_disk(part);
414	int idx;
415
416	/* in consecutive minor range? */
417	if (part->partno < disk->minors) {
418	*devt = MKDEV(disk->major, disk->first_minor + part->partno);
419	return 0;
420	}
421
422	/* allocate ext devt */
423	mutex_lock(&ext_devt_mutex);
424	idx = idr_alloc(&ext_devt_idr, part, 0, NR_EXT_DEVT, GFP_KERNEL);
425	mutex_unlock(&ext_devt_mutex);
426	if (idx < 0)
427	return idx == -ENOSPC ? -EBUSY : idx;
428
429	*devt = MKDEV(BLOCK_EXT_MAJOR, blk_mangle_minor(idx));
430	return 0;
431	}
432
433	/**
434	* blk_free_devt - free a dev_t
435	* @devt: dev_t to free
436	*
437	* Free @devt which was allocated using blk_alloc_devt().
438	*
439	* CONTEXT:
440	* Might sleep.
441	*/
442	void blk_free_devt(dev_t devt)
443	{
444	might_sleep();
445
446	if (devt == MKDEV(0, 0))
447	return;
448
449	if (MAJOR(devt) == BLOCK_EXT_MAJOR) {
450	mutex_lock(&ext_devt_mutex);
451	idr_remove(&ext_devt_idr, blk_mangle_minor(MINOR(devt)));
452	mutex_unlock(&ext_devt_mutex);
453	}
454	}
455
456	static char bdevt_str(dev_t devt, char buf)
457	{
458	if (MAJOR(devt) <= 0xff && MINOR(devt) <= 0xff) {
459	char tbuf[BDEVT_SIZE];
460	snprintf(tbuf, BDEVT_SIZE, "%02x%02x", MAJOR(devt), MINOR(devt));
461	snprintf(buf, BDEVT_SIZE, "%-9s", tbuf);
462	} else
463	snprintf(buf, BDEVT_SIZE, "%03x:%05x", MAJOR(devt), MINOR(devt));
464
465	return buf;
466	}
467
468	/*
469	* Register device numbers dev..(dev+range-1)
470	* range must be nonzero
471	* The hash chain is sorted on range, so that subranges can override.
472	*/
473	void blk_register_region(dev_t devt, unsigned long range, struct module *module,
474	struct kobject (probe)(dev_t, int , void ),
475	int (lock)(dev_t, void ), void *data)
476	{
477	kobj_map(bdev_map, devt, range, module, probe, lock, data);
478	}
479
480	EXPORT_SYMBOL(blk_register_region);
481
482	void blk_unregister_region(dev_t devt, unsigned long range)
483	{
484	kobj_unmap(bdev_map, devt, range);
485	}
486
487	EXPORT_SYMBOL(blk_unregister_region);
488
489	static struct kobject exact_match(dev_t devt, int partno, void *data)
490	{
491	struct gendisk *p = data;
492
493	return &disk_to_dev(p)->kobj;
494	}
495
496	static int exact_lock(dev_t devt, void *data)
497	{
498	struct gendisk *p = data;
499
500	if (!get_disk(p))
501	return -1;
502	return 0;
503	}
504
505	static void register_disk(struct gendisk *disk)
506	{
507	struct device *ddev = disk_to_dev(disk);
508	struct block_device *bdev;
509	struct disk_part_iter piter;
510	struct hd_struct *part;
511	int err;
512
513	ddev->parent = disk->driverfs_dev;
514
515	dev_set_name(ddev, disk->disk_name);
516
517	/* delay uevents, until we scanned partition table */
518	dev_set_uevent_suppress(ddev, 1);
519
520	if (device_add(ddev))
521	return;
522	if (!sysfs_deprecated) {
523	err = sysfs_create_link(block_depr, &ddev->kobj,
524	kobject_name(&ddev->kobj));
525	if (err) {
526	device_del(ddev);
527	return;
528	}
529	}
530
531	/*
532	* avoid probable deadlock caused by allocating memory with
533	* GFP_KERNEL in runtime_resume callback of its all ancestor
534	* devices
535	*/
536	pm_runtime_set_memalloc_noio(ddev, true);
537
538	disk->part0.holder_dir = kobject_create_and_add("holders", &ddev->kobj);
539	disk->slave_dir = kobject_create_and_add("slaves", &ddev->kobj);
540
541	/* No minors to use for partitions */
542	if (!disk_part_scan_enabled(disk))
543	goto exit;
544
545	/* No such device (e.g., media were just removed) */
546	if (!get_capacity(disk))
547	goto exit;
548
549	bdev = bdget_disk(disk, 0);
550	if (!bdev)
551	goto exit;
552
553	bdev->bd_invalidated = 1;
554	err = blkdev_get(bdev, FMODE_READ, NULL);
555	if (err < 0)
556	goto exit;
557	blkdev_put(bdev, FMODE_READ);
558
559	exit:
560	/* announce disk after possible partitions are created */
561	dev_set_uevent_suppress(ddev, 0);
562	kobject_uevent(&ddev->kobj, KOBJ_ADD);
563
564	/* announce possible partitions */
565	disk_part_iter_init(&piter, disk, 0);
566	while ((part = disk_part_iter_next(&piter)))
567	kobject_uevent(&part_to_dev(part)->kobj, KOBJ_ADD);
568	disk_part_iter_exit(&piter);
569	}
570
571	/**
572	* add_disk - add partitioning information to kernel list
573	* @disk: per-device partitioning information
574	*
575	* This function registers the partitioning information in @disk
576	* with the kernel.
577	*
578	* FIXME: error handling
579	*/
580	void add_disk(struct gendisk *disk)
581	{
582	struct backing_dev_info *bdi;
583	dev_t devt;
584	int retval;
585
586	/* minors == 0 indicates to use ext devt from part0 and should
587	* be accompanied with EXT_DEVT flag. Make sure all
588	* parameters make sense.
589	*/
590	WARN_ON(disk->minors && !(disk->major \|\| disk->first_minor));
591	WARN_ON(!disk->minors && !(disk->flags & GENHD_FL_EXT_DEVT));
592
593	disk->flags \|= GENHD_FL_UP;
594
595	retval = blk_alloc_devt(&disk->part0, &devt);
596	if (retval) {
597	WARN_ON(1);
598	return;
599	}
600	disk_to_dev(disk)->devt = devt;
601
602	/* ->major and ->first_minor aren't supposed to be
603	* dereferenced from here on, but set them just in case.
604	*/
605	disk->major = MAJOR(devt);
606	disk->first_minor = MINOR(devt);
607
608	disk_alloc_events(disk);
609
610	/* Register BDI before referencing it from bdev */
611	bdi = &disk->queue->backing_dev_info;
612	bdi_register_dev(bdi, disk_devt(disk));
613
614	blk_register_region(disk_devt(disk), disk->minors, NULL,
615	exact_match, exact_lock, disk);
616	register_disk(disk);
617	blk_register_queue(disk);
618
619	/*
620	* Take an extra ref on queue which will be put on disk_release()
621	* so that it sticks around as long as @disk is there.
622	*/
623	WARN_ON_ONCE(!blk_get_queue(disk->queue));
624
625	retval = sysfs_create_link(&disk_to_dev(disk)->kobj, &bdi->dev->kobj,
626	"bdi");
627	WARN_ON(retval);
628
629	disk_add_events(disk);
630	}
631	EXPORT_SYMBOL(add_disk);
632
633	void del_gendisk(struct gendisk *disk)
634	{
635	struct disk_part_iter piter;
636	struct hd_struct *part;
637
638	disk_del_events(disk);
639
640	/* invalidate stuff */
641	disk_part_iter_init(&piter, disk,
642	DISK_PITER_INCL_EMPTY \| DISK_PITER_REVERSE);
643	while ((part = disk_part_iter_next(&piter))) {
644	invalidate_partition(disk, part->partno);
645	delete_partition(disk, part->partno);
646	}
647	disk_part_iter_exit(&piter);
648
649	invalidate_partition(disk, 0);
650	set_capacity(disk, 0);
651	disk->flags &= ~GENHD_FL_UP;
652
653	sysfs_remove_link(&disk_to_dev(disk)->kobj, "bdi");
654	bdi_unregister(&disk->queue->backing_dev_info);
655	blk_unregister_queue(disk);
656	blk_unregister_region(disk_devt(disk), disk->minors);
657
658	part_stat_set_all(&disk->part0, 0);
659	disk->part0.stamp = 0;
660
661	kobject_put(disk->part0.holder_dir);
662	kobject_put(disk->slave_dir);
663	disk->driverfs_dev = NULL;
664	if (!sysfs_deprecated)
665	sysfs_remove_link(block_depr, dev_name(disk_to_dev(disk)));
666	pm_runtime_set_memalloc_noio(disk_to_dev(disk), false);
667	device_del(disk_to_dev(disk));
668	blk_free_devt(disk_to_dev(disk)->devt);
669	}
670	EXPORT_SYMBOL(del_gendisk);
671
672	/**
673	* get_gendisk - get partitioning information for a given device
674	* @devt: device to get partitioning information for
675	* @partno: returned partition index
676	*
677	* This function gets the structure containing partitioning
678	* information for the given device @devt.
679	*/
680	struct gendisk get_gendisk(dev_t devt, int partno)
681	{
682	struct gendisk *disk = NULL;
683
684	if (MAJOR(devt) != BLOCK_EXT_MAJOR) {
685	struct kobject *kobj;
686
687	kobj = kobj_lookup(bdev_map, devt, partno);
688	if (kobj)
689	disk = dev_to_disk(kobj_to_dev(kobj));
690	} else {
691	struct hd_struct *part;
692
693	mutex_lock(&ext_devt_mutex);
694	part = idr_find(&ext_devt_idr, blk_mangle_minor(MINOR(devt)));
695	if (part && get_disk(part_to_disk(part))) {
696	*partno = part->partno;
697	disk = part_to_disk(part);
698	}
699	mutex_unlock(&ext_devt_mutex);
700	}
701
702	return disk;
703	}
704	EXPORT_SYMBOL(get_gendisk);
705
706	/**
707	* bdget_disk - do bdget() by gendisk and partition number
708	* @disk: gendisk of interest
709	* @partno: partition number
710	*
711	* Find partition @partno from @disk, do bdget() on it.
712	*
713	* CONTEXT:
714	* Don't care.
715	*
716	* RETURNS:
717	* Resulting block_device on success, NULL on failure.
718	*/
719	struct block_device bdget_disk(struct gendisk disk, int partno)
720	{
721	struct hd_struct *part;
722	struct block_device *bdev = NULL;
723
724	part = disk_get_part(disk, partno);
725	if (part)
726	bdev = bdget(part_devt(part));
727	disk_put_part(part);
728
729	return bdev;
730	}
731	EXPORT_SYMBOL(bdget_disk);
732
733	/*
734	* print a full list of all partitions - intended for places where the root
735	* filesystem can't be mounted and thus to give the victim some idea of what
736	* went wrong
737	*/
738	void __init printk_all_partitions(void)
739	{
740	struct class_dev_iter iter;
741	struct device *dev;
742
743	class_dev_iter_init(&iter, &block_class, NULL, &disk_type);
744	while ((dev = class_dev_iter_next(&iter))) {
745	struct gendisk *disk = dev_to_disk(dev);
746	struct disk_part_iter piter;
747	struct hd_struct *part;
748	char name_buf[BDEVNAME_SIZE];
749	char devt_buf[BDEVT_SIZE];
750
751	/*
752	* Don't show empty devices or things that have been
753	* suppressed
754	*/
755	if (get_capacity(disk) == 0 \|\|
756	(disk->flags & GENHD_FL_SUPPRESS_PARTITION_INFO))
757	continue;
758
759	/*
760	* Note, unlike /proc/partitions, I am showing the
761	* numbers in hex - the same format as the root=
762	* option takes.
763	*/
764	disk_part_iter_init(&piter, disk, DISK_PITER_INCL_PART0);
765	while ((part = disk_part_iter_next(&piter))) {
766	bool is_part0 = part == &disk->part0;
767
768	printk("%s%s %10llu %s %s", is_part0 ? "" : " ",
769	bdevt_str(part_devt(part), devt_buf),
770	(unsigned long long)part_nr_sects_read(part) >> 1
771	, disk_name(disk, part->partno, name_buf),
772	part->info ? part->info->uuid : "");
773	if (is_part0) {
774	if (disk->driverfs_dev != NULL &&
775	disk->driverfs_dev->driver != NULL)
776	printk(" driver: %s\n",
777	disk->driverfs_dev->driver->name);
778	else
779	printk(" (driver?)\n");
780	} else
781	printk("\n");
782	}
783	disk_part_iter_exit(&piter);
784	}
785	class_dev_iter_exit(&iter);
786	}
787
788	#ifdef CONFIG_PROC_FS
789	/* iterator */
790	static void disk_seqf_start(struct seq_file seqf, loff_t *pos)
791	{
792	loff_t skip = *pos;
793	struct class_dev_iter *iter;
794	struct device *dev;
795
796	iter = kmalloc(sizeof(*iter), GFP_KERNEL);
797	if (!iter)
798	return ERR_PTR(-ENOMEM);
799
800	seqf->private = iter;
801	class_dev_iter_init(iter, &block_class, NULL, &disk_type);
802	do {
803	dev = class_dev_iter_next(iter);
804	if (!dev)
805	return NULL;
806	} while (skip--);
807
808	return dev_to_disk(dev);
809	}
810
811	static void disk_seqf_next(struct seq_file seqf, void v, loff_t pos)
812	{
813	struct device *dev;
814
815	(*pos)++;
816	dev = class_dev_iter_next(seqf->private);
817	if (dev)
818	return dev_to_disk(dev);
819
820	return NULL;
821	}
822
823	static void disk_seqf_stop(struct seq_file seqf, void v)
824	{
825	struct class_dev_iter *iter = seqf->private;
826
827	/* stop is called even after start failed :-( */
828	if (iter) {
829	class_dev_iter_exit(iter);
830	kfree(iter);
831	}
832	}
833
834	static void show_partition_start(struct seq_file seqf, loff_t *pos)
835	{
836	void *p;
837
838	p = disk_seqf_start(seqf, pos);
839	if (!IS_ERR_OR_NULL(p) && !*pos)
840	seq_puts(seqf, "major minor #blocks name\n\n");
841	return p;
842	}
843
844	static int show_partition(struct seq_file seqf, void v)
845	{
846	struct gendisk *sgp = v;
847	struct disk_part_iter piter;
848	struct hd_struct *part;
849	char buf[BDEVNAME_SIZE];
850
851	/* Don't show non-partitionable removeable devices or empty devices */
852	if (!get_capacity(sgp) \|\| (!disk_max_parts(sgp) &&
853	(sgp->flags & GENHD_FL_REMOVABLE)))
854	return 0;
855	if (sgp->flags & GENHD_FL_SUPPRESS_PARTITION_INFO)
856	return 0;
857
858	/* show the full disk and all non-0 size partitions of it */
859	disk_part_iter_init(&piter, sgp, DISK_PITER_INCL_PART0);
860	while ((part = disk_part_iter_next(&piter)))
861	seq_printf(seqf, "%4d %7d %10llu %s\n",
862	MAJOR(part_devt(part)), MINOR(part_devt(part)),
863	(unsigned long long)part_nr_sects_read(part) >> 1,
864	disk_name(sgp, part->partno, buf));
865	disk_part_iter_exit(&piter);
866
867	return 0;
868	}
869
870	static const struct seq_operations partitions_op = {
871	.start = show_partition_start,
872	.next = disk_seqf_next,
873	.stop = disk_seqf_stop,
874	.show = show_partition
875	};
876
877	static int partitions_open(struct inode inode, struct file file)
878	{
879	return seq_open(file, &partitions_op);
880	}
881
882	static const struct file_operations proc_partitions_operations = {
883	.open = partitions_open,
884	.read = seq_read,
885	.llseek = seq_lseek,
886	.release = seq_release,
887	};
888	#endif
889
890
891	static struct kobject base_probe(dev_t devt, int partno, void *data)
892	{
893	if (request_module("block-major-%d-%d", MAJOR(devt), MINOR(devt)) > 0)
894	/* Make old-style 2.4 aliases work */
895	request_module("block-major-%d", MAJOR(devt));
896	return NULL;
897	}
898
899	static int __init genhd_device_init(void)
900	{
901	int error;
902
903	block_class.dev_kobj = sysfs_dev_block_kobj;
904	error = class_register(&block_class);
905	if (unlikely(error))
906	return error;
907	bdev_map = kobj_map_init(base_probe, &block_class_lock);
908	blk_dev_init();
909
910	register_blkdev(BLOCK_EXT_MAJOR, "blkext");
911
912	/* create top-level block dir */
913	if (!sysfs_deprecated)
914	block_depr = kobject_create_and_add("block", NULL);
915	return 0;
916	}
917
918	subsys_initcall(genhd_device_init);
919
920	static ssize_t disk_range_show(struct device *dev,
921	struct device_attribute attr, char buf)
922	{
923	struct gendisk *disk = dev_to_disk(dev);
924
925	return sprintf(buf, "%d\n", disk->minors);
926	}
927
928	static ssize_t disk_ext_range_show(struct device *dev,
929	struct device_attribute attr, char buf)
930	{
931	struct gendisk *disk = dev_to_disk(dev);
932
933	return sprintf(buf, "%d\n", disk_max_parts(disk));
934	}
935
936	static ssize_t disk_removable_show(struct device *dev,
937	struct device_attribute attr, char buf)
938	{
939	struct gendisk *disk = dev_to_disk(dev);
940
941	return sprintf(buf, "%d\n",
942	(disk->flags & GENHD_FL_REMOVABLE ? 1 : 0));
943	}
944
945	static ssize_t disk_ro_show(struct device *dev,
946	struct device_attribute attr, char buf)
947	{
948	struct gendisk *disk = dev_to_disk(dev);
949
950	return sprintf(buf, "%d\n", get_disk_ro(disk) ? 1 : 0);
951	}
952
953	static ssize_t disk_capability_show(struct device *dev,
954	struct device_attribute attr, char buf)
955	{
956	struct gendisk *disk = dev_to_disk(dev);
957
958	return sprintf(buf, "%x\n", disk->flags);
959	}
960
961	static ssize_t disk_alignment_offset_show(struct device *dev,
962	struct device_attribute *attr,
963	char *buf)
964	{
965	struct gendisk *disk = dev_to_disk(dev);
966
967	return sprintf(buf, "%d\n", queue_alignment_offset(disk->queue));
968	}
969
970	static ssize_t disk_discard_alignment_show(struct device *dev,
971	struct device_attribute *attr,
972	char *buf)
973	{
974	struct gendisk *disk = dev_to_disk(dev);
975
976	return sprintf(buf, "%d\n", queue_discard_alignment(disk->queue));
977	}
978
979	static DEVICE_ATTR(range, S_IRUGO, disk_range_show, NULL);
980	static DEVICE_ATTR(ext_range, S_IRUGO, disk_ext_range_show, NULL);
981	static DEVICE_ATTR(removable, S_IRUGO, disk_removable_show, NULL);
982	static DEVICE_ATTR(ro, S_IRUGO, disk_ro_show, NULL);
983	static DEVICE_ATTR(size, S_IRUGO, part_size_show, NULL);
984	static DEVICE_ATTR(alignment_offset, S_IRUGO, disk_alignment_offset_show, NULL);
985	static DEVICE_ATTR(discard_alignment, S_IRUGO, disk_discard_alignment_show,
986	NULL);
987	static DEVICE_ATTR(capability, S_IRUGO, disk_capability_show, NULL);
988	static DEVICE_ATTR(stat, S_IRUGO, part_stat_show, NULL);
989	static DEVICE_ATTR(inflight, S_IRUGO, part_inflight_show, NULL);
990	#ifdef CONFIG_FAIL_MAKE_REQUEST
991	static struct device_attribute dev_attr_fail =
992	__ATTR(make-it-fail, S_IRUGO\|S_IWUSR, part_fail_show, part_fail_store);
993	#endif
994	#ifdef CONFIG_FAIL_IO_TIMEOUT
995	static struct device_attribute dev_attr_fail_timeout =
996	__ATTR(io-timeout-fail, S_IRUGO\|S_IWUSR, part_timeout_show,
997	part_timeout_store);
998	#endif
999
1000	static struct attribute *disk_attrs[] = {
1001	&dev_attr_range.attr,
1002	&dev_attr_ext_range.attr,
1003	&dev_attr_removable.attr,
1004	&dev_attr_ro.attr,
1005	&dev_attr_size.attr,
1006	&dev_attr_alignment_offset.attr,
1007	&dev_attr_discard_alignment.attr,
1008	&dev_attr_capability.attr,
1009	&dev_attr_stat.attr,
1010	&dev_attr_inflight.attr,
1011	#ifdef CONFIG_FAIL_MAKE_REQUEST
1012	&dev_attr_fail.attr,
1013	#endif
1014	#ifdef CONFIG_FAIL_IO_TIMEOUT
1015	&dev_attr_fail_timeout.attr,
1016	#endif
1017	NULL
1018	};
1019
1020	static struct attribute_group disk_attr_group = {
1021	.attrs = disk_attrs,
1022	};
1023
1024	static const struct attribute_group *disk_attr_groups[] = {
1025	&disk_attr_group,
1026	NULL
1027	};
1028
1029	/**
1030	* disk_replace_part_tbl - replace disk->part_tbl in RCU-safe way
1031	* @disk: disk to replace part_tbl for
1032	* @new_ptbl: new part_tbl to install
1033	*
1034	* Replace disk->part_tbl with @new_ptbl in RCU-safe way. The
1035	* original ptbl is freed using RCU callback.
1036	*
1037	* LOCKING:
1038	* Matching bd_mutx locked.
1039	*/
1040	static void disk_replace_part_tbl(struct gendisk *disk,
1041	struct disk_part_tbl *new_ptbl)
1042	{
1043	struct disk_part_tbl *old_ptbl = disk->part_tbl;
1044
1045	rcu_assign_pointer(disk->part_tbl, new_ptbl);
1046
1047	if (old_ptbl) {
1048	rcu_assign_pointer(old_ptbl->last_lookup, NULL);
1049	kfree_rcu(old_ptbl, rcu_head);
1050	}
1051	}
1052
1053	/**
1054	* disk_expand_part_tbl - expand disk->part_tbl
1055	* @disk: disk to expand part_tbl for
1056	* @partno: expand such that this partno can fit in
1057	*
1058	* Expand disk->part_tbl such that @partno can fit in. disk->part_tbl
1059	* uses RCU to allow unlocked dereferencing for stats and other stuff.
1060	*
1061	* LOCKING:
1062	* Matching bd_mutex locked, might sleep.
1063	*
1064	* RETURNS:
1065	* 0 on success, -errno on failure.
1066	*/
1067	int disk_expand_part_tbl(struct gendisk *disk, int partno)
1068	{
1069	struct disk_part_tbl *old_ptbl = disk->part_tbl;
1070	struct disk_part_tbl *new_ptbl;
1071	int len = old_ptbl ? old_ptbl->len : 0;
1072	int target = partno + 1;
1073	size_t size;
1074	int i;
1075
1076	/* disk_max_parts() is zero during initialization, ignore if so */
1077	if (disk_max_parts(disk) && target > disk_max_parts(disk))
1078	return -EINVAL;
1079
1080	if (target <= len)
1081	return 0;
1082
1083	size = sizeof(new_ptbl) + target sizeof(new_ptbl->part[0]);
1084	new_ptbl = kzalloc_node(size, GFP_KERNEL, disk->node_id);
1085	if (!new_ptbl)
1086	return -ENOMEM;
1087
1088	new_ptbl->len = target;
1089
1090	for (i = 0; i < len; i++)
1091	rcu_assign_pointer(new_ptbl->part[i], old_ptbl->part[i]);
1092
1093	disk_replace_part_tbl(disk, new_ptbl);
1094	return 0;
1095	}
1096
1097	static void disk_release(struct device *dev)
1098	{
1099	struct gendisk *disk = dev_to_disk(dev);
1100
1101	disk_release_events(disk);
1102	kfree(disk->random);
1103	disk_replace_part_tbl(disk, NULL);
1104	free_part_stats(&disk->part0);
1105	free_part_info(&disk->part0);
1106	if (disk->queue)
1107	blk_put_queue(disk->queue);
1108	kfree(disk);
1109	}
1110	struct class block_class = {
1111	.name = "block",
1112	};
1113
1114	static char block_devnode(struct device dev, umode_t *mode)
1115	{
1116	struct gendisk *disk = dev_to_disk(dev);
1117
1118	if (disk->devnode)
1119	return disk->devnode(disk, mode);
1120	return NULL;
1121	}
1122
1123	static struct device_type disk_type = {
1124	.name = "disk",
1125	.groups = disk_attr_groups,
1126	.release = disk_release,
1127	.devnode = block_devnode,
1128	};
1129
1130	#ifdef CONFIG_PROC_FS
1131	/*
1132	* aggregate disk stat collector. Uses the same stats that the sysfs
1133	* entries do, above, but makes them available through one seq_file.
1134	*
1135	* The output looks suspiciously like /proc/partitions with a bunch of
1136	* extra fields.
1137	*/
1138	static int diskstats_show(struct seq_file seqf, void v)
1139	{
1140	struct gendisk *gp = v;
1141	struct disk_part_iter piter;
1142	struct hd_struct *hd;
1143	char buf[BDEVNAME_SIZE];
1144	int cpu;
1145
1146	/*
1147	if (&disk_to_dev(gp)->kobj.entry == block_class.devices.next)
1148	seq_puts(seqf, "major minor name"
1149	" rio rmerge rsect ruse wio wmerge "
1150	"wsect wuse running use aveq"
1151	"\n\n");
1152	*/
1153
1154	disk_part_iter_init(&piter, gp, DISK_PITER_INCL_EMPTY_PART0);
1155	while ((hd = disk_part_iter_next(&piter))) {
1156	cpu = part_stat_lock();
1157	part_round_stats(cpu, hd);
1158	part_stat_unlock();
1159	seq_printf(seqf, "%4d %7d %s %lu %lu %lu "
1160	"%u %lu %lu %lu %u %u %u %u\n",
1161	MAJOR(part_devt(hd)), MINOR(part_devt(hd)),
1162	disk_name(gp, hd->partno, buf),
1163	part_stat_read(hd, ios[READ]),
1164	part_stat_read(hd, merges[READ]),
1165	part_stat_read(hd, sectors[READ]),
1166	jiffies_to_msecs(part_stat_read(hd, ticks[READ])),
1167	part_stat_read(hd, ios[WRITE]),
1168	part_stat_read(hd, merges[WRITE]),
1169	part_stat_read(hd, sectors[WRITE]),
1170	jiffies_to_msecs(part_stat_read(hd, ticks[WRITE])),
1171	part_in_flight(hd),
1172	jiffies_to_msecs(part_stat_read(hd, io_ticks)),
1173	jiffies_to_msecs(part_stat_read(hd, time_in_queue))
1174	);
1175	}
1176	disk_part_iter_exit(&piter);
1177
1178	return 0;
1179	}
1180
1181	static const struct seq_operations diskstats_op = {
1182	.start = disk_seqf_start,
1183	.next = disk_seqf_next,
1184	.stop = disk_seqf_stop,
1185	.show = diskstats_show
1186	};
1187
1188	static int diskstats_open(struct inode inode, struct file file)
1189	{
1190	return seq_open(file, &diskstats_op);
1191	}
1192
1193	static const struct file_operations proc_diskstats_operations = {
1194	.open = diskstats_open,
1195	.read = seq_read,
1196	.llseek = seq_lseek,
1197	.release = seq_release,
1198	};
1199
1200	static int __init proc_genhd_init(void)
1201	{
1202	proc_create("diskstats", 0, NULL, &proc_diskstats_operations);
1203	proc_create("partitions", 0, NULL, &proc_partitions_operations);
1204	return 0;
1205	}
1206	module_init(proc_genhd_init);
1207	#endif /* CONFIG_PROC_FS */
1208
1209	dev_t blk_lookup_devt(const char *name, int partno)
1210	{
1211	dev_t devt = MKDEV(0, 0);
1212	struct class_dev_iter iter;
1213	struct device *dev;
1214
1215	class_dev_iter_init(&iter, &block_class, NULL, &disk_type);
1216	while ((dev = class_dev_iter_next(&iter))) {
1217	struct gendisk *disk = dev_to_disk(dev);
1218	struct hd_struct *part;
1219
1220	if (strcmp(dev_name(dev), name))
1221	continue;
1222
1223	if (partno < disk->minors) {
1224	/* We need to return the right devno, even
1225	* if the partition doesn't exist yet.
1226	*/
1227	devt = MKDEV(MAJOR(dev->devt),
1228	MINOR(dev->devt) + partno);
1229	break;
1230	}
1231	part = disk_get_part(disk, partno);
1232	if (part) {
1233	devt = part_devt(part);
1234	disk_put_part(part);
1235	break;
1236	}
1237	disk_put_part(part);
1238	}
1239	class_dev_iter_exit(&iter);
1240	return devt;
1241	}
1242	EXPORT_SYMBOL(blk_lookup_devt);
1243
1244	struct gendisk *alloc_disk(int minors)
1245	{
1246	return alloc_disk_node(minors, NUMA_NO_NODE);
1247	}
1248	EXPORT_SYMBOL(alloc_disk);
1249
1250	struct gendisk *alloc_disk_node(int minors, int node_id)
1251	{
1252	struct gendisk *disk;
1253
1254	disk = kmalloc_node(sizeof(struct gendisk),
1255	GFP_KERNEL \| __GFP_ZERO, node_id);
1256	if (disk) {
1257	if (!init_part_stats(&disk->part0)) {
1258	kfree(disk);
1259	return NULL;
1260	}
1261	disk->node_id = node_id;
1262	if (disk_expand_part_tbl(disk, 0)) {
1263	free_part_stats(&disk->part0);
1264	kfree(disk);
1265	return NULL;
1266	}
1267	disk->part_tbl->part[0] = &disk->part0;
1268
1269	/*
1270	* set_capacity() and get_capacity() currently don't use
1271	* seqcounter to read/update the part0->nr_sects. Still init
1272	* the counter as we can read the sectors in IO submission
1273	* patch using seqence counters.
1274	*
1275	* TODO: Ideally set_capacity() and get_capacity() should be
1276	* converted to make use of bd_mutex and sequence counters.
1277	*/
1278	seqcount_init(&disk->part0.nr_sects_seq);
1279	hd_ref_init(&disk->part0);
1280
1281	disk->minors = minors;
1282	rand_initialize_disk(disk);
1283	disk_to_dev(disk)->class = &block_class;
1284	disk_to_dev(disk)->type = &disk_type;
1285	device_initialize(disk_to_dev(disk));
1286	}
1287	return disk;
1288	}
1289	EXPORT_SYMBOL(alloc_disk_node);
1290
1291	struct kobject get_disk(struct gendisk disk)
1292	{
1293	struct module *owner;
1294	struct kobject *kobj;
1295
1296	if (!disk->fops)
1297	return NULL;
1298	owner = disk->fops->owner;
1299	if (owner && !try_module_get(owner))
1300	return NULL;
1301	kobj = kobject_get(&disk_to_dev(disk)->kobj);
1302	if (kobj == NULL) {
1303	module_put(owner);
1304	return NULL;
1305	}
1306	return kobj;
1307
1308	}
1309
1310	EXPORT_SYMBOL(get_disk);
1311
1312	void put_disk(struct gendisk *disk)
1313	{
1314	if (disk)
1315	kobject_put(&disk_to_dev(disk)->kobj);
1316	}
1317
1318	EXPORT_SYMBOL(put_disk);
1319
1320	static void set_disk_ro_uevent(struct gendisk *gd, int ro)
1321	{
1322	char event[] = "DISK_RO=1";
1323	char *envp[] = { event, NULL };
1324
1325	if (!ro)
1326	event[8] = '0';
1327	kobject_uevent_env(&disk_to_dev(gd)->kobj, KOBJ_CHANGE, envp);
1328	}
1329
1330	void set_device_ro(struct block_device *bdev, int flag)
1331	{
1332	bdev->bd_part->policy = flag;
1333	}
1334
1335	EXPORT_SYMBOL(set_device_ro);
1336
1337	void set_disk_ro(struct gendisk *disk, int flag)
1338	{
1339	struct disk_part_iter piter;
1340	struct hd_struct *part;
1341
1342	if (disk->part0.policy != flag) {
1343	set_disk_ro_uevent(disk, flag);
1344	disk->part0.policy = flag;
1345	}
1346
1347	disk_part_iter_init(&piter, disk, DISK_PITER_INCL_EMPTY);
1348	while ((part = disk_part_iter_next(&piter)))
1349	part->policy = flag;
1350	disk_part_iter_exit(&piter);
1351	}
1352
1353	EXPORT_SYMBOL(set_disk_ro);
1354
1355	int bdev_read_only(struct block_device *bdev)
1356	{
1357	if (!bdev)
1358	return 0;
1359	return bdev->bd_part->policy;
1360	}
1361
1362	EXPORT_SYMBOL(bdev_read_only);
1363
1364	int invalidate_partition(struct gendisk *disk, int partno)
1365	{
1366	int res = 0;
1367	struct block_device *bdev = bdget_disk(disk, partno);
1368	if (bdev) {
1369	fsync_bdev(bdev);
1370	res = __invalidate_device(bdev, true);
1371	bdput(bdev);
1372	}
1373	return res;
1374	}
1375
1376	EXPORT_SYMBOL(invalidate_partition);
1377
1378	/*
1379	* Disk events - monitor disk events like media change and eject request.
1380	*/
1381	struct disk_events {
1382	struct list_head node; /* all disk_event's */
1383	struct gendisk disk; / the associated disk */
1384	spinlock_t lock;
1385
1386	struct mutex block_mutex; /* protects blocking */
1387	int block; /* event blocking depth */
1388	unsigned int pending; /* events already sent out */
1389	unsigned int clearing; /* events being cleared */
1390
1391	long poll_msecs; /* interval, -1 for default */
1392	struct delayed_work dwork;
1393	};
1394
1395	static const char *disk_events_strs[] = {
1396	[ilog2(DISK_EVENT_MEDIA_CHANGE)] = "media_change",
1397	[ilog2(DISK_EVENT_EJECT_REQUEST)] = "eject_request",
1398	};
1399
1400	static char *disk_uevents[] = {
1401	[ilog2(DISK_EVENT_MEDIA_CHANGE)] = "DISK_MEDIA_CHANGE=1",
1402	[ilog2(DISK_EVENT_EJECT_REQUEST)] = "DISK_EJECT_REQUEST=1",
1403	};
1404
1405	/* list of all disk_events */
1406	static DEFINE_MUTEX(disk_events_mutex);
1407	static LIST_HEAD(disk_events);
1408
1409	/* disable in-kernel polling by default */
1410	static unsigned long disk_events_dfl_poll_msecs = 0;
1411
1412	static unsigned long disk_events_poll_jiffies(struct gendisk *disk)
1413	{
1414	struct disk_events *ev = disk->ev;
1415	long intv_msecs = 0;
1416
1417	/*
1418	* If device-specific poll interval is set, always use it. If
1419	* the default is being used, poll iff there are events which
1420	* can't be monitored asynchronously.
1421	*/
1422	if (ev->poll_msecs >= 0)
1423	intv_msecs = ev->poll_msecs;
1424	else if (disk->events & ~disk->async_events)
1425	intv_msecs = disk_events_dfl_poll_msecs;
1426
1427	return msecs_to_jiffies(intv_msecs);
1428	}
1429
1430	/**
1431	* disk_block_events - block and flush disk event checking
1432	* @disk: disk to block events for
1433	*
1434	* On return from this function, it is guaranteed that event checking
1435	* isn't in progress and won't happen until unblocked by
1436	* disk_unblock_events(). Events blocking is counted and the actual
1437	* unblocking happens after the matching number of unblocks are done.
1438	*
1439	* Note that this intentionally does not block event checking from
1440	* disk_clear_events().
1441	*
1442	* CONTEXT:
1443	* Might sleep.
1444	*/
1445	void disk_block_events(struct gendisk *disk)
1446	{
1447	struct disk_events *ev = disk->ev;
1448	unsigned long flags;
1449	bool cancel;
1450
1451	if (!ev)
1452	return;
1453
1454	/*
1455	* Outer mutex ensures that the first blocker completes canceling
1456	* the event work before further blockers are allowed to finish.
1457	*/
1458	mutex_lock(&ev->block_mutex);
1459
1460	spin_lock_irqsave(&ev->lock, flags);
1461	cancel = !ev->block++;
1462	spin_unlock_irqrestore(&ev->lock, flags);
1463
1464	if (cancel)
1465	cancel_delayed_work_sync(&disk->ev->dwork);
1466
1467	mutex_unlock(&ev->block_mutex);
1468	}
1469
1470	static void __disk_unblock_events(struct gendisk *disk, bool check_now)
1471	{
1472	struct disk_events *ev = disk->ev;
1473	unsigned long intv;
1474	unsigned long flags;
1475
1476	spin_lock_irqsave(&ev->lock, flags);
1477
1478	if (WARN_ON_ONCE(ev->block <= 0))
1479	goto out_unlock;
1480
1481	if (--ev->block)
1482	goto out_unlock;
1483
1484	/*
1485	* Not exactly a latency critical operation, set poll timer
1486	* slack to 25% and kick event check.
1487	*/
1488	intv = disk_events_poll_jiffies(disk);
1489	set_timer_slack(&ev->dwork.timer, intv / 4);
1490	if (check_now)
1491	queue_delayed_work(system_freezable_wq, &ev->dwork, 0);
1492	else if (intv)
1493	queue_delayed_work(system_freezable_wq, &ev->dwork, intv);
1494	out_unlock:
1495	spin_unlock_irqrestore(&ev->lock, flags);
1496	}
1497
1498	/**
1499	* disk_unblock_events - unblock disk event checking
1500	* @disk: disk to unblock events for
1501	*
1502	* Undo disk_block_events(). When the block count reaches zero, it
1503	* starts events polling if configured.
1504	*
1505	* CONTEXT:
1506	* Don't care. Safe to call from irq context.
1507	*/
1508	void disk_unblock_events(struct gendisk *disk)
1509	{
1510	if (disk->ev)
1511	__disk_unblock_events(disk, false);
1512	}
1513
1514	/**
1515	* disk_flush_events - schedule immediate event checking and flushing
1516	* @disk: disk to check and flush events for
1517	* @mask: events to flush
1518	*
1519	* Schedule immediate event checking on @disk if not blocked. Events in
1520	* @mask are scheduled to be cleared from the driver. Note that this
1521	* doesn't clear the events from @disk->ev.
1522	*
1523	* CONTEXT:
1524	* If @mask is non-zero must be called with bdev->bd_mutex held.
1525	*/
1526	void disk_flush_events(struct gendisk *disk, unsigned int mask)
1527	{
1528	struct disk_events *ev = disk->ev;
1529
1530	if (!ev)
1531	return;
1532
1533	spin_lock_irq(&ev->lock);
1534	ev->clearing \|= mask;
1535	if (!ev->block)
1536	mod_delayed_work(system_freezable_wq, &ev->dwork, 0);
1537	spin_unlock_irq(&ev->lock);
1538	}
1539
1540	/**
1541	* disk_clear_events - synchronously check, clear and return pending events
1542	* @disk: disk to fetch and clear events from
1543	* @mask: mask of events to be fetched and clearted
1544	*
1545	* Disk events are synchronously checked and pending events in @mask
1546	* are cleared and returned. This ignores the block count.
1547	*
1548	* CONTEXT:
1549	* Might sleep.
1550	*/
1551	unsigned int disk_clear_events(struct gendisk *disk, unsigned int mask)
1552	{
1553	const struct block_device_operations *bdops = disk->fops;
1554	struct disk_events *ev = disk->ev;
1555	unsigned int pending;
1556	unsigned int clearing = mask;
1557
1558	if (!ev) {
1559	/* for drivers still using the old ->media_changed method */
1560	if ((mask & DISK_EVENT_MEDIA_CHANGE) &&
1561	bdops->media_changed && bdops->media_changed(disk))
1562	return DISK_EVENT_MEDIA_CHANGE;
1563	return 0;
1564	}
1565
1566	disk_block_events(disk);
1567
1568	/*
1569	* store the union of mask and ev->clearing on the stack so that the
1570	* race with disk_flush_events does not cause ambiguity (ev->clearing
1571	* can still be modified even if events are blocked).
1572	*/
1573	spin_lock_irq(&ev->lock);
1574	clearing \|= ev->clearing;
1575	ev->clearing = 0;
1576	spin_unlock_irq(&ev->lock);
1577
1578	disk_check_events(ev, &clearing);
1579	/*
1580	* if ev->clearing is not 0, the disk_flush_events got called in the
1581	* middle of this function, so we want to run the workfn without delay.
1582	*/
1583	__disk_unblock_events(disk, ev->clearing ? true : false);
1584
1585	/* then, fetch and clear pending events */
1586	spin_lock_irq(&ev->lock);
1587	pending = ev->pending & mask;
1588	ev->pending &= ~mask;
1589	spin_unlock_irq(&ev->lock);
1590	WARN_ON_ONCE(clearing & mask);
1591
1592	return pending;
1593	}
1594
1595	/*
1596	* Separate this part out so that a different pointer for clearing_ptr can be
1597	* passed in for disk_clear_events.
1598	*/
1599	static void disk_events_workfn(struct work_struct *work)
1600	{
1601	struct delayed_work *dwork = to_delayed_work(work);
1602	struct disk_events *ev = container_of(dwork, struct disk_events, dwork);
1603
1604	disk_check_events(ev, &ev->clearing);
1605	}
1606
1607	static void disk_check_events(struct disk_events *ev,
1608	unsigned int *clearing_ptr)
1609	{
1610	struct gendisk *disk = ev->disk;
1611	char *envp[ARRAY_SIZE(disk_uevents) + 1] = { };
1612	unsigned int clearing = *clearing_ptr;
1613	unsigned int events;
1614	unsigned long intv;
1615	int nr_events = 0, i;
1616
1617	/* check events */
1618	events = disk->fops->check_events(disk, clearing);
1619
1620	/* accumulate pending events and schedule next poll if necessary */
1621	spin_lock_irq(&ev->lock);
1622
1623	events &= ~ev->pending;
1624	ev->pending \|= events;
1625	*clearing_ptr &= ~clearing;
1626
1627	intv = disk_events_poll_jiffies(disk);
1628	if (!ev->block && intv)
1629	queue_delayed_work(system_freezable_wq, &ev->dwork, intv);
1630
1631	spin_unlock_irq(&ev->lock);
1632
1633	/*
1634	* Tell userland about new events. Only the events listed in
1635	* @disk->events are reported. Unlisted events are processed the
1636	* same internally but never get reported to userland.
1637	*/
1638	for (i = 0; i < ARRAY_SIZE(disk_uevents); i++)
1639	if (events & disk->events & (1 << i))
1640	envp[nr_events++] = disk_uevents[i];
1641
1642	if (nr_events)
1643	kobject_uevent_env(&disk_to_dev(disk)->kobj, KOBJ_CHANGE, envp);
1644	}
1645
1646	/*
1647	* A disk events enabled device has the following sysfs nodes under
1648	* its /sys/block/X/ directory.
1649	*
1650	* events : list of all supported events
1651	* events_async : list of events which can be detected w/o polling
1652	* events_poll_msecs : polling interval, 0: disable, -1: system default
1653	*/
1654	static ssize_t __disk_events_show(unsigned int events, char *buf)
1655	{
1656	const char *delim = "";
1657	ssize_t pos = 0;
1658	int i;
1659
1660	for (i = 0; i < ARRAY_SIZE(disk_events_strs); i++)
1661	if (events & (1 << i)) {
1662	pos += sprintf(buf + pos, "%s%s",
1663	delim, disk_events_strs[i]);
1664	delim = " ";
1665	}
1666	if (pos)
1667	pos += sprintf(buf + pos, "\n");
1668	return pos;
1669	}
1670
1671	static ssize_t disk_events_show(struct device *dev,
1672	struct device_attribute attr, char buf)
1673	{
1674	struct gendisk *disk = dev_to_disk(dev);
1675
1676	return __disk_events_show(disk->events, buf);
1677	}
1678
1679	static ssize_t disk_events_async_show(struct device *dev,
1680	struct device_attribute attr, char buf)
1681	{
1682	struct gendisk *disk = dev_to_disk(dev);
1683
1684	return __disk_events_show(disk->async_events, buf);
1685	}
1686
1687	static ssize_t disk_events_poll_msecs_show(struct device *dev,
1688	struct device_attribute *attr,
1689	char *buf)
1690	{
1691	struct gendisk *disk = dev_to_disk(dev);
1692
1693	return sprintf(buf, "%ld\n", disk->ev->poll_msecs);
1694	}
1695
1696	static ssize_t disk_events_poll_msecs_store(struct device *dev,
1697	struct device_attribute *attr,
1698	const char *buf, size_t count)
1699	{
1700	struct gendisk *disk = dev_to_disk(dev);
1701	long intv;
1702
1703	if (!count \|\| !sscanf(buf, "%ld", &intv))
1704	return -EINVAL;
1705
1706	if (intv < 0 && intv != -1)
1707	return -EINVAL;
1708
1709	disk_block_events(disk);
1710	disk->ev->poll_msecs = intv;
1711	__disk_unblock_events(disk, true);
1712
1713	return count;
1714	}
1715
1716	static const DEVICE_ATTR(events, S_IRUGO, disk_events_show, NULL);
1717	static const DEVICE_ATTR(events_async, S_IRUGO, disk_events_async_show, NULL);
1718	static const DEVICE_ATTR(events_poll_msecs, S_IRUGO\|S_IWUSR,
1719	disk_events_poll_msecs_show,
1720	disk_events_poll_msecs_store);
1721
1722	static const struct attribute *disk_events_attrs[] = {
1723	&dev_attr_events.attr,
1724	&dev_attr_events_async.attr,
1725	&dev_attr_events_poll_msecs.attr,
1726	NULL,
1727	};
1728
1729	/*
1730	* The default polling interval can be specified by the kernel
1731	* parameter block.events_dfl_poll_msecs which defaults to 0
1732	* (disable). This can also be modified runtime by writing to
1733	* /sys/module/block/events_dfl_poll_msecs.
1734	*/
1735	static int disk_events_set_dfl_poll_msecs(const char *val,
1736	const struct kernel_param *kp)
1737	{
1738	struct disk_events *ev;
1739	int ret;
1740
1741	ret = param_set_ulong(val, kp);
1742	if (ret < 0)
1743	return ret;
1744
1745	mutex_lock(&disk_events_mutex);
1746
1747	list_for_each_entry(ev, &disk_events, node)
1748	disk_flush_events(ev->disk, 0);
1749
1750	mutex_unlock(&disk_events_mutex);
1751
1752	return 0;
1753	}
1754
1755	static const struct kernel_param_ops disk_events_dfl_poll_msecs_param_ops = {
1756	.set = disk_events_set_dfl_poll_msecs,
1757	.get = param_get_ulong,
1758	};
1759
1760	#undef MODULE_PARAM_PREFIX
1761	#define MODULE_PARAM_PREFIX "block."
1762
1763	module_param_cb(events_dfl_poll_msecs, &disk_events_dfl_poll_msecs_param_ops,
1764	&disk_events_dfl_poll_msecs, 0644);
1765
1766	/*
1767	* disk_{alloc\|add\|del\|release}_events - initialize and destroy disk_events.
1768	*/
1769	static void disk_alloc_events(struct gendisk *disk)
1770	{
1771	struct disk_events *ev;
1772
1773	if (!disk->fops->check_events)
1774	return;
1775
1776	ev = kzalloc(sizeof(*ev), GFP_KERNEL);
1777	if (!ev) {
1778	pr_warn("%s: failed to initialize events\n", disk->disk_name);
1779	return;
1780	}
1781
1782	INIT_LIST_HEAD(&ev->node);
1783	ev->disk = disk;
1784	spin_lock_init(&ev->lock);
1785	mutex_init(&ev->block_mutex);
1786	ev->block = 1;
1787	ev->poll_msecs = -1;
1788	INIT_DELAYED_WORK(&ev->dwork, disk_events_workfn);
1789
1790	disk->ev = ev;
1791	}
1792
1793	static void disk_add_events(struct gendisk *disk)
1794	{
1795	if (!disk->ev)
1796	return;
1797
1798	/* FIXME: error handling */
1799	if (sysfs_create_files(&disk_to_dev(disk)->kobj, disk_events_attrs) < 0)
1800	pr_warn("%s: failed to create sysfs files for events\n",
1801	disk->disk_name);
1802
1803	mutex_lock(&disk_events_mutex);
1804	list_add_tail(&disk->ev->node, &disk_events);
1805	mutex_unlock(&disk_events_mutex);
1806
1807	/*
1808	* Block count is initialized to 1 and the following initial
1809	* unblock kicks it into action.
1810	*/
1811	__disk_unblock_events(disk, true);
1812	}
1813
1814	static void disk_del_events(struct gendisk *disk)
1815	{
1816	if (!disk->ev)
1817	return;
1818
1819	disk_block_events(disk);
1820
1821	mutex_lock(&disk_events_mutex);
1822	list_del_init(&disk->ev->node);
1823	mutex_unlock(&disk_events_mutex);
1824
1825	sysfs_remove_files(&disk_to_dev(disk)->kobj, disk_events_attrs);
1826	}
1827
1828	static void disk_release_events(struct gendisk *disk)
1829	{
1830	/* the block count should be 1 from disk_del_events() */
1831	WARN_ON_ONCE(disk->ev && disk->ev->block != 1);
1832	kfree(disk->ev);
1833	}
1834

Download this file

Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master

Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9

Kernel

Kernel Git Source Tree

Root/block/genhd.c

interactive