UBI: simplify internal interfaces
Artem Bityutskiy [Thu, 24 Jan 2008 15:04:01 +0000 (17:04 +0200)]
Instead of passing vol_id to all functions and then find
struct ubi_volume, pass struct ubi_volume pointer.

Signed-off-by: Artem Bityutskiy <Artem.Bityutskiy@nokia.com>

drivers/mtd/ubi/cdev.c
drivers/mtd/ubi/ubi.h
drivers/mtd/ubi/upd.c

index d9bd494..0c4044d 100644 (file)
@@ -354,7 +354,7 @@ static ssize_t vol_cdev_write(struct file *file, const char __user *buf,
        if (!vol->updating)
                return vol_cdev_direct_write(file, buf, count, offp);
 
-       err = ubi_more_update_data(ubi, vol->vol_id, buf, count);
+       err = ubi_more_update_data(ubi, vol, buf, count);
        if (err < 0) {
                ubi_err("cannot write %zd bytes of update data, error %d",
                        count, err);
@@ -427,7 +427,7 @@ static int vol_cdev_ioctl(struct inode *inode, struct file *file,
                if (err < 0)
                        break;
 
-               err = ubi_start_update(ubi, vol->vol_id, bytes);
+               err = ubi_start_update(ubi, vol, bytes);
                if (bytes == 0)
                        revoke_exclusive(desc, UBI_READWRITE);
                break;
index a8cdbd0..3a88cf1 100644 (file)
@@ -423,8 +423,9 @@ int ubi_add_volume(struct ubi_device *ubi, struct ubi_volume *vol);
 void ubi_free_volume(struct ubi_device *ubi, struct ubi_volume *vol);
 
 /* upd.c */
-int ubi_start_update(struct ubi_device *ubi, int vol_id, long long bytes);
-int ubi_more_update_data(struct ubi_device *ubi, int vol_id,
+int ubi_start_update(struct ubi_device *ubi, struct ubi_volume *vol,
+                    long long bytes);
+int ubi_more_update_data(struct ubi_device *ubi, struct ubi_volume *vol,
                         const void __user *buf, int count);
 
 /* misc.c */
index 3defa57..59c61ab 100644 (file)
 /**
  * set_update_marker - set update marker.
  * @ubi: UBI device description object
- * @vol_id: volume ID
+ * @vol: volume description object
  *
- * This function sets the update marker flag for volume @vol_id. Returns zero
+ * This function sets the update marker flag for volume @vol. Returns zero
  * in case of success and a negative error code in case of failure.
  */
-static int set_update_marker(struct ubi_device *ubi, int vol_id)
+static int set_update_marker(struct ubi_device *ubi, struct ubi_volume *vol)
 {
        int err;
        struct ubi_vtbl_record vtbl_rec;
-       struct ubi_volume *vol = ubi->volumes[vol_id];
 
-       dbg_msg("set update marker for volume %d", vol_id);
+       dbg_msg("set update marker for volume %d", vol->vol_id);
 
        if (vol->upd_marker) {
-               ubi_assert(ubi->vtbl[vol_id].upd_marker);
+               ubi_assert(ubi->vtbl[vol->vol_id].upd_marker);
                dbg_msg("already set");
                return 0;
        }
 
-       memcpy(&vtbl_rec, &ubi->vtbl[vol_id], sizeof(struct ubi_vtbl_record));
+       memcpy(&vtbl_rec, &ubi->vtbl[vol->vol_id],
+              sizeof(struct ubi_vtbl_record));
        vtbl_rec.upd_marker = 1;
 
        mutex_lock(&ubi->volumes_mutex);
-       err = ubi_change_vtbl_record(ubi, vol_id, &vtbl_rec);
+       err = ubi_change_vtbl_record(ubi, vol->vol_id, &vtbl_rec);
        mutex_unlock(&ubi->volumes_mutex);
        vol->upd_marker = 1;
        return err;
@@ -77,23 +77,24 @@ static int set_update_marker(struct ubi_device *ubi, int vol_id)
 /**
  * clear_update_marker - clear update marker.
  * @ubi: UBI device description object
- * @vol_id: volume ID
+ * @vol: volume description object
  * @bytes: new data size in bytes
  *
- * This function clears the update marker for volume @vol_id, sets new volume
+ * This function clears the update marker for volume @vol, sets new volume
  * data size and clears the "corrupted" flag (static volumes only). Returns
  * zero in case of success and a negative error code in case of failure.
  */
-static int clear_update_marker(struct ubi_device *ubi, int vol_id, long long bytes)
+static int clear_update_marker(struct ubi_device *ubi, struct ubi_volume *vol,
+                              long long bytes)
 {
        int err;
        uint64_t tmp;
        struct ubi_vtbl_record vtbl_rec;
-       struct ubi_volume *vol = ubi->volumes[vol_id];
 
-       dbg_msg("clear update marker for volume %d", vol_id);
+       dbg_msg("clear update marker for volume %d", vol->vol_id);
 
-       memcpy(&vtbl_rec, &ubi->vtbl[vol_id], sizeof(struct ubi_vtbl_record));
+       memcpy(&vtbl_rec, &ubi->vtbl[vol->vol_id],
+              sizeof(struct ubi_vtbl_record));
        ubi_assert(vol->upd_marker && vtbl_rec.upd_marker);
        vtbl_rec.upd_marker = 0;
 
@@ -109,7 +110,7 @@ static int clear_update_marker(struct ubi_device *ubi, int vol_id, long long byt
        }
 
        mutex_lock(&ubi->volumes_mutex);
-       err = ubi_change_vtbl_record(ubi, vol_id, &vtbl_rec);
+       err = ubi_change_vtbl_record(ubi, vol->vol_id, &vtbl_rec);
        mutex_unlock(&ubi->volumes_mutex);
        vol->upd_marker = 0;
        return err;
@@ -118,23 +119,23 @@ static int clear_update_marker(struct ubi_device *ubi, int vol_id, long long byt
 /**
  * ubi_start_update - start volume update.
  * @ubi: UBI device description object
- * @vol_id: volume ID
+ * @vol: volume description object
  * @bytes: update bytes
  *
  * This function starts volume update operation. If @bytes is zero, the volume
  * is just wiped out. Returns zero in case of success and a negative error code
  * in case of failure.
  */
-int ubi_start_update(struct ubi_device *ubi, int vol_id, long long bytes)
+int ubi_start_update(struct ubi_device *ubi, struct ubi_volume *vol,
+                    long long bytes)
 {
        int i, err;
        uint64_t tmp;
-       struct ubi_volume *vol = ubi->volumes[vol_id];
 
-       dbg_msg("start update of volume %d, %llu bytes", vol_id, bytes);
+       dbg_msg("start update of volume %d, %llu bytes", vol->vol_id, bytes);
        vol->updating = 1;
 
-       err = set_update_marker(ubi, vol_id);
+       err = set_update_marker(ubi, vol);
        if (err)
                return err;
 
@@ -146,7 +147,7 @@ int ubi_start_update(struct ubi_device *ubi, int vol_id, long long bytes)
        }
 
        if (bytes == 0) {
-               err = clear_update_marker(ubi, vol_id, 0);
+               err = clear_update_marker(ubi, vol, 0);
                if (err)
                        return err;
                err = ubi_wl_flush(ubi);
@@ -169,7 +170,7 @@ int ubi_start_update(struct ubi_device *ubi, int vol_id, long long bytes)
 /**
  * write_leb - write update data.
  * @ubi: UBI device description object
- * @vol_id: volume ID
+ * @vol: volume description object
  * @lnum: logical eraseblock number
  * @buf: data to write
  * @len: data size
@@ -195,11 +196,10 @@ int ubi_start_update(struct ubi_device *ubi, int vol_id, long long bytes)
  * This function returns zero in case of success and a negative error code in
  * case of failure.
  */
-static int write_leb(struct ubi_device *ubi, int vol_id, int lnum, void *buf,
-                    int len, int used_ebs)
+static int write_leb(struct ubi_device *ubi, struct ubi_volume *vol, int lnum,
+                    void *buf, int len, int used_ebs)
 {
        int err, l;
-       struct ubi_volume *vol = ubi->volumes[vol_id];
 
        if (vol->vol_type == UBI_DYNAMIC_VOLUME) {
                l = ALIGN(len, ubi->min_io_size);
@@ -244,11 +244,10 @@ static int write_leb(struct ubi_device *ubi, int vol_id, int lnum, void *buf,
  * the last call if the whole volume update was successfully finished, and a
  * negative error code in case of failure.
  */
-int ubi_more_update_data(struct ubi_device *ubi, int vol_id,
+int ubi_more_update_data(struct ubi_device *ubi, struct ubi_volume *vol,
                         const void __user *buf, int count)
 {
        uint64_t tmp;
-       struct ubi_volume *vol = ubi->volumes[vol_id];
        int lnum, offs, err = 0, len, to_write = count;
 
        dbg_msg("write %d of %lld bytes, %lld already passed",
@@ -293,8 +292,8 @@ int ubi_more_update_data(struct ubi_device *ubi, int vol_id,
                         * is the last chunk, it's time to flush the buffer.
                         */
                        ubi_assert(flush_len <= vol->usable_leb_size);
-                       err = write_leb(ubi, vol_id, lnum, vol->upd_buf,
-                                       flush_len, vol->upd_ebs);
+                       err = write_leb(ubi, vol, lnum, vol->upd_buf, flush_len,
+                                       vol->upd_ebs);
                        if (err)
                                return err;
                }
@@ -321,8 +320,8 @@ int ubi_more_update_data(struct ubi_device *ubi, int vol_id,
 
                if (len == vol->usable_leb_size ||
                    vol->upd_received + len == vol->upd_bytes) {
-                       err = write_leb(ubi, vol_id, lnum, vol->upd_buf, len,
-                                       vol->upd_ebs);
+                       err = write_leb(ubi, vol, lnum, vol->upd_buf,
+                                       len, vol->upd_ebs);
                        if (err)
                                break;
                }
@@ -336,7 +335,7 @@ int ubi_more_update_data(struct ubi_device *ubi, int vol_id,
        ubi_assert(vol->upd_received <= vol->upd_bytes);
        if (vol->upd_received == vol->upd_bytes) {
                /* The update is finished, clear the update marker */
-               err = clear_update_marker(ubi, vol_id, vol->upd_bytes);
+               err = clear_update_marker(ubi, vol, vol->upd_bytes);
                if (err)
                        return err;
                err = ubi_wl_flush(ubi);