6 files changed, 375 insertions, 15 deletions

diff --git a/drivers/mtd/ubi/build.c b/drivers/mtd/ubi/build.c
index 7210e1da1fcb..4418a2369b56 100644
--- a/drivers/mtd/ubi/build.c
+++ b/drivers/mtd/ubi/build.c
@@ -806,6 +806,7 @@ int ubi_attach_mtd_dev(struct mtd_info *mtd, int ubi_num, int vid_hdr_offset)
 
         mutex_init(&ubi->buf_mutex);
         mutex_init(&ubi->ckvol_mutex);
+        mutex_init(&ubi->mult_mutex);
         mutex_init(&ubi->volumes_mutex);
         spin_lock_init(&ubi->volumes_lock);
 
diff --git a/drivers/mtd/ubi/cdev.c b/drivers/mtd/ubi/cdev.c
index 7c19918cc914..bc8199c6a9f5 100644
--- a/drivers/mtd/ubi/cdev.c
+++ b/drivers/mtd/ubi/cdev.c
@@ -605,6 +605,166 @@ static int verify_rsvol_req(const struct ubi_device *ubi,
         return 0;
 }
 
+/**
+ * rename_volumes - rename UBI volumes.
+ * @ubi: UBI device description object
+ * @req: volumes re-name request
+ *
+ * This is a helper function for the volume re-name IOCTL which validates the
+ * the request, opens the volume and calls corresponding volumes management
+ * function. Returns zero in case of success and a negative error code in case
+ * of failure.
+ */
+static int rename_volumes(struct ubi_device *ubi,
+                          struct ubi_rnvol_req *req)
+{
+        int i, n, err;
+        struct list_head rename_list;
+        struct ubi_rename_entry *re, *re1;
+
+        if (req->count < 0 || req->count > UBI_MAX_RNVOL)
+                return -EINVAL;
+
+        if (req->count == 0)
+                return 0;
+
+        /* Validate volume IDs and names in the request */
+        for (i = 0; i < req->count; i++) {
+                if (req->ents[i].vol_id < 0 ||
+                    req->ents[i].vol_id >= ubi->vtbl_slots)
+                        return -EINVAL;
+                if (req->ents[i].name_len < 0)
+                        return -EINVAL;
+                if (req->ents[i].name_len > UBI_VOL_NAME_MAX)
+                        return -ENAMETOOLONG;
+                req->ents[i].name[req->ents[i].name_len] = '\0';
+                n = strlen(req->ents[i].name);
+                if (n != req->ents[i].name_len)
+                        err = -EINVAL;
+        }
+
+        /* Make sure volume IDs and names are unique */
+        for (i = 0; i < req->count - 1; i++) {
+                for (n = i + 1; n < req->count; n++) {
+                        if (req->ents[i].vol_id == req->ents[n].vol_id) {
+                                dbg_err("duplicated volume id %d",
+                                        req->ents[i].vol_id);
+                                return -EINVAL;
+                        }
+                        if (!strcmp(req->ents[i].name, req->ents[n].name)) {
+                                dbg_err("duplicated volume name \"%s\"",
+                                        req->ents[i].name);
+                                return -EINVAL;
+                        }
+                }
+        }
+
+        /* Create the re-name list */
+        INIT_LIST_HEAD(&rename_list);
+        for (i = 0; i < req->count; i++) {
+                int vol_id = req->ents[i].vol_id;
+                int name_len = req->ents[i].name_len;
+                const char *name = req->ents[i].name;
+
+                re = kzalloc(sizeof(struct ubi_rename_entry), GFP_KERNEL);
+                if (!re) {
+                        err = -ENOMEM;
+                        goto out_free;
+                }
+
+                re->desc = ubi_open_volume(ubi->ubi_num, vol_id, UBI_EXCLUSIVE);
+                if (IS_ERR(re->desc)) {
+                        err = PTR_ERR(re->desc);
+                        dbg_err("cannot open volume %d, error %d", vol_id, err);
+                        kfree(re);
+                        goto out_free;
+                }
+
+                /* Skip this re-naming if the name does not really change */
+                if (re->desc->vol->name_len == name_len &&
+                    !memcmp(re->desc->vol->name, name, name_len)) {
+                        ubi_close_volume(re->desc);
+                        kfree(re);
+                        continue;
+                }
+
+                re->new_name_len = name_len;
+                memcpy(re->new_name, name, name_len);
+                list_add_tail(&re->list, &rename_list);
+                dbg_msg("will rename volume %d from \"%s\" to \"%s\"",
+                        vol_id, re->desc->vol->name, name);
+        }
+
+        if (list_empty(&rename_list))
+                return 0;
+
+        /* Find out the volumes which have to be removed */
+        list_for_each_entry(re, &rename_list, list) {
+                struct ubi_volume_desc *desc;
+                int no_remove_needed = 0;
+
+                /*
+                 * Volume @re->vol_id is going to be re-named to
+                 * @re->new_name, while its current name is @name. If a volume
+                 * with name @re->new_name currently exists, it has to be
+                 * removed, unless it is also re-named in the request (@req).
+                 */
+                list_for_each_entry(re1, &rename_list, list) {
+                        if (re->new_name_len == re1->desc->vol->name_len &&
+                            !memcmp(re->new_name, re1->desc->vol->name,
+                                    re1->desc->vol->name_len)) {
+                                no_remove_needed = 1;
+                                break;
+                        }
+                }
+
+                if (no_remove_needed)
+                        continue;
+
+                /*
+                 * It seems we need to remove volume with name @re->new_name,
+                 * if it exists.
+                 */
+                desc = ubi_open_volume_nm(ubi->ubi_num, re->new_name, UBI_EXCLUSIVE);
+                if (IS_ERR(desc)) {
+                        err = PTR_ERR(desc);
+                        if (err == -ENODEV)
+                                /* Re-naming into a non-existing volume name */
+                                continue;
+
+                        /* The volume exists but busy, or an error occurred */
+                        dbg_err("cannot open volume \"%s\", error %d",
+                                re->new_name, err);
+                        goto out_free;
+                }
+
+                re = kzalloc(sizeof(struct ubi_rename_entry), GFP_KERNEL);
+                if (!re) {
+                        err = -ENOMEM;
+                        ubi_close_volume(desc);
+                        goto out_free;
+                }
+
+                re->remove = 1;
+                re->desc = desc;
+                list_add(&re->list, &rename_list);
+                dbg_msg("will remove volume %d, name \"%s\"",
+                        re->desc->vol->vol_id, re->desc->vol->name);
+        }
+
+        mutex_lock(&ubi->volumes_mutex);
+        err = ubi_rename_volumes(ubi, &rename_list);
+        mutex_unlock(&ubi->volumes_mutex);
+
+out_free:
+        list_for_each_entry_safe(re, re1, &rename_list, list) {
+                ubi_close_volume(re->desc);
+                list_del(&re->list);
+                kfree(re);
+        }
+        return err;
+}
+
 static int ubi_cdev_ioctl(struct inode *inode, struct file *file,
                           unsigned int cmd, unsigned long arg)
 {
@@ -670,7 +830,7 @@ static int ubi_cdev_ioctl(struct inode *inode, struct file *file,
                 }
 
                 mutex_lock(&ubi->volumes_mutex);
-                err = ubi_remove_volume(desc);
+                err = ubi_remove_volume(desc, 0);
                 mutex_unlock(&ubi->volumes_mutex);
 
                 /*
@@ -717,6 +877,32 @@ static int ubi_cdev_ioctl(struct inode *inode, struct file *file,
                 break;
         }
 
+        /* Re-name volumes command */
+        case UBI_IOCRNVOL:
+        {
+                struct ubi_rnvol_req *req;
+
+                dbg_msg("re-name volumes");
+                req = kmalloc(sizeof(struct ubi_rnvol_req), GFP_KERNEL);
+                if (!req) {
+                        err = -ENOMEM;
+                        break;
+                };
+
+                err = copy_from_user(req, argp, sizeof(struct ubi_rnvol_req));
+                if (err) {
+                        err = -EFAULT;
+                        kfree(req);
+                        break;
+                }
+
+                mutex_lock(&ubi->mult_mutex);
+                err = rename_volumes(ubi, req);
+                mutex_unlock(&ubi->mult_mutex);
+                kfree(req);
+                break;
+        }
+
         default:
                 err = -ENOTTY;
                 break;
diff --git a/drivers/mtd/ubi/ubi.h b/drivers/mtd/ubi/ubi.h
index 1fc32c863b78..274c67916b34 100644
--- a/drivers/mtd/ubi/ubi.h
+++ b/drivers/mtd/ubi/ubi.h
@@ -131,6 +131,27 @@ struct ubi_ltree_entry {
         struct rw_semaphore mutex;
 };
 
+/**
+ * struct ubi_rename_entry - volume re-name description data structure.
+ * @new_name_len: new volume name length
+ * @new_name: new volume name
+ * @remove: if not zero, this volume should be removed, not re-named
+ * @desc: descriptor of the volume
+ * @list: links re-name entries into a list
+ *
+ * This data structure is utilized in the multiple volume re-name code. Namely,
+ * UBI first creates a list of &struct ubi_rename_entry objects from the
+ * &struct ubi_rnvol_req request object, and then utilizes this list to do all
+ * the job.
+ */
+struct ubi_rename_entry {
+        int new_name_len;
+        char new_name[UBI_VOL_NAME_MAX + 1];
+        int remove;
+        struct ubi_volume_desc *desc;
+        struct list_head list;
+};
+
 struct ubi_volume_desc;
 
 /**
@@ -206,7 +227,7 @@ struct ubi_volume {
         int alignment;
         int data_pad;
         int name_len;
-        char name[UBI_VOL_NAME_MAX+1];
+        char name[UBI_VOL_NAME_MAX + 1];
 
         int upd_ebs;
         int ch_lnum;
@@ -272,7 +293,7 @@ struct ubi_wl_entry;
  * @vtbl_size: size of the volume table in bytes
  * @vtbl: in-RAM volume table copy
  * @volumes_mutex: protects on-flash volume table and serializes volume
- *                 changes, like creation, deletion, update, resize
+ *                 changes, like creation, deletion, update, re-size and re-name
  *
  * @max_ec: current highest erase counter value
  * @mean_ec: current mean erase counter value
@@ -330,6 +351,8 @@ struct ubi_wl_entry;
  * @peb_buf1: a buffer of PEB size used for different purposes
  * @peb_buf2: another buffer of PEB size used for different purposes
  * @buf_mutex: proptects @peb_buf1 and @peb_buf2
+ * @ckvol_mutex: serializes static volume checking when opening
+ * @mult_mutex: serializes operations on multiple volumes, like re-nameing
  * @dbg_peb_buf: buffer of PEB size used for debugging
  * @dbg_buf_mutex: proptects @dbg_peb_buf
  */
@@ -410,6 +433,7 @@ struct ubi_device {
         void *peb_buf2;
         struct mutex buf_mutex;
         struct mutex ckvol_mutex;
+        struct mutex mult_mutex;
 #ifdef CONFIG_MTD_UBI_DEBUG
         void *dbg_peb_buf;
         struct mutex dbg_buf_mutex;
@@ -426,12 +450,15 @@ extern struct mutex ubi_devices_mutex;
 /* vtbl.c */
 int ubi_change_vtbl_record(struct ubi_device *ubi, int idx,
                            struct ubi_vtbl_record *vtbl_rec);
+int ubi_vtbl_rename_volumes(struct ubi_device *ubi,
+                            struct list_head *rename_list);
 int ubi_read_volume_table(struct ubi_device *ubi, struct ubi_scan_info *si);
 
 /* vmt.c */
 int ubi_create_volume(struct ubi_device *ubi, struct ubi_mkvol_req *req);
-int ubi_remove_volume(struct ubi_volume_desc *desc);
+int ubi_remove_volume(struct ubi_volume_desc *desc, int no_vtbl);
 int ubi_resize_volume(struct ubi_volume_desc *desc, int reserved_pebs);
+int ubi_rename_volumes(struct ubi_device *ubi, struct list_head *rename_list);
 int ubi_add_volume(struct ubi_device *ubi, struct ubi_volume *vol);
 void ubi_free_volume(struct ubi_device *ubi, struct ubi_volume *vol);
 
diff --git a/drivers/mtd/ubi/vmt.c b/drivers/mtd/ubi/vmt.c
index 2cd886a5adac..4be4014c70df 100644
--- a/drivers/mtd/ubi/vmt.c
+++ b/drivers/mtd/ubi/vmt.c
@@ -402,13 +402,14 @@ out_unlock:
 /**
  * ubi_remove_volume - remove volume.
  * @desc: volume descriptor
+ * @no_vtbl: do not change volume table if not zero
  *
  * This function removes volume described by @desc. The volume has to be opened
  * in "exclusive" mode. Returns zero in case of success and a negative error
  * code in case of failure. The caller has to have the @ubi->volumes_mutex
  * locked.
  */
-int ubi_remove_volume(struct ubi_volume_desc *desc)
+int ubi_remove_volume(struct ubi_volume_desc *desc, int no_vtbl)
 {
         struct ubi_volume *vol = desc->vol;
         struct ubi_device *ubi = vol->ubi;
@@ -437,9 +438,11 @@ int ubi_remove_volume(struct ubi_volume_desc *desc)
         if (err)
                 goto out_err;
 
-        err = ubi_change_vtbl_record(ubi, vol_id, NULL);
-        if (err)
-                goto out_err;
+        if (!no_vtbl) {
+                err = ubi_change_vtbl_record(ubi, vol_id, NULL);
+                if (err)
+                        goto out_err;
+        }
 
         for (i = 0; i < vol->reserved_pebs; i++) {
                 err = ubi_eba_unmap_leb(ubi, vol, i);
@@ -465,7 +468,8 @@ int ubi_remove_volume(struct ubi_volume_desc *desc)
         ubi->vol_count -= 1;
         spin_unlock(&ubi->volumes_lock);
 
-        err = paranoid_check_volumes(ubi);
+        if (!no_vtbl)
+                err = paranoid_check_volumes(ubi);
         return err;
 
 out_err:
@@ -602,6 +606,44 @@ out_free:
 }
 
 /**
+ * ubi_rename_volumes - re-name UBI volumes.
+ * @ubi: UBI device description object
+ * @renam_list: list of &struct ubi_rename_entry objects
+ *
+ * This function re-names or removes volumes specified in the re-name list.
+ * Returns zero in case of success and a negative error code in case of
+ * failure.
+ */
+int ubi_rename_volumes(struct ubi_device *ubi, struct list_head *rename_list)
+{
+        int err;
+        struct ubi_rename_entry *re;
+
+        err = ubi_vtbl_rename_volumes(ubi, rename_list);
+        if (err)
+                return err;
+
+        list_for_each_entry(re, rename_list, list) {
+                if (re->remove) {
+                        err = ubi_remove_volume(re->desc, 1);
+                        if (err)
+                                break;
+                } else {
+                        struct ubi_volume *vol = re->desc->vol;
+
+                        spin_lock(&ubi->volumes_lock);
+                        vol->name_len = re->new_name_len;
+                        memcpy(vol->name, re->new_name, re->new_name_len + 1);
+                        spin_unlock(&ubi->volumes_lock);
+                }
+        }
+
+        if (!err)
+                paranoid_check_volumes(ubi);
+        return err;
+}
+
+/**
  * ubi_add_volume - add volume.
  * @ubi: UBI device description object
  * @vol: volume description object
@@ -826,10 +868,9 @@ static int paranoid_check_volume(struct ubi_device *ubi, int vol_id)
 
 fail:
         ubi_err("paranoid check failed for volume %d", vol_id);
-        if (vol) {
+        if (vol)
                 ubi_dbg_dump_vol_info(vol);
-                ubi_dbg_dump_vtbl_record(&ubi->vtbl[vol_id], vol_id);
-        }
+        ubi_dbg_dump_vtbl_record(&ubi->vtbl[vol_id], vol_id);
         spin_unlock(&ubi->volumes_lock);
         return -EINVAL;
 }
diff --git a/drivers/mtd/ubi/vtbl.c b/drivers/mtd/ubi/vtbl.c
index 05fb72fd268f..23c5376234b2 100644
--- a/drivers/mtd/ubi/vtbl.c
+++ b/drivers/mtd/ubi/vtbl.c
@@ -115,6 +115,57 @@ int ubi_change_vtbl_record(struct ubi_device *ubi, int idx,
 }
 
 /**
+ * ubi_vtbl_rename_volumes - rename UBI volumes in the volume table.
+ * @ubi: UBI device description object
+ * @renam_list: list of &struct ubi_rename_entry objects
+ *
+ * This function re-names multiple volumes specified in @req in the volume
+ * table. Returns zero in case of success and a negative error code in case of
+ * failure.
+ */
+int ubi_vtbl_rename_volumes(struct ubi_device *ubi,
+                            struct list_head *rename_list)
+{
+        int i, err;
+        struct ubi_rename_entry *re;
+        struct ubi_volume *layout_vol;
+
+        list_for_each_entry(re, rename_list, list) {
+                uint32_t crc;
+                struct ubi_volume *vol = re->desc->vol;
+                struct ubi_vtbl_record *vtbl_rec = &ubi->vtbl[vol->vol_id];
+
+                if (re->remove) {
+                        memcpy(vtbl_rec, &empty_vtbl_record,
+                               sizeof(struct ubi_vtbl_record));
+                        continue;
+                }
+
+                vtbl_rec->name_len = cpu_to_be16(re->new_name_len);
+                memcpy(vtbl_rec->name, re->new_name, re->new_name_len);
+                memset(vtbl_rec->name + re->new_name_len, 0,
+                       UBI_VOL_NAME_MAX + 1 - re->new_name_len);
+                crc = crc32(UBI_CRC32_INIT, vtbl_rec,
+                            UBI_VTBL_RECORD_SIZE_CRC);
+                vtbl_rec->crc = cpu_to_be32(crc);
+        }
+
+        layout_vol = ubi->volumes[vol_id2idx(ubi, UBI_LAYOUT_VOLUME_ID)];
+        for (i = 0; i < UBI_LAYOUT_VOLUME_EBS; i++) {
+                err = ubi_eba_unmap_leb(ubi, layout_vol, i);
+                if (err)
+                        return err;
+
+                err = ubi_eba_write_leb(ubi, layout_vol, i, ubi->vtbl, 0,
+                                        ubi->vtbl_size, UBI_LONGTERM);
+                if (err)
+                        return err;
+        }
+
+        return 0;
+}
+
+/**
  * vtbl_check - check if volume table is not corrupted and contains sensible
  *              data.
  * @ubi: UBI device description object
diff --git a/include/mtd/ubi-user.h b/include/mtd/ubi-user.h
index a7421f130cc0..e8e57c3dfcdb 100644
--- a/include/mtd/ubi-user.h
+++ b/include/mtd/ubi-user.h
@@ -58,6 +58,13 @@
  * device should be used. A &struct ubi_rsvol_req object has to be properly
  * filled and a pointer to it has to be passed to the IOCTL.
  *
+ * UBI volumes re-name
+ * ~~~~~~~~~~~~~~~~~~~
+ *
+ * To re-name several volumes atomically at one go, the %UBI_IOCRNVOL command
+ * of the UBI character device should be used. A &struct ubi_rnvol_req object
+ * has to be properly filled and a pointer to it has to be passed to the IOCTL.
+ *
  * UBI volume update
  * ~~~~~~~~~~~~~~~~~
  *
@@ -104,6 +111,8 @@
 #define UBI_IOCRMVOL _IOW(UBI_IOC_MAGIC, 1, int32_t)
 /* Re-size an UBI volume */
 #define UBI_IOCRSVOL _IOW(UBI_IOC_MAGIC, 2, struct ubi_rsvol_req)
+/* Re-name volumes */
+#define UBI_IOCRNVOL _IOW(UBI_IOC_MAGIC, 3, struct ubi_rnvol_req)
 
 /* IOCTL commands of the UBI control character device */
 
@@ -128,6 +137,9 @@
 /* Maximum MTD device name length supported by UBI */
 #define MAX_UBI_MTD_NAME_LEN 127
 
+/* Maximum amount of UBI volumes that can be re-named at one go */
+#define UBI_MAX_RNVOL 32
+
 /*
  * UBI data type hint constants.
  *
@@ -189,7 +201,7 @@ struct ubi_attach_req {
         int32_t ubi_num;
         int32_t mtd_num;
         int32_t vid_hdr_offset;
-        uint8_t padding[12];
+        int8_t padding[12];
 };
 
 /**
@@ -251,6 +263,48 @@ struct ubi_rsvol_req {
 } __attribute__ ((packed));
 
 /**
+ * struct ubi_rnvol_req - volumes re-name request.
+ * @count: count of volumes to re-name
+ * @padding1:  reserved for future, not used, has to be zeroed
+ * @vol_id: ID of the volume to re-name
+ * @name_len: name length
+ * @padding2:  reserved for future, not used, has to be zeroed
+ * @name: new volume name
+ *
+ * UBI allows to re-name up to %32 volumes at one go. The count of volumes to
+ * re-name is specified in the @count field. The ID of the volumes to re-name
+ * and the new names are specified in the @vol_id and @name fields.
+ *
+ * The UBI volume re-name operation is atomic, which means that should power cut
+ * happen, the volumes will have either old name or new name. So the possible
+ * use-cases of this command is atomic upgrade. Indeed, to upgrade, say, volumes
+ * A and B one may create temporary volumes %A1 and %B1 with the new contents,
+ * then atomically re-name A1->A and B1->B, in which case old %A and %B will
+ * be removed.
+ *
+ * If it is not desirable to remove old A and B, the re-name request has to
+ * contain 4 entries: A1->A, A->A1, B1->B, B->B1, in which case old A1 and B1
+ * become A and B, and old A and B will become A1 and B1.
+ *
+ * It is also OK to request: A1->A, A1->X, B1->B, B->Y, in which case old A1
+ * and B1 become A and B, and old A and B become X and Y.
+ *
+ * In other words, in case of re-naming into an existing volume name, the
+ * existing volume is removed, unless it is re-named as well at the same
+ * re-name request.
+ */
+struct ubi_rnvol_req {
+        int32_t count;
+        int8_t padding1[12];
+        struct {
+                int32_t vol_id;
+                int16_t name_len;
+                int8_t  padding2[2];
+                char    name[UBI_MAX_VOLUME_NAME + 1];
+        } ents[UBI_MAX_RNVOL];
+} __attribute__ ((packed));
+
+/**
  * struct ubi_leb_change_req - a data structure used in atomic logical
  *                             eraseblock change requests.
  * @lnum: logical eraseblock number to change
@@ -261,8 +315,8 @@ struct ubi_rsvol_req {
 struct ubi_leb_change_req {
         int32_t lnum;
         int32_t bytes;
-        uint8_t dtype;
-        uint8_t padding[7];
+        int8_t  dtype;
+        int8_t  padding[7];
 } __attribute__ ((packed));
 
 #endif /* __UBI_USER_H__ */