Commit def4e38d authored by Tejun Heo's avatar Tejun Heo Committed by Jens Axboe
Browse files

block: use class_dev_iterator instead of class_for_each_device() 



Recent block_class iteration updates 5c6f35c5..27f30251 converted all
class device iteration to class_for_each_device() and
class_find_device(), which are correct but pain in the ass to use.
This pach converts them to newly introduced class_dev_iterator so that
they can use more natural control structures instead of separate
callbacks and struct to pass parameters to them.

This results in smaller and easier code.

This patch also restores the original behavior of not printing header
in /proc/partitions if there's no partition to print.  This is trivial
but still user-visible behavior.

Signed-off-by: default avatarTejun Heo <tj@kernel.org>
Cc: Greg Kroah-Hartman <gregkh@suse.de>
Signed-off-by: default avatarJens Axboe <jens.axboe@oracle.com>
parent 2ac3cee5

block/genhd.c

+97 −155
Original line number Original line Diff line number Diff line
@@ -226,117 +226,114 @@ struct gendisk *get_gendisk(dev_t devt, int *part) 
}

}





/*

/*

 * print a partitions - intended for places where the root filesystem can't be

 * print a full list of all partitions - intended for places where the root

 * mounted and thus to give the victim some idea of what went wrong

 * filesystem can't be mounted and thus to give the victim some idea of what

 * went wrong

 */

 */

static int printk_partition(struct device *dev, void *data)

void __init printk_all_partitions(void)

{

{

	struct gendisk *sgp;

	struct class_dev_iter iter;

	struct device *dev;



	class_dev_iter_init(&iter, &block_class, NULL, &disk_type);

	while ((dev = class_dev_iter_next(&iter))) {

		struct gendisk *disk = dev_to_disk(dev);

		char buf[BDEVNAME_SIZE];

		char buf[BDEVNAME_SIZE];

		int n;

		int n;





	if (dev->type != &disk_type)

		return 0;



	sgp = dev_to_disk(dev);

		/*

		/*

	 * Don't show empty devices or things that have been surpressed

		 * Don't show empty devices or things that have been

		 * surpressed

		 */

		 */

	if (get_capacity(sgp) == 0 ||

		if (get_capacity(disk) == 0 ||

	    (sgp->flags & GENHD_FL_SUPPRESS_PARTITION_INFO))

		    (disk->flags & GENHD_FL_SUPPRESS_PARTITION_INFO))

		return 0;

			continue;





		/*

		/*

	 * Note, unlike /proc/partitions, I am showing the numbers in

		 * Note, unlike /proc/partitions, I am showing the

	 * hex - the same format as the root= option takes.

		 * numbers in hex - the same format as the root=

		 * option takes.

		 */

		 */

		printk("%02x%02x %10llu %s",

		printk("%02x%02x %10llu %s",

		sgp->major, sgp->first_minor,

		       disk->major, disk->first_minor,

		(unsigned long long)get_capacity(sgp) >> 1,

		       (unsigned long long)get_capacity(disk) >> 1,

		disk_name(sgp, 0, buf));

		       disk_name(disk, 0, buf));

	if (sgp->driverfs_dev != NULL &&

		if (disk->driverfs_dev != NULL &&

	    sgp->driverfs_dev->driver != NULL)

		    disk->driverfs_dev->driver != NULL)

			printk(" driver: %s\n",

			printk(" driver: %s\n",

			sgp->driverfs_dev->driver->name);

			       disk->driverfs_dev->driver->name);

		else

		else

			printk(" (driver?)\n");

			printk(" (driver?)\n");





		/* now show the partitions */

		/* now show the partitions */

	for (n = 0; n < sgp->minors - 1; ++n) {

		for (n = 0; n < disk->minors - 1; ++n) {

		if (sgp->part[n] == NULL)

			if (disk->part[n] == NULL)

				continue;

				continue;

		if (sgp->part[n]->nr_sects == 0)

			if (disk->part[n]->nr_sects == 0)

				continue;

				continue;

			printk("  %02x%02x %10llu %s\n",

			printk("  %02x%02x %10llu %s\n",

			sgp->major, n + 1 + sgp->first_minor,

			       disk->major, n + 1 + disk->first_minor,

			(unsigned long long)sgp->part[n]->nr_sects >> 1,

			       (unsigned long long)disk->part[n]->nr_sects >> 1,

			disk_name(sgp, n + 1, buf));

			       disk_name(disk, n + 1, buf));

		}

		}



	return 0;

	}

	}



	class_dev_iter_exit(&iter);

/*

 * print a full list of all partitions - intended for places where the root

 * filesystem can't be mounted and thus to give the victim some idea of what

 * went wrong

 */

void __init printk_all_partitions(void)

{

	class_for_each_device(&block_class, NULL, NULL, printk_partition);

}

}





