UBI: Extend UBI layer debug/messaging capabilities

If there is more then one UBI device mounted, there is no way to
distinguish between messages from different UBI devices.
Add device number to all ubi layer message types.

The R/O block driver messages were replaced by pr_* since
ubi_device structure is not used by it.

Amended a bit by Artem.

Signed-off-by: Tanya Brokhman <tlinder@codeaurora.org>
Signed-off-by: Artem Bityutskiy <artem.bityutskiy@linux.intel.com>

1 files changed, 36 insertions, 33 deletions

diff --git a/drivers/mtd/ubi/vmt.c b/drivers/mtd/ubi/vmt.c
index 8330703c098f..ff4d97848d1c 100644
--- a/drivers/mtd/ubi/vmt.c
+++ b/drivers/mtd/ubi/vmt.c
@@ -223,7 +223,7 @@ int ubi_create_volume(struct ubi_device *ubi, struct ubi_mkvol_req *req)
                         }
 
                 if (vol_id == UBI_VOL_NUM_AUTO) {
-                        ubi_err("out of volume IDs");
+                        ubi_err(ubi, "out of volume IDs");
                         err = -ENFILE;
                         goto out_unlock;
                 }
@@ -237,7 +237,7 @@ int ubi_create_volume(struct ubi_device *ubi, struct ubi_mkvol_req *req)
         /* Ensure that this volume does not exist */
         err = -EEXIST;
         if (ubi->volumes[vol_id]) {
-                ubi_err("volume %d already exists", vol_id);
+                ubi_err(ubi, "volume %d already exists", vol_id);
                 goto out_unlock;
         }
 
@@ -246,7 +246,8 @@ int ubi_create_volume(struct ubi_device *ubi, struct ubi_mkvol_req *req)
                 if (ubi->volumes[i] &&
                     ubi->volumes[i]->name_len == req->name_len &&
                     !strcmp(ubi->volumes[i]->name, req->name)) {
-                        ubi_err("volume \"%s\" exists (ID %d)", req->name, i);
+                        ubi_err(ubi, "volume \"%s\" exists (ID %d)",
+                                req->name, i);
                         goto out_unlock;
                 }
 
