UBI: add notification API (0e0ee1cc) · Commits · 戴 / test

drivers/mtd/ubi/build.c

+95 −5

Original line number	Original line	Diff line number	Diff line
	@@ -121,6 +121,94 @@ static struct device_attribute dev_bgt_enabled =
	static struct device_attribute dev_mtd_num =		static struct device_attribute dev_mtd_num =
	__ATTR(mtd_num, S_IRUGO, dev_attribute_show, NULL);		__ATTR(mtd_num, S_IRUGO, dev_attribute_show, NULL);

			/**
			* ubi_volume_notify - send a volume change notification.
			* @ubi: UBI device description object
			* @vol: volume description object of the changed volume
			* @ntype: notification type to send (%UBI_VOLUME_ADDED, etc)
			*
			* This is a helper function which notifies all subscribers about a volume
			* change event (creation, removal, re-sizing, re-naming, updating). Returns
			* zero in case of success and a negative error code in case of failure.
			*/
			int ubi_volume_notify(struct ubi_device ubi, struct ubi_volume vol, int ntype)
			{
			struct ubi_notification nt;

			ubi_do_get_device_info(ubi, &nt.di);
			ubi_do_get_volume_info(ubi, vol, &nt.vi);
			return blocking_notifier_call_chain(&ubi_notifiers, ntype, &nt);
			}

			/**
			* ubi_notify_all - send a notification to all volumes.
			* @ubi: UBI device description object
			* @ntype: notification type to send (%UBI_VOLUME_ADDED, etc)
			* @nb: the notifier to call
			*
			* This function walks all volumes of UBI device @ubi and sends the @ntype
			* notification for each volume. If @nb is %NULL, then all registered notifiers
			* are called, otherwise only the @nb notifier is called. Returns the number of
			* sent notifications.
			*/
			int ubi_notify_all(struct ubi_device ubi, int ntype, struct notifier_block nb)
			{
			struct ubi_notification nt;
			int i, count = 0;

			ubi_do_get_device_info(ubi, &nt.di);

			mutex_lock(&ubi->device_mutex);
			for (i = 0; i < ubi->vtbl_slots; i++) {
			/*
			* Since the @ubi->device is locked, and we are not going to
			* change @ubi->volumes, we do not have to lock
			* @ubi->volumes_lock.
			*/
			if (!ubi->volumes[i])
			continue;

			ubi_do_get_volume_info(ubi, ubi->volumes[i], &nt.vi);
			if (nb)
			nb->notifier_call(nb, ntype, &nt);
			else
			blocking_notifier_call_chain(&ubi_notifiers, ntype,
			&nt);
			count += 1;
			}
			mutex_unlock(&ubi->device_mutex);

			return count;
			}

			/**
			* ubi_enumerate_volumes - send "add" notification for all existing volumes.
			* @nb: the notifier to call
			*
			* This function walks all UBI devices and volumes and sends the
			* %UBI_VOLUME_ADDED notification for each volume. If @nb is %NULL, then all
			* registered notifiers are called, otherwise only the @nb notifier is called.
			* Returns the number of sent notifications.
			*/
			int ubi_enumerate_volumes(struct notifier_block *nb)
			{
			int i, count = 0;

			/*
			* Since the @ubi_devices_mutex is locked, and we are not going to
			* change @ubi_devices, we do not have to lock @ubi_devices_lock.
			*/
			for (i = 0; i < UBI_MAX_DEVICES; i++) {
			struct ubi_device *ubi = ubi_devices[i];

			if (!ubi)
			continue;
			count += ubi_notify_all(ubi, UBI_VOLUME_ADDED, nb);
			}

			return count;
			}

	/**		/**
	* ubi_get_device - get UBI device.		* ubi_get_device - get UBI device.
	* @ubi_num: UBI device number		* @ubi_num: UBI device number
	@@ -891,6 +979,7 @@ int ubi_attach_mtd_dev(struct mtd_info *mtd, int ubi_num, int vid_hdr_offset)
	spin_unlock(&ubi->wl_lock);		spin_unlock(&ubi->wl_lock);

	ubi_devices[ubi_num] = ubi;		ubi_devices[ubi_num] = ubi;
			ubi_notify_all(ubi, UBI_VOLUME_ADDED, NULL);
	return ubi_num;		return ubi_num;

	out_uif:		out_uif:
	@@ -933,13 +1022,13 @@ int ubi_detach_mtd_dev(int ubi_num, int anyway)
	if (ubi_num < 0 \|\| ubi_num >= UBI_MAX_DEVICES)		if (ubi_num < 0 \|\| ubi_num >= UBI_MAX_DEVICES)
	return -EINVAL;		return -EINVAL;

	spin_lock(&ubi_devices_lock);		ubi = ubi_get_device(ubi_num);
	ubi = ubi_devices[ubi_num];		if (!ubi)
	if (!ubi) {
	spin_unlock(&ubi_devices_lock);
	return -EINVAL;		return -EINVAL;
	}

			spin_lock(&ubi_devices_lock);
			put_device(&ubi->dev);
			ubi->ref_count -= 1;
	if (ubi->ref_count) {		if (ubi->ref_count) {
	if (!anyway) {		if (!anyway) {
	spin_unlock(&ubi_devices_lock);		spin_unlock(&ubi_devices_lock);
	@@ -953,6 +1042,7 @@ int ubi_detach_mtd_dev(int ubi_num, int anyway)
	spin_unlock(&ubi_devices_lock);		spin_unlock(&ubi_devices_lock);

	ubi_assert(ubi_num == ubi->ubi_num);		ubi_assert(ubi_num == ubi->ubi_num);
			ubi_notify_all(ubi, UBI_VOLUME_REMOVED, NULL);
	dbg_msg("detaching mtd%d from ubi%d", ubi->mtd->index, ubi_num);		dbg_msg("detaching mtd%d from ubi%d", ubi->mtd->index, ubi_num);

	/*		/*

drivers/mtd/ubi/cdev.c

+1 −0

Original line number	Original line	Diff line number	Diff line
	@@ -396,6 +396,7 @@ static ssize_t vol_cdev_write(struct file file, const char __user buf,
	}		}
	vol->checked = 1;		vol->checked = 1;
	ubi_gluebi_updated(vol);		ubi_gluebi_updated(vol);
			ubi_volume_notify(ubi, vol, UBI_VOLUME_UPDATED);
	revoke_exclusive(desc, UBI_READWRITE);		revoke_exclusive(desc, UBI_READWRITE);
	}		}

drivers/mtd/ubi/kapi.c

+92 −16

Original line number	Original line	Diff line number	Diff line
	@@ -25,6 +25,24 @@
	#include <asm/div64.h>		#include <asm/div64.h>
	#include "ubi.h"		#include "ubi.h"

			/**
			* ubi_do_get_device_info - get information about UBI device.
			* @ubi: UBI device description object
			* @di: the information is stored here
			*
			* This function is the same as 'ubi_get_device_info()', but it assumes the UBI
			* device is locked and cannot disappear.
			*/
			void ubi_do_get_device_info(struct ubi_device ubi, struct ubi_device_info di)
			{
			di->ubi_num = ubi->ubi_num;
			di->leb_size = ubi->leb_size;
			di->min_io_size = ubi->min_io_size;
			di->ro_mode = ubi->ro_mode;
			di->cdev = ubi->cdev.dev;
			}
			EXPORT_SYMBOL_GPL(ubi_do_get_device_info);

	/**		/**
	* ubi_get_device_info - get information about UBI device.		* ubi_get_device_info - get information about UBI device.
	* @ubi_num: UBI device number		* @ubi_num: UBI device number
	@@ -39,33 +57,24 @@ int ubi_get_device_info(int ubi_num, struct ubi_device_info *di)

	if (ubi_num < 0 \|\| ubi_num >= UBI_MAX_DEVICES)		if (ubi_num < 0 \|\| ubi_num >= UBI_MAX_DEVICES)
	return -EINVAL;		return -EINVAL;

	ubi = ubi_get_device(ubi_num);		ubi = ubi_get_device(ubi_num);
	if (!ubi)		if (!ubi)
	return -ENODEV;		return -ENODEV;
			ubi_do_get_device_info(ubi, di);
	di->ubi_num = ubi->ubi_num;
	di->leb_size = ubi->leb_size;
	di->min_io_size = ubi->min_io_size;
	di->ro_mode = ubi->ro_mode;
	di->cdev = ubi->cdev.dev;

	ubi_put_device(ubi);		ubi_put_device(ubi);
	return 0;		return 0;
	}		}
	EXPORT_SYMBOL_GPL(ubi_get_device_info);		EXPORT_SYMBOL_GPL(ubi_get_device_info);

	/**		/**
	* ubi_get_volume_info - get information about UBI volume.		* ubi_do_get_volume_info - get information about UBI volume.
	* @desc: volume descriptor		* @ubi: UBI device description object
			* @vol: volume description object
	* @vi: the information is stored here		* @vi: the information is stored here
	*/		*/
	void ubi_get_volume_info(struct ubi_volume_desc *desc,		void ubi_do_get_volume_info(struct ubi_device ubi, struct ubi_volume vol,
	struct ubi_volume_info *vi)		struct ubi_volume_info *vi)
	{		{
	const struct ubi_volume *vol = desc->vol;
	const struct ubi_device *ubi = vol->ubi;

	vi->vol_id = vol->vol_id;		vi->vol_id = vol->vol_id;
	vi->ubi_num = ubi->ubi_num;		vi->ubi_num = ubi->ubi_num;
	vi->size = vol->reserved_pebs;		vi->size = vol->reserved_pebs;
	@@ -79,6 +88,17 @@ void ubi_get_volume_info(struct ubi_volume_desc *desc,
	vi->name = vol->name;		vi->name = vol->name;
	vi->cdev = vol->cdev.dev;		vi->cdev = vol->cdev.dev;
	}		}

			/**
			* ubi_get_volume_info - get information about UBI volume.
			* @desc: volume descriptor
			* @vi: the information is stored here
			*/
			void ubi_get_volume_info(struct ubi_volume_desc *desc,
			struct ubi_volume_info *vi)
			{
			ubi_do_get_volume_info(desc->vol->ubi, desc->vol, vi);
			}
	EXPORT_SYMBOL_GPL(ubi_get_volume_info);		EXPORT_SYMBOL_GPL(ubi_get_volume_info);

	/**		/**
	@@ -561,7 +581,7 @@ int ubi_leb_unmap(struct ubi_volume_desc *desc, int lnum)
	EXPORT_SYMBOL_GPL(ubi_leb_unmap);		EXPORT_SYMBOL_GPL(ubi_leb_unmap);

	/**		/**
	* ubi_leb_map - map logical erasblock to a physical eraseblock.		* ubi_leb_map - map logical eraseblock to a physical eraseblock.
	* @desc: volume descriptor		* @desc: volume descriptor
	* @lnum: logical eraseblock number		* @lnum: logical eraseblock number
	* @dtype: expected data type		* @dtype: expected data type
	@@ -659,3 +679,59 @@ int ubi_sync(int ubi_num)
	return 0;		return 0;
	}		}
	EXPORT_SYMBOL_GPL(ubi_sync);		EXPORT_SYMBOL_GPL(ubi_sync);

			BLOCKING_NOTIFIER_HEAD(ubi_notifiers);

			/**
			* ubi_register_volume_notifier - register a volume notifier.
			* @nb: the notifier description object
			* @ignore_existing: if non-zero, do not send "added" notification for all
			* already existing volumes
			*
			* This function registers a volume notifier, which means that
			* 'nb->notifier_call()' will be invoked when an UBI volume is created,
			* removed, re-sized, re-named, or updated. The first argument of the function
			* is the notification type. The second argument is pointer to a
			* &struct ubi_notification object which describes the notification event.
			* Using UBI API from the volume notifier is prohibited.
			*
			* This function returns zero in case of success and a negative error code
			* in case of failure.
			*/
			int ubi_register_volume_notifier(struct notifier_block *nb,
			int ignore_existing)
			{
			int err;

			err = blocking_notifier_chain_register(&ubi_notifiers, nb);
			if (err != 0)
			return err;
			if (ignore_existing)
			return 0;

			/*
			* We are going to walk all UBI devices and all volumes, and
			* notify the user about existing volumes by the %UBI_VOLUME_ADDED
			* event. We have to lock the @ubi_devices_mutex to make sure UBI
			* devices do not disappear.
			*/
			mutex_lock(&ubi_devices_mutex);
			ubi_enumerate_volumes(nb);
			mutex_unlock(&ubi_devices_mutex);

			return err;
			}
			EXPORT_SYMBOL_GPL(ubi_register_volume_notifier);

			/**
			* ubi_unregister_volume_notifier - unregister the volume notifier.
			* @nb: the notifier description object
			*
			* This function unregisters volume notifier @nm and returns zero in case of
			* success and a negative error code in case of failure.
			*/
			int ubi_unregister_volume_notifier(struct notifier_block *nb)
			{
			return blocking_notifier_chain_unregister(&ubi_notifiers, nb);
			}
			EXPORT_SYMBOL_GPL(ubi_unregister_volume_notifier);

drivers/mtd/ubi/ubi.h

+12 −0

Original line number	Original line	Diff line number	Diff line
	@@ -38,6 +38,7 @@
	#include <linux/vmalloc.h>		#include <linux/vmalloc.h>
	#include <linux/mtd/mtd.h>		#include <linux/mtd/mtd.h>
	#include <linux/mtd/ubi.h>		#include <linux/mtd/ubi.h>
			#include <linux/notifier.h>

	#include "ubi-media.h"		#include "ubi-media.h"
	#include "scan.h"		#include "scan.h"
	@@ -483,6 +484,7 @@ extern const struct file_operations ubi_cdev_operations;
	extern const struct file_operations ubi_vol_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 mutex ubi_devices_mutex;
			extern struct blocking_notifier_head ubi_notifiers;

	/* vtbl.c */		/* vtbl.c */
	int ubi_change_vtbl_record(struct ubi_device *ubi, int idx,		int ubi_change_vtbl_record(struct ubi_device *ubi, int idx,
	@@ -575,6 +577,16 @@ struct ubi_device *ubi_get_device(int ubi_num);
	void ubi_put_device(struct ubi_device *ubi);		void ubi_put_device(struct ubi_device *ubi);
	struct ubi_device *ubi_get_by_major(int major);		struct ubi_device *ubi_get_by_major(int major);
	int ubi_major2num(int major);		int ubi_major2num(int major);
			int ubi_volume_notify(struct ubi_device ubi, struct ubi_volume vol,
			int ntype);
			int ubi_notify_all(struct ubi_device *ubi, int ntype,
			struct notifier_block *nb);
			int ubi_enumerate_volumes(struct notifier_block *nb);

			/* kapi.c */
			void ubi_do_get_device_info(struct ubi_device ubi, struct ubi_device_info di);
			void ubi_do_get_volume_info(struct ubi_device ubi, struct ubi_volume vol,
			struct ubi_volume_info *vi);

	/*		/*
	* ubi_rb_for_each_entry - walk an RB-tree.		* ubi_rb_for_each_entry - walk an RB-tree.

drivers/mtd/ubi/vmt.c

+4 −0

Original line number	Original line	Diff line number	Diff line
	@@ -358,6 +358,7 @@ int ubi_create_volume(struct ubi_device ubi, struct ubi_mkvol_req req)
	ubi->vol_count += 1;		ubi->vol_count += 1;
	spin_unlock(&ubi->volumes_lock);		spin_unlock(&ubi->volumes_lock);

			ubi_volume_notify(ubi, vol, UBI_VOLUME_ADDED);
	if (paranoid_check_volumes(ubi))		if (paranoid_check_volumes(ubi))
	dbg_err("check failed while creating volume %d", vol_id);		dbg_err("check failed while creating volume %d", vol_id);
	return err;		return err;
	@@ -466,6 +467,7 @@ int ubi_remove_volume(struct ubi_volume_desc *desc, int no_vtbl)
	ubi->vol_count -= 1;		ubi->vol_count -= 1;
	spin_unlock(&ubi->volumes_lock);		spin_unlock(&ubi->volumes_lock);

			ubi_volume_notify(ubi, vol, UBI_VOLUME_REMOVED);
	if (!no_vtbl && paranoid_check_volumes(ubi))		if (!no_vtbl && paranoid_check_volumes(ubi))
	dbg_err("check failed while removing volume %d", vol_id);		dbg_err("check failed while removing volume %d", vol_id);

	@@ -589,6 +591,7 @@ int ubi_resize_volume(struct ubi_volume_desc *desc, int reserved_pebs)
	(long long)vol->used_ebs * vol->usable_leb_size;		(long long)vol->used_ebs * vol->usable_leb_size;
	}		}

			ubi_volume_notify(ubi, vol, UBI_VOLUME_RESIZED);
	if (paranoid_check_volumes(ubi))		if (paranoid_check_volumes(ubi))
	dbg_err("check failed while re-sizing volume %d", vol_id);		dbg_err("check failed while re-sizing volume %d", vol_id);
	return err;		return err;
	@@ -635,6 +638,7 @@ int ubi_rename_volumes(struct ubi_device ubi, struct list_head rename_list)
	vol->name_len = re->new_name_len;		vol->name_len = re->new_name_len;
	memcpy(vol->name, re->new_name, re->new_name_len + 1);		memcpy(vol->name, re->new_name, re->new_name_len + 1);
	spin_unlock(&ubi->volumes_lock);		spin_unlock(&ubi->volumes_lock);
			ubi_volume_notify(ubi, vol, UBI_VOLUME_RENAMED);
	}		}
	}		}

Admin message