#ifdef CONFIG_PROC_FS

#ifdef CONFIG_PROC_FS

/* iterator */

/* iterator */

static int find_start(struct device *dev, void *data)

static void *disk_seqf_start(struct seq_file *seqf, loff_t *pos)

{

{

	loff_t *k = data;

	loff_t skip = *pos;

	struct class_dev_iter *iter;

	struct device *dev;





	if (dev->type != &disk_type)

	iter = kmalloc(GFP_KERNEL, sizeof(*iter));

		return 0;

	if (!iter)

	if (!*k)

		return ERR_PTR(-ENOMEM);

		return 1;



	(*k)--;

	seqf->private = iter;

	return 0;

	class_dev_iter_init(iter, &block_class, NULL, &disk_type);

	do {

		dev = class_dev_iter_next(iter);

		if (!dev)

			return NULL;

	} while (skip--);



	return dev_to_disk(dev);

}

}





static void *part_start(struct seq_file *part, loff_t *pos)

static void *disk_seqf_next(struct seq_file *seqf, void *v, loff_t *pos)

{

{

	struct device *dev;

	struct device *dev;

	loff_t n = *pos;



	if (!n)

		part->private = (void *)1LU;	/* tell show to print header */





	dev = class_find_device(&block_class, NULL, &n, find_start);

	(*pos)++;

	dev = class_dev_iter_next(seqf->private);

	if (dev)

	if (dev)

		return dev_to_disk(dev);

		return dev_to_disk(dev);





	return NULL;

	return NULL;

}

}





static int find_next(struct device *dev, void *data)

static void disk_seqf_stop(struct seq_file *seqf, void *v)

{

{

	if (dev->type == &disk_type)

	struct class_dev_iter *iter = seqf->private;

		return 1;

	return 0;

}





static void *part_next(struct seq_file *part, void *v, loff_t *pos)

	/* stop is called even after start failed :-( */

{

	if (iter) {

	struct gendisk *gp = v;

		class_dev_iter_exit(iter);

	struct device *dev;

		kfree(iter);

	++*pos;

	dev = class_find_device(&block_class, &gp->dev, NULL, find_next);

	if (dev) {

		put_device(dev);

		return dev_to_disk(dev);

	}

	}

	return NULL;

}

}





static void part_stop(struct seq_file *part, void *v)

static void *show_partition_start(struct seq_file *seqf, loff_t *pos)

{

{

	static void *p;



	p = disk_seqf_start(seqf, pos);

	if (!IS_ERR(p) && p)

		seq_puts(seqf, "major minor  #blocks  name\n\n");

	return p;

}

}





static int show_partition(struct seq_file *part, void *v)

static int show_partition(struct seq_file *part, void *v)
@@ -383,9 +380,9 @@ static int show_partition(struct seq_file *part, void *v) 
}

}





const struct seq_operations partitions_op = {

const struct seq_operations partitions_op = {

	.start	= part_start,

	.start	= show_partition_start,

	.next	= part_next,

	.next	= disk_seqf_next,

	.stop	= part_stop,

	.stop	= disk_seqf_stop,

	.show	= show_partition

	.show	= show_partition

};

};