@@ -257,9 +258,10 @@ int ubi_create_volume(struct ubi_device *ubi, struct ubi_mkvol_req *req)
 
         /* Reserve physical eraseblocks */
         if (vol->reserved_pebs > ubi->avail_pebs) {
-                ubi_err("not enough PEBs, only %d available", ubi->avail_pebs);
+                ubi_err(ubi, "not enough PEBs, only %d available",
+                        ubi->avail_pebs);
                 if (ubi->corr_peb_count)
-                        ubi_err("%d PEBs are corrupted and not used",
+                        ubi_err(ubi, "%d PEBs are corrupted and not used",
                                 ubi->corr_peb_count);
                 err = -ENOSPC;
                 goto out_unlock;
@@ -314,7 +316,7 @@ int ubi_create_volume(struct ubi_device *ubi, struct ubi_mkvol_req *req)
         dev = MKDEV(MAJOR(ubi->cdev.dev), vol_id + 1);
         err = cdev_add(&vol->cdev, dev, 1);
         if (err) {
-                ubi_err("cannot add character device");
+                ubi_err(ubi, "cannot add character device");
                 goto out_mapping;
         }
 
@@ -326,7 +328,7 @@ int ubi_create_volume(struct ubi_device *ubi, struct ubi_mkvol_req *req)
         dev_set_name(&vol->dev, "%s_%d", ubi->ubi_name, vol->vol_id);
         err = device_register(&vol->dev);
         if (err) {
-                ubi_err("cannot register device");
+                ubi_err(ubi, "cannot register device");
                 goto out_cdev;
         }
 
@@ -386,7 +388,7 @@ out_unlock:
                 kfree(vol);
         else
                 put_device(&vol->dev);
-        ubi_err("cannot create volume %d, error %d", vol_id, err);
+        ubi_err(ubi, "cannot create volume %d, error %d", vol_id, err);
         return err;
 }
 
@@ -454,7 +456,7 @@ int ubi_remove_volume(struct ubi_volume_desc *desc, int no_vtbl)
         return err;
 
 out_err:
-        ubi_err("cannot remove volume %d, error %d", vol_id, err);
+        ubi_err(ubi, "cannot remove volume %d, error %d", vol_id, err);
         spin_lock(&ubi->volumes_lock);
         ubi->volumes[vol_id] = vol;
 out_unlock:
@@ -487,7 +489,7 @@ int ubi_resize_volume(struct ubi_volume_desc *desc, int reserved_pebs)
 
         if (vol->vol_type == UBI_STATIC_VOLUME &&
             reserved_pebs < vol->used_ebs) {
-                ubi_err("too small size %d, %d LEBs contain data",
+                ubi_err(ubi, "too small size %d, %d LEBs contain data",
                         reserved_pebs, vol->used_ebs);
                 return -EINVAL;
         }
@@ -516,10 +518,10 @@ int ubi_resize_volume(struct ubi_volume_desc *desc, int reserved_pebs)
         if (pebs > 0) {
                 spin_lock(&ubi->volumes_lock);
                 if (pebs > ubi->avail_pebs) {
-                        ubi_err("not enough PEBs: requested %d, available %d",
+                        ubi_err(ubi, "not enough PEBs: requested %d, available %d",
                                 pebs, ubi->avail_pebs);
                         if (ubi->corr_peb_count)
-                                ubi_err("%d PEBs are corrupted and not used",
+                                ubi_err(ubi, "%d PEBs are corrupted and not used",
                                         ubi->corr_peb_count);
                         spin_unlock(&ubi->volumes_lock);
                         err = -ENOSPC;
@@ -643,7 +645,7 @@ int ubi_add_volume(struct ubi_device *ubi, struct ubi_volume *vol)
         dev = MKDEV(MAJOR(ubi->cdev.dev), vol->vol_id + 1);
         err = cdev_add(&vol->cdev, dev, 1);
         if (err) {
-                ubi_err("cannot add character device for volume %d, error %d",
+                ubi_err(ubi, "cannot add character device for volume %d, error %d",
                         vol_id, err);
                 return err;
         }
@@ -710,7 +712,7 @@ static int self_check_volume(struct ubi_device *ubi, int vol_id)
 
         if (!vol) {
                 if (reserved_pebs) {
-                        ubi_err("no volume info, but volume exists");
+                        ubi_err(ubi, "no volume info, but volume exists");
                         goto fail;
                 }
                 spin_unlock(&ubi->volumes_lock);
@@ -719,90 +721,91 @@ static int self_check_volume(struct ubi_device *ubi, int vol_id)
 
         if (vol->reserved_pebs < 0 || vol->alignment < 0 || vol->data_pad < 0 ||
             vol->name_len < 0) {
-                ubi_err("negative values");
+                ubi_err(ubi, "negative values");
                 goto fail;
         }
         if (vol->alignment > ubi->leb_size || vol->alignment == 0) {
-                ubi_err("bad alignment");
+                ubi_err(ubi, "bad alignment");
                 goto fail;
         }
 
         n = vol->alignment & (ubi->min_io_size - 1);
         if (vol->alignment != 1 && n) {
-                ubi_err("alignment is not multiple of min I/O unit");
+                ubi_err(ubi, "alignment is not multiple of min I/O unit");
                 goto fail;
         }
 
         n = ubi->leb_size % vol->alignment;
         if (vol->data_pad != n) {
-                ubi_err("bad data_pad, has to be %lld", n);
+                ubi_err(ubi, "bad data_pad, has to be %lld", n);
                 goto fail;
         }
 
         if (vol->vol_type != UBI_DYNAMIC_VOLUME &&
             vol->vol_type != UBI_STATIC_VOLUME) {
-                ubi_err("bad vol_type");
+                ubi_err(ubi, "bad vol_type");
                 goto fail;
         }
 
         if (vol->upd_marker && vol->corrupted) {
-                ubi_err("update marker and corrupted simultaneously");
+                ubi_err(ubi, "update marker and corrupted simultaneously");
                 goto fail;
         }
 
         if (vol->reserved_pebs > ubi->good_peb_count) {
-                ubi_err("too large reserved_pebs");
+                ubi_err(ubi, "too large reserved_pebs");
                 goto fail;
         }
 
         n = ubi->leb_size - vol->data_pad;
         if (vol->usable_leb_size != ubi->leb_size - vol->data_pad) {
-                ubi_err("bad usable_leb_size, has to be %lld", n);
+                ubi_err(ubi, "bad usable_leb_size, has to be %lld", n);
                 goto fail;
         }
 
         if (vol->name_len > UBI_VOL_NAME_MAX) {
-                ubi_err("too long volume name, max is %d", UBI_VOL_NAME_MAX);
+                ubi_err(ubi, "too long volume name, max is %d",
+                        UBI_VOL_NAME_MAX);
                 goto fail;
         }
 
         n = strnlen(vol->name, vol->name_len + 1);
         if (n != vol->name_len) {
-                ubi_err("bad name_len %lld", n);
+                ubi_err(ubi, "bad name_len %lld", n);
                 goto fail;
         }
 
         n = (long long)vol->used_ebs * vol->usable_leb_size;
         if (vol->vol_type == UBI_DYNAMIC_VOLUME) {
                 if (vol->corrupted) {
-                        ubi_err("corrupted dynamic volume");
+                        ubi_err(ubi, "corrupted dynamic volume");
                         goto fail;
                 }
                 if (vol->used_ebs != vol->reserved_pebs) {
-                        ubi_err("bad used_ebs");
+                        ubi_err(ubi, "bad used_ebs");
                         goto fail;
                 }
                 if (vol->last_eb_bytes != vol->usable_leb_size) {
-                        ubi_err("bad last_eb_bytes");
+                        ubi_err(ubi, "bad last_eb_bytes");
                         goto fail;
                 }
                 if (vol->used_bytes != n) {
-                        ubi_err("bad used_bytes");
+                        ubi_err(ubi, "bad used_bytes");
                         goto fail;
                 }
         } else {
                 if (vol->used_ebs < 0 || vol->used_ebs > vol->reserved_pebs) {
-                        ubi_err("bad used_ebs");
+                        ubi_err(ubi, "bad used_ebs");
                         goto fail;
                 }
                 if (vol->last_eb_bytes < 0 ||
                     vol->last_eb_bytes > vol->usable_leb_size) {
-                        ubi_err("bad last_eb_bytes");
+                        ubi_err(ubi, "bad last_eb_bytes");
                         goto fail;
                 }
                 if (vol->used_bytes < 0 || vol->used_bytes > n ||
                     vol->used_bytes < n - vol->usable_leb_size) {
-                        ubi_err("bad used_bytes");
+                        ubi_err(ubi, "bad used_bytes");
                         goto fail;
                 }
         }
@@ -820,7 +823,7 @@ static int self_check_volume(struct ubi_device *ubi, int vol_id)
         if (alignment != vol->alignment || data_pad != vol->data_pad ||
             upd_marker != vol->upd_marker || vol_type != vol->vol_type ||
             name_len != vol->name_len || strncmp(name, vol->name, name_len)) {
-                ubi_err("volume info is different");
+                ubi_err(ubi, "volume info is different");
                 goto fail;
         }
 
@@ -828,7 +831,7 @@ static int self_check_volume(struct ubi_device *ubi, int vol_id)
         return 0;
 
 fail:
-        ubi_err("self-check failed for volume %d", vol_id);
+        ubi_err(ubi, "self-check failed for volume %d", vol_id);
         if (vol)
                 ubi_dump_vol_info(vol);
         ubi_dump_vtbl_record(&ubi->vtbl[vol_id], vol_id);