UBI: Extend UBI layer debug/messaging capabilities

[linux-2.6-microblaze.git] / drivers / mtd / ubi / vmt.c

diff --git a/drivers/mtd/ubi/vmt.c b/drivers/mtd/ubi/vmt.c
index 8330703..ff4d978 100644 (file)
--- 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);