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);