[PATCH] UBI: Use static class and attribute groups

Takashi Iwai tiwai at suse.de
Tue May 19 00:36:48 PDT 2015


At Fri, 15 May 2015 16:20:05 +0800,
hujianyang wrote:
> 
> On 2015/2/26 17:19, Richard Weinberger wrote:
> > Am 26.02.2015 um 10:11 schrieb hujianyang:
> >> Hi Takashi,
> >>
> >> I think it's a good attempt. Did you test this patch on your environment
> >> or just changing the code?
> >>
> >> How do you feel about this patch, Richard?
> > 
> > I like the patch but had no time to look at it in detail and test it but this will happen soon. :)
> > 
> > Thanks,
> > //richard
> > 
> > ______________________________________________________
> > Linux MTD discussion mailing list
> > http://lists.infradead.org/mailman/listinfo/linux-mtd/
> > 
> > 
> 
> Hi Richard,
> 
> I've amended this patch a bit and Sheng Yong helped me test a little.
> Could you please review and do some test on it?
> 
> Thanks,
> Hu

Thanks Hu!  I must have overlooked the post from Richard.

My patch wasn't tested with the real hardware, mostly compile-tested
only.  So, yes, if anyone could test it, it'd be greatly appreciated.


Takashi

> 
> 
> From: Takashi Iwai <tiwai at suse.de>
> Date: Wed, 4 Feb 2015 14:51:11 +0100
> Subject: [PATCH] UBI: Use static class and attribute groups
> 
> This patch cleans up the manual device_create_file() or
> class_create_file() calls by replacing with static attribute groups.
> It simplifies the code and also avoids the possible races between the
> device/class registration and sysfs creations.
> 
> For the simplification, also make ubi_class a static instance with
> initializers, too.
> 
> Amend a bit by Hujianyang.
> 
> Signed-off-by: Takashi Iwai <tiwai at suse.de>
> Tested-by: Sheng Yong <shengyong1 at huawei.com>
> Signed-off-by: hujianyang <hujianyang at huawei.com>
> ---
>  drivers/mtd/ubi/build.c |  103 ++++++++++++++++------------------------------
>  drivers/mtd/ubi/ubi.h   |    2 +-
>  drivers/mtd/ubi/vmt.c   |   94 +++++++++---------------------------------
>  3 files changed, 57 insertions(+), 142 deletions(-)
> 
> diff --git a/drivers/mtd/ubi/build.c b/drivers/mtd/ubi/build.c
> index b7f824d..1554232 100644
> --- a/drivers/mtd/ubi/build.c
> +++ b/drivers/mtd/ubi/build.c
> @@ -83,8 +83,6 @@ static struct mtd_dev_param __initdata mtd_dev_param[UBI_MAX_DEVICES];
>  static bool fm_autoconvert;
>  static bool fm_debug;
>  #endif
> -/* Root UBI "class" object (corresponds to '/<sysfs>/class/ubi/') */
> -struct class *ubi_class;
> 
>  /* Slab cache for wear-leveling entries */
>  struct kmem_cache *ubi_wl_entry_slab;
> @@ -113,8 +111,17 @@ static ssize_t ubi_version_show(struct class *class,
>  }
> 
>  /* UBI version attribute ('/<sysfs>/class/ubi/version') */
> -static struct class_attribute ubi_version =
> -	__ATTR(version, S_IRUGO, ubi_version_show, NULL);
> +static struct class_attribute ubi_class_attrs[] = {
> +	__ATTR(version, S_IRUGO, ubi_version_show, NULL),
> +	__ATTR_NULL
> +};
> +
> +/* Root UBI "class" object (corresponds to '/<sysfs>/class/ubi/') */
> +struct class ubi_class = {
> +	.name		= UBI_NAME_STR,
> +	.owner		= THIS_MODULE,
> +	.class_attrs	= ubi_class_attrs,
> +};
> 
>  static ssize_t dev_attribute_show(struct device *dev,
>  				  struct device_attribute *attr, char *buf);
> @@ -385,6 +392,22 @@ static ssize_t dev_attribute_show(struct device *dev,
>  	return ret;
>  }
> 
> +static struct attribute *ubi_dev_attrs[] = {
> +	&dev_eraseblock_size.attr,
> +	&dev_avail_eraseblocks.attr,
> +	&dev_total_eraseblocks.attr,
> +	&dev_volumes_count.attr,
> +	&dev_max_ec.attr,
> +	&dev_reserved_for_bad.attr,
> +	&dev_bad_peb_count.attr,
> +	&dev_max_vol_count.attr,
> +	&dev_min_io_size.attr,
> +	&dev_bgt_enabled.attr,
> +	&dev_mtd_num.attr,
> +	NULL
> +};
> +ATTRIBUTE_GROUPS(ubi_dev);
> +
>  static void dev_release(struct device *dev)
>  {
>  	struct ubi_device *ubi = container_of(dev, struct ubi_device, dev);
> @@ -407,45 +430,15 @@ static int ubi_sysfs_init(struct ubi_device *ubi, int *ref)
> 
>  	ubi->dev.release = dev_release;
>  	ubi->dev.devt = ubi->cdev.dev;
> -	ubi->dev.class = ubi_class;
> +	ubi->dev.class = &ubi_class;
> +	ubi->dev.groups = ubi_dev_groups;
>  	dev_set_name(&ubi->dev, UBI_NAME_STR"%d", ubi->ubi_num);
>  	err = device_register(&ubi->dev);
>  	if (err)
>  		return err;
> 
>  	*ref = 1;
> -	err = device_create_file(&ubi->dev, &dev_eraseblock_size);
> -	if (err)
> -		return err;
> -	err = device_create_file(&ubi->dev, &dev_avail_eraseblocks);
> -	if (err)
> -		return err;
> -	err = device_create_file(&ubi->dev, &dev_total_eraseblocks);
> -	if (err)
> -		return err;
> -	err = device_create_file(&ubi->dev, &dev_volumes_count);
> -	if (err)
> -		return err;
> -	err = device_create_file(&ubi->dev, &dev_max_ec);
> -	if (err)
> -		return err;
> -	err = device_create_file(&ubi->dev, &dev_reserved_for_bad);
> -	if (err)
> -		return err;
> -	err = device_create_file(&ubi->dev, &dev_bad_peb_count);
> -	if (err)
> -		return err;
> -	err = device_create_file(&ubi->dev, &dev_max_vol_count);
> -	if (err)
> -		return err;
> -	err = device_create_file(&ubi->dev, &dev_min_io_size);
> -	if (err)
> -		return err;
> -	err = device_create_file(&ubi->dev, &dev_bgt_enabled);
> -	if (err)
> -		return err;
> -	err = device_create_file(&ubi->dev, &dev_mtd_num);
> -	return err;
> +	return 0;
>  }
> 
>  /**
> @@ -454,17 +447,6 @@ static int ubi_sysfs_init(struct ubi_device *ubi, int *ref)
>   */
>  static void ubi_sysfs_close(struct ubi_device *ubi)
>  {
> -	device_remove_file(&ubi->dev, &dev_mtd_num);
> -	device_remove_file(&ubi->dev, &dev_bgt_enabled);
> -	device_remove_file(&ubi->dev, &dev_min_io_size);
> -	device_remove_file(&ubi->dev, &dev_max_vol_count);
> -	device_remove_file(&ubi->dev, &dev_bad_peb_count);
> -	device_remove_file(&ubi->dev, &dev_reserved_for_bad);
> -	device_remove_file(&ubi->dev, &dev_max_ec);
> -	device_remove_file(&ubi->dev, &dev_volumes_count);
> -	device_remove_file(&ubi->dev, &dev_total_eraseblocks);
> -	device_remove_file(&ubi->dev, &dev_avail_eraseblocks);
> -	device_remove_file(&ubi->dev, &dev_eraseblock_size);
>  	device_unregister(&ubi->dev);
>  }
> 
> @@ -1233,23 +1215,14 @@ static int __init ubi_init(void)
>  	}
> 
>  	/* Create base sysfs directory and sysfs files */
> -	ubi_class = class_create(THIS_MODULE, UBI_NAME_STR);
> -	if (IS_ERR(ubi_class)) {
> -		err = PTR_ERR(ubi_class);
> -		pr_err("UBI error: cannot create UBI class");
> -		goto out;
> -	}
> -
> -	err = class_create_file(ubi_class, &ubi_version);
> -	if (err) {
> -		pr_err("UBI error: cannot create sysfs file");
> -		goto out_class;
> -	}
> +	err = class_register(&ubi_class);
> +	if (err < 0)
> +		return err;
> 
>  	err = misc_register(&ubi_ctrl_cdev);
>  	if (err) {
>  		pr_err("UBI error: cannot register device");
> -		goto out_version;
> +		goto out;
>  	}
> 
>  	ubi_wl_entry_slab = kmem_cache_create("ubi_wl_entry_slab",
> @@ -1333,11 +1306,8 @@ out_slab:
>  	kmem_cache_destroy(ubi_wl_entry_slab);
>  out_dev_unreg:
>  	misc_deregister(&ubi_ctrl_cdev);
> -out_version:
> -	class_remove_file(ubi_class, &ubi_version);
> -out_class:
> -	class_destroy(ubi_class);
>  out:
> +	class_unregister(&ubi_class);
>  	pr_err("UBI error: cannot initialize UBI, error %d", err);
>  	return err;
>  }
> @@ -1358,8 +1328,7 @@ static void __exit ubi_exit(void)
>  	ubi_debugfs_exit();
>  	kmem_cache_destroy(ubi_wl_entry_slab);
>  	misc_deregister(&ubi_ctrl_cdev);
> -	class_remove_file(ubi_class, &ubi_version);
> -	class_destroy(ubi_class);
> +	class_unregister(&ubi_class);
>  }
>  module_exit(ubi_exit);
> 
> diff --git a/drivers/mtd/ubi/ubi.h b/drivers/mtd/ubi/ubi.h
> index c998212..2974b67 100644
> --- a/drivers/mtd/ubi/ubi.h
> +++ b/drivers/mtd/ubi/ubi.h
> @@ -775,7 +775,7 @@ extern struct kmem_cache *ubi_wl_entry_slab;
>  extern const struct file_operations ubi_ctrl_cdev_operations;
>  extern const struct file_operations ubi_cdev_operations;
>  extern const struct file_operations ubi_vol_cdev_operations;
> -extern struct class *ubi_class;
> +extern struct class ubi_class;
>  extern struct mutex ubi_devices_mutex;
>  extern struct blocking_notifier_head ubi_notifiers;
> 
> diff --git a/drivers/mtd/ubi/vmt.c b/drivers/mtd/ubi/vmt.c
> index ff4d978..55e1d72 100644
> --- a/drivers/mtd/ubi/vmt.c
> +++ b/drivers/mtd/ubi/vmt.c
> @@ -120,6 +120,19 @@ static ssize_t vol_attribute_show(struct device *dev,
>  	return ret;
>  }
> 
> +static struct attribute *volume_dev_attrs[] = {
> +	&attr_vol_reserved_ebs.attr,
> +	&attr_vol_type.attr,
> +	&attr_vol_name.attr,
> +	&attr_vol_corrupted.attr,
> +	&attr_vol_alignment.attr,
> +	&attr_vol_usable_eb_size.attr,
> +	&attr_vol_data_bytes.attr,
> +	&attr_vol_upd_marker.attr,
> +	NULL
> +};
> +ATTRIBUTE_GROUPS(volume_dev);
> +
>  /* Release method for volume devices */
>  static void vol_release(struct device *dev)
>  {
> @@ -130,64 +143,6 @@ static void vol_release(struct device *dev)
>  }
> 
>  /**
> - * volume_sysfs_init - initialize sysfs for new volume.
> - * @ubi: UBI device description object
> - * @vol: volume description object
> - *
> - * This function returns zero in case of success and a negative error code in
> - * case of failure.
> - *
> - * Note, this function does not free allocated resources in case of failure -
> - * the caller does it. This is because this would cause release() here and the
> - * caller would oops.
> - */
> -static int volume_sysfs_init(struct ubi_device *ubi, struct ubi_volume *vol)
> -{
> -	int err;
> -
> -	err = device_create_file(&vol->dev, &attr_vol_reserved_ebs);
> -	if (err)
> -		return err;
> -	err = device_create_file(&vol->dev, &attr_vol_type);
> -	if (err)
> -		return err;
> -	err = device_create_file(&vol->dev, &attr_vol_name);
> -	if (err)
> -		return err;
> -	err = device_create_file(&vol->dev, &attr_vol_corrupted);
> -	if (err)
> -		return err;
> -	err = device_create_file(&vol->dev, &attr_vol_alignment);
> -	if (err)
> -		return err;
> -	err = device_create_file(&vol->dev, &attr_vol_usable_eb_size);
> -	if (err)
> -		return err;
> -	err = device_create_file(&vol->dev, &attr_vol_data_bytes);
> -	if (err)
> -		return err;
> -	err = device_create_file(&vol->dev, &attr_vol_upd_marker);
> -	return err;
> -}
> -
> -/**
> - * volume_sysfs_close - close sysfs for a volume.
> - * @vol: volume description object
> - */
> -static void volume_sysfs_close(struct ubi_volume *vol)
> -{
> -	device_remove_file(&vol->dev, &attr_vol_upd_marker);
> -	device_remove_file(&vol->dev, &attr_vol_data_bytes);
> -	device_remove_file(&vol->dev, &attr_vol_usable_eb_size);
> -	device_remove_file(&vol->dev, &attr_vol_alignment);
> -	device_remove_file(&vol->dev, &attr_vol_corrupted);
> -	device_remove_file(&vol->dev, &attr_vol_name);
> -	device_remove_file(&vol->dev, &attr_vol_type);
> -	device_remove_file(&vol->dev, &attr_vol_reserved_ebs);
> -	device_unregister(&vol->dev);
> -}
> -
> -/**
>   * ubi_create_volume - create volume.
>   * @ubi: UBI device description object
>   * @req: volume creation request
> @@ -323,7 +278,8 @@ int ubi_create_volume(struct ubi_device *ubi, struct ubi_mkvol_req *req)
>  	vol->dev.release = vol_release;
>  	vol->dev.parent = &ubi->dev;
>  	vol->dev.devt = dev;
> -	vol->dev.class = ubi_class;
> +	vol->dev.class = &ubi_class;
> +	vol->dev.groups = volume_dev_groups;
> 
>  	dev_set_name(&vol->dev, "%s_%d", ubi->ubi_name, vol->vol_id);
>  	err = device_register(&vol->dev);
> @@ -332,10 +288,6 @@ int ubi_create_volume(struct ubi_device *ubi, struct ubi_mkvol_req *req)
>  		goto out_cdev;
>  	}
> 
> -	err = volume_sysfs_init(ubi, vol);
> -	if (err)
> -		goto out_sysfs;
> -
>  	/* Fill volume table record */
>  	memset(&vtbl_rec, 0, sizeof(struct ubi_vtbl_record));
>  	vtbl_rec.reserved_pebs = cpu_to_be32(vol->reserved_pebs);
> @@ -372,7 +324,7 @@ out_sysfs:
>  	 */
>  	do_free = 0;
>  	get_device(&vol->dev);
> -	volume_sysfs_close(vol);
> +	device_unregister(&vol->dev);
>  out_cdev:
>  	cdev_del(&vol->cdev);
>  out_mapping:
> @@ -440,7 +392,7 @@ int ubi_remove_volume(struct ubi_volume_desc *desc, int no_vtbl)
>  	}
> 
>  	cdev_del(&vol->cdev);
> -	volume_sysfs_close(vol);
> +	device_unregister(&vol->dev);
> 
>  	spin_lock(&ubi->volumes_lock);
>  	ubi->rsvd_pebs -= reserved_pebs;
> @@ -653,19 +605,13 @@ int ubi_add_volume(struct ubi_device *ubi, struct ubi_volume *vol)
>  	vol->dev.release = vol_release;
>  	vol->dev.parent = &ubi->dev;
>  	vol->dev.devt = dev;
> -	vol->dev.class = ubi_class;
> +	vol->dev.class = &ubi_class;
> +	vol->dev.groups = volume_dev_groups;
>  	dev_set_name(&vol->dev, "%s_%d", ubi->ubi_name, vol->vol_id);
>  	err = device_register(&vol->dev);
>  	if (err)
>  		goto out_cdev;
> 
> -	err = volume_sysfs_init(ubi, vol);
> -	if (err) {
> -		cdev_del(&vol->cdev);
> -		volume_sysfs_close(vol);
> -		return err;
> -	}
> -
>  	self_check_volumes(ubi);
>  	return err;
> 
> @@ -688,7 +634,7 @@ void ubi_free_volume(struct ubi_device *ubi, struct ubi_volume *vol)
> 
>  	ubi->volumes[vol->vol_id] = NULL;
>  	cdev_del(&vol->cdev);
> -	volume_sysfs_close(vol);
> +	device_unregister(&vol->dev);
>  }
> 
>  /**
> -- 
> 1.6.0.2
> 



More information about the linux-mtd mailing list