Skip to content

Commit

Permalink
block: use class_dev_iterator instead of class_for_each_device()
Browse files Browse the repository at this point in the history 
Recent block_class iteration updates 5c6f35c..27f3025 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: Tejun Heo <tj@kernel.org>
Cc: Greg Kroah-Hartman <gregkh@suse.de>
Signed-off-by: Jens Axboe <jens.axboe@oracle.com>
  • Loading branch information
Tejun Heo authored and Jens Axboe committed Oct 9, 2008
1 parent 2ac3cee commit def4e38
Showing 1 changed file with 97 additions and 155 deletions.
252 changes: 97 additions & 155 deletions block/genhd.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -225,118 +225,115 @@ struct gendisk *get_gendisk(dev_t devt, int *part)
return kobj ? dev_to_disk(dev) : NULL;
}

/*
* print a partitions - intended for places where the root 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)
{
struct gendisk *sgp;
char buf[BDEVNAME_SIZE];
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
*/
if (get_capacity(sgp) == 0 ||
(sgp->flags & GENHD_FL_SUPPRESS_PARTITION_INFO))
return 0;

/*
* Note, unlike /proc/partitions, I am showing the numbers in
* hex - the same format as the root= option takes.
*/
printk("%02x%02x %10llu %s",
sgp->major, sgp->first_minor,
(unsigned long long)get_capacity(sgp) >> 1,
disk_name(sgp, 0, buf));
if (sgp->driverfs_dev != NULL &&
sgp->driverfs_dev->driver != NULL)
printk(" driver: %s\n",
sgp->driverfs_dev->driver->name);
else
printk(" (driver?)\n");

/* now show the partitions */
for (n = 0; n < sgp->minors - 1; ++n) {
if (sgp->part[n] == NULL)
continue;
if (sgp->part[n]->nr_sects == 0)
continue;
printk(" %02x%02x %10llu %s\n",
sgp->major, n + 1 + sgp->first_minor,
(unsigned long long)sgp->part[n]->nr_sects >> 1,
disk_name(sgp, n + 1, buf));
}

return 0;
}

/*
* 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);
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];
int n;

/*
* Don't show empty devices or things that have been
* surpressed
*/
if (get_capacity(disk) == 0 ||
(disk->flags & GENHD_FL_SUPPRESS_PARTITION_INFO))
continue;

/*
* Note, unlike /proc/partitions, I am showing the
* numbers in hex - the same format as the root=
* option takes.
*/
printk("%02x%02x %10llu %s",
disk->major, disk->first_minor,
(unsigned long long)get_capacity(disk) >> 1,
disk_name(disk, 0, buf));
if (disk->driverfs_dev != NULL &&
disk->driverfs_dev->driver != NULL)
printk(" driver: %s\n",
disk->driverfs_dev->driver->name);
else
printk(" (driver?)\n");

/* now show the partitions */
for (n = 0; n < disk->minors - 1; ++n) {
if (disk->part[n] == NULL)
continue;
if (disk->part[n]->nr_sects == 0)
continue;
printk(" %02x%02x %10llu %s\n",
disk->major, n + 1 + disk->first_minor,
(unsigned long long)disk->part[n]->nr_sects >> 1,
disk_name(disk, n + 1, buf));
}
}
class_dev_iter_exit(&iter);
}

#ifdef CONFIG_PROC_FS
/* 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)
return 0;
if (!*k)
return 1;
(*k)--;
return 0;
iter = kmalloc(GFP_KERNEL, sizeof(*iter));
if (!iter)
return ERR_PTR(-ENOMEM);

seqf->private = iter;
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;
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)
return dev_to_disk(dev);

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)
return 1;
return 0;
}
struct class_dev_iter *iter = seqf->private;

static void *part_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);
/* stop is called even after start failed :-( */
if (iter) {
class_dev_iter_exit(iter);
kfree(iter);
}
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)
Expand Down Expand Up @@ -383,9 +380,9 @@ static int show_partition(struct seq_file *part, void *v)
}

const struct seq_operations partitions_op = {
.start = part_start,
.next = part_next,
.stop = part_stop,
.start = show_partition_start,
.next = disk_seqf_next,
.stop = disk_seqf_stop,
.show = show_partition
};
#endif
Expand Down Expand Up @@ -567,44 +564,6 @@ static struct device_type disk_type = {
};

#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)
{
struct gendisk *gp = v;
Expand Down Expand Up @@ -666,9 +625,9 @@ static int diskstats_show(struct seq_file *s, void *v)
}

const struct seq_operations diskstats_op = {
.start = diskstats_start,
.next = diskstats_next,
.stop = diskstats_stop,
.start = disk_seqf_start,
.next = disk_seqf_next,
.stop = disk_seqf_stop,
.show = diskstats_show
};
#endif /* CONFIG_PROC_FS */
Expand Down Expand Up @@ -696,40 +655,23 @@ void genhd_media_change_notify(struct gendisk *disk)
EXPORT_SYMBOL_GPL(genhd_media_change_notify);
#endif /* 0 */

struct find_block {
const char *name;
int part;
};

static int match_id(struct device *dev, void *data)
dev_t blk_lookup_devt(const char *name, int part)
{
struct find_block *find = data;
dev_t devt = MKDEV(0, 0);
struct class_dev_iter iter;
struct device *dev;

if (dev->type != &disk_type)
return 0;
if (strcmp(dev->bus_id, find->name) == 0) {
class_dev_iter_init(&iter, &block_class, NULL, &disk_type);
while ((dev = class_dev_iter_next(&iter))) {
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)
{
struct device *dev;
dev_t devt = MKDEV(0, 0);
struct find_block find;

find.name = name;
find.part = part;
dev = class_find_device(&block_class, NULL, &find, match_id);
if (dev) {
put_device(dev);
devt = MKDEV(MAJOR(dev->devt),
MINOR(dev->devt) + part);
if (!strcmp(dev->bus_id, name) && part < disk->minors) {
devt = MKDEV(MAJOR(dev->devt),
MINOR(dev->devt) + part);
break;
}
}

class_dev_iter_exit(&iter);
return devt;
}
EXPORT_SYMBOL(blk_lookup_devt);
Expand Down

0 comments on commit def4e38

Please sign in to comment.