#endif

#endif
@@ -567,44 +564,6 @@ static struct device_type disk_type = { 
};

};





#ifdef CONFIG_PROC_FS

#ifdef CONFIG_PROC_FS

/*

 * aggregate disk stat collector.  Uses the same stats that the sysfs

 * entries do, above, but makes them available through one seq_file.

 *

 * The output looks suspiciously like /proc/partitions with a bunch of

 * extra fields.

 */



static void *diskstats_start(struct seq_file *part, loff_t *pos)

{

	struct device *dev;

	loff_t n = *pos;



	dev = class_find_device(&block_class, NULL, &n, find_start);

	if (dev)

		return dev_to_disk(dev);



	return NULL;

}



static void *diskstats_next(struct seq_file *part, void *v, loff_t *pos)

{

	struct gendisk *gp = v;

	struct device *dev;



	++*pos;

	dev = class_find_device(&block_class, &gp->dev, NULL, find_next);

	if (dev) {

		put_device(dev);

		return dev_to_disk(dev);

	}

	return NULL;

}



static void diskstats_stop(struct seq_file *part, void *v)

{

}



static int diskstats_show(struct seq_file *s, void *v)

static int diskstats_show(struct seq_file *s, void *v)

{

{

	struct gendisk *gp = v;

	struct gendisk *gp = v;
@@ -666,9 +625,9 @@ static int diskstats_show(struct seq_file *s, void *v) 
}

}





const struct seq_operations diskstats_op = {

const struct seq_operations diskstats_op = {

	.start	= diskstats_start,

	.start	= disk_seqf_start,

	.next	= diskstats_next,

	.next	= disk_seqf_next,

	.stop	= diskstats_stop,

	.stop	= disk_seqf_stop,

	.show	= diskstats_show

	.show	= diskstats_show

};

};

#endif /* CONFIG_PROC_FS */

#endif /* CONFIG_PROC_FS */
@@ -696,40 +655,23 @@ void genhd_media_change_notify(struct gendisk *disk) 
EXPORT_SYMBOL_GPL(genhd_media_change_notify);

EXPORT_SYMBOL_GPL(genhd_media_change_notify);

#endif  /*  0  */

#endif  /*  0  */





struct find_block {

	const char *name;

	int part;

};



static int match_id(struct device *dev, void *data)

{

	struct find_block *find = data;



	if (dev->type != &disk_type)

		return 0;

	if (strcmp(dev->bus_id, find->name) == 0) {

		struct gendisk *disk = dev_to_disk(dev);

		if (find->part < disk->minors)

			return 1;

	}

	return 0;

}



dev_t blk_lookup_devt(const char *name, int part)

dev_t blk_lookup_devt(const char *name, int part)

{

{

	struct device *dev;

	dev_t devt = MKDEV(0, 0);

	dev_t devt = MKDEV(0, 0);

	struct find_block find;

	struct class_dev_iter iter;

	struct device *dev;





	find.name = name;

	class_dev_iter_init(&iter, &block_class, NULL, &disk_type);

	find.part = part;

	while ((dev = class_dev_iter_next(&iter))) {

	dev = class_find_device(&block_class, NULL, &find, match_id);

		struct gendisk *disk = dev_to_disk(dev);

	if (dev) {



		put_device(dev);

		if (!strcmp(dev->bus_id, name) && part < disk->minors) {

			devt = MKDEV(MAJOR(dev->devt),

			devt = MKDEV(MAJOR(dev->devt),

				     MINOR(dev->devt) + part);

				     MINOR(dev->devt) + part);

			break;

		}

		}



	}

	class_dev_iter_exit(&iter);

	return devt;

	return devt;

}

}

EXPORT_SYMBOL(blk_lookup_devt);

EXPORT_SYMBOL(blk_lookup_devt);

CRA Git | Maintained and supported by SUSTech CRA and CCSE