1 files changed, 93 insertions, 93 deletions

diff --git a/fs/ubifs/debug.c b/fs/ubifs/debug.c
index 4cfb3e82c56f..4c46a9865fa7 100644
--- a/fs/ubifs/debug.c
+++ b/fs/ubifs/debug.c
@@ -746,7 +746,7 @@ void ubifs_dump_lprops(struct ubifs_info *c)
         for (lnum = c->main_first; lnum < c->leb_cnt; lnum++) {
                 err = ubifs_read_one_lp(c, lnum, &lp);
                 if (err) {
-                        ubifs_err("cannot read lprops for LEB %d", lnum);
+                        ubifs_err(c, "cannot read lprops for LEB %d", lnum);
                         continue;
                 }
 
@@ -819,13 +819,13 @@ void ubifs_dump_leb(const struct ubifs_info *c, int lnum)
 
         buf = __vmalloc(c->leb_size, GFP_NOFS, PAGE_KERNEL);
         if (!buf) {
-                ubifs_err("cannot allocate memory for dumping LEB %d", lnum);
+                ubifs_err(c, "cannot allocate memory for dumping LEB %d", lnum);
                 return;
         }
 
         sleb = ubifs_scan(c, lnum, 0, buf, 0);
         if (IS_ERR(sleb)) {
-                ubifs_err("scan error %d", (int)PTR_ERR(sleb));
+                ubifs_err(c, "scan error %d", (int)PTR_ERR(sleb));
                 goto out;
         }
 
@@ -1032,7 +1032,7 @@ int dbg_check_space_info(struct ubifs_info *c)
         spin_unlock(&c->space_lock);
 
         if (free != d->saved_free) {
-                ubifs_err("free space changed from %lld to %lld",
+                ubifs_err(c, "free space changed from %lld to %lld",
                           d->saved_free, free);
                 goto out;
         }
@@ -1040,15 +1040,15 @@ int dbg_check_space_info(struct ubifs_info *c)
         return 0;
 
 out:
-        ubifs_msg("saved lprops statistics dump");
+        ubifs_msg(c, "saved lprops statistics dump");
         ubifs_dump_lstats(&d->saved_lst);
-        ubifs_msg("saved budgeting info dump");
+        ubifs_msg(c, "saved budgeting info dump");
         ubifs_dump_budg(c, &d->saved_bi);
-        ubifs_msg("saved idx_gc_cnt %d", d->saved_idx_gc_cnt);
-        ubifs_msg("current lprops statistics dump");
+        ubifs_msg(c, "saved idx_gc_cnt %d", d->saved_idx_gc_cnt);
+        ubifs_msg(c, "current lprops statistics dump");
         ubifs_get_lp_stats(c, &lst);
         ubifs_dump_lstats(&lst);
-        ubifs_msg("current budgeting info dump");
+        ubifs_msg(c, "current budgeting info dump");
         ubifs_dump_budg(c, &c->bi);
         dump_stack();
         return -EINVAL;
@@ -1077,9 +1077,9 @@ int dbg_check_synced_i_size(const struct ubifs_info *c, struct inode *inode)
         mutex_lock(&ui->ui_mutex);
         spin_lock(&ui->ui_lock);
         if (ui->ui_size != ui->synced_i_size && !ui->dirty) {
-                ubifs_err("ui_size is %lld, synced_i_size is %lld, but inode is clean",
+                ubifs_err(c, "ui_size is %lld, synced_i_size is %lld, but inode is clean",
                           ui->ui_size, ui->synced_i_size);
-                ubifs_err("i_ino %lu, i_mode %#x, i_size %lld", inode->i_ino,
+                ubifs_err(c, "i_ino %lu, i_mode %#x, i_size %lld", inode->i_ino,
                           inode->i_mode, i_size_read(inode));
                 dump_stack();
                 err = -EINVAL;
@@ -1140,7 +1140,7 @@ int dbg_check_dir(struct ubifs_info *c, const struct inode *dir)
         kfree(pdent);
 
         if (i_size_read(dir) != size) {
-                ubifs_err("directory inode %lu has size %llu, but calculated size is %llu",
+                ubifs_err(c, "directory inode %lu has size %llu, but calculated size is %llu",
                           dir->i_ino, (unsigned long long)i_size_read(dir),
                           (unsigned long long)size);
                 ubifs_dump_inode(c, dir);
@@ -1148,7 +1148,7 @@ int dbg_check_dir(struct ubifs_info *c, const struct inode *dir)
                 return -EINVAL;
         }
         if (dir->i_nlink != nlink) {
-                ubifs_err("directory inode %lu has nlink %u, but calculated nlink is %u",
+                ubifs_err(c, "directory inode %lu has nlink %u, but calculated nlink is %u",
                           dir->i_ino, dir->i_nlink, nlink);
                 ubifs_dump_inode(c, dir);
                 dump_stack();
@@ -1207,10 +1207,10 @@ static int dbg_check_key_order(struct ubifs_info *c, struct ubifs_zbranch *zbr1,
         err = 1;
         key_read(c, &dent1->key, &key);
         if (keys_cmp(c, &zbr1->key, &key)) {
-                ubifs_err("1st entry at %d:%d has key %s", zbr1->lnum,
+                ubifs_err(c, "1st entry at %d:%d has key %s", zbr1->lnum,
                           zbr1->offs, dbg_snprintf_key(c, &key, key_buf,
                                                        DBG_KEY_BUF_LEN));
-                ubifs_err("but it should have key %s according to tnc",
+                ubifs_err(c, "but it should have key %s according to tnc",
                           dbg_snprintf_key(c, &zbr1->key, key_buf,
                                            DBG_KEY_BUF_LEN));
                 ubifs_dump_node(c, dent1);
@@ -1219,10 +1219,10 @@ static int dbg_check_key_order(struct ubifs_info *c, struct ubifs_zbranch *zbr1,
 
         key_read(c, &dent2->key, &key);
         if (keys_cmp(c, &zbr2->key, &key)) {
-                ubifs_err("2nd entry at %d:%d has key %s", zbr1->lnum,
+                ubifs_err(c, "2nd entry at %d:%d has key %s", zbr1->lnum,
                           zbr1->offs, dbg_snprintf_key(c, &key, key_buf,
                                                        DBG_KEY_BUF_LEN));
-                ubifs_err("but it should have key %s according to tnc",
+                ubifs_err(c, "but it should have key %s according to tnc",
                           dbg_snprintf_key(c, &zbr2->key, key_buf,
                                            DBG_KEY_BUF_LEN));
                 ubifs_dump_node(c, dent2);
@@ -1238,14 +1238,14 @@ static int dbg_check_key_order(struct ubifs_info *c, struct ubifs_zbranch *zbr1,
                 goto out_free;
         }
         if (cmp == 0 && nlen1 == nlen2)
-                ubifs_err("2 xent/dent nodes with the same name");
+                ubifs_err(c, "2 xent/dent nodes with the same name");
         else
-                ubifs_err("bad order of colliding key %s",
+                ubifs_err(c, "bad order of colliding key %s",
                           dbg_snprintf_key(c, &key, key_buf, DBG_KEY_BUF_LEN));
 
-        ubifs_msg("first node at %d:%d\n", zbr1->lnum, zbr1->offs);
+        ubifs_msg(c, "first node at %d:%d\n", zbr1->lnum, zbr1->offs);
         ubifs_dump_node(c, dent1);
-        ubifs_msg("second node at %d:%d\n", zbr2->lnum, zbr2->offs);
+        ubifs_msg(c, "second node at %d:%d\n", zbr2->lnum, zbr2->offs);
         ubifs_dump_node(c, dent2);
 
 out_free:
@@ -1447,11 +1447,11 @@ static int dbg_check_znode(struct ubifs_info *c, struct ubifs_zbranch *zbr)
         return 0;
 
 out:
-        ubifs_err("failed, error %d", err);
-        ubifs_msg("dump of the znode");
+        ubifs_err(c, "failed, error %d", err);
+        ubifs_msg(c, "dump of the znode");
         ubifs_dump_znode(c, znode);
         if (zp) {
-                ubifs_msg("dump of the parent znode");
+                ubifs_msg(c, "dump of the parent znode");
                 ubifs_dump_znode(c, zp);
         }
         dump_stack();
@@ -1518,9 +1518,9 @@ int dbg_check_tnc(struct ubifs_info *c, int extra)
                         if (err < 0)
                                 return err;
                         if (err) {
-                                ubifs_msg("first znode");
+                                ubifs_msg(c, "first znode");
                                 ubifs_dump_znode(c, prev);
-                                ubifs_msg("second znode");
+                                ubifs_msg(c, "second znode");
                                 ubifs_dump_znode(c, znode);
                                 return -EINVAL;
                         }
@@ -1529,13 +1529,13 @@ int dbg_check_tnc(struct ubifs_info *c, int extra)
 
         if (extra) {
                 if (clean_cnt != atomic_long_read(&c->clean_zn_cnt)) {
-                        ubifs_err("incorrect clean_zn_cnt %ld, calculated %ld",
+                        ubifs_err(c, "incorrect clean_zn_cnt %ld, calculated %ld",
                                   atomic_long_read(&c->clean_zn_cnt),
                                   clean_cnt);
                         return -EINVAL;
                 }
                 if (dirty_cnt != atomic_long_read(&c->dirty_zn_cnt)) {
-                        ubifs_err("incorrect dirty_zn_cnt %ld, calculated %ld",
+                        ubifs_err(c, "incorrect dirty_zn_cnt %ld, calculated %ld",
                                   atomic_long_read(&c->dirty_zn_cnt),
                                   dirty_cnt);
                         return -EINVAL;
@@ -1608,7 +1608,7 @@ int dbg_walk_index(struct ubifs_info *c, dbg_leaf_callback leaf_cb,
                 if (znode_cb) {
                         err = znode_cb(c, znode, priv);
                         if (err) {
-                                ubifs_err("znode checking function returned error %d",
+                                ubifs_err(c, "znode checking function returned error %d",
                                           err);
                                 ubifs_dump_znode(c, znode);
                                 goto out_dump;
@@ -1619,7 +1619,7 @@ int dbg_walk_index(struct ubifs_info *c, dbg_leaf_callback leaf_cb,
                                 zbr = &znode->zbranch[idx];
                                 err = leaf_cb(c, zbr, priv);
                                 if (err) {
-                                        ubifs_err("leaf checking function returned error %d, for leaf at LEB %d:%d",
+                                        ubifs_err(c, "leaf checking function returned error %d, for leaf at LEB %d:%d",
                                                   err, zbr->lnum, zbr->offs);
                                         goto out_dump;
                                 }
@@ -1675,7 +1675,7 @@ out_dump:
                 zbr = &znode->parent->zbranch[znode->iip];
         else
                 zbr = &c->zroot;
-        ubifs_msg("dump of znode at LEB %d:%d", zbr->lnum, zbr->offs);
+        ubifs_msg(c, "dump of znode at LEB %d:%d", zbr->lnum, zbr->offs);
         ubifs_dump_znode(c, znode);
 out_unlock:
         mutex_unlock(&c->tnc_mutex);
@@ -1722,12 +1722,12 @@ int dbg_check_idx_size(struct ubifs_info *c, long long idx_size)
 
         err = dbg_walk_index(c, NULL, add_size, &calc);
         if (err) {
-                ubifs_err("error %d while walking the index", err);
+                ubifs_err(c, "error %d while walking the index", err);
                 return err;
         }
 
         if (calc != idx_size) {
-                ubifs_err("index size check failed: calculated size is %lld, should be %lld",
+                ubifs_err(c, "index size check failed: calculated size is %lld, should be %lld",
                           calc, idx_size);
                 dump_stack();
                 return -EINVAL;
@@ -1814,7 +1814,7 @@ static struct fsck_inode *add_inode(struct ubifs_info *c,
         }
 
         if (inum > c->highest_inum) {
-                ubifs_err("too high inode number, max. is %lu",
+                ubifs_err(c, "too high inode number, max. is %lu",
                           (unsigned long)c->highest_inum);
                 return ERR_PTR(-EINVAL);
         }
@@ -1921,17 +1921,17 @@ static struct fsck_inode *read_add_inode(struct ubifs_info *c,
         ino_key_init(c, &key, inum);
         err = ubifs_lookup_level0(c, &key, &znode, &n);
         if (!err) {
-                ubifs_err("inode %lu not found in index", (unsigned long)inum);
+                ubifs_err(c, "inode %lu not found in index", (unsigned long)inum);
                 return ERR_PTR(-ENOENT);
         } else if (err < 0) {
-                ubifs_err("error %d while looking up inode %lu",
+                ubifs_err(c, "error %d while looking up inode %lu",
                           err, (unsigned long)inum);
                 return ERR_PTR(err);
         }
 
         zbr = &znode->zbranch[n];
         if (zbr->len < UBIFS_INO_NODE_SZ) {
-                ubifs_err("bad node %lu node length %d",
+                ubifs_err(c, "bad node %lu node length %d",
                           (unsigned long)inum, zbr->len);
                 return ERR_PTR(-EINVAL);
         }
@@ -1942,7 +1942,7 @@ static struct fsck_inode *read_add_inode(struct ubifs_info *c,
 
         err = ubifs_tnc_read_node(c, zbr, ino);
         if (err) {
-                ubifs_err("cannot read inode node at LEB %d:%d, error %d",
+                ubifs_err(c, "cannot read inode node at LEB %d:%d, error %d",
                           zbr->lnum, zbr->offs, err);
                 kfree(ino);
                 return ERR_PTR(err);
@@ -1951,7 +1951,7 @@ static struct fsck_inode *read_add_inode(struct ubifs_info *c,
         fscki = add_inode(c, fsckd, ino);
         kfree(ino);
         if (IS_ERR(fscki)) {
-                ubifs_err("error %ld while adding inode %lu node",
+                ubifs_err(c, "error %ld while adding inode %lu node",
                           PTR_ERR(fscki), (unsigned long)inum);
                 return fscki;
         }
@@ -1985,7 +1985,7 @@ static int check_leaf(struct ubifs_info *c, struct ubifs_zbranch *zbr,
         struct fsck_inode *fscki;
 
         if (zbr->len < UBIFS_CH_SZ) {
-                ubifs_err("bad leaf length %d (LEB %d:%d)",
+                ubifs_err(c, "bad leaf length %d (LEB %d:%d)",
                           zbr->len, zbr->lnum, zbr->offs);
                 return -EINVAL;
         }
@@ -1996,7 +1996,7 @@ static int check_leaf(struct ubifs_info *c, struct ubifs_zbranch *zbr,
 
         err = ubifs_tnc_read_node(c, zbr, node);
         if (err) {
-                ubifs_err("cannot read leaf node at LEB %d:%d, error %d",
+                ubifs_err(c, "cannot read leaf node at LEB %d:%d, error %d",
                           zbr->lnum, zbr->offs, err);
                 goto out_free;
         }
@@ -2006,7 +2006,7 @@ static int check_leaf(struct ubifs_info *c, struct ubifs_zbranch *zbr,
                 fscki = add_inode(c, priv, node);
                 if (IS_ERR(fscki)) {
                         err = PTR_ERR(fscki);
-                        ubifs_err("error %d while adding inode node", err);
+                        ubifs_err(c, "error %d while adding inode node", err);
                         goto out_dump;
                 }
                 goto out;
@@ -2014,7 +2014,7 @@ static int check_leaf(struct ubifs_info *c, struct ubifs_zbranch *zbr,
 
         if (type != UBIFS_DENT_KEY && type != UBIFS_XENT_KEY &&
             type != UBIFS_DATA_KEY) {
-                ubifs_err("unexpected node type %d at LEB %d:%d",
+                ubifs_err(c, "unexpected node type %d at LEB %d:%d",
                           type, zbr->lnum, zbr->offs);
                 err = -EINVAL;
                 goto out_free;
@@ -2022,7 +2022,7 @@ static int check_leaf(struct ubifs_info *c, struct ubifs_zbranch *zbr,
 
         ch = node;
         if (le64_to_cpu(ch->sqnum) > c->max_sqnum) {
-                ubifs_err("too high sequence number, max. is %llu",
+                ubifs_err(c, "too high sequence number, max. is %llu",
                           c->max_sqnum);
                 err = -EINVAL;
                 goto out_dump;
@@ -2042,7 +2042,7 @@ static int check_leaf(struct ubifs_info *c, struct ubifs_zbranch *zbr,
                 fscki = read_add_inode(c, priv, inum);
                 if (IS_ERR(fscki)) {
                         err = PTR_ERR(fscki);
-                        ubifs_err("error %d while processing data node and trying to find inode node %lu",
+                        ubifs_err(c, "error %d while processing data node and trying to find inode node %lu",
                                   err, (unsigned long)inum);
                         goto out_dump;
                 }
@@ -2052,7 +2052,7 @@ static int check_leaf(struct ubifs_info *c, struct ubifs_zbranch *zbr,
                 blk_offs <<= UBIFS_BLOCK_SHIFT;
                 blk_offs += le32_to_cpu(dn->size);
                 if (blk_offs > fscki->size) {
-                        ubifs_err("data node at LEB %d:%d is not within inode size %lld",
+                        ubifs_err(c, "data node at LEB %d:%d is not within inode size %lld",
                                   zbr->lnum, zbr->offs, fscki->size);
                         err = -EINVAL;
                         goto out_dump;
@@ -2076,7 +2076,7 @@ static int check_leaf(struct ubifs_info *c, struct ubifs_zbranch *zbr,
                 fscki = read_add_inode(c, priv, inum);
                 if (IS_ERR(fscki)) {
                         err = PTR_ERR(fscki);
-                        ubifs_err("error %d while processing entry node and trying to find inode node %lu",
+                        ubifs_err(c, "error %d while processing entry node and trying to find inode node %lu",
                                   err, (unsigned long)inum);
                         goto out_dump;
                 }
@@ -2088,7 +2088,7 @@ static int check_leaf(struct ubifs_info *c, struct ubifs_zbranch *zbr,
                 fscki1 = read_add_inode(c, priv, inum);
                 if (IS_ERR(fscki1)) {
                         err = PTR_ERR(fscki1);
-                        ubifs_err("error %d while processing entry node and trying to find parent inode node %lu",
+                        ubifs_err(c, "error %d while processing entry node and trying to find parent inode node %lu",
                                   err, (unsigned long)inum);
                         goto out_dump;
                 }
@@ -2111,7 +2111,7 @@ out:
         return 0;
 
 out_dump:
-        ubifs_msg("dump of node at LEB %d:%d", zbr->lnum, zbr->offs);
+        ubifs_msg(c, "dump of node at LEB %d:%d", zbr->lnum, zbr->offs);
         ubifs_dump_node(c, node);
 out_free:
         kfree(node);
@@ -2162,52 +2162,52 @@ static int check_inodes(struct ubifs_info *c, struct fsck_data *fsckd)
                          */
                         if (fscki->inum != UBIFS_ROOT_INO &&
                             fscki->references != 1) {
-                                ubifs_err("directory inode %lu has %d direntries which refer it, but should be 1",
+                                ubifs_err(c, "directory inode %lu has %d direntries which refer it, but should be 1",
                                           (unsigned long)fscki->inum,
                                           fscki->references);
                                 goto out_dump;
                         }
                         if (fscki->inum == UBIFS_ROOT_INO &&
                             fscki->references != 0) {
-                                ubifs_err("root inode %lu has non-zero (%d) direntries which refer it",
+                                ubifs_err(c, "root inode %lu has non-zero (%d) direntries which refer it",
                                           (unsigned long)fscki->inum,
                                           fscki->references);
                                 goto out_dump;
                         }
                         if (fscki->calc_sz != fscki->size) {
-                                ubifs_err("directory inode %lu size is %lld, but calculated size is %lld",
+                                ubifs_err(c, "directory inode %lu size is %lld, but calculated size is %lld",
                                           (unsigned long)fscki->inum,
                                           fscki->size, fscki->calc_sz);
                                 goto out_dump;
                         }
                         if (fscki->calc_cnt != fscki->nlink) {
-                                ubifs_err("directory inode %lu nlink is %d, but calculated nlink is %d",
+                                ubifs_err(c, "directory inode %lu nlink is %d, but calculated nlink is %d",
                                           (unsigned long)fscki->inum,
                                           fscki->nlink, fscki->calc_cnt);
                                 goto out_dump;
                         }
                 } else {
                         if (fscki->references != fscki->nlink) {
-                                ubifs_err("inode %lu nlink is %d, but calculated nlink is %d",
+                                ubifs_err(c, "inode %lu nlink is %d, but calculated nlink is %d",
                                           (unsigned long)fscki->inum,
                                           fscki->nlink, fscki->references);
                                 goto out_dump;
                         }
                 }
                 if (fscki->xattr_sz != fscki->calc_xsz) {
-                        ubifs_err("inode %lu has xattr size %u, but calculated size is %lld",
+                        ubifs_err(c, "inode %lu has xattr size %u, but calculated size is %lld",
                                   (unsigned long)fscki->inum, fscki->xattr_sz,
                                   fscki->calc_xsz);
                         goto out_dump;
                 }
                 if (fscki->xattr_cnt != fscki->calc_xcnt) {
-                        ubifs_err("inode %lu has %u xattrs, but calculated count is %lld",
+                        ubifs_err(c, "inode %lu has %u xattrs, but calculated count is %lld",
                                   (unsigned long)fscki->inum,
                                   fscki->xattr_cnt, fscki->calc_xcnt);
                         goto out_dump;
                 }
                 if (fscki->xattr_nms != fscki->calc_xnms) {
-                        ubifs_err("inode %lu has xattr names' size %u, but calculated names' size is %lld",
+                        ubifs_err(c, "inode %lu has xattr names' size %u, but calculated names' size is %lld",
                                   (unsigned long)fscki->inum, fscki->xattr_nms,
                                   fscki->calc_xnms);
                         goto out_dump;
@@ -2221,11 +2221,11 @@ out_dump:
         ino_key_init(c, &key, fscki->inum);
         err = ubifs_lookup_level0(c, &key, &znode, &n);
         if (!err) {
-                ubifs_err("inode %lu not found in index",
+                ubifs_err(c, "inode %lu not found in index",
                           (unsigned long)fscki->inum);
                 return -ENOENT;
         } else if (err < 0) {
-                ubifs_err("error %d while looking up inode %lu",
+                ubifs_err(c, "error %d while looking up inode %lu",
                           err, (unsigned long)fscki->inum);
                 return err;
         }
@@ -2237,13 +2237,13 @@ out_dump:
 
         err = ubifs_tnc_read_node(c, zbr, ino);
         if (err) {
-                ubifs_err("cannot read inode node at LEB %d:%d, error %d",
+                ubifs_err(c, "cannot read inode node at LEB %d:%d, error %d",
                           zbr->lnum, zbr->offs, err);
                 kfree(ino);
                 return err;
         }
 
-        ubifs_msg("dump of the inode %lu sitting in LEB %d:%d",
+        ubifs_msg(c, "dump of the inode %lu sitting in LEB %d:%d",
                   (unsigned long)fscki->inum, zbr->lnum, zbr->offs);
         ubifs_dump_node(c, ino);
         kfree(ino);
@@ -2284,7 +2284,7 @@ int dbg_check_filesystem(struct ubifs_info *c)
         return 0;
 
 out_free:
-        ubifs_err("file-system check failed with error %d", err);
+        ubifs_err(c, "file-system check failed with error %d", err);
         dump_stack();
         free_inodes(&fsckd);
         return err;
@@ -2315,12 +2315,12 @@ int dbg_check_data_nodes_order(struct ubifs_info *c, struct list_head *head)
                 sb = container_of(cur->next, struct ubifs_scan_node, list);
 
                 if (sa->type != UBIFS_DATA_NODE) {
-                        ubifs_err("bad node type %d", sa->type);
+                        ubifs_err(c, "bad node type %d", sa->type);
                         ubifs_dump_node(c, sa->node);
                         return -EINVAL;
                 }
                 if (sb->type != UBIFS_DATA_NODE) {
-                        ubifs_err("bad node type %d", sb->type);
+                        ubifs_err(c, "bad node type %d", sb->type);
                         ubifs_dump_node(c, sb->node);
                         return -EINVAL;
                 }
@@ -2331,7 +2331,7 @@ int dbg_check_data_nodes_order(struct ubifs_info *c, struct list_head *head)
                 if (inuma < inumb)
                         continue;
                 if (inuma > inumb) {
-                        ubifs_err("larger inum %lu goes before inum %lu",
+                        ubifs_err(c, "larger inum %lu goes before inum %lu",
                                   (unsigned long)inuma, (unsigned long)inumb);
                         goto error_dump;
                 }
@@ -2340,11 +2340,11 @@ int dbg_check_data_nodes_order(struct ubifs_info *c, struct list_head *head)
                 blkb = key_block(c, &sb->key);
 
                 if (blka > blkb) {
-                        ubifs_err("larger block %u goes before %u", blka, blkb);
+                        ubifs_err(c, "larger block %u goes before %u", blka, blkb);
                         goto error_dump;
                 }
                 if (blka == blkb) {
-                        ubifs_err("two data nodes for the same block");
+                        ubifs_err(c, "two data nodes for the same block");
                         goto error_dump;
                 }
         }
@@ -2383,19 +2383,19 @@ int dbg_check_nondata_nodes_order(struct ubifs_info *c, struct list_head *head)
 
                 if (sa->type != UBIFS_INO_NODE && sa->type != UBIFS_DENT_NODE &&
                     sa->type != UBIFS_XENT_NODE) {
-                        ubifs_err("bad node type %d", sa->type);
+                        ubifs_err(c, "bad node type %d", sa->type);
                         ubifs_dump_node(c, sa->node);
                         return -EINVAL;
                 }
                 if (sa->type != UBIFS_INO_NODE && sa->type != UBIFS_DENT_NODE &&
                     sa->type != UBIFS_XENT_NODE) {
-                        ubifs_err("bad node type %d", sb->type);
+                        ubifs_err(c, "bad node type %d", sb->type);
                         ubifs_dump_node(c, sb->node);
                         return -EINVAL;
                 }
 
                 if (sa->type != UBIFS_INO_NODE && sb->type == UBIFS_INO_NODE) {
-                        ubifs_err("non-inode node goes before inode node");
+                        ubifs_err(c, "non-inode node goes before inode node");
                         goto error_dump;
                 }
 
@@ -2405,7 +2405,7 @@ int dbg_check_nondata_nodes_order(struct ubifs_info *c, struct list_head *head)
                 if (sa->type == UBIFS_INO_NODE && sb->type == UBIFS_INO_NODE) {
                         /* Inode nodes are sorted in descending size order */
                         if (sa->len < sb->len) {
-                                ubifs_err("smaller inode node goes first");
+                                ubifs_err(c, "smaller inode node goes first");
                                 goto error_dump;
                         }
                         continue;
@@ -2421,7 +2421,7 @@ int dbg_check_nondata_nodes_order(struct ubifs_info *c, struct list_head *head)
                 if (inuma < inumb)
                         continue;
                 if (inuma > inumb) {
-                        ubifs_err("larger inum %lu goes before inum %lu",
+                        ubifs_err(c, "larger inum %lu goes before inum %lu",
                                   (unsigned long)inuma, (unsigned long)inumb);
                         goto error_dump;
                 }
@@ -2430,7 +2430,7 @@ int dbg_check_nondata_nodes_order(struct ubifs_info *c, struct list_head *head)
                 hashb = key_block(c, &sb->key);
 
                 if (hasha > hashb) {
-                        ubifs_err("larger hash %u goes before %u",
+                        ubifs_err(c, "larger hash %u goes before %u",
                                   hasha, hashb);
                         goto error_dump;
                 }
@@ -2439,9 +2439,9 @@ int dbg_check_nondata_nodes_order(struct ubifs_info *c, struct list_head *head)
         return 0;
 
 error_dump:
-        ubifs_msg("dumping first node");
+        ubifs_msg(c, "dumping first node");
         ubifs_dump_node(c, sa->node);
-        ubifs_msg("dumping second node");
+        ubifs_msg(c, "dumping second node");
         ubifs_dump_node(c, sb->node);
         return -EINVAL;
         return 0;
@@ -2470,13 +2470,13 @@ static int power_cut_emulated(struct ubifs_info *c, int lnum, int write)
                                 delay = prandom_u32() % 60000;
                                 d->pc_timeout = jiffies;
                                 d->pc_timeout += msecs_to_jiffies(delay);
-                                ubifs_warn("failing after %lums", delay);
+                                ubifs_warn(c, "failing after %lums", delay);
                         } else {
                                 d->pc_delay = 2;
                                 delay = prandom_u32() % 10000;
                                 /* Fail within 10000 operations */
                                 d->pc_cnt_max = delay;
-                                ubifs_warn("failing after %lu calls", delay);
+                                ubifs_warn(c, "failing after %lu calls", delay);
                         }
                 }
 
@@ -2494,55 +2494,55 @@ static int power_cut_emulated(struct ubifs_info *c, int lnum, int write)
                         return 0;
                 if (chance(19, 20))
                         return 0;
-                ubifs_warn("failing in super block LEB %d", lnum);
+                ubifs_warn(c, "failing in super block LEB %d", lnum);
         } else if (lnum == UBIFS_MST_LNUM || lnum == UBIFS_MST_LNUM + 1) {
                 if (chance(19, 20))
                         return 0;
-                ubifs_warn("failing in master LEB %d", lnum);
+                ubifs_warn(c, "failing in master LEB %d", lnum);
         } else if (lnum >= UBIFS_LOG_LNUM && lnum <= c->log_last) {
                 if (write && chance(99, 100))
                         return 0;
                 if (chance(399, 400))
                         return 0;
-                ubifs_warn("failing in log LEB %d", lnum);
+                ubifs_warn(c, "failing in log LEB %d", lnum);
         } else if (lnum >= c->lpt_first && lnum <= c->lpt_last) {
                 if (write && chance(7, 8))
                         return 0;
                 if (chance(19, 20))
                         return 0;
-                ubifs_warn("failing in LPT LEB %d", lnum);
+                ubifs_warn(c, "failing in LPT LEB %d", lnum);
         } else if (lnum >= c->orph_first && lnum <= c->orph_last) {
                 if (write && chance(1, 2))
                         return 0;
                 if (chance(9, 10))
                         return 0;
-                ubifs_warn("failing in orphan LEB %d", lnum);
+                ubifs_warn(c, "failing in orphan LEB %d", lnum);
         } else if (lnum == c->ihead_lnum) {
                 if (chance(99, 100))
                         return 0;
-                ubifs_warn("failing in index head LEB %d", lnum);
+                ubifs_warn(c, "failing in index head LEB %d", lnum);
         } else if (c->jheads && lnum == c->jheads[GCHD].wbuf.lnum) {
                 if (chance(9, 10))
                         return 0;
-                ubifs_warn("failing in GC head LEB %d", lnum);
+                ubifs_warn(c, "failing in GC head LEB %d", lnum);
         } else if (write && !RB_EMPTY_ROOT(&c->buds) &&
                    !ubifs_search_bud(c, lnum)) {
                 if (chance(19, 20))
                         return 0;
-                ubifs_warn("failing in non-bud LEB %d", lnum);
+                ubifs_warn(c, "failing in non-bud LEB %d", lnum);
         } else if (c->cmt_state == COMMIT_RUNNING_BACKGROUND ||
                    c->cmt_state == COMMIT_RUNNING_REQUIRED) {
                 if (chance(999, 1000))
                         return 0;
-                ubifs_warn("failing in bud LEB %d commit running", lnum);
+                ubifs_warn(c, "failing in bud LEB %d commit running", lnum);
         } else {
                 if (chance(9999, 10000))
                         return 0;
-                ubifs_warn("failing in bud LEB %d commit not running", lnum);
+                ubifs_warn(c, "failing in bud LEB %d commit not running", lnum);
         }
 
         d->pc_happened = 1;
-        ubifs_warn("========== Power cut emulated ==========");
+        ubifs_warn(c, "========== Power cut emulated ==========");
         dump_stack();
         return 1;
 }
@@ -2557,7 +2557,7 @@ static int corrupt_data(const struct ubifs_info *c, const void *buf,
         /* Corruption span max to end of write unit */
         to = min(len, ALIGN(from + 1, c->max_write_size));
 
-        ubifs_warn("filled bytes %u-%u with %s", from, to - 1,
+        ubifs_warn(c, "filled bytes %u-%u with %s", from, to - 1,
                    ffs ? "0xFFs" : "random data");
 
         if (ffs)
@@ -2579,7 +2579,7 @@ int dbg_leb_write(struct ubifs_info *c, int lnum, const void *buf,
         failing = power_cut_emulated(c, lnum, 1);
         if (failing) {
                 len = corrupt_data(c, buf, len);
-                ubifs_warn("actually write %d bytes to LEB %d:%d (the buffer was corrupted)",
+                ubifs_warn(c, "actually write %d bytes to LEB %d:%d (the buffer was corrupted)",
                            len, lnum, offs);
         }
         err = ubi_leb_write(c->ubi, lnum, buf, offs, len);
@@ -2909,7 +2909,7 @@ out_remove:
         debugfs_remove_recursive(d->dfs_dir);
 out:
         err = dent ? PTR_ERR(dent) : -ENODEV;
-        ubifs_err("cannot create \"%s\" debugfs file or directory, error %d\n",
+        ubifs_err(c, "cannot create \"%s\" debugfs file or directory, error %d\n",
                   fname, err);
         return err;
 }
@@ -3063,8 +3063,8 @@ out_remove:
         debugfs_remove_recursive(dfs_rootdir);
 out:
         err = dent ? PTR_ERR(dent) : -ENODEV;
-        ubifs_err("cannot create \"%s\" debugfs file or directory, error %d\n",
-                  fname, err);
+        pr_err("UBIFS error (pid %d): cannot create \"%s\" debugfs file or directory, error %d\n",
+               current->pid, fname, err);
         return err;
 }