aboutsummaryrefslogtreecommitdiffstats
path: root/fs
diff options
context:
space:
mode:
authorSheng Yong <shengyong1@huawei.com>2015-03-20 06:39:42 -0400
committerArtem Bityutskiy <artem.bityutskiy@linux.intel.com>2015-03-25 05:08:41 -0400
commit235c362bd0f6afcf767bc72aa0c647e1434cc631 (patch)
tree1cbc858f95877e51ddf48ea00dec0f6f7a481469 /fs
parent8a87dc55f75f19ffdbb52066afea1b633577c79f (diff)
UBIFS: extend debug/message capabilities
In the case where we have more than one volumes on different UBI devices, it may be not that easy to tell which volume prints the messages. Add ubi number and volume id in ubifs_msg/warn/error to help debug. These two values are passed by struct ubifs_info. For those where ubifs_info is not initialized yet, ubifs_* is replaced by pr_*. For those where ubifs_info is not avaliable, ubifs_info is passed to the calling function as a const parameter. The output looks like, [ 95.444879] UBIFS (ubi0:1): background thread "ubifs_bgt0_1" started, PID 696 [ 95.484688] UBIFS (ubi0:1): UBIFS: mounted UBI device 0, volume 1, name "test1" [ 95.484694] UBIFS (ubi0:1): LEB size: 126976 bytes (124 KiB), min./max. I/O unit sizes: 2048 bytes/2048 bytes [ 95.484699] UBIFS (ubi0:1): FS size: 30220288 bytes (28 MiB, 238 LEBs), journal size 1523712 bytes (1 MiB, 12 LEBs) [ 95.484703] UBIFS (ubi0:1): reserved for root: 1427378 bytes (1393 KiB) [ 95.484709] UBIFS (ubi0:1): media format: w4/r0 (latest is w4/r0), UUID 40DFFC0E-70BE-4193-8905-F7D6DFE60B17, small LPT model [ 95.489875] UBIFS (ubi1:0): background thread "ubifs_bgt1_0" started, PID 699 [ 95.529713] UBIFS (ubi1:0): UBIFS: mounted UBI device 1, volume 0, name "test2" [ 95.529718] UBIFS (ubi1:0): LEB size: 126976 bytes (124 KiB), min./max. I/O unit sizes: 2048 bytes/2048 bytes [ 95.529724] UBIFS (ubi1:0): FS size: 19808256 bytes (18 MiB, 156 LEBs), journal size 1015809 bytes (0 MiB, 8 LEBs) [ 95.529727] UBIFS (ubi1:0): reserved for root: 935592 bytes (913 KiB) [ 95.529733] UBIFS (ubi1:0): media format: w4/r0 (latest is w4/r0), UUID EEB7779D-F419-4CA9-811B-831CAC7233D4, small LPT model [ 954.264767] UBIFS error (ubi1:0 pid 756): ubifs_read_node: bad node type (255 but expected 6) [ 954.367030] UBIFS error (ubi1:0 pid 756): ubifs_read_node: bad node at LEB 0:0, LEB mapping status 1 Signed-off-by: Sheng Yong <shengyong1@huawei.com> Signed-off-by: Artem Bityutskiy <artem.bityutskiy@linux.intel.com>
Diffstat (limited to 'fs')
-rw-r--r--fs/ubifs/budget.c2
-rw-r--r--fs/ubifs/commit.c12
-rw-r--r--fs/ubifs/compress.c22
-rw-r--r--fs/ubifs/debug.c186
-rw-r--r--fs/ubifs/dir.c12
-rw-r--r--fs/ubifs/file.c17
-rw-r--r--fs/ubifs/io.c40
-rw-r--r--fs/ubifs/ioctl.c2
-rw-r--r--fs/ubifs/journal.c17
-rw-r--r--fs/ubifs/log.c4
-rw-r--r--fs/ubifs/lprops.c62
-rw-r--r--fs/ubifs/lpt.c59
-rw-r--r--fs/ubifs/lpt_commit.c34
-rw-r--r--fs/ubifs/master.c6
-rw-r--r--fs/ubifs/orphan.c26
-rw-r--r--fs/ubifs/recovery.c34
-rw-r--r--fs/ubifs/replay.c34
-rw-r--r--fs/ubifs/sb.c30
-rw-r--r--fs/ubifs/scan.c24
-rw-r--r--fs/ubifs/super.c105
-rw-r--r--fs/ubifs/tnc.c20
-rw-r--r--fs/ubifs/tnc_commit.c12
-rw-r--r--fs/ubifs/tnc_misc.c24
-rw-r--r--fs/ubifs/ubifs.h26
-rw-r--r--fs/ubifs/xattr.c18
25 files changed, 419 insertions, 409 deletions
diff --git a/fs/ubifs/budget.c b/fs/ubifs/budget.c
index eb997e9c4ab0..11a11b32a2a9 100644
--- a/fs/ubifs/budget.c
+++ b/fs/ubifs/budget.c
@@ -509,7 +509,7 @@ again:
509 c->bi.nospace_rp = 1; 509 c->bi.nospace_rp = 1;
510 smp_wmb(); 510 smp_wmb();
511 } else 511 } else
512 ubifs_err("cannot budget space, error %d", err); 512 ubifs_err(c, "cannot budget space, error %d", err);
513 return err; 513 return err;
514} 514}
515 515
diff --git a/fs/ubifs/commit.c b/fs/ubifs/commit.c
index 26b69b2d4a45..63f56619991d 100644
--- a/fs/ubifs/commit.c
+++ b/fs/ubifs/commit.c
@@ -225,7 +225,7 @@ out_cancel:
225out_up: 225out_up:
226 up_write(&c->commit_sem); 226 up_write(&c->commit_sem);
227out: 227out:
228 ubifs_err("commit failed, error %d", err); 228 ubifs_err(c, "commit failed, error %d", err);
229 spin_lock(&c->cs_lock); 229 spin_lock(&c->cs_lock);
230 c->cmt_state = COMMIT_BROKEN; 230 c->cmt_state = COMMIT_BROKEN;
231 wake_up(&c->cmt_wq); 231 wake_up(&c->cmt_wq);
@@ -289,7 +289,7 @@ int ubifs_bg_thread(void *info)
289 int err; 289 int err;
290 struct ubifs_info *c = info; 290 struct ubifs_info *c = info;
291 291
292 ubifs_msg("background thread \"%s\" started, PID %d", 292 ubifs_msg(c, "background thread \"%s\" started, PID %d",
293 c->bgt_name, current->pid); 293 c->bgt_name, current->pid);
294 set_freezable(); 294 set_freezable();
295 295
@@ -324,7 +324,7 @@ int ubifs_bg_thread(void *info)
324 cond_resched(); 324 cond_resched();
325 } 325 }
326 326
327 ubifs_msg("background thread \"%s\" stops", c->bgt_name); 327 ubifs_msg(c, "background thread \"%s\" stops", c->bgt_name);
328 return 0; 328 return 0;
329} 329}
330 330
@@ -712,13 +712,13 @@ out:
712 return 0; 712 return 0;
713 713
714out_dump: 714out_dump:
715 ubifs_err("dumping index node (iip=%d)", i->iip); 715 ubifs_err(c, "dumping index node (iip=%d)", i->iip);
716 ubifs_dump_node(c, idx); 716 ubifs_dump_node(c, idx);
717 list_del(&i->list); 717 list_del(&i->list);
718 kfree(i); 718 kfree(i);
719 if (!list_empty(&list)) { 719 if (!list_empty(&list)) {
720 i = list_entry(list.prev, struct idx_node, list); 720 i = list_entry(list.prev, struct idx_node, list);
721 ubifs_err("dumping parent index node"); 721 ubifs_err(c, "dumping parent index node");
722 ubifs_dump_node(c, &i->idx); 722 ubifs_dump_node(c, &i->idx);
723 } 723 }
724out_free: 724out_free:
@@ -727,7 +727,7 @@ out_free:
727 list_del(&i->list); 727 list_del(&i->list);
728 kfree(i); 728 kfree(i);
729 } 729 }
730 ubifs_err("failed, error %d", err); 730 ubifs_err(c, "failed, error %d", err);
731 if (err > 0) 731 if (err > 0)
732 err = -EINVAL; 732 err = -EINVAL;
733 return err; 733 return err;
diff --git a/fs/ubifs/compress.c b/fs/ubifs/compress.c
index 2bfa0953335d..565cb56d7225 100644
--- a/fs/ubifs/compress.c
+++ b/fs/ubifs/compress.c
@@ -92,8 +92,8 @@ struct ubifs_compressor *ubifs_compressors[UBIFS_COMPR_TYPES_CNT];
92 * Note, if the input buffer was not compressed, it is copied to the output 92 * Note, if the input buffer was not compressed, it is copied to the output
93 * buffer and %UBIFS_COMPR_NONE is returned in @compr_type. 93 * buffer and %UBIFS_COMPR_NONE is returned in @compr_type.
94 */ 94 */
95void ubifs_compress(const void *in_buf, int in_len, void *out_buf, int *out_len, 95void ubifs_compress(const struct ubifs_info *c, const void *in_buf,
96 int *compr_type) 96 int in_len, void *out_buf, int *out_len, int *compr_type)
97{ 97{
98 int err; 98 int err;
99 struct ubifs_compressor *compr = ubifs_compressors[*compr_type]; 99 struct ubifs_compressor *compr = ubifs_compressors[*compr_type];
@@ -112,9 +112,9 @@ void ubifs_compress(const void *in_buf, int in_len, void *out_buf, int *out_len,
112 if (compr->comp_mutex) 112 if (compr->comp_mutex)
113 mutex_unlock(compr->comp_mutex); 113 mutex_unlock(compr->comp_mutex);
114 if (unlikely(err)) { 114 if (unlikely(err)) {
115 ubifs_warn("cannot compress %d bytes, compressor %s, error %d, leave data uncompressed", 115 ubifs_warn(c, "cannot compress %d bytes, compressor %s, error %d, leave data uncompressed",
116 in_len, compr->name, err); 116 in_len, compr->name, err);
117 goto no_compr; 117 goto no_compr;
118 } 118 }
119 119
120 /* 120 /*
@@ -144,21 +144,21 @@ no_compr:
144 * The length of the uncompressed data is returned in @out_len. This functions 144 * The length of the uncompressed data is returned in @out_len. This functions
145 * returns %0 on success or a negative error code on failure. 145 * returns %0 on success or a negative error code on failure.
146 */ 146 */
147int ubifs_decompress(const void *in_buf, int in_len, void *out_buf, 147int ubifs_decompress(const struct ubifs_info *c, const void *in_buf,
148 int *out_len, int compr_type) 148 int in_len, void *out_buf, int *out_len, int compr_type)
149{ 149{
150 int err; 150 int err;
151 struct ubifs_compressor *compr; 151 struct ubifs_compressor *compr;
152 152
153 if (unlikely(compr_type < 0 || compr_type >= UBIFS_COMPR_TYPES_CNT)) { 153 if (unlikely(compr_type < 0 || compr_type >= UBIFS_COMPR_TYPES_CNT)) {
154 ubifs_err("invalid compression type %d", compr_type); 154 ubifs_err(c, "invalid compression type %d", compr_type);
155 return -EINVAL; 155 return -EINVAL;
156 } 156 }
157 157
158 compr = ubifs_compressors[compr_type]; 158 compr = ubifs_compressors[compr_type];
159 159
160 if (unlikely(!compr->capi_name)) { 160 if (unlikely(!compr->capi_name)) {
161 ubifs_err("%s compression is not compiled in", compr->name); 161 ubifs_err(c, "%s compression is not compiled in", compr->name);
162 return -EINVAL; 162 return -EINVAL;
163 } 163 }
164 164
@@ -175,7 +175,7 @@ int ubifs_decompress(const void *in_buf, int in_len, void *out_buf,
175 if (compr->decomp_mutex) 175 if (compr->decomp_mutex)
176 mutex_unlock(compr->decomp_mutex); 176 mutex_unlock(compr->decomp_mutex);
177 if (err) 177 if (err)
178 ubifs_err("cannot decompress %d bytes, compressor %s, error %d", 178 ubifs_err(c, "cannot decompress %d bytes, compressor %s, error %d",
179 in_len, compr->name, err); 179 in_len, compr->name, err);
180 180
181 return err; 181 return err;
@@ -193,8 +193,8 @@ static int __init compr_init(struct ubifs_compressor *compr)
193 if (compr->capi_name) { 193 if (compr->capi_name) {
194 compr->cc = crypto_alloc_comp(compr->capi_name, 0, 0); 194 compr->cc = crypto_alloc_comp(compr->capi_name, 0, 0);
195 if (IS_ERR(compr->cc)) { 195 if (IS_ERR(compr->cc)) {
196 ubifs_err("cannot initialize compressor %s, error %ld", 196 pr_err("UBIFS error (pid %d): cannot initialize compressor %s, error %ld",
197 compr->name, PTR_ERR(compr->cc)); 197 current->pid, compr->name, PTR_ERR(compr->cc));
198 return PTR_ERR(compr->cc); 198 return PTR_ERR(compr->cc);
199 } 199 }
200 } 200 }
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)
746 for (lnum = c->main_first; lnum < c->leb_cnt; lnum++) { 746 for (lnum = c->main_first; lnum < c->leb_cnt; lnum++) {
747 err = ubifs_read_one_lp(c, lnum, &lp); 747 err = ubifs_read_one_lp(c, lnum, &lp);
748 if (err) { 748 if (err) {
749 ubifs_err("cannot read lprops for LEB %d", lnum); 749 ubifs_err(c, "cannot read lprops for LEB %d", lnum);
750 continue; 750 continue;
751 } 751 }
752 752
@@ -819,13 +819,13 @@ void ubifs_dump_leb(const struct ubifs_info *c, int lnum)
819 819
820 buf = __vmalloc(c->leb_size, GFP_NOFS, PAGE_KERNEL); 820 buf = __vmalloc(c->leb_size, GFP_NOFS, PAGE_KERNEL);
821 if (!buf) { 821 if (!buf) {
822 ubifs_err("cannot allocate memory for dumping LEB %d", lnum); 822 ubifs_err(c, "cannot allocate memory for dumping LEB %d", lnum);
823 return; 823 return;
824 } 824 }
825 825
826 sleb = ubifs_scan(c, lnum, 0, buf, 0); 826 sleb = ubifs_scan(c, lnum, 0, buf, 0);
827 if (IS_ERR(sleb)) { 827 if (IS_ERR(sleb)) {
828 ubifs_err("scan error %d", (int)PTR_ERR(sleb)); 828 ubifs_err(c, "scan error %d", (int)PTR_ERR(sleb));
829 goto out; 829 goto out;
830 } 830 }
831 831
@@ -1032,7 +1032,7 @@ int dbg_check_space_info(struct ubifs_info *c)
1032 spin_unlock(&c->space_lock); 1032 spin_unlock(&c->space_lock);
1033 1033
1034 if (free != d->saved_free) { 1034 if (free != d->saved_free) {
1035 ubifs_err("free space changed from %lld to %lld", 1035 ubifs_err(c, "free space changed from %lld to %lld",
1036 d->saved_free, free); 1036 d->saved_free, free);
1037 goto out; 1037 goto out;
1038 } 1038 }
@@ -1040,15 +1040,15 @@ int dbg_check_space_info(struct ubifs_info *c)
1040 return 0; 1040 return 0;
1041 1041
1042out: 1042out:
1043 ubifs_msg("saved lprops statistics dump"); 1043 ubifs_msg(c, "saved lprops statistics dump");
1044 ubifs_dump_lstats(&d->saved_lst); 1044 ubifs_dump_lstats(&d->saved_lst);
1045 ubifs_msg("saved budgeting info dump"); 1045 ubifs_msg(c, "saved budgeting info dump");
1046 ubifs_dump_budg(c, &d->saved_bi); 1046 ubifs_dump_budg(c, &d->saved_bi);
1047 ubifs_msg("saved idx_gc_cnt %d", d->saved_idx_gc_cnt); 1047 ubifs_msg(c, "saved idx_gc_cnt %d", d->saved_idx_gc_cnt);
1048 ubifs_msg("current lprops statistics dump"); 1048 ubifs_msg(c, "current lprops statistics dump");
1049 ubifs_get_lp_stats(c, &lst); 1049 ubifs_get_lp_stats(c, &lst);
1050 ubifs_dump_lstats(&lst); 1050 ubifs_dump_lstats(&lst);
1051 ubifs_msg("current budgeting info dump"); 1051 ubifs_msg(c, "current budgeting info dump");
1052 ubifs_dump_budg(c, &c->bi); 1052 ubifs_dump_budg(c, &c->bi);
1053 dump_stack(); 1053 dump_stack();
1054 return -EINVAL; 1054 return -EINVAL;
@@ -1077,9 +1077,9 @@ int dbg_check_synced_i_size(const struct ubifs_info *c, struct inode *inode)
1077 mutex_lock(&ui->ui_mutex); 1077 mutex_lock(&ui->ui_mutex);
1078 spin_lock(&ui->ui_lock); 1078 spin_lock(&ui->ui_lock);
1079 if (ui->ui_size != ui->synced_i_size && !ui->dirty) { 1079 if (ui->ui_size != ui->synced_i_size && !ui->dirty) {
1080 ubifs_err("ui_size is %lld, synced_i_size is %lld, but inode is clean", 1080 ubifs_err(c, "ui_size is %lld, synced_i_size is %lld, but inode is clean",
1081 ui->ui_size, ui->synced_i_size); 1081 ui->ui_size, ui->synced_i_size);
1082 ubifs_err("i_ino %lu, i_mode %#x, i_size %lld", inode->i_ino, 1082 ubifs_err(c, "i_ino %lu, i_mode %#x, i_size %lld", inode->i_ino,
1083 inode->i_mode, i_size_read(inode)); 1083 inode->i_mode, i_size_read(inode));
1084 dump_stack(); 1084 dump_stack();
1085 err = -EINVAL; 1085 err = -EINVAL;
@@ -1140,7 +1140,7 @@ int dbg_check_dir(struct ubifs_info *c, const struct inode *dir)
1140 kfree(pdent); 1140 kfree(pdent);
1141 1141
1142 if (i_size_read(dir) != size) { 1142 if (i_size_read(dir) != size) {
1143 ubifs_err("directory inode %lu has size %llu, but calculated size is %llu", 1143 ubifs_err(c, "directory inode %lu has size %llu, but calculated size is %llu",
1144 dir->i_ino, (unsigned long long)i_size_read(dir), 1144 dir->i_ino, (unsigned long long)i_size_read(dir),
1145 (unsigned long long)size); 1145 (unsigned long long)size);
1146 ubifs_dump_inode(c, dir); 1146 ubifs_dump_inode(c, dir);
@@ -1148,7 +1148,7 @@ int dbg_check_dir(struct ubifs_info *c, const struct inode *dir)
1148 return -EINVAL; 1148 return -EINVAL;
1149 } 1149 }
1150 if (dir->i_nlink != nlink) { 1150 if (dir->i_nlink != nlink) {
1151 ubifs_err("directory inode %lu has nlink %u, but calculated nlink is %u", 1151 ubifs_err(c, "directory inode %lu has nlink %u, but calculated nlink is %u",
1152 dir->i_ino, dir->i_nlink, nlink); 1152 dir->i_ino, dir->i_nlink, nlink);
1153 ubifs_dump_inode(c, dir); 1153 ubifs_dump_inode(c, dir);
1154 dump_stack(); 1154 dump_stack();
@@ -1207,10 +1207,10 @@ static int dbg_check_key_order(struct ubifs_info *c, struct ubifs_zbranch *zbr1,
1207 err = 1; 1207 err = 1;
1208 key_read(c, &dent1->key, &key); 1208 key_read(c, &dent1->key, &key);
1209 if (keys_cmp(c, &zbr1->key, &key)) { 1209 if (keys_cmp(c, &zbr1->key, &key)) {
1210 ubifs_err("1st entry at %d:%d has key %s", zbr1->lnum, 1210 ubifs_err(c, "1st entry at %d:%d has key %s", zbr1->lnum,
1211 zbr1->offs, dbg_snprintf_key(c, &key, key_buf, 1211 zbr1->offs, dbg_snprintf_key(c, &key, key_buf,
1212 DBG_KEY_BUF_LEN)); 1212 DBG_KEY_BUF_LEN));
1213 ubifs_err("but it should have key %s according to tnc", 1213 ubifs_err(c, "but it should have key %s according to tnc",
1214 dbg_snprintf_key(c, &zbr1->key, key_buf, 1214 dbg_snprintf_key(c, &zbr1->key, key_buf,
1215 DBG_KEY_BUF_LEN)); 1215 DBG_KEY_BUF_LEN));
1216 ubifs_dump_node(c, dent1); 1216 ubifs_dump_node(c, dent1);
@@ -1219,10 +1219,10 @@ static int dbg_check_key_order(struct ubifs_info *c, struct ubifs_zbranch *zbr1,
1219 1219
1220 key_read(c, &dent2->key, &key); 1220 key_read(c, &dent2->key, &key);
1221 if (keys_cmp(c, &zbr2->key, &key)) { 1221 if (keys_cmp(c, &zbr2->key, &key)) {
1222 ubifs_err("2nd entry at %d:%d has key %s", zbr1->lnum, 1222 ubifs_err(c, "2nd entry at %d:%d has key %s", zbr1->lnum,
1223 zbr1->offs, dbg_snprintf_key(c, &key, key_buf, 1223 zbr1->offs, dbg_snprintf_key(c, &key, key_buf,
1224 DBG_KEY_BUF_LEN)); 1224 DBG_KEY_BUF_LEN));
1225 ubifs_err("but it should have key %s according to tnc", 1225 ubifs_err(c, "but it should have key %s according to tnc",
1226 dbg_snprintf_key(c, &zbr2->key, key_buf, 1226 dbg_snprintf_key(c, &zbr2->key, key_buf,
1227 DBG_KEY_BUF_LEN)); 1227 DBG_KEY_BUF_LEN));
1228 ubifs_dump_node(c, dent2); 1228 ubifs_dump_node(c, dent2);
@@ -1238,14 +1238,14 @@ static int dbg_check_key_order(struct ubifs_info *c, struct ubifs_zbranch *zbr1,
1238 goto out_free; 1238 goto out_free;
1239 } 1239 }
1240 if (cmp == 0 && nlen1 == nlen2) 1240 if (cmp == 0 && nlen1 == nlen2)
1241 ubifs_err("2 xent/dent nodes with the same name"); 1241 ubifs_err(c, "2 xent/dent nodes with the same name");
1242 else 1242 else
1243 ubifs_err("bad order of colliding key %s", 1243 ubifs_err(c, "bad order of colliding key %s",
1244 dbg_snprintf_key(c, &key, key_buf, DBG_KEY_BUF_LEN)); 1244 dbg_snprintf_key(c, &key, key_buf, DBG_KEY_BUF_LEN));
1245 1245
1246 ubifs_msg("first node at %d:%d\n", zbr1->lnum, zbr1->offs); 1246 ubifs_msg(c, "first node at %d:%d\n", zbr1->lnum, zbr1->offs);
1247 ubifs_dump_node(c, dent1); 1247 ubifs_dump_node(c, dent1);
1248 ubifs_msg("second node at %d:%d\n", zbr2->lnum, zbr2->offs); 1248 ubifs_msg(c, "second node at %d:%d\n", zbr2->lnum, zbr2->offs);
1249 ubifs_dump_node(c, dent2); 1249 ubifs_dump_node(c, dent2);
1250 1250
1251out_free: 1251out_free:
@@ -1447,11 +1447,11 @@ static int dbg_check_znode(struct ubifs_info *c, struct ubifs_zbranch *zbr)
1447 return 0; 1447 return 0;
1448 1448
1449out: 1449out:
1450 ubifs_err("failed, error %d", err); 1450 ubifs_err(c, "failed, error %d", err);
1451 ubifs_msg("dump of the znode"); 1451 ubifs_msg(c, "dump of the znode");
1452 ubifs_dump_znode(c, znode); 1452 ubifs_dump_znode(c, znode);
1453 if (zp) { 1453 if (zp) {
1454 ubifs_msg("dump of the parent znode"); 1454 ubifs_msg(c, "dump of the parent znode");
1455 ubifs_dump_znode(c, zp); 1455 ubifs_dump_znode(c, zp);
1456 } 1456 }
1457 dump_stack(); 1457 dump_stack();
@@ -1518,9 +1518,9 @@ int dbg_check_tnc(struct ubifs_info *c, int extra)
1518 if (err < 0) 1518 if (err < 0)
1519 return err; 1519 return err;
1520 if (err) { 1520 if (err) {
1521 ubifs_msg("first znode"); 1521 ubifs_msg(c, "first znode");
1522 ubifs_dump_znode(c, prev); 1522 ubifs_dump_znode(c, prev);
1523 ubifs_msg("second znode"); 1523 ubifs_msg(c, "second znode");
1524 ubifs_dump_znode(c, znode); 1524 ubifs_dump_znode(c, znode);
1525 return -EINVAL; 1525 return -EINVAL;
1526 } 1526 }
@@ -1529,13 +1529,13 @@ int dbg_check_tnc(struct ubifs_info *c, int extra)
1529 1529
1530 if (extra) { 1530 if (extra) {
1531 if (clean_cnt != atomic_long_read(&c->clean_zn_cnt)) { 1531 if (clean_cnt != atomic_long_read(&c->clean_zn_cnt)) {
1532 ubifs_err("incorrect clean_zn_cnt %ld, calculated %ld", 1532 ubifs_err(c, "incorrect clean_zn_cnt %ld, calculated %ld",
1533 atomic_long_read(&c->clean_zn_cnt), 1533 atomic_long_read(&c->clean_zn_cnt),
1534 clean_cnt); 1534 clean_cnt);
1535 return -EINVAL; 1535 return -EINVAL;
1536 } 1536 }
1537 if (dirty_cnt != atomic_long_read(&c->dirty_zn_cnt)) { 1537 if (dirty_cnt != atomic_long_read(&c->dirty_zn_cnt)) {
1538 ubifs_err("incorrect dirty_zn_cnt %ld, calculated %ld", 1538 ubifs_err(c, "incorrect dirty_zn_cnt %ld, calculated %ld",
1539 atomic_long_read(&c->dirty_zn_cnt), 1539 atomic_long_read(&c->dirty_zn_cnt),
1540 dirty_cnt); 1540 dirty_cnt);
1541 return -EINVAL; 1541 return -EINVAL;
@@ -1608,7 +1608,7 @@ int dbg_walk_index(struct ubifs_info *c, dbg_leaf_callback leaf_cb,
1608 if (znode_cb) { 1608 if (znode_cb) {
1609 err = znode_cb(c, znode, priv); 1609 err = znode_cb(c, znode, priv);
1610 if (err) { 1610 if (err) {
1611 ubifs_err("znode checking function returned error %d", 1611 ubifs_err(c, "znode checking function returned error %d",
1612 err); 1612 err);
1613 ubifs_dump_znode(c, znode); 1613 ubifs_dump_znode(c, znode);
1614 goto out_dump; 1614 goto out_dump;
@@ -1619,7 +1619,7 @@ int dbg_walk_index(struct ubifs_info *c, dbg_leaf_callback leaf_cb,
1619 zbr = &znode->zbranch[idx]; 1619 zbr = &znode->zbranch[idx];
1620 err = leaf_cb(c, zbr, priv); 1620 err = leaf_cb(c, zbr, priv);
1621 if (err) { 1621 if (err) {
1622 ubifs_err("leaf checking function returned error %d, for leaf at LEB %d:%d", 1622 ubifs_err(c, "leaf checking function returned error %d, for leaf at LEB %d:%d",
1623 err, zbr->lnum, zbr->offs); 1623 err, zbr->lnum, zbr->offs);
1624 goto out_dump; 1624 goto out_dump;
1625 } 1625 }
@@ -1675,7 +1675,7 @@ out_dump:
1675 zbr = &znode->parent->zbranch[znode->iip]; 1675 zbr = &znode->parent->zbranch[znode->iip];
1676 else 1676 else
1677 zbr = &c->zroot; 1677 zbr = &c->zroot;
1678 ubifs_msg("dump of znode at LEB %d:%d", zbr->lnum, zbr->offs); 1678 ubifs_msg(c, "dump of znode at LEB %d:%d", zbr->lnum, zbr->offs);
1679 ubifs_dump_znode(c, znode); 1679 ubifs_dump_znode(c, znode);
1680out_unlock: 1680out_unlock:
1681 mutex_unlock(&c->tnc_mutex); 1681 mutex_unlock(&c->tnc_mutex);
@@ -1722,12 +1722,12 @@ int dbg_check_idx_size(struct ubifs_info *c, long long idx_size)
1722 1722
1723 err = dbg_walk_index(c, NULL, add_size, &calc); 1723 err = dbg_walk_index(c, NULL, add_size, &calc);
1724 if (err) { 1724 if (err) {
1725 ubifs_err("error %d while walking the index", err); 1725 ubifs_err(c, "error %d while walking the index", err);
1726 return err; 1726 return err;
1727 } 1727 }
1728 1728
1729 if (calc != idx_size) { 1729 if (calc != idx_size) {
1730 ubifs_err("index size check failed: calculated size is %lld, should be %lld", 1730 ubifs_err(c, "index size check failed: calculated size is %lld, should be %lld",
1731 calc, idx_size); 1731 calc, idx_size);
1732 dump_stack(); 1732 dump_stack();
1733 return -EINVAL; 1733 return -EINVAL;
@@ -1814,7 +1814,7 @@ static struct fsck_inode *add_inode(struct ubifs_info *c,
1814 } 1814 }
1815 1815
1816 if (inum > c->highest_inum) { 1816 if (inum > c->highest_inum) {
1817 ubifs_err("too high inode number, max. is %lu", 1817 ubifs_err(c, "too high inode number, max. is %lu",
1818 (unsigned long)c->highest_inum); 1818 (unsigned long)c->highest_inum);
1819 return ERR_PTR(-EINVAL); 1819 return ERR_PTR(-EINVAL);
1820 } 1820 }
@@ -1921,17 +1921,17 @@ static struct fsck_inode *read_add_inode(struct ubifs_info *c,
1921 ino_key_init(c, &key, inum); 1921 ino_key_init(c, &key, inum);
1922 err = ubifs_lookup_level0(c, &key, &znode, &n); 1922 err = ubifs_lookup_level0(c, &key, &znode, &n);
1923 if (!err) { 1923 if (!err) {
1924 ubifs_err("inode %lu not found in index", (unsigned long)inum); 1924 ubifs_err(c, "inode %lu not found in index", (unsigned long)inum);
1925 return ERR_PTR(-ENOENT); 1925 return ERR_PTR(-ENOENT);
1926 } else if (err < 0) { 1926 } else if (err < 0) {
1927 ubifs_err("error %d while looking up inode %lu", 1927 ubifs_err(c, "error %d while looking up inode %lu",
1928 err, (unsigned long)inum); 1928 err, (unsigned long)inum);
1929 return ERR_PTR(err); 1929 return ERR_PTR(err);
1930 } 1930 }
1931 1931
1932 zbr = &znode->zbranch[n]; 1932 zbr = &znode->zbranch[n];
1933 if (zbr->len < UBIFS_INO_NODE_SZ) { 1933 if (zbr->len < UBIFS_INO_NODE_SZ) {
1934 ubifs_err("bad node %lu node length %d", 1934 ubifs_err(c, "bad node %lu node length %d",
1935 (unsigned long)inum, zbr->len); 1935 (unsigned long)inum, zbr->len);
1936 return ERR_PTR(-EINVAL); 1936 return ERR_PTR(-EINVAL);
1937 } 1937 }
@@ -1942,7 +1942,7 @@ static struct fsck_inode *read_add_inode(struct ubifs_info *c,
1942 1942
1943 err = ubifs_tnc_read_node(c, zbr, ino); 1943 err = ubifs_tnc_read_node(c, zbr, ino);
1944 if (err) { 1944 if (err) {
1945 ubifs_err("cannot read inode node at LEB %d:%d, error %d", 1945 ubifs_err(c, "cannot read inode node at LEB %d:%d, error %d",
1946 zbr->lnum, zbr->offs, err); 1946 zbr->lnum, zbr->offs, err);
1947 kfree(ino); 1947 kfree(ino);
1948 return ERR_PTR(err); 1948 return ERR_PTR(err);
@@ -1951,7 +1951,7 @@ static struct fsck_inode *read_add_inode(struct ubifs_info *c,
1951 fscki = add_inode(c, fsckd, ino); 1951 fscki = add_inode(c, fsckd, ino);
1952 kfree(ino); 1952 kfree(ino);
1953 if (IS_ERR(fscki)) { 1953 if (IS_ERR(fscki)) {
1954 ubifs_err("error %ld while adding inode %lu node", 1954 ubifs_err(c, "error %ld while adding inode %lu node",
1955 PTR_ERR(fscki), (unsigned long)inum); 1955 PTR_ERR(fscki), (unsigned long)inum);
1956 return fscki; 1956 return fscki;
1957 } 1957 }
@@ -1985,7 +1985,7 @@ static int check_leaf(struct ubifs_info *c, struct ubifs_zbranch *zbr,
1985 struct fsck_inode *fscki; 1985 struct fsck_inode *fscki;
1986 1986
1987 if (zbr->len < UBIFS_CH_SZ) { 1987 if (zbr->len < UBIFS_CH_SZ) {
1988 ubifs_err("bad leaf length %d (LEB %d:%d)", 1988 ubifs_err(c, "bad leaf length %d (LEB %d:%d)",
1989 zbr->len, zbr->lnum, zbr->offs); 1989 zbr->len, zbr->lnum, zbr->offs);
1990 return -EINVAL; 1990 return -EINVAL;
1991 } 1991 }
@@ -1996,7 +1996,7 @@ static int check_leaf(struct ubifs_info *c, struct ubifs_zbranch *zbr,
1996 1996
1997 err = ubifs_tnc_read_node(c, zbr, node); 1997 err = ubifs_tnc_read_node(c, zbr, node);
1998 if (err) { 1998 if (err) {
1999 ubifs_err("cannot read leaf node at LEB %d:%d, error %d", 1999 ubifs_err(c, "cannot read leaf node at LEB %d:%d, error %d",
2000 zbr->lnum, zbr->offs, err); 2000 zbr->lnum, zbr->offs, err);
2001 goto out_free; 2001 goto out_free;
2002 } 2002 }
@@ -2006,7 +2006,7 @@ static int check_leaf(struct ubifs_info *c, struct ubifs_zbranch *zbr,
2006 fscki = add_inode(c, priv, node); 2006 fscki = add_inode(c, priv, node);
2007 if (IS_ERR(fscki)) { 2007 if (IS_ERR(fscki)) {
2008 err = PTR_ERR(fscki); 2008 err = PTR_ERR(fscki);
2009 ubifs_err("error %d while adding inode node", err); 2009 ubifs_err(c, "error %d while adding inode node", err);
2010 goto out_dump; 2010 goto out_dump;
2011 } 2011 }
2012 goto out; 2012 goto out;
@@ -2014,7 +2014,7 @@ static int check_leaf(struct ubifs_info *c, struct ubifs_zbranch *zbr,
2014 2014
2015 if (type != UBIFS_DENT_KEY && type != UBIFS_XENT_KEY && 2015 if (type != UBIFS_DENT_KEY && type != UBIFS_XENT_KEY &&
2016 type != UBIFS_DATA_KEY) { 2016 type != UBIFS_DATA_KEY) {
2017 ubifs_err("unexpected node type %d at LEB %d:%d", 2017 ubifs_err(c, "unexpected node type %d at LEB %d:%d",
2018 type, zbr->lnum, zbr->offs); 2018 type, zbr->lnum, zbr->offs);
2019 err = -EINVAL; 2019 err = -EINVAL;
2020 goto out_free; 2020 goto out_free;
@@ -2022,7 +2022,7 @@ static int check_leaf(struct ubifs_info *c, struct ubifs_zbranch *zbr,
2022 2022
2023 ch = node; 2023 ch = node;
2024 if (le64_to_cpu(ch->sqnum) > c->max_sqnum) { 2024 if (le64_to_cpu(ch->sqnum) > c->max_sqnum) {
2025 ubifs_err("too high sequence number, max. is %llu", 2025 ubifs_err(c, "too high sequence number, max. is %llu",
2026 c->max_sqnum); 2026 c->max_sqnum);
2027 err = -EINVAL; 2027 err = -EINVAL;
2028 goto out_dump; 2028 goto out_dump;
@@ -2042,7 +2042,7 @@ static int check_leaf(struct ubifs_info *c, struct ubifs_zbranch *zbr,
2042 fscki = read_add_inode(c, priv, inum); 2042 fscki = read_add_inode(c, priv, inum);
2043 if (IS_ERR(fscki)) { 2043 if (IS_ERR(fscki)) {
2044 err = PTR_ERR(fscki); 2044 err = PTR_ERR(fscki);
2045 ubifs_err("error %d while processing data node and trying to find inode node %lu", 2045 ubifs_err(c, "error %d while processing data node and trying to find inode node %lu",
2046 err, (unsigned long)inum); 2046 err, (unsigned long)inum);
2047 goto out_dump; 2047 goto out_dump;
2048 } 2048 }
@@ -2052,7 +2052,7 @@ static int check_leaf(struct ubifs_info *c, struct ubifs_zbranch *zbr,
2052 blk_offs <<= UBIFS_BLOCK_SHIFT; 2052 blk_offs <<= UBIFS_BLOCK_SHIFT;
2053 blk_offs += le32_to_cpu(dn->size); 2053 blk_offs += le32_to_cpu(dn->size);
2054 if (blk_offs > fscki->size) { 2054 if (blk_offs > fscki->size) {
2055 ubifs_err("data node at LEB %d:%d is not within inode size %lld", 2055 ubifs_err(c, "data node at LEB %d:%d is not within inode size %lld",
2056 zbr->lnum, zbr->offs, fscki->size); 2056 zbr->lnum, zbr->offs, fscki->size);
2057 err = -EINVAL; 2057 err = -EINVAL;
2058 goto out_dump; 2058 goto out_dump;
@@ -2076,7 +2076,7 @@ static int check_leaf(struct ubifs_info *c, struct ubifs_zbranch *zbr,
2076 fscki = read_add_inode(c, priv, inum); 2076 fscki = read_add_inode(c, priv, inum);
2077 if (IS_ERR(fscki)) { 2077 if (IS_ERR(fscki)) {
2078 err = PTR_ERR(fscki); 2078 err = PTR_ERR(fscki);
2079 ubifs_err("error %d while processing entry node and trying to find inode node %lu", 2079 ubifs_err(c, "error %d while processing entry node and trying to find inode node %lu",
2080 err, (unsigned long)inum); 2080 err, (unsigned long)inum);
2081 goto out_dump; 2081 goto out_dump;
2082 } 2082 }
@@ -2088,7 +2088,7 @@ static int check_leaf(struct ubifs_info *c, struct ubifs_zbranch *zbr,
2088 fscki1 = read_add_inode(c, priv, inum); 2088 fscki1 = read_add_inode(c, priv, inum);
2089 if (IS_ERR(fscki1)) { 2089 if (IS_ERR(fscki1)) {
2090 err = PTR_ERR(fscki1); 2090 err = PTR_ERR(fscki1);
2091 ubifs_err("error %d while processing entry node and trying to find parent inode node %lu", 2091 ubifs_err(c, "error %d while processing entry node and trying to find parent inode node %lu",
2092 err, (unsigned long)inum); 2092 err, (unsigned long)inum);
2093 goto out_dump; 2093 goto out_dump;
2094 } 2094 }
@@ -2111,7 +2111,7 @@ out:
2111 return 0; 2111 return 0;
2112 2112
2113out_dump: 2113out_dump:
2114 ubifs_msg("dump of node at LEB %d:%d", zbr->lnum, zbr->offs); 2114 ubifs_msg(c, "dump of node at LEB %d:%d", zbr->lnum, zbr->offs);
2115 ubifs_dump_node(c, node); 2115 ubifs_dump_node(c, node);
2116out_free: 2116out_free:
2117 kfree(node); 2117 kfree(node);
@@ -2162,52 +2162,52 @@ static int check_inodes(struct ubifs_info *c, struct fsck_data *fsckd)
2162 */ 2162 */
2163 if (fscki->inum != UBIFS_ROOT_INO && 2163 if (fscki->inum != UBIFS_ROOT_INO &&
2164 fscki->references != 1) { 2164 fscki->references != 1) {
2165 ubifs_err("directory inode %lu has %d direntries which refer it, but should be 1", 2165 ubifs_err(c, "directory inode %lu has %d direntries which refer it, but should be 1",
2166 (unsigned long)fscki->inum, 2166 (unsigned long)fscki->inum,
2167 fscki->references); 2167 fscki->references);
2168 goto out_dump; 2168 goto out_dump;
2169 } 2169 }
2170 if (fscki->inum == UBIFS_ROOT_INO && 2170 if (fscki->inum == UBIFS_ROOT_INO &&
2171 fscki->references != 0) { 2171 fscki->references != 0) {
2172 ubifs_err("root inode %lu has non-zero (%d) direntries which refer it", 2172 ubifs_err(c, "root inode %lu has non-zero (%d) direntries which refer it",
2173 (unsigned long)fscki->inum, 2173 (unsigned long)fscki->inum,
2174 fscki->references); 2174 fscki->references);
2175 goto out_dump; 2175 goto out_dump;
2176 } 2176 }
2177 if (fscki->calc_sz != fscki->size) { 2177 if (fscki->calc_sz != fscki->size) {
2178 ubifs_err("directory inode %lu size is %lld, but calculated size is %lld", 2178 ubifs_err(c, "directory inode %lu size is %lld, but calculated size is %lld",
2179 (unsigned long)fscki->inum, 2179 (unsigned long)fscki->inum,
2180 fscki->size, fscki->calc_sz); 2180 fscki->size, fscki->calc_sz);
2181 goto out_dump; 2181 goto out_dump;
2182 } 2182 }
2183 if (fscki->calc_cnt != fscki->nlink) { 2183 if (fscki->calc_cnt != fscki->nlink) {
2184 ubifs_err("directory inode %lu nlink is %d, but calculated nlink is %d", 2184 ubifs_err(c, "directory inode %lu nlink is %d, but calculated nlink is %d",
2185 (unsigned long)fscki->inum, 2185 (unsigned long)fscki->inum,
2186 fscki->nlink, fscki->calc_cnt); 2186 fscki->nlink, fscki->calc_cnt);
2187 goto out_dump; 2187 goto out_dump;
2188 } 2188 }
2189 } else { 2189 } else {
2190 if (fscki->references != fscki->nlink) { 2190 if (fscki->references != fscki->nlink) {
2191 ubifs_err("inode %lu nlink is %d, but calculated nlink is %d", 2191 ubifs_err(c, "inode %lu nlink is %d, but calculated nlink is %d",
2192 (unsigned long)fscki->inum, 2192 (unsigned long)fscki->inum,
2193 fscki->nlink, fscki->references); 2193 fscki->nlink, fscki->references);
2194 goto out_dump; 2194 goto out_dump;
2195 } 2195 }
2196 } 2196 }
2197 if (fscki->xattr_sz != fscki->calc_xsz) { 2197 if (fscki->xattr_sz != fscki->calc_xsz) {
2198 ubifs_err("inode %lu has xattr size %u, but calculated size is %lld", 2198 ubifs_err(c, "inode %lu has xattr size %u, but calculated size is %lld",
2199 (unsigned long)fscki->inum, fscki->xattr_sz, 2199 (unsigned long)fscki->inum, fscki->xattr_sz,
2200 fscki->calc_xsz); 2200 fscki->calc_xsz);
2201 goto out_dump; 2201 goto out_dump;
2202 } 2202 }
2203 if (fscki->xattr_cnt != fscki->calc_xcnt) { 2203 if (fscki->xattr_cnt != fscki->calc_xcnt) {
2204 ubifs_err("inode %lu has %u xattrs, but calculated count is %lld", 2204 ubifs_err(c, "inode %lu has %u xattrs, but calculated count is %lld",
2205 (unsigned long)fscki->inum, 2205 (unsigned long)fscki->inum,
2206 fscki->xattr_cnt, fscki->calc_xcnt); 2206 fscki->xattr_cnt, fscki->calc_xcnt);
2207 goto out_dump; 2207 goto out_dump;
2208 } 2208 }
2209 if (fscki->xattr_nms != fscki->calc_xnms) { 2209 if (fscki->xattr_nms != fscki->calc_xnms) {
2210 ubifs_err("inode %lu has xattr names' size %u, but calculated names' size is %lld", 2210 ubifs_err(c, "inode %lu has xattr names' size %u, but calculated names' size is %lld",
2211 (unsigned long)fscki->inum, fscki->xattr_nms, 2211 (unsigned long)fscki->inum, fscki->xattr_nms,
2212 fscki->calc_xnms); 2212 fscki->calc_xnms);
2213 goto out_dump; 2213 goto out_dump;
@@ -2221,11 +2221,11 @@ out_dump:
2221 ino_key_init(c, &key, fscki->inum); 2221 ino_key_init(c, &key, fscki->inum);
2222 err = ubifs_lookup_level0(c, &key, &znode, &n); 2222 err = ubifs_lookup_level0(c, &key, &znode, &n);
2223 if (!err) { 2223 if (!err) {
2224 ubifs_err("inode %lu not found in index", 2224 ubifs_err(c, "inode %lu not found in index",
2225 (unsigned long)fscki->inum); 2225 (unsigned long)fscki->inum);
2226 return -ENOENT; 2226 return -ENOENT;
2227 } else if (err < 0) { 2227 } else if (err < 0) {
2228 ubifs_err("error %d while looking up inode %lu", 2228 ubifs_err(c, "error %d while looking up inode %lu",
2229 err, (unsigned long)fscki->inum); 2229 err, (unsigned long)fscki->inum);
2230 return err; 2230 return err;
2231 } 2231 }
@@ -2237,13 +2237,13 @@ out_dump:
2237 2237
2238 err = ubifs_tnc_read_node(c, zbr, ino); 2238 err = ubifs_tnc_read_node(c, zbr, ino);
2239 if (err) { 2239 if (err) {
2240 ubifs_err("cannot read inode node at LEB %d:%d, error %d", 2240 ubifs_err(c, "cannot read inode node at LEB %d:%d, error %d",
2241 zbr->lnum, zbr->offs, err); 2241 zbr->lnum, zbr->offs, err);
2242 kfree(ino); 2242 kfree(ino);
2243 return err; 2243 return err;
2244 } 2244 }
2245 2245
2246 ubifs_msg("dump of the inode %lu sitting in LEB %d:%d", 2246 ubifs_msg(c, "dump of the inode %lu sitting in LEB %d:%d",
2247 (unsigned long)fscki->inum, zbr->lnum, zbr->offs); 2247 (unsigned long)fscki->inum, zbr->lnum, zbr->offs);
2248 ubifs_dump_node(c, ino); 2248 ubifs_dump_node(c, ino);
2249 kfree(ino); 2249 kfree(ino);
@@ -2284,7 +2284,7 @@ int dbg_check_filesystem(struct ubifs_info *c)
2284 return 0; 2284 return 0;
2285 2285
2286out_free: 2286out_free:
2287 ubifs_err("file-system check failed with error %d", err); 2287 ubifs_err(c, "file-system check failed with error %d", err);
2288 dump_stack(); 2288 dump_stack();
2289 free_inodes(&fsckd); 2289 free_inodes(&fsckd);
2290 return err; 2290 return err;
@@ -2315,12 +2315,12 @@ int dbg_check_data_nodes_order(struct ubifs_info *c, struct list_head *head)
2315 sb = container_of(cur->next, struct ubifs_scan_node, list); 2315 sb = container_of(cur->next, struct ubifs_scan_node, list);
2316 2316
2317 if (sa->type != UBIFS_DATA_NODE) { 2317 if (sa->type != UBIFS_DATA_NODE) {
2318 ubifs_err("bad node type %d", sa->type); 2318 ubifs_err(c, "bad node type %d", sa->type);
2319 ubifs_dump_node(c, sa->node); 2319 ubifs_dump_node(c, sa->node);
2320 return -EINVAL; 2320 return -EINVAL;
2321 } 2321 }
2322 if (sb->type != UBIFS_DATA_NODE) { 2322 if (sb->type != UBIFS_DATA_NODE) {
2323 ubifs_err("bad node type %d", sb->type); 2323 ubifs_err(c, "bad node type %d", sb->type);
2324 ubifs_dump_node(c, sb->node); 2324 ubifs_dump_node(c, sb->node);
2325 return -EINVAL; 2325 return -EINVAL;
2326 } 2326 }
@@ -2331,7 +2331,7 @@ int dbg_check_data_nodes_order(struct ubifs_info *c, struct list_head *head)
2331 if (inuma < inumb) 2331 if (inuma < inumb)
2332 continue; 2332 continue;
2333 if (inuma > inumb) { 2333 if (inuma > inumb) {
2334 ubifs_err("larger inum %lu goes before inum %lu", 2334 ubifs_err(c, "larger inum %lu goes before inum %lu",
2335 (unsigned long)inuma, (unsigned long)inumb); 2335 (unsigned long)inuma, (unsigned long)inumb);
2336 goto error_dump; 2336 goto error_dump;
2337 } 2337 }
@@ -2340,11 +2340,11 @@ int dbg_check_data_nodes_order(struct ubifs_info *c, struct list_head *head)
2340 blkb = key_block(c, &sb->key); 2340 blkb = key_block(c, &sb->key);
2341 2341
2342 if (blka > blkb) { 2342 if (blka > blkb) {
2343 ubifs_err("larger block %u goes before %u", blka, blkb); 2343 ubifs_err(c, "larger block %u goes before %u", blka, blkb);
2344 goto error_dump; 2344 goto error_dump;
2345 } 2345 }
2346 if (blka == blkb) { 2346 if (blka == blkb) {
2347 ubifs_err("two data nodes for the same block"); 2347 ubifs_err(c, "two data nodes for the same block");
2348 goto error_dump; 2348 goto error_dump;
2349 } 2349 }
2350 } 2350 }
@@ -2383,19 +2383,19 @@ int dbg_check_nondata_nodes_order(struct ubifs_info *c, struct list_head *head)
2383 2383
2384 if (sa->type != UBIFS_INO_NODE && sa->type != UBIFS_DENT_NODE && 2384 if (sa->type != UBIFS_INO_NODE && sa->type != UBIFS_DENT_NODE &&
2385 sa->type != UBIFS_XENT_NODE) { 2385 sa->type != UBIFS_XENT_NODE) {
2386 ubifs_err("bad node type %d", sa->type); 2386 ubifs_err(c, "bad node type %d", sa->type);
2387 ubifs_dump_node(c, sa->node); 2387 ubifs_dump_node(c, sa->node);
2388 return -EINVAL; 2388 return -EINVAL;
2389 } 2389 }
2390 if (sa->type != UBIFS_INO_NODE && sa->type != UBIFS_DENT_NODE && 2390 if (sa->type != UBIFS_INO_NODE && sa->type != UBIFS_DENT_NODE &&
2391 sa->type != UBIFS_XENT_NODE) { 2391 sa->type != UBIFS_XENT_NODE) {
2392 ubifs_err("bad node type %d", sb->type); 2392 ubifs_err(c, "bad node type %d", sb->type);
2393 ubifs_dump_node(c, sb->node); 2393 ubifs_dump_node(c, sb->node);
2394 return -EINVAL; 2394 return -EINVAL;
2395 } 2395 }
2396 2396
2397 if (sa->type != UBIFS_INO_NODE && sb->type == UBIFS_INO_NODE) { 2397 if (sa->type != UBIFS_INO_NODE && sb->type == UBIFS_INO_NODE) {
2398 ubifs_err("non-inode node goes before inode node"); 2398 ubifs_err(c, "non-inode node goes before inode node");
2399 goto error_dump; 2399 goto error_dump;
2400 } 2400 }
2401 2401
@@ -2405,7 +2405,7 @@ int dbg_check_nondata_nodes_order(struct ubifs_info *c, struct list_head *head)
2405 if (sa->type == UBIFS_INO_NODE && sb->type == UBIFS_INO_NODE) { 2405 if (sa->type == UBIFS_INO_NODE && sb->type == UBIFS_INO_NODE) {
2406 /* Inode nodes are sorted in descending size order */ 2406 /* Inode nodes are sorted in descending size order */
2407 if (sa->len < sb->len) { 2407 if (sa->len < sb->len) {
2408 ubifs_err("smaller inode node goes first"); 2408 ubifs_err(c, "smaller inode node goes first");
2409 goto error_dump; 2409 goto error_dump;
2410 } 2410 }
2411 continue; 2411 continue;
@@ -2421,7 +2421,7 @@ int dbg_check_nondata_nodes_order(struct ubifs_info *c, struct list_head *head)
2421 if (inuma < inumb) 2421 if (inuma < inumb)
2422 continue; 2422 continue;
2423 if (inuma > inumb) { 2423 if (inuma > inumb) {
2424 ubifs_err("larger inum %lu goes before inum %lu", 2424 ubifs_err(c, "larger inum %lu goes before inum %lu",
2425 (unsigned long)inuma, (unsigned long)inumb); 2425 (unsigned long)inuma, (unsigned long)inumb);
2426 goto error_dump; 2426 goto error_dump;
2427 } 2427 }
@@ -2430,7 +2430,7 @@ int dbg_check_nondata_nodes_order(struct ubifs_info *c, struct list_head *head)
2430 hashb = key_block(c, &sb->key); 2430 hashb = key_block(c, &sb->key);
2431 2431
2432 if (hasha > hashb) { 2432 if (hasha > hashb) {
2433 ubifs_err("larger hash %u goes before %u", 2433 ubifs_err(c, "larger hash %u goes before %u",
2434 hasha, hashb); 2434 hasha, hashb);
2435 goto error_dump; 2435 goto error_dump;
2436 } 2436 }
@@ -2439,9 +2439,9 @@ int dbg_check_nondata_nodes_order(struct ubifs_info *c, struct list_head *head)
2439 return 0; 2439 return 0;
2440 2440
2441error_dump: 2441error_dump:
2442 ubifs_msg("dumping first node"); 2442 ubifs_msg(c, "dumping first node");
2443 ubifs_dump_node(c, sa->node); 2443 ubifs_dump_node(c, sa->node);
2444 ubifs_msg("dumping second node"); 2444 ubifs_msg(c, "dumping second node");
2445 ubifs_dump_node(c, sb->node); 2445 ubifs_dump_node(c, sb->node);
2446 return -EINVAL; 2446 return -EINVAL;
2447 return 0; 2447 return 0;
@@ -2470,13 +2470,13 @@ static int power_cut_emulated(struct ubifs_info *c, int lnum, int write)
2470 delay = prandom_u32() % 60000; 2470 delay = prandom_u32() % 60000;
2471 d->pc_timeout = jiffies; 2471 d->pc_timeout = jiffies;
2472 d->pc_timeout += msecs_to_jiffies(delay); 2472 d->pc_timeout += msecs_to_jiffies(delay);
2473 ubifs_warn("failing after %lums", delay); 2473 ubifs_warn(c, "failing after %lums", delay);
2474 } else { 2474 } else {
2475 d->pc_delay = 2; 2475 d->pc_delay = 2;
2476 delay = prandom_u32() % 10000; 2476 delay = prandom_u32() % 10000;
2477 /* Fail within 10000 operations */ 2477 /* Fail within 10000 operations */
2478 d->pc_cnt_max = delay; 2478 d->pc_cnt_max = delay;
2479 ubifs_warn("failing after %lu calls", delay); 2479 ubifs_warn(c, "failing after %lu calls", delay);
2480 } 2480 }
2481 } 2481 }
2482 2482
@@ -2494,55 +2494,55 @@ static int power_cut_emulated(struct ubifs_info *c, int lnum, int write)
2494 return 0; 2494 return 0;
2495 if (chance(19, 20)) 2495 if (chance(19, 20))
2496 return 0; 2496 return 0;
2497 ubifs_warn("failing in super block LEB %d", lnum); 2497 ubifs_warn(c, "failing in super block LEB %d", lnum);
2498 } else if (lnum == UBIFS_MST_LNUM || lnum == UBIFS_MST_LNUM + 1) { 2498 } else if (lnum == UBIFS_MST_LNUM || lnum == UBIFS_MST_LNUM + 1) {
2499 if (chance(19, 20)) 2499 if (chance(19, 20))
2500 return 0; 2500 return 0;
2501 ubifs_warn("failing in master LEB %d", lnum); 2501 ubifs_warn(c, "failing in master LEB %d", lnum);
2502 } else if (lnum >= UBIFS_LOG_LNUM && lnum <= c->log_last) { 2502 } else if (lnum >= UBIFS_LOG_LNUM && lnum <= c->log_last) {
2503 if (write && chance(99, 100)) 2503 if (write && chance(99, 100))
2504 return 0; 2504 return 0;
2505 if (chance(399, 400)) 2505 if (chance(399, 400))
2506 return 0; 2506 return 0;
2507 ubifs_warn("failing in log LEB %d", lnum); 2507 ubifs_warn(c, "failing in log LEB %d", lnum);
2508 } else if (lnum >= c->lpt_first && lnum <= c->lpt_last) { 2508 } else if (lnum >= c->lpt_first && lnum <= c->lpt_last) {
2509 if (write && chance(7, 8)) 2509 if (write && chance(7, 8))
2510 return 0; 2510 return 0;
2511 if (chance(19, 20)) 2511 if (chance(19, 20))
2512 return 0; 2512 return 0;
2513 ubifs_warn("failing in LPT LEB %d", lnum); 2513 ubifs_warn(c, "failing in LPT LEB %d", lnum);
2514 } else if (lnum >= c->orph_first && lnum <= c->orph_last) { 2514 } else if (lnum >= c->orph_first && lnum <= c->orph_last) {
2515 if (write && chance(1, 2)) 2515 if (write && chance(1, 2))
2516 return 0; 2516 return 0;
2517 if (chance(9, 10)) 2517 if (chance(9, 10))
2518 return 0; 2518 return 0;
2519 ubifs_warn("failing in orphan LEB %d", lnum); 2519 ubifs_warn(c, "failing in orphan LEB %d", lnum);
2520 } else if (lnum == c->ihead_lnum) { 2520 } else if (lnum == c->ihead_lnum) {
2521 if (chance(99, 100)) 2521 if (chance(99, 100))
2522 return 0; 2522 return 0;
2523 ubifs_warn("failing in index head LEB %d", lnum); 2523 ubifs_warn(c, "failing in index head LEB %d", lnum);
2524 } else if (c->jheads && lnum == c->jheads[GCHD].wbuf.lnum) { 2524 } else if (c->jheads && lnum == c->jheads[GCHD].wbuf.lnum) {
2525 if (chance(9, 10)) 2525 if (chance(9, 10))
2526 return 0; 2526 return 0;
2527 ubifs_warn("failing in GC head LEB %d", lnum); 2527 ubifs_warn(c, "failing in GC head LEB %d", lnum);
2528 } else if (write && !RB_EMPTY_ROOT(&c->buds) && 2528 } else if (write && !RB_EMPTY_ROOT(&c->buds) &&
2529 !ubifs_search_bud(c, lnum)) { 2529 !ubifs_search_bud(c, lnum)) {
2530 if (chance(19, 20)) 2530 if (chance(19, 20))
2531 return 0; 2531 return 0;
2532 ubifs_warn("failing in non-bud LEB %d", lnum); 2532 ubifs_warn(c, "failing in non-bud LEB %d", lnum);
2533 } else if (c->cmt_state == COMMIT_RUNNING_BACKGROUND || 2533 } else if (c->cmt_state == COMMIT_RUNNING_BACKGROUND ||
2534 c->cmt_state == COMMIT_RUNNING_REQUIRED) { 2534 c->cmt_state == COMMIT_RUNNING_REQUIRED) {
2535 if (chance(999, 1000)) 2535 if (chance(999, 1000))
2536 return 0; 2536 return 0;
2537 ubifs_warn("failing in bud LEB %d commit running", lnum); 2537 ubifs_warn(c, "failing in bud LEB %d commit running", lnum);
2538 } else { 2538 } else {
2539 if (chance(9999, 10000)) 2539 if (chance(9999, 10000))
2540 return 0; 2540 return 0;
2541 ubifs_warn("failing in bud LEB %d commit not running", lnum); 2541 ubifs_warn(c, "failing in bud LEB %d commit not running", lnum);
2542 } 2542 }
2543 2543
2544 d->pc_happened = 1; 2544 d->pc_happened = 1;
2545 ubifs_warn("========== Power cut emulated =========="); 2545 ubifs_warn(c, "========== Power cut emulated ==========");
2546 dump_stack(); 2546 dump_stack();
2547 return 1; 2547 return 1;
2548} 2548}
@@ -2557,7 +2557,7 @@ static int corrupt_data(const struct ubifs_info *c, const void *buf,
2557 /* Corruption span max to end of write unit */ 2557 /* Corruption span max to end of write unit */
2558 to = min(len, ALIGN(from + 1, c->max_write_size)); 2558 to = min(len, ALIGN(from + 1, c->max_write_size));
2559 2559
2560 ubifs_warn("filled bytes %u-%u with %s", from, to - 1, 2560 ubifs_warn(c, "filled bytes %u-%u with %s", from, to - 1,
2561 ffs ? "0xFFs" : "random data"); 2561 ffs ? "0xFFs" : "random data");
2562 2562
2563 if (ffs) 2563 if (ffs)
@@ -2579,7 +2579,7 @@ int dbg_leb_write(struct ubifs_info *c, int lnum, const void *buf,
2579 failing = power_cut_emulated(c, lnum, 1); 2579 failing = power_cut_emulated(c, lnum, 1);
2580 if (failing) { 2580 if (failing) {
2581 len = corrupt_data(c, buf, len); 2581 len = corrupt_data(c, buf, len);
2582 ubifs_warn("actually write %d bytes to LEB %d:%d (the buffer was corrupted)", 2582 ubifs_warn(c, "actually write %d bytes to LEB %d:%d (the buffer was corrupted)",
2583 len, lnum, offs); 2583 len, lnum, offs);
2584 } 2584 }
2585 err = ubi_leb_write(c->ubi, lnum, buf, offs, len); 2585 err = ubi_leb_write(c->ubi, lnum, buf, offs, len);
@@ -2909,7 +2909,7 @@ out_remove:
2909 debugfs_remove_recursive(d->dfs_dir); 2909 debugfs_remove_recursive(d->dfs_dir);
2910out: 2910out:
2911 err = dent ? PTR_ERR(dent) : -ENODEV; 2911 err = dent ? PTR_ERR(dent) : -ENODEV;
2912 ubifs_err("cannot create \"%s\" debugfs file or directory, error %d\n", 2912 ubifs_err(c, "cannot create \"%s\" debugfs file or directory, error %d\n",
2913 fname, err); 2913 fname, err);
2914 return err; 2914 return err;
2915} 2915}
@@ -3063,8 +3063,8 @@ out_remove:
3063 debugfs_remove_recursive(dfs_rootdir); 3063 debugfs_remove_recursive(dfs_rootdir);
3064out: 3064out:
3065 err = dent ? PTR_ERR(dent) : -ENODEV; 3065 err = dent ? PTR_ERR(dent) : -ENODEV;
3066 ubifs_err("cannot create \"%s\" debugfs file or directory, error %d\n", 3066 pr_err("UBIFS error (pid %d): cannot create \"%s\" debugfs file or directory, error %d\n",
3067 fname, err); 3067 current->pid, fname, err);
3068 return err; 3068 return err;
3069} 3069}
3070 3070
diff --git a/fs/ubifs/dir.c b/fs/ubifs/dir.c
index 5b24bc42cad9..90fe60c2f112 100644
--- a/fs/ubifs/dir.c
+++ b/fs/ubifs/dir.c
@@ -146,12 +146,12 @@ struct inode *ubifs_new_inode(struct ubifs_info *c, const struct inode *dir,
146 if (c->highest_inum >= INUM_WARN_WATERMARK) { 146 if (c->highest_inum >= INUM_WARN_WATERMARK) {
147 if (c->highest_inum >= INUM_WATERMARK) { 147 if (c->highest_inum >= INUM_WATERMARK) {
148 spin_unlock(&c->cnt_lock); 148 spin_unlock(&c->cnt_lock);
149 ubifs_err("out of inode numbers"); 149 ubifs_err(c, "out of inode numbers");
150 make_bad_inode(inode); 150 make_bad_inode(inode);
151 iput(inode); 151 iput(inode);
152 return ERR_PTR(-EINVAL); 152 return ERR_PTR(-EINVAL);
153 } 153 }
154 ubifs_warn("running out of inode numbers (current %lu, max %d)", 154 ubifs_warn(c, "running out of inode numbers (current %lu, max %d)",
155 (unsigned long)c->highest_inum, INUM_WATERMARK); 155 (unsigned long)c->highest_inum, INUM_WATERMARK);
156 } 156 }
157 157
@@ -222,7 +222,7 @@ static struct dentry *ubifs_lookup(struct inode *dir, struct dentry *dentry,
222 * checking. 222 * checking.
223 */ 223 */
224 err = PTR_ERR(inode); 224 err = PTR_ERR(inode);
225 ubifs_err("dead directory entry '%pd', error %d", 225 ubifs_err(c, "dead directory entry '%pd', error %d",
226 dentry, err); 226 dentry, err);
227 ubifs_ro_mode(c, err); 227 ubifs_ro_mode(c, err);
228 goto out; 228 goto out;
@@ -297,7 +297,7 @@ out_inode:
297 iput(inode); 297 iput(inode);
298out_budg: 298out_budg:
299 ubifs_release_budget(c, &req); 299 ubifs_release_budget(c, &req);
300 ubifs_err("cannot create regular file, error %d", err); 300 ubifs_err(c, "cannot create regular file, error %d", err);
301 return err; 301 return err;
302} 302}
303 303
@@ -450,7 +450,7 @@ static int ubifs_readdir(struct file *file, struct dir_context *ctx)
450 450
451out: 451out:
452 if (err != -ENOENT) { 452 if (err != -ENOENT) {
453 ubifs_err("cannot find next direntry, error %d", err); 453 ubifs_err(c, "cannot find next direntry, error %d", err);
454 return err; 454 return err;
455 } 455 }
456 456
@@ -744,7 +744,7 @@ static int ubifs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
744 dir->i_mtime = dir->i_ctime = inode->i_ctime; 744 dir->i_mtime = dir->i_ctime = inode->i_ctime;
745 err = ubifs_jnl_update(c, dir, &dentry->d_name, inode, 0, 0); 745 err = ubifs_jnl_update(c, dir, &dentry->d_name, inode, 0, 0);
746 if (err) { 746 if (err) {
747 ubifs_err("cannot create directory, error %d", err); 747 ubifs_err(c, "cannot create directory, error %d", err);
748 goto out_cancel; 748 goto out_cancel;
749 } 749 }
750 mutex_unlock(&dir_ui->ui_mutex); 750 mutex_unlock(&dir_ui->ui_mutex);
diff --git a/fs/ubifs/file.c b/fs/ubifs/file.c
index e627c0acf626..9cd12976ed1b 100644
--- a/fs/ubifs/file.c
+++ b/fs/ubifs/file.c
@@ -80,7 +80,7 @@ static int read_block(struct inode *inode, void *addr, unsigned int block,
80 80
81 dlen = le32_to_cpu(dn->ch.len) - UBIFS_DATA_NODE_SZ; 81 dlen = le32_to_cpu(dn->ch.len) - UBIFS_DATA_NODE_SZ;
82 out_len = UBIFS_BLOCK_SIZE; 82 out_len = UBIFS_BLOCK_SIZE;
83 err = ubifs_decompress(&dn->data, dlen, addr, &out_len, 83 err = ubifs_decompress(c, &dn->data, dlen, addr, &out_len,
84 le16_to_cpu(dn->compr_type)); 84 le16_to_cpu(dn->compr_type));
85 if (err || len != out_len) 85 if (err || len != out_len)
86 goto dump; 86 goto dump;
@@ -96,7 +96,7 @@ static int read_block(struct inode *inode, void *addr, unsigned int block,
96 return 0; 96 return 0;
97 97
98dump: 98dump:
99 ubifs_err("bad data node (block %u, inode %lu)", 99 ubifs_err(c, "bad data node (block %u, inode %lu)",
100 block, inode->i_ino); 100 block, inode->i_ino);
101 ubifs_dump_node(c, dn); 101 ubifs_dump_node(c, dn);
102 return -EINVAL; 102 return -EINVAL;
@@ -161,13 +161,14 @@ static int do_readpage(struct page *page)
161 addr += UBIFS_BLOCK_SIZE; 161 addr += UBIFS_BLOCK_SIZE;
162 } 162 }
163 if (err) { 163 if (err) {
164 struct ubifs_info *c = inode->i_sb->s_fs_info;
164 if (err == -ENOENT) { 165 if (err == -ENOENT) {
165 /* Not found, so it must be a hole */ 166 /* Not found, so it must be a hole */
166 SetPageChecked(page); 167 SetPageChecked(page);
167 dbg_gen("hole"); 168 dbg_gen("hole");
168 goto out_free; 169 goto out_free;
169 } 170 }
170 ubifs_err("cannot read page %lu of inode %lu, error %d", 171 ubifs_err(c, "cannot read page %lu of inode %lu, error %d",
171 page->index, inode->i_ino, err); 172 page->index, inode->i_ino, err);
172 goto error; 173 goto error;
173 } 174 }
@@ -650,7 +651,7 @@ static int populate_page(struct ubifs_info *c, struct page *page,
650 651
651 dlen = le32_to_cpu(dn->ch.len) - UBIFS_DATA_NODE_SZ; 652 dlen = le32_to_cpu(dn->ch.len) - UBIFS_DATA_NODE_SZ;
652 out_len = UBIFS_BLOCK_SIZE; 653 out_len = UBIFS_BLOCK_SIZE;
653 err = ubifs_decompress(&dn->data, dlen, addr, &out_len, 654 err = ubifs_decompress(c, &dn->data, dlen, addr, &out_len,
654 le16_to_cpu(dn->compr_type)); 655 le16_to_cpu(dn->compr_type));
655 if (err || len != out_len) 656 if (err || len != out_len)
656 goto out_err; 657 goto out_err;
@@ -698,7 +699,7 @@ out_err:
698 SetPageError(page); 699 SetPageError(page);
699 flush_dcache_page(page); 700 flush_dcache_page(page);
700 kunmap(page); 701 kunmap(page);
701 ubifs_err("bad data node (block %u, inode %lu)", 702 ubifs_err(c, "bad data node (block %u, inode %lu)",
702 page_block, inode->i_ino); 703 page_block, inode->i_ino);
703 return -EINVAL; 704 return -EINVAL;
704} 705}
@@ -802,7 +803,7 @@ out_free:
802 return ret; 803 return ret;
803 804
804out_warn: 805out_warn:
805 ubifs_warn("ignoring error %d and skipping bulk-read", err); 806 ubifs_warn(c, "ignoring error %d and skipping bulk-read", err);
806 goto out_free; 807 goto out_free;
807 808
808out_bu_off: 809out_bu_off:
@@ -930,7 +931,7 @@ static int do_writepage(struct page *page, int len)
930 } 931 }
931 if (err) { 932 if (err) {
932 SetPageError(page); 933 SetPageError(page);
933 ubifs_err("cannot write page %lu of inode %lu, error %d", 934 ubifs_err(c, "cannot write page %lu of inode %lu, error %d",
934 page->index, inode->i_ino, err); 935 page->index, inode->i_ino, err);
935 ubifs_ro_mode(c, err); 936 ubifs_ro_mode(c, err);
936 } 937 }
@@ -1485,7 +1486,7 @@ static int ubifs_vm_page_mkwrite(struct vm_area_struct *vma,
1485 err = ubifs_budget_space(c, &req); 1486 err = ubifs_budget_space(c, &req);
1486 if (unlikely(err)) { 1487 if (unlikely(err)) {
1487 if (err == -ENOSPC) 1488 if (err == -ENOSPC)
1488 ubifs_warn("out of space for mmapped file (inode number %lu)", 1489 ubifs_warn(c, "out of space for mmapped file (inode number %lu)",
1489 inode->i_ino); 1490 inode->i_ino);
1490 return VM_FAULT_SIGBUS; 1491 return VM_FAULT_SIGBUS;
1491 } 1492 }
diff --git a/fs/ubifs/io.c b/fs/ubifs/io.c
index fb08b0c514b6..97be41215332 100644
--- a/fs/ubifs/io.c
+++ b/fs/ubifs/io.c
@@ -85,7 +85,7 @@ void ubifs_ro_mode(struct ubifs_info *c, int err)
85 c->ro_error = 1; 85 c->ro_error = 1;
86 c->no_chk_data_crc = 0; 86 c->no_chk_data_crc = 0;
87 c->vfs_sb->s_flags |= MS_RDONLY; 87 c->vfs_sb->s_flags |= MS_RDONLY;
88 ubifs_warn("switched to read-only mode, error %d", err); 88 ubifs_warn(c, "switched to read-only mode, error %d", err);
89 dump_stack(); 89 dump_stack();
90 } 90 }
91} 91}
@@ -107,7 +107,7 @@ int ubifs_leb_read(const struct ubifs_info *c, int lnum, void *buf, int offs,
107 * @even_ebadmsg is true. 107 * @even_ebadmsg is true.
108 */ 108 */
109 if (err && (err != -EBADMSG || even_ebadmsg)) { 109 if (err && (err != -EBADMSG || even_ebadmsg)) {
110 ubifs_err("reading %d bytes from LEB %d:%d failed, error %d", 110 ubifs_err(c, "reading %d bytes from LEB %d:%d failed, error %d",
111 len, lnum, offs, err); 111 len, lnum, offs, err);
112 dump_stack(); 112 dump_stack();
113 } 113 }
@@ -127,7 +127,7 @@ int ubifs_leb_write(struct ubifs_info *c, int lnum, const void *buf, int offs,
127 else 127 else
128 err = dbg_leb_write(c, lnum, buf, offs, len); 128 err = dbg_leb_write(c, lnum, buf, offs, len);
129 if (err) { 129 if (err) {
130 ubifs_err("writing %d bytes to LEB %d:%d failed, error %d", 130 ubifs_err(c, "writing %d bytes to LEB %d:%d failed, error %d",
131 len, lnum, offs, err); 131 len, lnum, offs, err);
132 ubifs_ro_mode(c, err); 132 ubifs_ro_mode(c, err);
133 dump_stack(); 133 dump_stack();
@@ -147,7 +147,7 @@ int ubifs_leb_change(struct ubifs_info *c, int lnum, const void *buf, int len)
147 else 147 else
148 err = dbg_leb_change(c, lnum, buf, len); 148 err = dbg_leb_change(c, lnum, buf, len);
149 if (err) { 149 if (err) {
150 ubifs_err("changing %d bytes in LEB %d failed, error %d", 150 ubifs_err(c, "changing %d bytes in LEB %d failed, error %d",
151 len, lnum, err); 151 len, lnum, err);
152 ubifs_ro_mode(c, err); 152 ubifs_ro_mode(c, err);
153 dump_stack(); 153 dump_stack();
@@ -167,7 +167,7 @@ int ubifs_leb_unmap(struct ubifs_info *c, int lnum)
167 else 167 else
168 err = dbg_leb_unmap(c, lnum); 168 err = dbg_leb_unmap(c, lnum);
169 if (err) { 169 if (err) {
170 ubifs_err("unmap LEB %d failed, error %d", lnum, err); 170 ubifs_err(c, "unmap LEB %d failed, error %d", lnum, err);
171 ubifs_ro_mode(c, err); 171 ubifs_ro_mode(c, err);
172 dump_stack(); 172 dump_stack();
173 } 173 }
@@ -186,7 +186,7 @@ int ubifs_leb_map(struct ubifs_info *c, int lnum)
186 else 186 else
187 err = dbg_leb_map(c, lnum); 187 err = dbg_leb_map(c, lnum);
188 if (err) { 188 if (err) {
189 ubifs_err("mapping LEB %d failed, error %d", lnum, err); 189 ubifs_err(c, "mapping LEB %d failed, error %d", lnum, err);
190 ubifs_ro_mode(c, err); 190 ubifs_ro_mode(c, err);
191 dump_stack(); 191 dump_stack();
192 } 192 }
@@ -199,7 +199,7 @@ int ubifs_is_mapped(const struct ubifs_info *c, int lnum)
199 199
200 err = ubi_is_mapped(c->ubi, lnum); 200 err = ubi_is_mapped(c->ubi, lnum);
201 if (err < 0) { 201 if (err < 0) {
202 ubifs_err("ubi_is_mapped failed for LEB %d, error %d", 202 ubifs_err(c, "ubi_is_mapped failed for LEB %d, error %d",
203 lnum, err); 203 lnum, err);
204 dump_stack(); 204 dump_stack();
205 } 205 }
@@ -247,7 +247,7 @@ int ubifs_check_node(const struct ubifs_info *c, const void *buf, int lnum,
247 magic = le32_to_cpu(ch->magic); 247 magic = le32_to_cpu(ch->magic);
248 if (magic != UBIFS_NODE_MAGIC) { 248 if (magic != UBIFS_NODE_MAGIC) {
249 if (!quiet) 249 if (!quiet)
250 ubifs_err("bad magic %#08x, expected %#08x", 250 ubifs_err(c, "bad magic %#08x, expected %#08x",
251 magic, UBIFS_NODE_MAGIC); 251 magic, UBIFS_NODE_MAGIC);
252 err = -EUCLEAN; 252 err = -EUCLEAN;
253 goto out; 253 goto out;
@@ -256,7 +256,7 @@ int ubifs_check_node(const struct ubifs_info *c, const void *buf, int lnum,
256 type = ch->node_type; 256 type = ch->node_type;
257 if (type < 0 || type >= UBIFS_NODE_TYPES_CNT) { 257 if (type < 0 || type >= UBIFS_NODE_TYPES_CNT) {
258 if (!quiet) 258 if (!quiet)
259 ubifs_err("bad node type %d", type); 259 ubifs_err(c, "bad node type %d", type);
260 goto out; 260 goto out;
261 } 261 }
262 262
@@ -279,7 +279,7 @@ int ubifs_check_node(const struct ubifs_info *c, const void *buf, int lnum,
279 node_crc = le32_to_cpu(ch->crc); 279 node_crc = le32_to_cpu(ch->crc);
280 if (crc != node_crc) { 280 if (crc != node_crc) {
281 if (!quiet) 281 if (!quiet)
282 ubifs_err("bad CRC: calculated %#08x, read %#08x", 282 ubifs_err(c, "bad CRC: calculated %#08x, read %#08x",
283 crc, node_crc); 283 crc, node_crc);
284 err = -EUCLEAN; 284 err = -EUCLEAN;
285 goto out; 285 goto out;
@@ -289,10 +289,10 @@ int ubifs_check_node(const struct ubifs_info *c, const void *buf, int lnum,
289 289
290out_len: 290out_len:
291 if (!quiet) 291 if (!quiet)
292 ubifs_err("bad node length %d", node_len); 292 ubifs_err(c, "bad node length %d", node_len);
293out: 293out:
294 if (!quiet) { 294 if (!quiet) {
295 ubifs_err("bad node at LEB %d:%d", lnum, offs); 295 ubifs_err(c, "bad node at LEB %d:%d", lnum, offs);
296 ubifs_dump_node(c, buf); 296 ubifs_dump_node(c, buf);
297 dump_stack(); 297 dump_stack();
298 } 298 }
@@ -355,11 +355,11 @@ static unsigned long long next_sqnum(struct ubifs_info *c)
355 355
356 if (unlikely(sqnum >= SQNUM_WARN_WATERMARK)) { 356 if (unlikely(sqnum >= SQNUM_WARN_WATERMARK)) {
357 if (sqnum >= SQNUM_WATERMARK) { 357 if (sqnum >= SQNUM_WATERMARK) {
358 ubifs_err("sequence number overflow %llu, end of life", 358 ubifs_err(c, "sequence number overflow %llu, end of life",
359 sqnum); 359 sqnum);
360 ubifs_ro_mode(c, -EINVAL); 360 ubifs_ro_mode(c, -EINVAL);
361 } 361 }
362 ubifs_warn("running out of sequence numbers, end of life soon"); 362 ubifs_warn(c, "running out of sequence numbers, end of life soon");
363 } 363 }
364 364
365 return sqnum; 365 return sqnum;
@@ -636,7 +636,7 @@ int ubifs_bg_wbufs_sync(struct ubifs_info *c)
636 err = ubifs_wbuf_sync_nolock(wbuf); 636 err = ubifs_wbuf_sync_nolock(wbuf);
637 mutex_unlock(&wbuf->io_mutex); 637 mutex_unlock(&wbuf->io_mutex);
638 if (err) { 638 if (err) {
639 ubifs_err("cannot sync write-buffer, error %d", err); 639 ubifs_err(c, "cannot sync write-buffer, error %d", err);
640 ubifs_ro_mode(c, err); 640 ubifs_ro_mode(c, err);
641 goto out_timers; 641 goto out_timers;
642 } 642 }
@@ -833,7 +833,7 @@ exit:
833 return 0; 833 return 0;
834 834
835out: 835out:
836 ubifs_err("cannot write %d bytes to LEB %d:%d, error %d", 836 ubifs_err(c, "cannot write %d bytes to LEB %d:%d, error %d",
837 len, wbuf->lnum, wbuf->offs, err); 837 len, wbuf->lnum, wbuf->offs, err);
838 ubifs_dump_node(c, buf); 838 ubifs_dump_node(c, buf);
839 dump_stack(); 839 dump_stack();
@@ -932,27 +932,27 @@ int ubifs_read_node_wbuf(struct ubifs_wbuf *wbuf, void *buf, int type, int len,
932 } 932 }
933 933
934 if (type != ch->node_type) { 934 if (type != ch->node_type) {
935 ubifs_err("bad node type (%d but expected %d)", 935 ubifs_err(c, "bad node type (%d but expected %d)",
936 ch->node_type, type); 936 ch->node_type, type);
937 goto out; 937 goto out;
938 } 938 }
939 939
940 err = ubifs_check_node(c, buf, lnum, offs, 0, 0); 940 err = ubifs_check_node(c, buf, lnum, offs, 0, 0);
941 if (err) { 941 if (err) {
942 ubifs_err("expected node type %d", type); 942 ubifs_err(c, "expected node type %d", type);
943 return err; 943 return err;
944 } 944 }
945 945
946 rlen = le32_to_cpu(ch->len); 946 rlen = le32_to_cpu(ch->len);
947 if (rlen != len) { 947 if (rlen != len) {
948 ubifs_err("bad node length %d, expected %d", rlen, len); 948 ubifs_err(c, "bad node length %d, expected %d", rlen, len);
949 goto out; 949 goto out;
950 } 950 }
951 951
952 return 0; 952 return 0;
953 953
954out: 954out:
955 ubifs_err("bad node at LEB %d:%d", lnum, offs); 955 ubifs_err(c, "bad node at LEB %d:%d", lnum, offs);
956 ubifs_dump_node(c, buf); 956 ubifs_dump_node(c, buf);
957 dump_stack(); 957 dump_stack();
958 return -EINVAL; 958 return -EINVAL;
diff --git a/fs/ubifs/ioctl.c b/fs/ubifs/ioctl.c
index 648b143606cc..3c7b29de0ca7 100644
--- a/fs/ubifs/ioctl.c
+++ b/fs/ubifs/ioctl.c
@@ -138,7 +138,7 @@ static int setflags(struct inode *inode, int flags)
138 return err; 138 return err;
139 139
140out_unlock: 140out_unlock:
141 ubifs_err("can't modify inode %lu attributes", inode->i_ino); 141 ubifs_err(c, "can't modify inode %lu attributes", inode->i_ino);
142 mutex_unlock(&ui->ui_mutex); 142 mutex_unlock(&ui->ui_mutex);
143 ubifs_release_budget(c, &req); 143 ubifs_release_budget(c, &req);
144 return err; 144 return err;
diff --git a/fs/ubifs/journal.c b/fs/ubifs/journal.c
index f6ac3f29323c..90ae1a8439d9 100644
--- a/fs/ubifs/journal.c
+++ b/fs/ubifs/journal.c
@@ -363,11 +363,11 @@ again:
363 * This should not happen unless the journal size limitations 363 * This should not happen unless the journal size limitations
364 * are too tough. 364 * are too tough.
365 */ 365 */
366 ubifs_err("stuck in space allocation"); 366 ubifs_err(c, "stuck in space allocation");
367 err = -ENOSPC; 367 err = -ENOSPC;
368 goto out; 368 goto out;
369 } else if (cmt_retries > 32) 369 } else if (cmt_retries > 32)
370 ubifs_warn("too many space allocation re-tries (%d)", 370 ubifs_warn(c, "too many space allocation re-tries (%d)",
371 cmt_retries); 371 cmt_retries);
372 372
373 dbg_jnl("-EAGAIN, commit and retry (retried %d times)", 373 dbg_jnl("-EAGAIN, commit and retry (retried %d times)",
@@ -380,7 +380,7 @@ again:
380 goto again; 380 goto again;
381 381
382out: 382out:
383 ubifs_err("cannot reserve %d bytes in jhead %d, error %d", 383 ubifs_err(c, "cannot reserve %d bytes in jhead %d, error %d",
384 len, jhead, err); 384 len, jhead, err);
385 if (err == -ENOSPC) { 385 if (err == -ENOSPC) {
386 /* This are some budgeting problems, print useful information */ 386 /* This are some budgeting problems, print useful information */
@@ -731,7 +731,7 @@ int ubifs_jnl_write_data(struct ubifs_info *c, const struct inode *inode,
731 compr_type = ui->compr_type; 731 compr_type = ui->compr_type;
732 732
733 out_len = dlen - UBIFS_DATA_NODE_SZ; 733 out_len = dlen - UBIFS_DATA_NODE_SZ;
734 ubifs_compress(buf, len, &data->data, &out_len, &compr_type); 734 ubifs_compress(c, buf, len, &data->data, &out_len, &compr_type);
735 ubifs_assert(out_len <= UBIFS_BLOCK_SIZE); 735 ubifs_assert(out_len <= UBIFS_BLOCK_SIZE);
736 736
737 dlen = UBIFS_DATA_NODE_SZ + out_len; 737 dlen = UBIFS_DATA_NODE_SZ + out_len;
@@ -1100,7 +1100,8 @@ out_free:
1100 * This function is used when an inode is truncated and the last data node of 1100 * This function is used when an inode is truncated and the last data node of
1101 * the inode has to be re-compressed and re-written. 1101 * the inode has to be re-compressed and re-written.
1102 */ 1102 */
1103static int recomp_data_node(struct ubifs_data_node *dn, int *new_len) 1103static int recomp_data_node(const struct ubifs_info *c,
1104 struct ubifs_data_node *dn, int *new_len)
1104{ 1105{
1105 void *buf; 1106 void *buf;
1106 int err, len, compr_type, out_len; 1107 int err, len, compr_type, out_len;
@@ -1112,11 +1113,11 @@ static int recomp_data_node(struct ubifs_data_node *dn, int *new_len)
1112 1113
1113 len = le32_to_cpu(dn->ch.len) - UBIFS_DATA_NODE_SZ; 1114 len = le32_to_cpu(dn->ch.len) - UBIFS_DATA_NODE_SZ;
1114 compr_type = le16_to_cpu(dn->compr_type); 1115 compr_type = le16_to_cpu(dn->compr_type);
1115 err = ubifs_decompress(&dn->data, len, buf, &out_len, compr_type); 1116 err = ubifs_decompress(c, &dn->data, len, buf, &out_len, compr_type);
1116 if (err) 1117 if (err)
1117 goto out; 1118 goto out;
1118 1119
1119 ubifs_compress(buf, *new_len, &dn->data, &out_len, &compr_type); 1120 ubifs_compress(c, buf, *new_len, &dn->data, &out_len, &compr_type);
1120 ubifs_assert(out_len <= UBIFS_BLOCK_SIZE); 1121 ubifs_assert(out_len <= UBIFS_BLOCK_SIZE);
1121 dn->compr_type = cpu_to_le16(compr_type); 1122 dn->compr_type = cpu_to_le16(compr_type);
1122 dn->size = cpu_to_le32(*new_len); 1123 dn->size = cpu_to_le32(*new_len);
@@ -1191,7 +1192,7 @@ int ubifs_jnl_truncate(struct ubifs_info *c, const struct inode *inode,
1191 int compr_type = le16_to_cpu(dn->compr_type); 1192 int compr_type = le16_to_cpu(dn->compr_type);
1192 1193
1193 if (compr_type != UBIFS_COMPR_NONE) { 1194 if (compr_type != UBIFS_COMPR_NONE) {
1194 err = recomp_data_node(dn, &dlen); 1195 err = recomp_data_node(c, dn, &dlen);
1195 if (err) 1196 if (err)
1196 goto out_free; 1197 goto out_free;
1197 } else { 1198 } else {
diff --git a/fs/ubifs/log.c b/fs/ubifs/log.c
index c14628fbeee2..8c795e6392b1 100644
--- a/fs/ubifs/log.c
+++ b/fs/ubifs/log.c
@@ -696,7 +696,7 @@ int ubifs_consolidate_log(struct ubifs_info *c)
696 destroy_done_tree(&done_tree); 696 destroy_done_tree(&done_tree);
697 vfree(buf); 697 vfree(buf);
698 if (write_lnum == c->lhead_lnum) { 698 if (write_lnum == c->lhead_lnum) {
699 ubifs_err("log is too full"); 699 ubifs_err(c, "log is too full");
700 return -EINVAL; 700 return -EINVAL;
701 } 701 }
702 /* Unmap remaining LEBs */ 702 /* Unmap remaining LEBs */
@@ -743,7 +743,7 @@ static int dbg_check_bud_bytes(struct ubifs_info *c)
743 bud_bytes += c->leb_size - bud->start; 743 bud_bytes += c->leb_size - bud->start;
744 744
745 if (c->bud_bytes != bud_bytes) { 745 if (c->bud_bytes != bud_bytes) {
746 ubifs_err("bad bud_bytes %lld, calculated %lld", 746 ubifs_err(c, "bad bud_bytes %lld, calculated %lld",
747 c->bud_bytes, bud_bytes); 747 c->bud_bytes, bud_bytes);
748 err = -EINVAL; 748 err = -EINVAL;
749 } 749 }
diff --git a/fs/ubifs/lprops.c b/fs/ubifs/lprops.c
index 46190a7c42a6..a0011aa3a779 100644
--- a/fs/ubifs/lprops.c
+++ b/fs/ubifs/lprops.c
@@ -682,7 +682,7 @@ int ubifs_change_one_lp(struct ubifs_info *c, int lnum, int free, int dirty,
682out: 682out:
683 ubifs_release_lprops(c); 683 ubifs_release_lprops(c);
684 if (err) 684 if (err)
685 ubifs_err("cannot change properties of LEB %d, error %d", 685 ubifs_err(c, "cannot change properties of LEB %d, error %d",
686 lnum, err); 686 lnum, err);
687 return err; 687 return err;
688} 688}
@@ -721,7 +721,7 @@ int ubifs_update_one_lp(struct ubifs_info *c, int lnum, int free, int dirty,
721out: 721out:
722 ubifs_release_lprops(c); 722 ubifs_release_lprops(c);
723 if (err) 723 if (err)
724 ubifs_err("cannot update properties of LEB %d, error %d", 724 ubifs_err(c, "cannot update properties of LEB %d, error %d",
725 lnum, err); 725 lnum, err);
726 return err; 726 return err;
727} 727}
@@ -746,7 +746,7 @@ int ubifs_read_one_lp(struct ubifs_info *c, int lnum, struct ubifs_lprops *lp)
746 lpp = ubifs_lpt_lookup(c, lnum); 746 lpp = ubifs_lpt_lookup(c, lnum);
747 if (IS_ERR(lpp)) { 747 if (IS_ERR(lpp)) {
748 err = PTR_ERR(lpp); 748 err = PTR_ERR(lpp);
749 ubifs_err("cannot read properties of LEB %d, error %d", 749 ubifs_err(c, "cannot read properties of LEB %d, error %d",
750 lnum, err); 750 lnum, err);
751 goto out; 751 goto out;
752 } 752 }
@@ -873,13 +873,13 @@ int dbg_check_cats(struct ubifs_info *c)
873 873
874 list_for_each_entry(lprops, &c->empty_list, list) { 874 list_for_each_entry(lprops, &c->empty_list, list) {
875 if (lprops->free != c->leb_size) { 875 if (lprops->free != c->leb_size) {
876 ubifs_err("non-empty LEB %d on empty list (free %d dirty %d flags %d)", 876 ubifs_err(c, "non-empty LEB %d on empty list (free %d dirty %d flags %d)",
877 lprops->lnum, lprops->free, lprops->dirty, 877 lprops->lnum, lprops->free, lprops->dirty,
878 lprops->flags); 878 lprops->flags);
879 return -EINVAL; 879 return -EINVAL;
880 } 880 }
881 if (lprops->flags & LPROPS_TAKEN) { 881 if (lprops->flags & LPROPS_TAKEN) {
882 ubifs_err("taken LEB %d on empty list (free %d dirty %d flags %d)", 882 ubifs_err(c, "taken LEB %d on empty list (free %d dirty %d flags %d)",
883 lprops->lnum, lprops->free, lprops->dirty, 883 lprops->lnum, lprops->free, lprops->dirty,
884 lprops->flags); 884 lprops->flags);
885 return -EINVAL; 885 return -EINVAL;
@@ -889,13 +889,13 @@ int dbg_check_cats(struct ubifs_info *c)
889 i = 0; 889 i = 0;
890 list_for_each_entry(lprops, &c->freeable_list, list) { 890 list_for_each_entry(lprops, &c->freeable_list, list) {
891 if (lprops->free + lprops->dirty != c->leb_size) { 891 if (lprops->free + lprops->dirty != c->leb_size) {
892 ubifs_err("non-freeable LEB %d on freeable list (free %d dirty %d flags %d)", 892 ubifs_err(c, "non-freeable LEB %d on freeable list (free %d dirty %d flags %d)",
893 lprops->lnum, lprops->free, lprops->dirty, 893 lprops->lnum, lprops->free, lprops->dirty,
894 lprops->flags); 894 lprops->flags);
895 return -EINVAL; 895 return -EINVAL;
896 } 896 }
897 if (lprops->flags & LPROPS_TAKEN) { 897 if (lprops->flags & LPROPS_TAKEN) {
898 ubifs_err("taken LEB %d on freeable list (free %d dirty %d flags %d)", 898 ubifs_err(c, "taken LEB %d on freeable list (free %d dirty %d flags %d)",
899 lprops->lnum, lprops->free, lprops->dirty, 899 lprops->lnum, lprops->free, lprops->dirty,
900 lprops->flags); 900 lprops->flags);
901 return -EINVAL; 901 return -EINVAL;
@@ -903,7 +903,7 @@ int dbg_check_cats(struct ubifs_info *c)
903 i += 1; 903 i += 1;
904 } 904 }
905 if (i != c->freeable_cnt) { 905 if (i != c->freeable_cnt) {
906 ubifs_err("freeable list count %d expected %d", i, 906 ubifs_err(c, "freeable list count %d expected %d", i,
907 c->freeable_cnt); 907 c->freeable_cnt);
908 return -EINVAL; 908 return -EINVAL;
909 } 909 }
@@ -912,26 +912,26 @@ int dbg_check_cats(struct ubifs_info *c)
912 list_for_each(pos, &c->idx_gc) 912 list_for_each(pos, &c->idx_gc)
913 i += 1; 913 i += 1;
914 if (i != c->idx_gc_cnt) { 914 if (i != c->idx_gc_cnt) {
915 ubifs_err("idx_gc list count %d expected %d", i, 915 ubifs_err(c, "idx_gc list count %d expected %d", i,
916 c->idx_gc_cnt); 916 c->idx_gc_cnt);
917 return -EINVAL; 917 return -EINVAL;
918 } 918 }
919 919
920 list_for_each_entry(lprops, &c->frdi_idx_list, list) { 920 list_for_each_entry(lprops, &c->frdi_idx_list, list) {
921 if (lprops->free + lprops->dirty != c->leb_size) { 921 if (lprops->free + lprops->dirty != c->leb_size) {
922 ubifs_err("non-freeable LEB %d on frdi_idx list (free %d dirty %d flags %d)", 922 ubifs_err(c, "non-freeable LEB %d on frdi_idx list (free %d dirty %d flags %d)",
923 lprops->lnum, lprops->free, lprops->dirty, 923 lprops->lnum, lprops->free, lprops->dirty,
924 lprops->flags); 924 lprops->flags);
925 return -EINVAL; 925 return -EINVAL;
926 } 926 }
927 if (lprops->flags & LPROPS_TAKEN) { 927 if (lprops->flags & LPROPS_TAKEN) {
928 ubifs_err("taken LEB %d on frdi_idx list (free %d dirty %d flags %d)", 928 ubifs_err(c, "taken LEB %d on frdi_idx list (free %d dirty %d flags %d)",
929 lprops->lnum, lprops->free, lprops->dirty, 929 lprops->lnum, lprops->free, lprops->dirty,
930 lprops->flags); 930 lprops->flags);
931 return -EINVAL; 931 return -EINVAL;
932 } 932 }
933 if (!(lprops->flags & LPROPS_INDEX)) { 933 if (!(lprops->flags & LPROPS_INDEX)) {
934 ubifs_err("non-index LEB %d on frdi_idx list (free %d dirty %d flags %d)", 934 ubifs_err(c, "non-index LEB %d on frdi_idx list (free %d dirty %d flags %d)",
935 lprops->lnum, lprops->free, lprops->dirty, 935 lprops->lnum, lprops->free, lprops->dirty,
936 lprops->flags); 936 lprops->flags);
937 return -EINVAL; 937 return -EINVAL;
@@ -944,15 +944,15 @@ int dbg_check_cats(struct ubifs_info *c)
944 for (i = 0; i < heap->cnt; i++) { 944 for (i = 0; i < heap->cnt; i++) {
945 lprops = heap->arr[i]; 945 lprops = heap->arr[i];
946 if (!lprops) { 946 if (!lprops) {
947 ubifs_err("null ptr in LPT heap cat %d", cat); 947 ubifs_err(c, "null ptr in LPT heap cat %d", cat);
948 return -EINVAL; 948 return -EINVAL;
949 } 949 }
950 if (lprops->hpos != i) { 950 if (lprops->hpos != i) {
951 ubifs_err("bad ptr in LPT heap cat %d", cat); 951 ubifs_err(c, "bad ptr in LPT heap cat %d", cat);
952 return -EINVAL; 952 return -EINVAL;
953 } 953 }
954 if (lprops->flags & LPROPS_TAKEN) { 954 if (lprops->flags & LPROPS_TAKEN) {
955 ubifs_err("taken LEB in LPT heap cat %d", cat); 955 ubifs_err(c, "taken LEB in LPT heap cat %d", cat);
956 return -EINVAL; 956 return -EINVAL;
957 } 957 }
958 } 958 }
@@ -988,7 +988,7 @@ void dbg_check_heap(struct ubifs_info *c, struct ubifs_lpt_heap *heap, int cat,
988 goto out; 988 goto out;
989 } 989 }
990 if (lprops != lp) { 990 if (lprops != lp) {
991 ubifs_err("lprops %zx lp %zx lprops->lnum %d lp->lnum %d", 991 ubifs_err(c, "lprops %zx lp %zx lprops->lnum %d lp->lnum %d",
992 (size_t)lprops, (size_t)lp, lprops->lnum, 992 (size_t)lprops, (size_t)lp, lprops->lnum,
993 lp->lnum); 993 lp->lnum);
994 err = 4; 994 err = 4;
@@ -1008,7 +1008,7 @@ void dbg_check_heap(struct ubifs_info *c, struct ubifs_lpt_heap *heap, int cat,
1008 } 1008 }
1009out: 1009out:
1010 if (err) { 1010 if (err) {
1011 ubifs_err("failed cat %d hpos %d err %d", cat, i, err); 1011 ubifs_err(c, "failed cat %d hpos %d err %d", cat, i, err);
1012 dump_stack(); 1012 dump_stack();
1013 ubifs_dump_heap(c, heap, cat); 1013 ubifs_dump_heap(c, heap, cat);
1014 } 1014 }
@@ -1039,7 +1039,7 @@ static int scan_check_cb(struct ubifs_info *c,
1039 if (cat != LPROPS_UNCAT) { 1039 if (cat != LPROPS_UNCAT) {
1040 cat = ubifs_categorize_lprops(c, lp); 1040 cat = ubifs_categorize_lprops(c, lp);
1041 if (cat != (lp->flags & LPROPS_CAT_MASK)) { 1041 if (cat != (lp->flags & LPROPS_CAT_MASK)) {
1042 ubifs_err("bad LEB category %d expected %d", 1042 ubifs_err(c, "bad LEB category %d expected %d",
1043 (lp->flags & LPROPS_CAT_MASK), cat); 1043 (lp->flags & LPROPS_CAT_MASK), cat);
1044 return -EINVAL; 1044 return -EINVAL;
1045 } 1045 }
@@ -1074,7 +1074,7 @@ static int scan_check_cb(struct ubifs_info *c,
1074 } 1074 }
1075 } 1075 }
1076 if (!found) { 1076 if (!found) {
1077 ubifs_err("bad LPT list (category %d)", cat); 1077 ubifs_err(c, "bad LPT list (category %d)", cat);
1078 return -EINVAL; 1078 return -EINVAL;
1079 } 1079 }
1080 } 1080 }
@@ -1086,7 +1086,7 @@ static int scan_check_cb(struct ubifs_info *c,
1086 1086
1087 if ((lp->hpos != -1 && heap->arr[lp->hpos]->lnum != lnum) || 1087 if ((lp->hpos != -1 && heap->arr[lp->hpos]->lnum != lnum) ||
1088 lp != heap->arr[lp->hpos]) { 1088 lp != heap->arr[lp->hpos]) {
1089 ubifs_err("bad LPT heap (category %d)", cat); 1089 ubifs_err(c, "bad LPT heap (category %d)", cat);
1090 return -EINVAL; 1090 return -EINVAL;
1091 } 1091 }
1092 } 1092 }
@@ -1133,7 +1133,7 @@ static int scan_check_cb(struct ubifs_info *c,
1133 is_idx = (snod->type == UBIFS_IDX_NODE) ? 1 : 0; 1133 is_idx = (snod->type == UBIFS_IDX_NODE) ? 1 : 0;
1134 1134
1135 if (is_idx && snod->type != UBIFS_IDX_NODE) { 1135 if (is_idx && snod->type != UBIFS_IDX_NODE) {
1136 ubifs_err("indexing node in data LEB %d:%d", 1136 ubifs_err(c, "indexing node in data LEB %d:%d",
1137 lnum, snod->offs); 1137 lnum, snod->offs);
1138 goto out_destroy; 1138 goto out_destroy;
1139 } 1139 }
@@ -1159,7 +1159,7 @@ static int scan_check_cb(struct ubifs_info *c,
1159 1159
1160 if (free > c->leb_size || free < 0 || dirty > c->leb_size || 1160 if (free > c->leb_size || free < 0 || dirty > c->leb_size ||
1161 dirty < 0) { 1161 dirty < 0) {
1162 ubifs_err("bad calculated accounting for LEB %d: free %d, dirty %d", 1162 ubifs_err(c, "bad calculated accounting for LEB %d: free %d, dirty %d",
1163 lnum, free, dirty); 1163 lnum, free, dirty);
1164 goto out_destroy; 1164 goto out_destroy;
1165 } 1165 }
@@ -1206,13 +1206,13 @@ static int scan_check_cb(struct ubifs_info *c,
1206 /* Free but not unmapped LEB, it's fine */ 1206 /* Free but not unmapped LEB, it's fine */
1207 is_idx = 0; 1207 is_idx = 0;
1208 else { 1208 else {
1209 ubifs_err("indexing node without indexing flag"); 1209 ubifs_err(c, "indexing node without indexing flag");
1210 goto out_print; 1210 goto out_print;
1211 } 1211 }
1212 } 1212 }
1213 1213
1214 if (!is_idx && (lp->flags & LPROPS_INDEX)) { 1214 if (!is_idx && (lp->flags & LPROPS_INDEX)) {
1215 ubifs_err("data node with indexing flag"); 1215 ubifs_err(c, "data node with indexing flag");
1216 goto out_print; 1216 goto out_print;
1217 } 1217 }
1218 1218
@@ -1241,7 +1241,7 @@ static int scan_check_cb(struct ubifs_info *c,
1241 return LPT_SCAN_CONTINUE; 1241 return LPT_SCAN_CONTINUE;
1242 1242
1243out_print: 1243out_print:
1244 ubifs_err("bad accounting of LEB %d: free %d, dirty %d flags %#x, should be free %d, dirty %d", 1244 ubifs_err(c, "bad accounting of LEB %d: free %d, dirty %d flags %#x, should be free %d, dirty %d",
1245 lnum, lp->free, lp->dirty, lp->flags, free, dirty); 1245 lnum, lp->free, lp->dirty, lp->flags, free, dirty);
1246 ubifs_dump_leb(c, lnum); 1246 ubifs_dump_leb(c, lnum);
1247out_destroy: 1247out_destroy:
@@ -1293,11 +1293,11 @@ int dbg_check_lprops(struct ubifs_info *c)
1293 lst.total_free != c->lst.total_free || 1293 lst.total_free != c->lst.total_free ||
1294 lst.total_dirty != c->lst.total_dirty || 1294 lst.total_dirty != c->lst.total_dirty ||
1295 lst.total_used != c->lst.total_used) { 1295 lst.total_used != c->lst.total_used) {
1296 ubifs_err("bad overall accounting"); 1296 ubifs_err(c, "bad overall accounting");
1297 ubifs_err("calculated: empty_lebs %d, idx_lebs %d, total_free %lld, total_dirty %lld, total_used %lld", 1297 ubifs_err(c, "calculated: empty_lebs %d, idx_lebs %d, total_free %lld, total_dirty %lld, total_used %lld",
1298 lst.empty_lebs, lst.idx_lebs, lst.total_free, 1298 lst.empty_lebs, lst.idx_lebs, lst.total_free,
1299 lst.total_dirty, lst.total_used); 1299 lst.total_dirty, lst.total_used);
1300 ubifs_err("read from lprops: empty_lebs %d, idx_lebs %d, total_free %lld, total_dirty %lld, total_used %lld", 1300 ubifs_err(c, "read from lprops: empty_lebs %d, idx_lebs %d, total_free %lld, total_dirty %lld, total_used %lld",
1301 c->lst.empty_lebs, c->lst.idx_lebs, c->lst.total_free, 1301 c->lst.empty_lebs, c->lst.idx_lebs, c->lst.total_free,
1302 c->lst.total_dirty, c->lst.total_used); 1302 c->lst.total_dirty, c->lst.total_used);
1303 err = -EINVAL; 1303 err = -EINVAL;
@@ -1306,10 +1306,10 @@ int dbg_check_lprops(struct ubifs_info *c)
1306 1306
1307 if (lst.total_dead != c->lst.total_dead || 1307 if (lst.total_dead != c->lst.total_dead ||
1308 lst.total_dark != c->lst.total_dark) { 1308 lst.total_dark != c->lst.total_dark) {
1309 ubifs_err("bad dead/dark space accounting"); 1309 ubifs_err(c, "bad dead/dark space accounting");
1310 ubifs_err("calculated: total_dead %lld, total_dark %lld", 1310 ubifs_err(c, "calculated: total_dead %lld, total_dark %lld",
1311 lst.total_dead, lst.total_dark); 1311 lst.total_dead, lst.total_dark);
1312 ubifs_err("read from lprops: total_dead %lld, total_dark %lld", 1312 ubifs_err(c, "read from lprops: total_dead %lld, total_dark %lld",
1313 c->lst.total_dead, c->lst.total_dark); 1313 c->lst.total_dead, c->lst.total_dark);
1314 err = -EINVAL; 1314 err = -EINVAL;
1315 goto out; 1315 goto out;
diff --git a/fs/ubifs/lpt.c b/fs/ubifs/lpt.c
index 421bd0a80424..dc9f27e9d61b 100644
--- a/fs/ubifs/lpt.c
+++ b/fs/ubifs/lpt.c
@@ -145,13 +145,13 @@ int ubifs_calc_lpt_geom(struct ubifs_info *c)
145 sz = c->lpt_sz * 2; /* Must have at least 2 times the size */ 145 sz = c->lpt_sz * 2; /* Must have at least 2 times the size */
146 lebs_needed = div_u64(sz + c->leb_size - 1, c->leb_size); 146 lebs_needed = div_u64(sz + c->leb_size - 1, c->leb_size);
147 if (lebs_needed > c->lpt_lebs) { 147 if (lebs_needed > c->lpt_lebs) {
148 ubifs_err("too few LPT LEBs"); 148 ubifs_err(c, "too few LPT LEBs");
149 return -EINVAL; 149 return -EINVAL;
150 } 150 }
151 151
152 /* Verify that ltab fits in a single LEB (since ltab is a single node */ 152 /* Verify that ltab fits in a single LEB (since ltab is a single node */
153 if (c->ltab_sz > c->leb_size) { 153 if (c->ltab_sz > c->leb_size) {
154 ubifs_err("LPT ltab too big"); 154 ubifs_err(c, "LPT ltab too big");
155 return -EINVAL; 155 return -EINVAL;
156 } 156 }
157 157
@@ -213,7 +213,7 @@ static int calc_dflt_lpt_geom(struct ubifs_info *c, int *main_lebs,
213 continue; 213 continue;
214 } 214 }
215 if (c->ltab_sz > c->leb_size) { 215 if (c->ltab_sz > c->leb_size) {
216 ubifs_err("LPT ltab too big"); 216 ubifs_err(c, "LPT ltab too big");
217 return -EINVAL; 217 return -EINVAL;
218 } 218 }
219 *main_lebs = c->main_lebs; 219 *main_lebs = c->main_lebs;
@@ -911,7 +911,7 @@ static void replace_cats(struct ubifs_info *c, struct ubifs_pnode *old_pnode,
911 * 911 *
912 * This function returns %0 on success and a negative error code on failure. 912 * This function returns %0 on success and a negative error code on failure.
913 */ 913 */
914static int check_lpt_crc(void *buf, int len) 914static int check_lpt_crc(const struct ubifs_info *c, void *buf, int len)
915{ 915{
916 int pos = 0; 916 int pos = 0;
917 uint8_t *addr = buf; 917 uint8_t *addr = buf;
@@ -921,8 +921,8 @@ static int check_lpt_crc(void *buf, int len)
921 calc_crc = crc16(-1, buf + UBIFS_LPT_CRC_BYTES, 921 calc_crc = crc16(-1, buf + UBIFS_LPT_CRC_BYTES,
922 len - UBIFS_LPT_CRC_BYTES); 922 len - UBIFS_LPT_CRC_BYTES);
923 if (crc != calc_crc) { 923 if (crc != calc_crc) {
924 ubifs_err("invalid crc in LPT node: crc %hx calc %hx", crc, 924 ubifs_err(c, "invalid crc in LPT node: crc %hx calc %hx",
925 calc_crc); 925 crc, calc_crc);
926 dump_stack(); 926 dump_stack();
927 return -EINVAL; 927 return -EINVAL;
928 } 928 }
@@ -938,14 +938,15 @@ static int check_lpt_crc(void *buf, int len)
938 * 938 *
939 * This function returns %0 on success and a negative error code on failure. 939 * This function returns %0 on success and a negative error code on failure.
940 */ 940 */
941static int check_lpt_type(uint8_t **addr, int *pos, int type) 941static int check_lpt_type(const struct ubifs_info *c, uint8_t **addr,
942 int *pos, int type)
942{ 943{
943 int node_type; 944 int node_type;
944 945
945 node_type = ubifs_unpack_bits(addr, pos, UBIFS_LPT_TYPE_BITS); 946 node_type = ubifs_unpack_bits(addr, pos, UBIFS_LPT_TYPE_BITS);
946 if (node_type != type) { 947 if (node_type != type) {
947 ubifs_err("invalid type (%d) in LPT node type %d", node_type, 948 ubifs_err(c, "invalid type (%d) in LPT node type %d",
948 type); 949 node_type, type);
949 dump_stack(); 950 dump_stack();
950 return -EINVAL; 951 return -EINVAL;
951 } 952 }
@@ -966,7 +967,7 @@ static int unpack_pnode(const struct ubifs_info *c, void *buf,
966 uint8_t *addr = buf + UBIFS_LPT_CRC_BYTES; 967 uint8_t *addr = buf + UBIFS_LPT_CRC_BYTES;
967 int i, pos = 0, err; 968 int i, pos = 0, err;
968 969
969 err = check_lpt_type(&addr, &pos, UBIFS_LPT_PNODE); 970 err = check_lpt_type(c, &addr, &pos, UBIFS_LPT_PNODE);
970 if (err) 971 if (err)
971 return err; 972 return err;
972 if (c->big_lpt) 973 if (c->big_lpt)
@@ -985,7 +986,7 @@ static int unpack_pnode(const struct ubifs_info *c, void *buf,
985 lprops->flags = 0; 986 lprops->flags = 0;
986 lprops->flags |= ubifs_categorize_lprops(c, lprops); 987 lprops->flags |= ubifs_categorize_lprops(c, lprops);
987 } 988 }
988 err = check_lpt_crc(buf, c->pnode_sz); 989 err = check_lpt_crc(c, buf, c->pnode_sz);
989 return err; 990 return err;
990} 991}
991 992
@@ -1003,7 +1004,7 @@ int ubifs_unpack_nnode(const struct ubifs_info *c, void *buf,
1003 uint8_t *addr = buf + UBIFS_LPT_CRC_BYTES; 1004 uint8_t *addr = buf + UBIFS_LPT_CRC_BYTES;
1004 int i, pos = 0, err; 1005 int i, pos = 0, err;
1005 1006
1006 err = check_lpt_type(&addr, &pos, UBIFS_LPT_NNODE); 1007 err = check_lpt_type(c, &addr, &pos, UBIFS_LPT_NNODE);
1007 if (err) 1008 if (err)
1008 return err; 1009 return err;
1009 if (c->big_lpt) 1010 if (c->big_lpt)
@@ -1019,7 +1020,7 @@ int ubifs_unpack_nnode(const struct ubifs_info *c, void *buf,
1019 nnode->nbranch[i].offs = ubifs_unpack_bits(&addr, &pos, 1020 nnode->nbranch[i].offs = ubifs_unpack_bits(&addr, &pos,
1020 c->lpt_offs_bits); 1021 c->lpt_offs_bits);
1021 } 1022 }
1022 err = check_lpt_crc(buf, c->nnode_sz); 1023 err = check_lpt_crc(c, buf, c->nnode_sz);
1023 return err; 1024 return err;
1024} 1025}
1025 1026
@@ -1035,7 +1036,7 @@ static int unpack_ltab(const struct ubifs_info *c, void *buf)
1035 uint8_t *addr = buf + UBIFS_LPT_CRC_BYTES; 1036 uint8_t *addr = buf + UBIFS_LPT_CRC_BYTES;
1036 int i, pos = 0, err; 1037 int i, pos = 0, err;
1037 1038
1038 err = check_lpt_type(&addr, &pos, UBIFS_LPT_LTAB); 1039 err = check_lpt_type(c, &addr, &pos, UBIFS_LPT_LTAB);
1039 if (err) 1040 if (err)
1040 return err; 1041 return err;
1041 for (i = 0; i < c->lpt_lebs; i++) { 1042 for (i = 0; i < c->lpt_lebs; i++) {
@@ -1051,7 +1052,7 @@ static int unpack_ltab(const struct ubifs_info *c, void *buf)
1051 c->ltab[i].tgc = 0; 1052 c->ltab[i].tgc = 0;
1052 c->ltab[i].cmt = 0; 1053 c->ltab[i].cmt = 0;
1053 } 1054 }
1054 err = check_lpt_crc(buf, c->ltab_sz); 1055 err = check_lpt_crc(c, buf, c->ltab_sz);
1055 return err; 1056 return err;
1056} 1057}
1057 1058
@@ -1067,7 +1068,7 @@ static int unpack_lsave(const struct ubifs_info *c, void *buf)
1067 uint8_t *addr = buf + UBIFS_LPT_CRC_BYTES; 1068 uint8_t *addr = buf + UBIFS_LPT_CRC_BYTES;
1068 int i, pos = 0, err; 1069 int i, pos = 0, err;
1069 1070
1070 err = check_lpt_type(&addr, &pos, UBIFS_LPT_LSAVE); 1071 err = check_lpt_type(c, &addr, &pos, UBIFS_LPT_LSAVE);
1071 if (err) 1072 if (err)
1072 return err; 1073 return err;
1073 for (i = 0; i < c->lsave_cnt; i++) { 1074 for (i = 0; i < c->lsave_cnt; i++) {
@@ -1077,7 +1078,7 @@ static int unpack_lsave(const struct ubifs_info *c, void *buf)
1077 return -EINVAL; 1078 return -EINVAL;
1078 c->lsave[i] = lnum; 1079 c->lsave[i] = lnum;
1079 } 1080 }
1080 err = check_lpt_crc(buf, c->lsave_sz); 1081 err = check_lpt_crc(c, buf, c->lsave_sz);
1081 return err; 1082 return err;
1082} 1083}
1083 1084
@@ -1243,7 +1244,7 @@ int ubifs_read_nnode(struct ubifs_info *c, struct ubifs_nnode *parent, int iip)
1243 return 0; 1244 return 0;
1244 1245
1245out: 1246out:
1246 ubifs_err("error %d reading nnode at %d:%d", err, lnum, offs); 1247 ubifs_err(c, "error %d reading nnode at %d:%d", err, lnum, offs);
1247 dump_stack(); 1248 dump_stack();
1248 kfree(nnode); 1249 kfree(nnode);
1249 return err; 1250 return err;
@@ -1308,10 +1309,10 @@ static int read_pnode(struct ubifs_info *c, struct ubifs_nnode *parent, int iip)
1308 return 0; 1309 return 0;
1309 1310
1310out: 1311out:
1311 ubifs_err("error %d reading pnode at %d:%d", err, lnum, offs); 1312 ubifs_err(c, "error %d reading pnode at %d:%d", err, lnum, offs);
1312 ubifs_dump_pnode(c, pnode, parent, iip); 1313 ubifs_dump_pnode(c, pnode, parent, iip);
1313 dump_stack(); 1314 dump_stack();
1314 ubifs_err("calc num: %d", calc_pnode_num_from_parent(c, parent, iip)); 1315 ubifs_err(c, "calc num: %d", calc_pnode_num_from_parent(c, parent, iip));
1315 kfree(pnode); 1316 kfree(pnode);
1316 return err; 1317 return err;
1317} 1318}
@@ -2095,7 +2096,7 @@ static int dbg_chk_pnode(struct ubifs_info *c, struct ubifs_pnode *pnode,
2095 int i; 2096 int i;
2096 2097
2097 if (pnode->num != col) { 2098 if (pnode->num != col) {
2098 ubifs_err("pnode num %d expected %d parent num %d iip %d", 2099 ubifs_err(c, "pnode num %d expected %d parent num %d iip %d",
2099 pnode->num, col, pnode->parent->num, pnode->iip); 2100 pnode->num, col, pnode->parent->num, pnode->iip);
2100 return -EINVAL; 2101 return -EINVAL;
2101 } 2102 }
@@ -2110,13 +2111,13 @@ static int dbg_chk_pnode(struct ubifs_info *c, struct ubifs_pnode *pnode,
2110 if (lnum >= c->leb_cnt) 2111 if (lnum >= c->leb_cnt)
2111 continue; 2112 continue;
2112 if (lprops->lnum != lnum) { 2113 if (lprops->lnum != lnum) {
2113 ubifs_err("bad LEB number %d expected %d", 2114 ubifs_err(c, "bad LEB number %d expected %d",
2114 lprops->lnum, lnum); 2115 lprops->lnum, lnum);
2115 return -EINVAL; 2116 return -EINVAL;
2116 } 2117 }
2117 if (lprops->flags & LPROPS_TAKEN) { 2118 if (lprops->flags & LPROPS_TAKEN) {
2118 if (cat != LPROPS_UNCAT) { 2119 if (cat != LPROPS_UNCAT) {
2119 ubifs_err("LEB %d taken but not uncat %d", 2120 ubifs_err(c, "LEB %d taken but not uncat %d",
2120 lprops->lnum, cat); 2121 lprops->lnum, cat);
2121 return -EINVAL; 2122 return -EINVAL;
2122 } 2123 }
@@ -2129,7 +2130,7 @@ static int dbg_chk_pnode(struct ubifs_info *c, struct ubifs_pnode *pnode,
2129 case LPROPS_FRDI_IDX: 2130 case LPROPS_FRDI_IDX:
2130 break; 2131 break;
2131 default: 2132 default:
2132 ubifs_err("LEB %d index but cat %d", 2133 ubifs_err(c, "LEB %d index but cat %d",
2133 lprops->lnum, cat); 2134 lprops->lnum, cat);
2134 return -EINVAL; 2135 return -EINVAL;
2135 } 2136 }
@@ -2142,7 +2143,7 @@ static int dbg_chk_pnode(struct ubifs_info *c, struct ubifs_pnode *pnode,
2142 case LPROPS_FREEABLE: 2143 case LPROPS_FREEABLE:
2143 break; 2144 break;
2144 default: 2145 default:
2145 ubifs_err("LEB %d not index but cat %d", 2146 ubifs_err(c, "LEB %d not index but cat %d",
2146 lprops->lnum, cat); 2147 lprops->lnum, cat);
2147 return -EINVAL; 2148 return -EINVAL;
2148 } 2149 }
@@ -2183,14 +2184,14 @@ static int dbg_chk_pnode(struct ubifs_info *c, struct ubifs_pnode *pnode,
2183 break; 2184 break;
2184 } 2185 }
2185 if (!found) { 2186 if (!found) {
2186 ubifs_err("LEB %d cat %d not found in cat heap/list", 2187 ubifs_err(c, "LEB %d cat %d not found in cat heap/list",
2187 lprops->lnum, cat); 2188 lprops->lnum, cat);
2188 return -EINVAL; 2189 return -EINVAL;
2189 } 2190 }
2190 switch (cat) { 2191 switch (cat) {
2191 case LPROPS_EMPTY: 2192 case LPROPS_EMPTY:
2192 if (lprops->free != c->leb_size) { 2193 if (lprops->free != c->leb_size) {
2193 ubifs_err("LEB %d cat %d free %d dirty %d", 2194 ubifs_err(c, "LEB %d cat %d free %d dirty %d",
2194 lprops->lnum, cat, lprops->free, 2195 lprops->lnum, cat, lprops->free,
2195 lprops->dirty); 2196 lprops->dirty);
2196 return -EINVAL; 2197 return -EINVAL;
@@ -2199,7 +2200,7 @@ static int dbg_chk_pnode(struct ubifs_info *c, struct ubifs_pnode *pnode,
2199 case LPROPS_FREEABLE: 2200 case LPROPS_FREEABLE:
2200 case LPROPS_FRDI_IDX: 2201 case LPROPS_FRDI_IDX:
2201 if (lprops->free + lprops->dirty != c->leb_size) { 2202 if (lprops->free + lprops->dirty != c->leb_size) {
2202 ubifs_err("LEB %d cat %d free %d dirty %d", 2203 ubifs_err(c, "LEB %d cat %d free %d dirty %d",
2203 lprops->lnum, cat, lprops->free, 2204 lprops->lnum, cat, lprops->free,
2204 lprops->dirty); 2205 lprops->dirty);
2205 return -EINVAL; 2206 return -EINVAL;
@@ -2236,7 +2237,7 @@ int dbg_check_lpt_nodes(struct ubifs_info *c, struct ubifs_cnode *cnode,
2236 /* cnode is a nnode */ 2237 /* cnode is a nnode */
2237 num = calc_nnode_num(row, col); 2238 num = calc_nnode_num(row, col);
2238 if (cnode->num != num) { 2239 if (cnode->num != num) {
2239 ubifs_err("nnode num %d expected %d parent num %d iip %d", 2240 ubifs_err(c, "nnode num %d expected %d parent num %d iip %d",
2240 cnode->num, num, 2241 cnode->num, num,
2241 (nnode ? nnode->num : 0), cnode->iip); 2242 (nnode ? nnode->num : 0), cnode->iip);
2242 return -EINVAL; 2243 return -EINVAL;
diff --git a/fs/ubifs/lpt_commit.c b/fs/ubifs/lpt_commit.c
index d9c02928e992..ce89bdc3eb02 100644
--- a/fs/ubifs/lpt_commit.c
+++ b/fs/ubifs/lpt_commit.c
@@ -319,7 +319,7 @@ static int layout_cnodes(struct ubifs_info *c)
319 return 0; 319 return 0;
320 320
321no_space: 321no_space:
322 ubifs_err("LPT out of space at LEB %d:%d needing %d, done_ltab %d, done_lsave %d", 322 ubifs_err(c, "LPT out of space at LEB %d:%d needing %d, done_ltab %d, done_lsave %d",
323 lnum, offs, len, done_ltab, done_lsave); 323 lnum, offs, len, done_ltab, done_lsave);
324 ubifs_dump_lpt_info(c); 324 ubifs_dump_lpt_info(c);
325 ubifs_dump_lpt_lebs(c); 325 ubifs_dump_lpt_lebs(c);
@@ -543,7 +543,7 @@ static int write_cnodes(struct ubifs_info *c)
543 return 0; 543 return 0;
544 544
545no_space: 545no_space:
546 ubifs_err("LPT out of space mismatch at LEB %d:%d needing %d, done_ltab %d, done_lsave %d", 546 ubifs_err(c, "LPT out of space mismatch at LEB %d:%d needing %d, done_ltab %d, done_lsave %d",
547 lnum, offs, len, done_ltab, done_lsave); 547 lnum, offs, len, done_ltab, done_lsave);
548 ubifs_dump_lpt_info(c); 548 ubifs_dump_lpt_info(c);
549 ubifs_dump_lpt_lebs(c); 549 ubifs_dump_lpt_lebs(c);
@@ -1638,7 +1638,7 @@ static int dbg_check_ltab_lnum(struct ubifs_info *c, int lnum)
1638 1638
1639 buf = p = __vmalloc(c->leb_size, GFP_NOFS, PAGE_KERNEL); 1639 buf = p = __vmalloc(c->leb_size, GFP_NOFS, PAGE_KERNEL);
1640 if (!buf) { 1640 if (!buf) {
1641 ubifs_err("cannot allocate memory for ltab checking"); 1641 ubifs_err(c, "cannot allocate memory for ltab checking");
1642 return 0; 1642 return 0;
1643 } 1643 }
1644 1644
@@ -1660,18 +1660,18 @@ static int dbg_check_ltab_lnum(struct ubifs_info *c, int lnum)
1660 continue; 1660 continue;
1661 } 1661 }
1662 if (!dbg_is_all_ff(p, len)) { 1662 if (!dbg_is_all_ff(p, len)) {
1663 ubifs_err("invalid empty space in LEB %d at %d", 1663 ubifs_err(c, "invalid empty space in LEB %d at %d",
1664 lnum, c->leb_size - len); 1664 lnum, c->leb_size - len);
1665 err = -EINVAL; 1665 err = -EINVAL;
1666 } 1666 }
1667 i = lnum - c->lpt_first; 1667 i = lnum - c->lpt_first;
1668 if (len != c->ltab[i].free) { 1668 if (len != c->ltab[i].free) {
1669 ubifs_err("invalid free space in LEB %d (free %d, expected %d)", 1669 ubifs_err(c, "invalid free space in LEB %d (free %d, expected %d)",
1670 lnum, len, c->ltab[i].free); 1670 lnum, len, c->ltab[i].free);
1671 err = -EINVAL; 1671 err = -EINVAL;
1672 } 1672 }
1673 if (dirty != c->ltab[i].dirty) { 1673 if (dirty != c->ltab[i].dirty) {
1674 ubifs_err("invalid dirty space in LEB %d (dirty %d, expected %d)", 1674 ubifs_err(c, "invalid dirty space in LEB %d (dirty %d, expected %d)",
1675 lnum, dirty, c->ltab[i].dirty); 1675 lnum, dirty, c->ltab[i].dirty);
1676 err = -EINVAL; 1676 err = -EINVAL;
1677 } 1677 }
@@ -1725,7 +1725,7 @@ int dbg_check_ltab(struct ubifs_info *c)
1725 for (lnum = c->lpt_first; lnum <= c->lpt_last; lnum++) { 1725 for (lnum = c->lpt_first; lnum <= c->lpt_last; lnum++) {
1726 err = dbg_check_ltab_lnum(c, lnum); 1726 err = dbg_check_ltab_lnum(c, lnum);
1727 if (err) { 1727 if (err) {
1728 ubifs_err("failed at LEB %d", lnum); 1728 ubifs_err(c, "failed at LEB %d", lnum);
1729 return err; 1729 return err;
1730 } 1730 }
1731 } 1731 }
@@ -1757,7 +1757,7 @@ int dbg_chk_lpt_free_spc(struct ubifs_info *c)
1757 free += c->leb_size; 1757 free += c->leb_size;
1758 } 1758 }
1759 if (free < c->lpt_sz) { 1759 if (free < c->lpt_sz) {
1760 ubifs_err("LPT space error: free %lld lpt_sz %lld", 1760 ubifs_err(c, "LPT space error: free %lld lpt_sz %lld",
1761 free, c->lpt_sz); 1761 free, c->lpt_sz);
1762 ubifs_dump_lpt_info(c); 1762 ubifs_dump_lpt_info(c);
1763 ubifs_dump_lpt_lebs(c); 1763 ubifs_dump_lpt_lebs(c);
@@ -1797,12 +1797,12 @@ int dbg_chk_lpt_sz(struct ubifs_info *c, int action, int len)
1797 d->chk_lpt_lebs = 0; 1797 d->chk_lpt_lebs = 0;
1798 d->chk_lpt_wastage = 0; 1798 d->chk_lpt_wastage = 0;
1799 if (c->dirty_pn_cnt > c->pnode_cnt) { 1799 if (c->dirty_pn_cnt > c->pnode_cnt) {
1800 ubifs_err("dirty pnodes %d exceed max %d", 1800 ubifs_err(c, "dirty pnodes %d exceed max %d",
1801 c->dirty_pn_cnt, c->pnode_cnt); 1801 c->dirty_pn_cnt, c->pnode_cnt);
1802 err = -EINVAL; 1802 err = -EINVAL;
1803 } 1803 }
1804 if (c->dirty_nn_cnt > c->nnode_cnt) { 1804 if (c->dirty_nn_cnt > c->nnode_cnt) {
1805 ubifs_err("dirty nnodes %d exceed max %d", 1805 ubifs_err(c, "dirty nnodes %d exceed max %d",
1806 c->dirty_nn_cnt, c->nnode_cnt); 1806 c->dirty_nn_cnt, c->nnode_cnt);
1807 err = -EINVAL; 1807 err = -EINVAL;
1808 } 1808 }
@@ -1820,22 +1820,22 @@ int dbg_chk_lpt_sz(struct ubifs_info *c, int action, int len)
1820 chk_lpt_sz *= d->chk_lpt_lebs; 1820 chk_lpt_sz *= d->chk_lpt_lebs;
1821 chk_lpt_sz += len - c->nhead_offs; 1821 chk_lpt_sz += len - c->nhead_offs;
1822 if (d->chk_lpt_sz != chk_lpt_sz) { 1822 if (d->chk_lpt_sz != chk_lpt_sz) {
1823 ubifs_err("LPT wrote %lld but space used was %lld", 1823 ubifs_err(c, "LPT wrote %lld but space used was %lld",
1824 d->chk_lpt_sz, chk_lpt_sz); 1824 d->chk_lpt_sz, chk_lpt_sz);
1825 err = -EINVAL; 1825 err = -EINVAL;
1826 } 1826 }
1827 if (d->chk_lpt_sz > c->lpt_sz) { 1827 if (d->chk_lpt_sz > c->lpt_sz) {
1828 ubifs_err("LPT wrote %lld but lpt_sz is %lld", 1828 ubifs_err(c, "LPT wrote %lld but lpt_sz is %lld",
1829 d->chk_lpt_sz, c->lpt_sz); 1829 d->chk_lpt_sz, c->lpt_sz);
1830 err = -EINVAL; 1830 err = -EINVAL;
1831 } 1831 }
1832 if (d->chk_lpt_sz2 && d->chk_lpt_sz != d->chk_lpt_sz2) { 1832 if (d->chk_lpt_sz2 && d->chk_lpt_sz != d->chk_lpt_sz2) {
1833 ubifs_err("LPT layout size %lld but wrote %lld", 1833 ubifs_err(c, "LPT layout size %lld but wrote %lld",
1834 d->chk_lpt_sz, d->chk_lpt_sz2); 1834 d->chk_lpt_sz, d->chk_lpt_sz2);
1835 err = -EINVAL; 1835 err = -EINVAL;
1836 } 1836 }
1837 if (d->chk_lpt_sz2 && d->new_nhead_offs != len) { 1837 if (d->chk_lpt_sz2 && d->new_nhead_offs != len) {
1838 ubifs_err("LPT new nhead offs: expected %d was %d", 1838 ubifs_err(c, "LPT new nhead offs: expected %d was %d",
1839 d->new_nhead_offs, len); 1839 d->new_nhead_offs, len);
1840 err = -EINVAL; 1840 err = -EINVAL;
1841 } 1841 }
@@ -1845,7 +1845,7 @@ int dbg_chk_lpt_sz(struct ubifs_info *c, int action, int len)
1845 if (c->big_lpt) 1845 if (c->big_lpt)
1846 lpt_sz += c->lsave_sz; 1846 lpt_sz += c->lsave_sz;
1847 if (d->chk_lpt_sz - d->chk_lpt_wastage > lpt_sz) { 1847 if (d->chk_lpt_sz - d->chk_lpt_wastage > lpt_sz) {
1848 ubifs_err("LPT chk_lpt_sz %lld + waste %lld exceeds %lld", 1848 ubifs_err(c, "LPT chk_lpt_sz %lld + waste %lld exceeds %lld",
1849 d->chk_lpt_sz, d->chk_lpt_wastage, lpt_sz); 1849 d->chk_lpt_sz, d->chk_lpt_wastage, lpt_sz);
1850 err = -EINVAL; 1850 err = -EINVAL;
1851 } 1851 }
@@ -1887,7 +1887,7 @@ static void dump_lpt_leb(const struct ubifs_info *c, int lnum)
1887 pr_err("(pid %d) start dumping LEB %d\n", current->pid, lnum); 1887 pr_err("(pid %d) start dumping LEB %d\n", current->pid, lnum);
1888 buf = p = __vmalloc(c->leb_size, GFP_NOFS, PAGE_KERNEL); 1888 buf = p = __vmalloc(c->leb_size, GFP_NOFS, PAGE_KERNEL);
1889 if (!buf) { 1889 if (!buf) {
1890 ubifs_err("cannot allocate memory to dump LPT"); 1890 ubifs_err(c, "cannot allocate memory to dump LPT");
1891 return; 1891 return;
1892 } 1892 }
1893 1893
@@ -1962,7 +1962,7 @@ static void dump_lpt_leb(const struct ubifs_info *c, int lnum)
1962 pr_err("LEB %d:%d, lsave len\n", lnum, offs); 1962 pr_err("LEB %d:%d, lsave len\n", lnum, offs);
1963 break; 1963 break;
1964 default: 1964 default:
1965 ubifs_err("LPT node type %d not recognized", node_type); 1965 ubifs_err(c, "LPT node type %d not recognized", node_type);
1966 goto out; 1966 goto out;
1967 } 1967 }
1968 1968
diff --git a/fs/ubifs/master.c b/fs/ubifs/master.c
index 1a4bb9e8b3b8..c6a5e39e2ba5 100644
--- a/fs/ubifs/master.c
+++ b/fs/ubifs/master.c
@@ -82,7 +82,7 @@ out:
82 return -EUCLEAN; 82 return -EUCLEAN;
83 83
84out_dump: 84out_dump:
85 ubifs_err("unexpected node type %d master LEB %d:%d", 85 ubifs_err(c, "unexpected node type %d master LEB %d:%d",
86 snod->type, lnum, snod->offs); 86 snod->type, lnum, snod->offs);
87 ubifs_scan_destroy(sleb); 87 ubifs_scan_destroy(sleb);
88 return -EINVAL; 88 return -EINVAL;
@@ -240,7 +240,7 @@ static int validate_master(const struct ubifs_info *c)
240 return 0; 240 return 0;
241 241
242out: 242out:
243 ubifs_err("bad master node at offset %d error %d", c->mst_offs, err); 243 ubifs_err(c, "bad master node at offset %d error %d", c->mst_offs, err);
244 ubifs_dump_node(c, c->mst_node); 244 ubifs_dump_node(c, c->mst_node);
245 return -EINVAL; 245 return -EINVAL;
246} 246}
@@ -316,7 +316,7 @@ int ubifs_read_master(struct ubifs_info *c)
316 316
317 if (c->leb_cnt < old_leb_cnt || 317 if (c->leb_cnt < old_leb_cnt ||
318 c->leb_cnt < UBIFS_MIN_LEB_CNT) { 318 c->leb_cnt < UBIFS_MIN_LEB_CNT) {
319 ubifs_err("bad leb_cnt on master node"); 319 ubifs_err(c, "bad leb_cnt on master node");
320 ubifs_dump_node(c, c->mst_node); 320 ubifs_dump_node(c, c->mst_node);
321 return -EINVAL; 321 return -EINVAL;
322 } 322 }
diff --git a/fs/ubifs/orphan.c b/fs/ubifs/orphan.c
index 4409f486ecef..caf2d123e9ee 100644
--- a/fs/ubifs/orphan.c
+++ b/fs/ubifs/orphan.c
@@ -88,7 +88,7 @@ int ubifs_add_orphan(struct ubifs_info *c, ino_t inum)
88 else if (inum > o->inum) 88 else if (inum > o->inum)
89 p = &(*p)->rb_right; 89 p = &(*p)->rb_right;
90 else { 90 else {
91 ubifs_err("orphaned twice"); 91 ubifs_err(c, "orphaned twice");
92 spin_unlock(&c->orphan_lock); 92 spin_unlock(&c->orphan_lock);
93 kfree(orphan); 93 kfree(orphan);
94 return 0; 94 return 0;
@@ -155,7 +155,7 @@ void ubifs_delete_orphan(struct ubifs_info *c, ino_t inum)
155 } 155 }
156 } 156 }
157 spin_unlock(&c->orphan_lock); 157 spin_unlock(&c->orphan_lock);
158 ubifs_err("missing orphan ino %lu", (unsigned long)inum); 158 ubifs_err(c, "missing orphan ino %lu", (unsigned long)inum);
159 dump_stack(); 159 dump_stack();
160} 160}
161 161
@@ -287,7 +287,7 @@ static int write_orph_node(struct ubifs_info *c, int atomic)
287 * We limit the number of orphans so that this should 287 * We limit the number of orphans so that this should
288 * never happen. 288 * never happen.
289 */ 289 */
290 ubifs_err("out of space in orphan area"); 290 ubifs_err(c, "out of space in orphan area");
291 return -EINVAL; 291 return -EINVAL;
292 } 292 }
293 } 293 }
@@ -397,7 +397,7 @@ static int consolidate(struct ubifs_info *c)
397 * We limit the number of orphans so that this should 397 * We limit the number of orphans so that this should
398 * never happen. 398 * never happen.
399 */ 399 */
400 ubifs_err("out of space in orphan area"); 400 ubifs_err(c, "out of space in orphan area");
401 err = -EINVAL; 401 err = -EINVAL;
402 } 402 }
403 spin_unlock(&c->orphan_lock); 403 spin_unlock(&c->orphan_lock);
@@ -569,7 +569,7 @@ static int do_kill_orphans(struct ubifs_info *c, struct ubifs_scan_leb *sleb,
569 569
570 list_for_each_entry(snod, &sleb->nodes, list) { 570 list_for_each_entry(snod, &sleb->nodes, list) {
571 if (snod->type != UBIFS_ORPH_NODE) { 571 if (snod->type != UBIFS_ORPH_NODE) {
572 ubifs_err("invalid node type %d in orphan area at %d:%d", 572 ubifs_err(c, "invalid node type %d in orphan area at %d:%d",
573 snod->type, sleb->lnum, snod->offs); 573 snod->type, sleb->lnum, snod->offs);
574 ubifs_dump_node(c, snod->node); 574 ubifs_dump_node(c, snod->node);
575 return -EINVAL; 575 return -EINVAL;
@@ -596,7 +596,7 @@ static int do_kill_orphans(struct ubifs_info *c, struct ubifs_scan_leb *sleb,
596 * number. That makes this orphan node, out of date. 596 * number. That makes this orphan node, out of date.
597 */ 597 */
598 if (!first) { 598 if (!first) {
599 ubifs_err("out of order commit number %llu in orphan node at %d:%d", 599 ubifs_err(c, "out of order commit number %llu in orphan node at %d:%d",
600 cmt_no, sleb->lnum, snod->offs); 600 cmt_no, sleb->lnum, snod->offs);
601 ubifs_dump_node(c, snod->node); 601 ubifs_dump_node(c, snod->node);
602 return -EINVAL; 602 return -EINVAL;
@@ -831,20 +831,20 @@ static int dbg_orphan_check(struct ubifs_info *c, struct ubifs_zbranch *zbr,
831 if (inum != ci->last_ino) { 831 if (inum != ci->last_ino) {
832 /* Lowest node type is the inode node, so it comes first */ 832 /* Lowest node type is the inode node, so it comes first */
833 if (key_type(c, &zbr->key) != UBIFS_INO_KEY) 833 if (key_type(c, &zbr->key) != UBIFS_INO_KEY)
834 ubifs_err("found orphan node ino %lu, type %d", 834 ubifs_err(c, "found orphan node ino %lu, type %d",
835 (unsigned long)inum, key_type(c, &zbr->key)); 835 (unsigned long)inum, key_type(c, &zbr->key));
836 ci->last_ino = inum; 836 ci->last_ino = inum;
837 ci->tot_inos += 1; 837 ci->tot_inos += 1;
838 err = ubifs_tnc_read_node(c, zbr, ci->node); 838 err = ubifs_tnc_read_node(c, zbr, ci->node);
839 if (err) { 839 if (err) {
840 ubifs_err("node read failed, error %d", err); 840 ubifs_err(c, "node read failed, error %d", err);
841 return err; 841 return err;
842 } 842 }
843 if (ci->node->nlink == 0) 843 if (ci->node->nlink == 0)
844 /* Must be recorded as an orphan */ 844 /* Must be recorded as an orphan */
845 if (!dbg_find_check_orphan(&ci->root, inum) && 845 if (!dbg_find_check_orphan(&ci->root, inum) &&
846 !dbg_find_orphan(c, inum)) { 846 !dbg_find_orphan(c, inum)) {
847 ubifs_err("missing orphan, ino %lu", 847 ubifs_err(c, "missing orphan, ino %lu",
848 (unsigned long)inum); 848 (unsigned long)inum);
849 ci->missing += 1; 849 ci->missing += 1;
850 } 850 }
@@ -887,7 +887,7 @@ static int dbg_scan_orphans(struct ubifs_info *c, struct check_info *ci)
887 887
888 buf = __vmalloc(c->leb_size, GFP_NOFS, PAGE_KERNEL); 888 buf = __vmalloc(c->leb_size, GFP_NOFS, PAGE_KERNEL);
889 if (!buf) { 889 if (!buf) {
890 ubifs_err("cannot allocate memory to check orphans"); 890 ubifs_err(c, "cannot allocate memory to check orphans");
891 return 0; 891 return 0;
892 } 892 }
893 893
@@ -925,7 +925,7 @@ static int dbg_check_orphans(struct ubifs_info *c)
925 ci.root = RB_ROOT; 925 ci.root = RB_ROOT;
926 ci.node = kmalloc(UBIFS_MAX_INO_NODE_SZ, GFP_NOFS); 926 ci.node = kmalloc(UBIFS_MAX_INO_NODE_SZ, GFP_NOFS);
927 if (!ci.node) { 927 if (!ci.node) {
928 ubifs_err("out of memory"); 928 ubifs_err(c, "out of memory");
929 return -ENOMEM; 929 return -ENOMEM;
930 } 930 }
931 931
@@ -935,12 +935,12 @@ static int dbg_check_orphans(struct ubifs_info *c)
935 935
936 err = dbg_walk_index(c, &dbg_orphan_check, NULL, &ci); 936 err = dbg_walk_index(c, &dbg_orphan_check, NULL, &ci);
937 if (err) { 937 if (err) {
938 ubifs_err("cannot scan TNC, error %d", err); 938 ubifs_err(c, "cannot scan TNC, error %d", err);
939 goto out; 939 goto out;
940 } 940 }
941 941
942 if (ci.missing) { 942 if (ci.missing) {
943 ubifs_err("%lu missing orphan(s)", ci.missing); 943 ubifs_err(c, "%lu missing orphan(s)", ci.missing);
944 err = -EINVAL; 944 err = -EINVAL;
945 goto out; 945 goto out;
946 } 946 }
diff --git a/fs/ubifs/recovery.c b/fs/ubifs/recovery.c
index 13ca4dbc4d19..695fc71d5244 100644
--- a/fs/ubifs/recovery.c
+++ b/fs/ubifs/recovery.c
@@ -305,7 +305,7 @@ int ubifs_recover_master_node(struct ubifs_info *c)
305 mst = mst2; 305 mst = mst2;
306 } 306 }
307 307
308 ubifs_msg("recovered master node from LEB %d", 308 ubifs_msg(c, "recovered master node from LEB %d",
309 (mst == mst1 ? UBIFS_MST_LNUM : UBIFS_MST_LNUM + 1)); 309 (mst == mst1 ? UBIFS_MST_LNUM : UBIFS_MST_LNUM + 1));
310 310
311 memcpy(c->mst_node, mst, UBIFS_MST_NODE_SZ); 311 memcpy(c->mst_node, mst, UBIFS_MST_NODE_SZ);
@@ -360,13 +360,13 @@ int ubifs_recover_master_node(struct ubifs_info *c)
360out_err: 360out_err:
361 err = -EINVAL; 361 err = -EINVAL;
362out_free: 362out_free:
363 ubifs_err("failed to recover master node"); 363 ubifs_err(c, "failed to recover master node");
364 if (mst1) { 364 if (mst1) {
365 ubifs_err("dumping first master node"); 365 ubifs_err(c, "dumping first master node");
366 ubifs_dump_node(c, mst1); 366 ubifs_dump_node(c, mst1);
367 } 367 }
368 if (mst2) { 368 if (mst2) {
369 ubifs_err("dumping second master node"); 369 ubifs_err(c, "dumping second master node");
370 ubifs_dump_node(c, mst2); 370 ubifs_dump_node(c, mst2);
371 } 371 }
372 vfree(buf2); 372 vfree(buf2);
@@ -682,7 +682,7 @@ struct ubifs_scan_leb *ubifs_recover_leb(struct ubifs_info *c, int lnum,
682 ret, lnum, offs); 682 ret, lnum, offs);
683 break; 683 break;
684 } else { 684 } else {
685 ubifs_err("unexpected return value %d", ret); 685 ubifs_err(c, "unexpected return value %d", ret);
686 err = -EINVAL; 686 err = -EINVAL;
687 goto error; 687 goto error;
688 } 688 }
@@ -702,7 +702,7 @@ struct ubifs_scan_leb *ubifs_recover_leb(struct ubifs_info *c, int lnum,
702 * See header comment for this file for more 702 * See header comment for this file for more
703 * explanations about the reasons we have this check. 703 * explanations about the reasons we have this check.
704 */ 704 */
705 ubifs_err("corrupt empty space LEB %d:%d, corruption starts at %d", 705 ubifs_err(c, "corrupt empty space LEB %d:%d, corruption starts at %d",
706 lnum, offs, corruption); 706 lnum, offs, corruption);
707 /* Make sure we dump interesting non-0xFF data */ 707 /* Make sure we dump interesting non-0xFF data */
708 offs += corruption; 708 offs += corruption;
@@ -788,13 +788,13 @@ struct ubifs_scan_leb *ubifs_recover_leb(struct ubifs_info *c, int lnum,
788 788
789corrupted_rescan: 789corrupted_rescan:
790 /* Re-scan the corrupted data with verbose messages */ 790 /* Re-scan the corrupted data with verbose messages */
791 ubifs_err("corruption %d", ret); 791 ubifs_err(c, "corruption %d", ret);
792 ubifs_scan_a_node(c, buf, len, lnum, offs, 1); 792 ubifs_scan_a_node(c, buf, len, lnum, offs, 1);
793corrupted: 793corrupted:
794 ubifs_scanned_corruption(c, lnum, offs, buf); 794 ubifs_scanned_corruption(c, lnum, offs, buf);
795 err = -EUCLEAN; 795 err = -EUCLEAN;
796error: 796error:
797 ubifs_err("LEB %d scanning failed", lnum); 797 ubifs_err(c, "LEB %d scanning failed", lnum);
798 ubifs_scan_destroy(sleb); 798 ubifs_scan_destroy(sleb);
799 return ERR_PTR(err); 799 return ERR_PTR(err);
800} 800}
@@ -826,15 +826,15 @@ static int get_cs_sqnum(struct ubifs_info *c, int lnum, int offs,
826 goto out_free; 826 goto out_free;
827 ret = ubifs_scan_a_node(c, cs_node, UBIFS_CS_NODE_SZ, lnum, offs, 0); 827 ret = ubifs_scan_a_node(c, cs_node, UBIFS_CS_NODE_SZ, lnum, offs, 0);
828 if (ret != SCANNED_A_NODE) { 828 if (ret != SCANNED_A_NODE) {
829 ubifs_err("Not a valid node"); 829 ubifs_err(c, "Not a valid node");
830 goto out_err; 830 goto out_err;
831 } 831 }
832 if (cs_node->ch.node_type != UBIFS_CS_NODE) { 832 if (cs_node->ch.node_type != UBIFS_CS_NODE) {
833 ubifs_err("Node a CS node, type is %d", cs_node->ch.node_type); 833 ubifs_err(c, "Node a CS node, type is %d", cs_node->ch.node_type);
834 goto out_err; 834 goto out_err;
835 } 835 }
836 if (le64_to_cpu(cs_node->cmt_no) != c->cmt_no) { 836 if (le64_to_cpu(cs_node->cmt_no) != c->cmt_no) {
837 ubifs_err("CS node cmt_no %llu != current cmt_no %llu", 837 ubifs_err(c, "CS node cmt_no %llu != current cmt_no %llu",
838 (unsigned long long)le64_to_cpu(cs_node->cmt_no), 838 (unsigned long long)le64_to_cpu(cs_node->cmt_no),
839 c->cmt_no); 839 c->cmt_no);
840 goto out_err; 840 goto out_err;
@@ -847,7 +847,7 @@ static int get_cs_sqnum(struct ubifs_info *c, int lnum, int offs,
847out_err: 847out_err:
848 err = -EINVAL; 848 err = -EINVAL;
849out_free: 849out_free:
850 ubifs_err("failed to get CS sqnum"); 850 ubifs_err(c, "failed to get CS sqnum");
851 kfree(cs_node); 851 kfree(cs_node);
852 return err; 852 return err;
853} 853}
@@ -899,7 +899,7 @@ struct ubifs_scan_leb *ubifs_recover_log_leb(struct ubifs_info *c, int lnum,
899 } 899 }
900 } 900 }
901 if (snod->sqnum > cs_sqnum) { 901 if (snod->sqnum > cs_sqnum) {
902 ubifs_err("unrecoverable log corruption in LEB %d", 902 ubifs_err(c, "unrecoverable log corruption in LEB %d",
903 lnum); 903 lnum);
904 ubifs_scan_destroy(sleb); 904 ubifs_scan_destroy(sleb);
905 return ERR_PTR(-EUCLEAN); 905 return ERR_PTR(-EUCLEAN);
@@ -1037,7 +1037,7 @@ static int clean_an_unclean_leb(struct ubifs_info *c,
1037 } 1037 }
1038 1038
1039 if (ret == SCANNED_EMPTY_SPACE) { 1039 if (ret == SCANNED_EMPTY_SPACE) {
1040 ubifs_err("unexpected empty space at %d:%d", 1040 ubifs_err(c, "unexpected empty space at %d:%d",
1041 lnum, offs); 1041 lnum, offs);
1042 return -EUCLEAN; 1042 return -EUCLEAN;
1043 } 1043 }
@@ -1131,7 +1131,7 @@ static int grab_empty_leb(struct ubifs_info *c)
1131 */ 1131 */
1132 lnum = ubifs_find_free_leb_for_idx(c); 1132 lnum = ubifs_find_free_leb_for_idx(c);
1133 if (lnum < 0) { 1133 if (lnum < 0) {
1134 ubifs_err("could not find an empty LEB"); 1134 ubifs_err(c, "could not find an empty LEB");
1135 ubifs_dump_lprops(c); 1135 ubifs_dump_lprops(c);
1136 ubifs_dump_budg(c, &c->bi); 1136 ubifs_dump_budg(c, &c->bi);
1137 return lnum; 1137 return lnum;
@@ -1211,7 +1211,7 @@ int ubifs_rcvry_gc_commit(struct ubifs_info *c)
1211 } 1211 }
1212 mutex_unlock(&wbuf->io_mutex); 1212 mutex_unlock(&wbuf->io_mutex);
1213 if (err < 0) { 1213 if (err < 0) {
1214 ubifs_err("GC failed, error %d", err); 1214 ubifs_err(c, "GC failed, error %d", err);
1215 if (err == -EAGAIN) 1215 if (err == -EAGAIN)
1216 err = -EINVAL; 1216 err = -EINVAL;
1217 return err; 1217 return err;
@@ -1458,7 +1458,7 @@ static int fix_size_in_place(struct ubifs_info *c, struct size_entry *e)
1458 return 0; 1458 return 0;
1459 1459
1460out: 1460out:
1461 ubifs_warn("inode %lu failed to fix size %lld -> %lld error %d", 1461 ubifs_warn(c, "inode %lu failed to fix size %lld -> %lld error %d",
1462 (unsigned long)e->inum, e->i_size, e->d_size, err); 1462 (unsigned long)e->inum, e->i_size, e->d_size, err);
1463 return err; 1463 return err;
1464} 1464}
diff --git a/fs/ubifs/replay.c b/fs/ubifs/replay.c
index 9b40a1c5e160..3ca4540130b5 100644
--- a/fs/ubifs/replay.c
+++ b/fs/ubifs/replay.c
@@ -458,13 +458,13 @@ int ubifs_validate_entry(struct ubifs_info *c,
458 nlen > UBIFS_MAX_NLEN || dent->name[nlen] != 0 || 458 nlen > UBIFS_MAX_NLEN || dent->name[nlen] != 0 ||
459 strnlen(dent->name, nlen) != nlen || 459 strnlen(dent->name, nlen) != nlen ||
460 le64_to_cpu(dent->inum) > MAX_INUM) { 460 le64_to_cpu(dent->inum) > MAX_INUM) {
461 ubifs_err("bad %s node", key_type == UBIFS_DENT_KEY ? 461 ubifs_err(c, "bad %s node", key_type == UBIFS_DENT_KEY ?
462 "directory entry" : "extended attribute entry"); 462 "directory entry" : "extended attribute entry");
463 return -EINVAL; 463 return -EINVAL;
464 } 464 }
465 465
466 if (key_type != UBIFS_DENT_KEY && key_type != UBIFS_XENT_KEY) { 466 if (key_type != UBIFS_DENT_KEY && key_type != UBIFS_XENT_KEY) {
467 ubifs_err("bad key type %d", key_type); 467 ubifs_err(c, "bad key type %d", key_type);
468 return -EINVAL; 468 return -EINVAL;
469 } 469 }
470 470
@@ -589,7 +589,7 @@ static int replay_bud(struct ubifs_info *c, struct bud_entry *b)
589 cond_resched(); 589 cond_resched();
590 590
591 if (snod->sqnum >= SQNUM_WATERMARK) { 591 if (snod->sqnum >= SQNUM_WATERMARK) {
592 ubifs_err("file system's life ended"); 592 ubifs_err(c, "file system's life ended");
593 goto out_dump; 593 goto out_dump;
594 } 594 }
595 595
@@ -647,7 +647,7 @@ static int replay_bud(struct ubifs_info *c, struct bud_entry *b)
647 if (old_size < 0 || old_size > c->max_inode_sz || 647 if (old_size < 0 || old_size > c->max_inode_sz ||
648 new_size < 0 || new_size > c->max_inode_sz || 648 new_size < 0 || new_size > c->max_inode_sz ||
649 old_size <= new_size) { 649 old_size <= new_size) {
650 ubifs_err("bad truncation node"); 650 ubifs_err(c, "bad truncation node");
651 goto out_dump; 651 goto out_dump;
652 } 652 }
653 653
@@ -662,7 +662,7 @@ static int replay_bud(struct ubifs_info *c, struct bud_entry *b)
662 break; 662 break;
663 } 663 }
664 default: 664 default:
665 ubifs_err("unexpected node type %d in bud LEB %d:%d", 665 ubifs_err(c, "unexpected node type %d in bud LEB %d:%d",
666 snod->type, lnum, snod->offs); 666 snod->type, lnum, snod->offs);
667 err = -EINVAL; 667 err = -EINVAL;
668 goto out_dump; 668 goto out_dump;
@@ -685,7 +685,7 @@ out:
685 return err; 685 return err;
686 686
687out_dump: 687out_dump:
688 ubifs_err("bad node is at LEB %d:%d", lnum, snod->offs); 688 ubifs_err(c, "bad node is at LEB %d:%d", lnum, snod->offs);
689 ubifs_dump_node(c, snod->node); 689 ubifs_dump_node(c, snod->node);
690 ubifs_scan_destroy(sleb); 690 ubifs_scan_destroy(sleb);
691 return -EINVAL; 691 return -EINVAL;
@@ -805,7 +805,7 @@ static int validate_ref(struct ubifs_info *c, const struct ubifs_ref_node *ref)
805 if (bud) { 805 if (bud) {
806 if (bud->jhead == jhead && bud->start <= offs) 806 if (bud->jhead == jhead && bud->start <= offs)
807 return 1; 807 return 1;
808 ubifs_err("bud at LEB %d:%d was already referred", lnum, offs); 808 ubifs_err(c, "bud at LEB %d:%d was already referred", lnum, offs);
809 return -EINVAL; 809 return -EINVAL;
810 } 810 }
811 811
@@ -861,12 +861,12 @@ static int replay_log_leb(struct ubifs_info *c, int lnum, int offs, void *sbuf)
861 * numbers. 861 * numbers.
862 */ 862 */
863 if (snod->type != UBIFS_CS_NODE) { 863 if (snod->type != UBIFS_CS_NODE) {
864 ubifs_err("first log node at LEB %d:%d is not CS node", 864 ubifs_err(c, "first log node at LEB %d:%d is not CS node",
865 lnum, offs); 865 lnum, offs);
866 goto out_dump; 866 goto out_dump;
867 } 867 }
868 if (le64_to_cpu(node->cmt_no) != c->cmt_no) { 868 if (le64_to_cpu(node->cmt_no) != c->cmt_no) {
869 ubifs_err("first CS node at LEB %d:%d has wrong commit number %llu expected %llu", 869 ubifs_err(c, "first CS node at LEB %d:%d has wrong commit number %llu expected %llu",
870 lnum, offs, 870 lnum, offs,
871 (unsigned long long)le64_to_cpu(node->cmt_no), 871 (unsigned long long)le64_to_cpu(node->cmt_no),
872 c->cmt_no); 872 c->cmt_no);
@@ -891,7 +891,7 @@ static int replay_log_leb(struct ubifs_info *c, int lnum, int offs, void *sbuf)
891 891
892 /* Make sure the first node sits at offset zero of the LEB */ 892 /* Make sure the first node sits at offset zero of the LEB */
893 if (snod->offs != 0) { 893 if (snod->offs != 0) {
894 ubifs_err("first node is not at zero offset"); 894 ubifs_err(c, "first node is not at zero offset");
895 goto out_dump; 895 goto out_dump;
896 } 896 }
897 897
@@ -899,12 +899,12 @@ static int replay_log_leb(struct ubifs_info *c, int lnum, int offs, void *sbuf)
899 cond_resched(); 899 cond_resched();
900 900
901 if (snod->sqnum >= SQNUM_WATERMARK) { 901 if (snod->sqnum >= SQNUM_WATERMARK) {
902 ubifs_err("file system's life ended"); 902 ubifs_err(c, "file system's life ended");
903 goto out_dump; 903 goto out_dump;
904 } 904 }
905 905
906 if (snod->sqnum < c->cs_sqnum) { 906 if (snod->sqnum < c->cs_sqnum) {
907 ubifs_err("bad sqnum %llu, commit sqnum %llu", 907 ubifs_err(c, "bad sqnum %llu, commit sqnum %llu",
908 snod->sqnum, c->cs_sqnum); 908 snod->sqnum, c->cs_sqnum);
909 goto out_dump; 909 goto out_dump;
910 } 910 }
@@ -934,12 +934,12 @@ static int replay_log_leb(struct ubifs_info *c, int lnum, int offs, void *sbuf)
934 case UBIFS_CS_NODE: 934 case UBIFS_CS_NODE:
935 /* Make sure it sits at the beginning of LEB */ 935 /* Make sure it sits at the beginning of LEB */
936 if (snod->offs != 0) { 936 if (snod->offs != 0) {
937 ubifs_err("unexpected node in log"); 937 ubifs_err(c, "unexpected node in log");
938 goto out_dump; 938 goto out_dump;
939 } 939 }
940 break; 940 break;
941 default: 941 default:
942 ubifs_err("unexpected node in log"); 942 ubifs_err(c, "unexpected node in log");
943 goto out_dump; 943 goto out_dump;
944 } 944 }
945 } 945 }
@@ -955,7 +955,7 @@ out:
955 return err; 955 return err;
956 956
957out_dump: 957out_dump:
958 ubifs_err("log error detected while replaying the log at LEB %d:%d", 958 ubifs_err(c, "log error detected while replaying the log at LEB %d:%d",
959 lnum, offs + snod->offs); 959 lnum, offs + snod->offs);
960 ubifs_dump_node(c, snod->node); 960 ubifs_dump_node(c, snod->node);
961 ubifs_scan_destroy(sleb); 961 ubifs_scan_destroy(sleb);
@@ -1017,7 +1017,7 @@ int ubifs_replay_journal(struct ubifs_info *c)
1017 return free; /* Error code */ 1017 return free; /* Error code */
1018 1018
1019 if (c->ihead_offs != c->leb_size - free) { 1019 if (c->ihead_offs != c->leb_size - free) {
1020 ubifs_err("bad index head LEB %d:%d", c->ihead_lnum, 1020 ubifs_err(c, "bad index head LEB %d:%d", c->ihead_lnum,
1021 c->ihead_offs); 1021 c->ihead_offs);
1022 return -EINVAL; 1022 return -EINVAL;
1023 } 1023 }
@@ -1040,7 +1040,7 @@ int ubifs_replay_journal(struct ubifs_info *c)
1040 * someting went wrong and we cannot proceed mounting 1040 * someting went wrong and we cannot proceed mounting
1041 * the file-system. 1041 * the file-system.
1042 */ 1042 */
1043 ubifs_err("no UBIFS nodes found at the log head LEB %d:%d, possibly corrupted", 1043 ubifs_err(c, "no UBIFS nodes found at the log head LEB %d:%d, possibly corrupted",
1044 lnum, 0); 1044 lnum, 0);
1045 err = -EINVAL; 1045 err = -EINVAL;
1046 } 1046 }
diff --git a/fs/ubifs/sb.c b/fs/ubifs/sb.c
index 79c6dbbc0e04..f4fbc7b6b794 100644
--- a/fs/ubifs/sb.c
+++ b/fs/ubifs/sb.c
@@ -335,7 +335,7 @@ static int create_default_filesystem(struct ubifs_info *c)
335 if (err) 335 if (err)
336 return err; 336 return err;
337 337
338 ubifs_msg("default file-system created"); 338 ubifs_msg(c, "default file-system created");
339 return 0; 339 return 0;
340} 340}
341 341
@@ -365,13 +365,13 @@ static int validate_sb(struct ubifs_info *c, struct ubifs_sb_node *sup)
365 } 365 }
366 366
367 if (le32_to_cpu(sup->min_io_size) != c->min_io_size) { 367 if (le32_to_cpu(sup->min_io_size) != c->min_io_size) {
368 ubifs_err("min. I/O unit mismatch: %d in superblock, %d real", 368 ubifs_err(c, "min. I/O unit mismatch: %d in superblock, %d real",
369 le32_to_cpu(sup->min_io_size), c->min_io_size); 369 le32_to_cpu(sup->min_io_size), c->min_io_size);
370 goto failed; 370 goto failed;
371 } 371 }
372 372
373 if (le32_to_cpu(sup->leb_size) != c->leb_size) { 373 if (le32_to_cpu(sup->leb_size) != c->leb_size) {
374 ubifs_err("LEB size mismatch: %d in superblock, %d real", 374 ubifs_err(c, "LEB size mismatch: %d in superblock, %d real",
375 le32_to_cpu(sup->leb_size), c->leb_size); 375 le32_to_cpu(sup->leb_size), c->leb_size);
376 goto failed; 376 goto failed;
377 } 377 }
@@ -393,33 +393,33 @@ static int validate_sb(struct ubifs_info *c, struct ubifs_sb_node *sup)
393 min_leb_cnt += c->lpt_lebs + c->orph_lebs + c->jhead_cnt + 6; 393 min_leb_cnt += c->lpt_lebs + c->orph_lebs + c->jhead_cnt + 6;
394 394
395 if (c->leb_cnt < min_leb_cnt || c->leb_cnt > c->vi.size) { 395 if (c->leb_cnt < min_leb_cnt || c->leb_cnt > c->vi.size) {
396 ubifs_err("bad LEB count: %d in superblock, %d on UBI volume, %d minimum required", 396 ubifs_err(c, "bad LEB count: %d in superblock, %d on UBI volume, %d minimum required",
397 c->leb_cnt, c->vi.size, min_leb_cnt); 397 c->leb_cnt, c->vi.size, min_leb_cnt);
398 goto failed; 398 goto failed;
399 } 399 }
400 400
401 if (c->max_leb_cnt < c->leb_cnt) { 401 if (c->max_leb_cnt < c->leb_cnt) {
402 ubifs_err("max. LEB count %d less than LEB count %d", 402 ubifs_err(c, "max. LEB count %d less than LEB count %d",
403 c->max_leb_cnt, c->leb_cnt); 403 c->max_leb_cnt, c->leb_cnt);
404 goto failed; 404 goto failed;
405 } 405 }
406 406
407 if (c->main_lebs < UBIFS_MIN_MAIN_LEBS) { 407 if (c->main_lebs < UBIFS_MIN_MAIN_LEBS) {
408 ubifs_err("too few main LEBs count %d, must be at least %d", 408 ubifs_err(c, "too few main LEBs count %d, must be at least %d",
409 c->main_lebs, UBIFS_MIN_MAIN_LEBS); 409 c->main_lebs, UBIFS_MIN_MAIN_LEBS);
410 goto failed; 410 goto failed;
411 } 411 }
412 412
413 max_bytes = (long long)c->leb_size * UBIFS_MIN_BUD_LEBS; 413 max_bytes = (long long)c->leb_size * UBIFS_MIN_BUD_LEBS;
414 if (c->max_bud_bytes < max_bytes) { 414 if (c->max_bud_bytes < max_bytes) {
415 ubifs_err("too small journal (%lld bytes), must be at least %lld bytes", 415 ubifs_err(c, "too small journal (%lld bytes), must be at least %lld bytes",
416 c->max_bud_bytes, max_bytes); 416 c->max_bud_bytes, max_bytes);
417 goto failed; 417 goto failed;
418 } 418 }
419 419
420 max_bytes = (long long)c->leb_size * c->main_lebs; 420 max_bytes = (long long)c->leb_size * c->main_lebs;
421 if (c->max_bud_bytes > max_bytes) { 421 if (c->max_bud_bytes > max_bytes) {
422 ubifs_err("too large journal size (%lld bytes), only %lld bytes available in the main area", 422 ubifs_err(c, "too large journal size (%lld bytes), only %lld bytes available in the main area",
423 c->max_bud_bytes, max_bytes); 423 c->max_bud_bytes, max_bytes);
424 goto failed; 424 goto failed;
425 } 425 }
@@ -468,7 +468,7 @@ static int validate_sb(struct ubifs_info *c, struct ubifs_sb_node *sup)
468 return 0; 468 return 0;
469 469
470failed: 470failed:
471 ubifs_err("bad superblock, error %d", err); 471 ubifs_err(c, "bad superblock, error %d", err);
472 ubifs_dump_node(c, sup); 472 ubifs_dump_node(c, sup);
473 return -EINVAL; 473 return -EINVAL;
474} 474}
@@ -549,12 +549,12 @@ int ubifs_read_superblock(struct ubifs_info *c)
549 ubifs_assert(!c->ro_media || c->ro_mount); 549 ubifs_assert(!c->ro_media || c->ro_mount);
550 if (!c->ro_mount || 550 if (!c->ro_mount ||
551 c->ro_compat_version > UBIFS_RO_COMPAT_VERSION) { 551 c->ro_compat_version > UBIFS_RO_COMPAT_VERSION) {
552 ubifs_err("on-flash format version is w%d/r%d, but software only supports up to version w%d/r%d", 552 ubifs_err(c, "on-flash format version is w%d/r%d, but software only supports up to version w%d/r%d",
553 c->fmt_version, c->ro_compat_version, 553 c->fmt_version, c->ro_compat_version,
554 UBIFS_FORMAT_VERSION, 554 UBIFS_FORMAT_VERSION,
555 UBIFS_RO_COMPAT_VERSION); 555 UBIFS_RO_COMPAT_VERSION);
556 if (c->ro_compat_version <= UBIFS_RO_COMPAT_VERSION) { 556 if (c->ro_compat_version <= UBIFS_RO_COMPAT_VERSION) {
557 ubifs_msg("only R/O mounting is possible"); 557 ubifs_msg(c, "only R/O mounting is possible");
558 err = -EROFS; 558 err = -EROFS;
559 } else 559 } else
560 err = -EINVAL; 560 err = -EINVAL;
@@ -570,7 +570,7 @@ int ubifs_read_superblock(struct ubifs_info *c)
570 } 570 }
571 571
572 if (c->fmt_version < 3) { 572 if (c->fmt_version < 3) {
573 ubifs_err("on-flash format version %d is not supported", 573 ubifs_err(c, "on-flash format version %d is not supported",
574 c->fmt_version); 574 c->fmt_version);
575 err = -EINVAL; 575 err = -EINVAL;
576 goto out; 576 goto out;
@@ -595,7 +595,7 @@ int ubifs_read_superblock(struct ubifs_info *c)
595 c->key_len = UBIFS_SK_LEN; 595 c->key_len = UBIFS_SK_LEN;
596 break; 596 break;
597 default: 597 default:
598 ubifs_err("unsupported key format"); 598 ubifs_err(c, "unsupported key format");
599 err = -EINVAL; 599 err = -EINVAL;
600 goto out; 600 goto out;
601 } 601 }
@@ -785,7 +785,7 @@ int ubifs_fixup_free_space(struct ubifs_info *c)
785 ubifs_assert(c->space_fixup); 785 ubifs_assert(c->space_fixup);
786 ubifs_assert(!c->ro_mount); 786 ubifs_assert(!c->ro_mount);
787 787
788 ubifs_msg("start fixing up free space"); 788 ubifs_msg(c, "start fixing up free space");
789 789
790 err = fixup_free_space(c); 790 err = fixup_free_space(c);
791 if (err) 791 if (err)
@@ -804,6 +804,6 @@ int ubifs_fixup_free_space(struct ubifs_info *c)
804 if (err) 804 if (err)
805 return err; 805 return err;
806 806
807 ubifs_msg("free space fixup complete"); 807 ubifs_msg(c, "free space fixup complete");
808 return err; 808 return err;
809} 809}
diff --git a/fs/ubifs/scan.c b/fs/ubifs/scan.c
index 89adbc4d08ac..aab87340d3de 100644
--- a/fs/ubifs/scan.c
+++ b/fs/ubifs/scan.c
@@ -100,7 +100,7 @@ int ubifs_scan_a_node(const struct ubifs_info *c, void *buf, int len, int lnum,
100 if (pad_len < 0 || 100 if (pad_len < 0 ||
101 offs + node_len + pad_len > c->leb_size) { 101 offs + node_len + pad_len > c->leb_size) {
102 if (!quiet) { 102 if (!quiet) {
103 ubifs_err("bad pad node at LEB %d:%d", 103 ubifs_err(c, "bad pad node at LEB %d:%d",
104 lnum, offs); 104 lnum, offs);
105 ubifs_dump_node(c, pad); 105 ubifs_dump_node(c, pad);
106 } 106 }
@@ -110,7 +110,7 @@ int ubifs_scan_a_node(const struct ubifs_info *c, void *buf, int len, int lnum,
110 /* Make the node pads to 8-byte boundary */ 110 /* Make the node pads to 8-byte boundary */
111 if ((node_len + pad_len) & 7) { 111 if ((node_len + pad_len) & 7) {
112 if (!quiet) 112 if (!quiet)
113 ubifs_err("bad padding length %d - %d", 113 ubifs_err(c, "bad padding length %d - %d",
114 offs, offs + node_len + pad_len); 114 offs, offs + node_len + pad_len);
115 return SCANNED_A_BAD_PAD_NODE; 115 return SCANNED_A_BAD_PAD_NODE;
116 } 116 }
@@ -152,7 +152,7 @@ struct ubifs_scan_leb *ubifs_start_scan(const struct ubifs_info *c, int lnum,
152 152
153 err = ubifs_leb_read(c, lnum, sbuf + offs, offs, c->leb_size - offs, 0); 153 err = ubifs_leb_read(c, lnum, sbuf + offs, offs, c->leb_size - offs, 0);
154 if (err && err != -EBADMSG) { 154 if (err && err != -EBADMSG) {
155 ubifs_err("cannot read %d bytes from LEB %d:%d, error %d", 155 ubifs_err(c, "cannot read %d bytes from LEB %d:%d, error %d",
156 c->leb_size - offs, lnum, offs, err); 156 c->leb_size - offs, lnum, offs, err);
157 kfree(sleb); 157 kfree(sleb);
158 return ERR_PTR(err); 158 return ERR_PTR(err);
@@ -240,11 +240,11 @@ void ubifs_scanned_corruption(const struct ubifs_info *c, int lnum, int offs,
240{ 240{
241 int len; 241 int len;
242 242
243 ubifs_err("corruption at LEB %d:%d", lnum, offs); 243 ubifs_err(c, "corruption at LEB %d:%d", lnum, offs);
244 len = c->leb_size - offs; 244 len = c->leb_size - offs;
245 if (len > 8192) 245 if (len > 8192)
246 len = 8192; 246 len = 8192;
247 ubifs_err("first %d bytes from LEB %d:%d", len, lnum, offs); 247 ubifs_err(c, "first %d bytes from LEB %d:%d", len, lnum, offs);
248 print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET, 32, 4, buf, len, 1); 248 print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET, 32, 4, buf, len, 1);
249} 249}
250 250
@@ -299,16 +299,16 @@ struct ubifs_scan_leb *ubifs_scan(const struct ubifs_info *c, int lnum,
299 299
300 switch (ret) { 300 switch (ret) {
301 case SCANNED_GARBAGE: 301 case SCANNED_GARBAGE:
302 ubifs_err("garbage"); 302 ubifs_err(c, "garbage");
303 goto corrupted; 303 goto corrupted;
304 case SCANNED_A_NODE: 304 case SCANNED_A_NODE:
305 break; 305 break;
306 case SCANNED_A_CORRUPT_NODE: 306 case SCANNED_A_CORRUPT_NODE:
307 case SCANNED_A_BAD_PAD_NODE: 307 case SCANNED_A_BAD_PAD_NODE:
308 ubifs_err("bad node"); 308 ubifs_err(c, "bad node");
309 goto corrupted; 309 goto corrupted;
310 default: 310 default:
311 ubifs_err("unknown"); 311 ubifs_err(c, "unknown");
312 err = -EINVAL; 312 err = -EINVAL;
313 goto error; 313 goto error;
314 } 314 }
@@ -325,7 +325,7 @@ struct ubifs_scan_leb *ubifs_scan(const struct ubifs_info *c, int lnum,
325 325
326 if (offs % c->min_io_size) { 326 if (offs % c->min_io_size) {
327 if (!quiet) 327 if (!quiet)
328 ubifs_err("empty space starts at non-aligned offset %d", 328 ubifs_err(c, "empty space starts at non-aligned offset %d",
329 offs); 329 offs);
330 goto corrupted; 330 goto corrupted;
331 } 331 }
@@ -338,7 +338,7 @@ struct ubifs_scan_leb *ubifs_scan(const struct ubifs_info *c, int lnum,
338 for (; len; offs++, buf++, len--) 338 for (; len; offs++, buf++, len--)
339 if (*(uint8_t *)buf != 0xff) { 339 if (*(uint8_t *)buf != 0xff) {
340 if (!quiet) 340 if (!quiet)
341 ubifs_err("corrupt empty space at LEB %d:%d", 341 ubifs_err(c, "corrupt empty space at LEB %d:%d",
342 lnum, offs); 342 lnum, offs);
343 goto corrupted; 343 goto corrupted;
344 } 344 }
@@ -348,14 +348,14 @@ struct ubifs_scan_leb *ubifs_scan(const struct ubifs_info *c, int lnum,
348corrupted: 348corrupted:
349 if (!quiet) { 349 if (!quiet) {
350 ubifs_scanned_corruption(c, lnum, offs, buf); 350 ubifs_scanned_corruption(c, lnum, offs, buf);
351 ubifs_err("LEB %d scanning failed", lnum); 351 ubifs_err(c, "LEB %d scanning failed", lnum);
352 } 352 }
353 err = -EUCLEAN; 353 err = -EUCLEAN;
354 ubifs_scan_destroy(sleb); 354 ubifs_scan_destroy(sleb);
355 return ERR_PTR(err); 355 return ERR_PTR(err);
356 356
357error: 357error:
358 ubifs_err("LEB %d scanning failed, error %d", lnum, err); 358 ubifs_err(c, "LEB %d scanning failed, error %d", lnum, err);
359 ubifs_scan_destroy(sleb); 359 ubifs_scan_destroy(sleb);
360 return ERR_PTR(err); 360 return ERR_PTR(err);
361} 361}
diff --git a/fs/ubifs/super.c b/fs/ubifs/super.c
index 0b7378a7ee04..75e6f04bb795 100644
--- a/fs/ubifs/super.c
+++ b/fs/ubifs/super.c
@@ -70,13 +70,13 @@ static int validate_inode(struct ubifs_info *c, const struct inode *inode)
70 const struct ubifs_inode *ui = ubifs_inode(inode); 70 const struct ubifs_inode *ui = ubifs_inode(inode);
71 71
72 if (inode->i_size > c->max_inode_sz) { 72 if (inode->i_size > c->max_inode_sz) {
73 ubifs_err("inode is too large (%lld)", 73 ubifs_err(c, "inode is too large (%lld)",
74 (long long)inode->i_size); 74 (long long)inode->i_size);
75 return 1; 75 return 1;
76 } 76 }
77 77
78 if (ui->compr_type >= UBIFS_COMPR_TYPES_CNT) { 78 if (ui->compr_type >= UBIFS_COMPR_TYPES_CNT) {
79 ubifs_err("unknown compression type %d", ui->compr_type); 79 ubifs_err(c, "unknown compression type %d", ui->compr_type);
80 return 2; 80 return 2;
81 } 81 }
82 82
@@ -90,7 +90,7 @@ static int validate_inode(struct ubifs_info *c, const struct inode *inode)
90 return 5; 90 return 5;
91 91
92 if (!ubifs_compr_present(ui->compr_type)) { 92 if (!ubifs_compr_present(ui->compr_type)) {
93 ubifs_warn("inode %lu uses '%s' compression, but it was not compiled in", 93 ubifs_warn(c, "inode %lu uses '%s' compression, but it was not compiled in",
94 inode->i_ino, ubifs_compr_name(ui->compr_type)); 94 inode->i_ino, ubifs_compr_name(ui->compr_type));
95 } 95 }
96 96
@@ -242,14 +242,14 @@ struct inode *ubifs_iget(struct super_block *sb, unsigned long inum)
242 return inode; 242 return inode;
243 243
244out_invalid: 244out_invalid:
245 ubifs_err("inode %lu validation failed, error %d", inode->i_ino, err); 245 ubifs_err(c, "inode %lu validation failed, error %d", inode->i_ino, err);
246 ubifs_dump_node(c, ino); 246 ubifs_dump_node(c, ino);
247 ubifs_dump_inode(c, inode); 247 ubifs_dump_inode(c, inode);
248 err = -EINVAL; 248 err = -EINVAL;
249out_ino: 249out_ino:
250 kfree(ino); 250 kfree(ino);
251out: 251out:
252 ubifs_err("failed to read inode %lu, error %d", inode->i_ino, err); 252 ubifs_err(c, "failed to read inode %lu, error %d", inode->i_ino, err);
253 iget_failed(inode); 253 iget_failed(inode);
254 return ERR_PTR(err); 254 return ERR_PTR(err);
255} 255}
@@ -319,7 +319,7 @@ static int ubifs_write_inode(struct inode *inode, struct writeback_control *wbc)
319 if (inode->i_nlink) { 319 if (inode->i_nlink) {
320 err = ubifs_jnl_write_inode(c, inode); 320 err = ubifs_jnl_write_inode(c, inode);
321 if (err) 321 if (err)
322 ubifs_err("can't write inode %lu, error %d", 322 ubifs_err(c, "can't write inode %lu, error %d",
323 inode->i_ino, err); 323 inode->i_ino, err);
324 else 324 else
325 err = dbg_check_inode_size(c, inode, ui->ui_size); 325 err = dbg_check_inode_size(c, inode, ui->ui_size);
@@ -363,7 +363,7 @@ static void ubifs_evict_inode(struct inode *inode)
363 * Worst case we have a lost orphan inode wasting space, so a 363 * Worst case we have a lost orphan inode wasting space, so a
364 * simple error message is OK here. 364 * simple error message is OK here.
365 */ 365 */
366 ubifs_err("can't delete inode %lu, error %d", 366 ubifs_err(c, "can't delete inode %lu, error %d",
367 inode->i_ino, err); 367 inode->i_ino, err);
368 368
369out: 369out:
@@ -492,17 +492,17 @@ static int ubifs_sync_fs(struct super_block *sb, int wait)
492static int init_constants_early(struct ubifs_info *c) 492static int init_constants_early(struct ubifs_info *c)
493{ 493{
494 if (c->vi.corrupted) { 494 if (c->vi.corrupted) {
495 ubifs_warn("UBI volume is corrupted - read-only mode"); 495 ubifs_warn(c, "UBI volume is corrupted - read-only mode");
496 c->ro_media = 1; 496 c->ro_media = 1;
497 } 497 }
498 498
499 if (c->di.ro_mode) { 499 if (c->di.ro_mode) {
500 ubifs_msg("read-only UBI device"); 500 ubifs_msg(c, "read-only UBI device");
501 c->ro_media = 1; 501 c->ro_media = 1;
502 } 502 }
503 503
504 if (c->vi.vol_type == UBI_STATIC_VOLUME) { 504 if (c->vi.vol_type == UBI_STATIC_VOLUME) {
505 ubifs_msg("static UBI volume - read-only mode"); 505 ubifs_msg(c, "static UBI volume - read-only mode");
506 c->ro_media = 1; 506 c->ro_media = 1;
507 } 507 }
508 508
@@ -516,19 +516,19 @@ static int init_constants_early(struct ubifs_info *c)
516 c->max_write_shift = fls(c->max_write_size) - 1; 516 c->max_write_shift = fls(c->max_write_size) - 1;
517 517
518 if (c->leb_size < UBIFS_MIN_LEB_SZ) { 518 if (c->leb_size < UBIFS_MIN_LEB_SZ) {
519 ubifs_err("too small LEBs (%d bytes), min. is %d bytes", 519 ubifs_err(c, "too small LEBs (%d bytes), min. is %d bytes",
520 c->leb_size, UBIFS_MIN_LEB_SZ); 520 c->leb_size, UBIFS_MIN_LEB_SZ);
521 return -EINVAL; 521 return -EINVAL;
522 } 522 }
523 523
524 if (c->leb_cnt < UBIFS_MIN_LEB_CNT) { 524 if (c->leb_cnt < UBIFS_MIN_LEB_CNT) {
525 ubifs_err("too few LEBs (%d), min. is %d", 525 ubifs_err(c, "too few LEBs (%d), min. is %d",
526 c->leb_cnt, UBIFS_MIN_LEB_CNT); 526 c->leb_cnt, UBIFS_MIN_LEB_CNT);
527 return -EINVAL; 527 return -EINVAL;
528 } 528 }
529 529
530 if (!is_power_of_2(c->min_io_size)) { 530 if (!is_power_of_2(c->min_io_size)) {
531 ubifs_err("bad min. I/O size %d", c->min_io_size); 531 ubifs_err(c, "bad min. I/O size %d", c->min_io_size);
532 return -EINVAL; 532 return -EINVAL;
533 } 533 }
534 534
@@ -539,7 +539,7 @@ static int init_constants_early(struct ubifs_info *c)
539 if (c->max_write_size < c->min_io_size || 539 if (c->max_write_size < c->min_io_size ||
540 c->max_write_size % c->min_io_size || 540 c->max_write_size % c->min_io_size ||
541 !is_power_of_2(c->max_write_size)) { 541 !is_power_of_2(c->max_write_size)) {
542 ubifs_err("bad write buffer size %d for %d min. I/O unit", 542 ubifs_err(c, "bad write buffer size %d for %d min. I/O unit",
543 c->max_write_size, c->min_io_size); 543 c->max_write_size, c->min_io_size);
544 return -EINVAL; 544 return -EINVAL;
545 } 545 }
@@ -665,7 +665,7 @@ static int init_constants_sb(struct ubifs_info *c)
665 tmp = UBIFS_CS_NODE_SZ + UBIFS_REF_NODE_SZ * c->jhead_cnt; 665 tmp = UBIFS_CS_NODE_SZ + UBIFS_REF_NODE_SZ * c->jhead_cnt;
666 tmp = ALIGN(tmp, c->min_io_size); 666 tmp = ALIGN(tmp, c->min_io_size);
667 if (tmp > c->leb_size) { 667 if (tmp > c->leb_size) {
668 ubifs_err("too small LEB size %d, at least %d needed", 668 ubifs_err(c, "too small LEB size %d, at least %d needed",
669 c->leb_size, tmp); 669 c->leb_size, tmp);
670 return -EINVAL; 670 return -EINVAL;
671 } 671 }
@@ -680,7 +680,7 @@ static int init_constants_sb(struct ubifs_info *c)
680 tmp /= c->leb_size; 680 tmp /= c->leb_size;
681 tmp += 1; 681 tmp += 1;
682 if (c->log_lebs < tmp) { 682 if (c->log_lebs < tmp) {
683 ubifs_err("too small log %d LEBs, required min. %d LEBs", 683 ubifs_err(c, "too small log %d LEBs, required min. %d LEBs",
684 c->log_lebs, tmp); 684 c->log_lebs, tmp);
685 return -EINVAL; 685 return -EINVAL;
686 } 686 }
@@ -772,7 +772,7 @@ static int take_gc_lnum(struct ubifs_info *c)
772 int err; 772 int err;
773 773
774 if (c->gc_lnum == -1) { 774 if (c->gc_lnum == -1) {
775 ubifs_err("no LEB for GC"); 775 ubifs_err(c, "no LEB for GC");
776 return -EINVAL; 776 return -EINVAL;
777 } 777 }
778 778
@@ -857,7 +857,7 @@ static void free_orphans(struct ubifs_info *c)
857 orph = list_entry(c->orph_list.next, struct ubifs_orphan, list); 857 orph = list_entry(c->orph_list.next, struct ubifs_orphan, list);
858 list_del(&orph->list); 858 list_del(&orph->list);
859 kfree(orph); 859 kfree(orph);
860 ubifs_err("orphan list not empty at unmount"); 860 ubifs_err(c, "orphan list not empty at unmount");
861 } 861 }
862 862
863 vfree(c->orph_buf); 863 vfree(c->orph_buf);
@@ -954,7 +954,8 @@ static const match_table_t tokens = {
954 */ 954 */
955static int parse_standard_option(const char *option) 955static int parse_standard_option(const char *option)
956{ 956{
957 ubifs_msg("parse %s", option); 957
958 pr_notice("UBIFS: parse %s\n", option);
958 if (!strcmp(option, "sync")) 959 if (!strcmp(option, "sync"))
959 return MS_SYNCHRONOUS; 960 return MS_SYNCHRONOUS;
960 return 0; 961 return 0;
@@ -1026,7 +1027,7 @@ static int ubifs_parse_options(struct ubifs_info *c, char *options,
1026 else if (!strcmp(name, "zlib")) 1027 else if (!strcmp(name, "zlib"))
1027 c->mount_opts.compr_type = UBIFS_COMPR_ZLIB; 1028 c->mount_opts.compr_type = UBIFS_COMPR_ZLIB;
1028 else { 1029 else {
1029 ubifs_err("unknown compressor \"%s\"", name); 1030 ubifs_err(c, "unknown compressor \"%s\"", name); //FIXME: is c ready?
1030 kfree(name); 1031 kfree(name);
1031 return -EINVAL; 1032 return -EINVAL;
1032 } 1033 }
@@ -1042,7 +1043,7 @@ static int ubifs_parse_options(struct ubifs_info *c, char *options,
1042 1043
1043 flag = parse_standard_option(p); 1044 flag = parse_standard_option(p);
1044 if (!flag) { 1045 if (!flag) {
1045 ubifs_err("unrecognized mount option \"%s\" or missing value", 1046 ubifs_err(c, "unrecognized mount option \"%s\" or missing value",
1046 p); 1047 p);
1047 return -EINVAL; 1048 return -EINVAL;
1048 } 1049 }
@@ -1105,7 +1106,7 @@ again:
1105 } 1106 }
1106 1107
1107 /* Just disable bulk-read */ 1108 /* Just disable bulk-read */
1108 ubifs_warn("cannot allocate %d bytes of memory for bulk-read, disabling it", 1109 ubifs_warn(c, "cannot allocate %d bytes of memory for bulk-read, disabling it",
1109 c->max_bu_buf_len); 1110 c->max_bu_buf_len);
1110 c->mount_opts.bulk_read = 1; 1111 c->mount_opts.bulk_read = 1;
1111 c->bulk_read = 0; 1112 c->bulk_read = 0;
@@ -1124,7 +1125,7 @@ static int check_free_space(struct ubifs_info *c)
1124{ 1125{
1125 ubifs_assert(c->dark_wm > 0); 1126 ubifs_assert(c->dark_wm > 0);
1126 if (c->lst.total_free + c->lst.total_dirty < c->dark_wm) { 1127 if (c->lst.total_free + c->lst.total_dirty < c->dark_wm) {
1127 ubifs_err("insufficient free space to mount in R/W mode"); 1128 ubifs_err(c, "insufficient free space to mount in R/W mode");
1128 ubifs_dump_budg(c, &c->bi); 1129 ubifs_dump_budg(c, &c->bi);
1129 ubifs_dump_lprops(c); 1130 ubifs_dump_lprops(c);
1130 return -ENOSPC; 1131 return -ENOSPC;
@@ -1166,14 +1167,14 @@ static int mount_ubifs(struct ubifs_info *c)
1166 * This UBI volume is empty, and read-only, or the file system 1167 * This UBI volume is empty, and read-only, or the file system
1167 * is mounted read-only - we cannot format it. 1168 * is mounted read-only - we cannot format it.
1168 */ 1169 */
1169 ubifs_err("can't format empty UBI volume: read-only %s", 1170 ubifs_err(c, "can't format empty UBI volume: read-only %s",
1170 c->ro_media ? "UBI volume" : "mount"); 1171 c->ro_media ? "UBI volume" : "mount");
1171 err = -EROFS; 1172 err = -EROFS;
1172 goto out_free; 1173 goto out_free;
1173 } 1174 }
1174 1175
1175 if (c->ro_media && !c->ro_mount) { 1176 if (c->ro_media && !c->ro_mount) {
1176 ubifs_err("cannot mount read-write - read-only media"); 1177 ubifs_err(c, "cannot mount read-write - read-only media");
1177 err = -EROFS; 1178 err = -EROFS;
1178 goto out_free; 1179 goto out_free;
1179 } 1180 }
@@ -1221,7 +1222,7 @@ static int mount_ubifs(struct ubifs_info *c)
1221 * or overridden by mount options is actually compiled in. 1222 * or overridden by mount options is actually compiled in.
1222 */ 1223 */
1223 if (!ubifs_compr_present(c->default_compr)) { 1224 if (!ubifs_compr_present(c->default_compr)) {
1224 ubifs_err("'compressor \"%s\" is not compiled in", 1225 ubifs_err(c, "'compressor \"%s\" is not compiled in",
1225 ubifs_compr_name(c->default_compr)); 1226 ubifs_compr_name(c->default_compr));
1226 err = -ENOTSUPP; 1227 err = -ENOTSUPP;
1227 goto out_free; 1228 goto out_free;
@@ -1250,7 +1251,7 @@ static int mount_ubifs(struct ubifs_info *c)
1250 if (IS_ERR(c->bgt)) { 1251 if (IS_ERR(c->bgt)) {
1251 err = PTR_ERR(c->bgt); 1252 err = PTR_ERR(c->bgt);
1252 c->bgt = NULL; 1253 c->bgt = NULL;
1253 ubifs_err("cannot spawn \"%s\", error %d", 1254 ubifs_err(c, "cannot spawn \"%s\", error %d",
1254 c->bgt_name, err); 1255 c->bgt_name, err);
1255 goto out_wbufs; 1256 goto out_wbufs;
1256 } 1257 }
@@ -1264,7 +1265,7 @@ static int mount_ubifs(struct ubifs_info *c)
1264 init_constants_master(c); 1265 init_constants_master(c);
1265 1266
1266 if ((c->mst_node->flags & cpu_to_le32(UBIFS_MST_DIRTY)) != 0) { 1267 if ((c->mst_node->flags & cpu_to_le32(UBIFS_MST_DIRTY)) != 0) {
1267 ubifs_msg("recovery needed"); 1268 ubifs_msg(c, "recovery needed");
1268 c->need_recovery = 1; 1269 c->need_recovery = 1;
1269 } 1270 }
1270 1271
@@ -1373,10 +1374,10 @@ static int mount_ubifs(struct ubifs_info *c)
1373 1374
1374 if (c->need_recovery) { 1375 if (c->need_recovery) {
1375 if (c->ro_mount) 1376 if (c->ro_mount)
1376 ubifs_msg("recovery deferred"); 1377 ubifs_msg(c, "recovery deferred");
1377 else { 1378 else {
1378 c->need_recovery = 0; 1379 c->need_recovery = 0;
1379 ubifs_msg("recovery completed"); 1380 ubifs_msg(c, "recovery completed");
1380 /* 1381 /*
1381 * GC LEB has to be empty and taken at this point. But 1382 * GC LEB has to be empty and taken at this point. But
1382 * the journal head LEBs may also be accounted as 1383 * the journal head LEBs may also be accounted as
@@ -1397,20 +1398,20 @@ static int mount_ubifs(struct ubifs_info *c)
1397 1398
1398 c->mounting = 0; 1399 c->mounting = 0;
1399 1400
1400 ubifs_msg("mounted UBI device %d, volume %d, name \"%s\"%s", 1401 ubifs_msg(c, "UBIFS: mounted UBI device %d, volume %d, name \"%s\"%s",
1401 c->vi.ubi_num, c->vi.vol_id, c->vi.name, 1402 c->vi.ubi_num, c->vi.vol_id, c->vi.name,
1402 c->ro_mount ? ", R/O mode" : ""); 1403 c->ro_mount ? ", R/O mode" : "");
1403 x = (long long)c->main_lebs * c->leb_size; 1404 x = (long long)c->main_lebs * c->leb_size;
1404 y = (long long)c->log_lebs * c->leb_size + c->max_bud_bytes; 1405 y = (long long)c->log_lebs * c->leb_size + c->max_bud_bytes;
1405 ubifs_msg("LEB size: %d bytes (%d KiB), min./max. I/O unit sizes: %d bytes/%d bytes", 1406 ubifs_msg(c, "LEB size: %d bytes (%d KiB), min./max. I/O unit sizes: %d bytes/%d bytes",
1406 c->leb_size, c->leb_size >> 10, c->min_io_size, 1407 c->leb_size, c->leb_size >> 10, c->min_io_size,
1407 c->max_write_size); 1408 c->max_write_size);
1408 ubifs_msg("FS size: %lld bytes (%lld MiB, %d LEBs), journal size %lld bytes (%lld MiB, %d LEBs)", 1409 ubifs_msg(c, "FS size: %lld bytes (%lld MiB, %d LEBs), journal size %lld bytes (%lld MiB, %d LEBs)",
1409 x, x >> 20, c->main_lebs, 1410 x, x >> 20, c->main_lebs,
1410 y, y >> 20, c->log_lebs + c->max_bud_cnt); 1411 y, y >> 20, c->log_lebs + c->max_bud_cnt);
1411 ubifs_msg("reserved for root: %llu bytes (%llu KiB)", 1412 ubifs_msg(c, "reserved for root: %llu bytes (%llu KiB)",
1412 c->report_rp_size, c->report_rp_size >> 10); 1413 c->report_rp_size, c->report_rp_size >> 10);
1413 ubifs_msg("media format: w%d/r%d (latest is w%d/r%d), UUID %pUB%s", 1414 ubifs_msg(c, "media format: w%d/r%d (latest is w%d/r%d), UUID %pUB%s",
1414 c->fmt_version, c->ro_compat_version, 1415 c->fmt_version, c->ro_compat_version,
1415 UBIFS_FORMAT_VERSION, UBIFS_RO_COMPAT_VERSION, c->uuid, 1416 UBIFS_FORMAT_VERSION, UBIFS_RO_COMPAT_VERSION, c->uuid,
1416 c->big_lpt ? ", big LPT model" : ", small LPT model"); 1417 c->big_lpt ? ", big LPT model" : ", small LPT model");
@@ -1543,8 +1544,8 @@ static int ubifs_remount_rw(struct ubifs_info *c)
1543 int err, lnum; 1544 int err, lnum;
1544 1545
1545 if (c->rw_incompat) { 1546 if (c->rw_incompat) {
1546 ubifs_err("the file-system is not R/W-compatible"); 1547 ubifs_err(c, "the file-system is not R/W-compatible");
1547 ubifs_msg("on-flash format version is w%d/r%d, but software only supports up to version w%d/r%d", 1548 ubifs_msg(c, "on-flash format version is w%d/r%d, but software only supports up to version w%d/r%d",
1548 c->fmt_version, c->ro_compat_version, 1549 c->fmt_version, c->ro_compat_version,
1549 UBIFS_FORMAT_VERSION, UBIFS_RO_COMPAT_VERSION); 1550 UBIFS_FORMAT_VERSION, UBIFS_RO_COMPAT_VERSION);
1550 return -EROFS; 1551 return -EROFS;
@@ -1581,7 +1582,7 @@ static int ubifs_remount_rw(struct ubifs_info *c)
1581 } 1582 }
1582 1583
1583 if (c->need_recovery) { 1584 if (c->need_recovery) {
1584 ubifs_msg("completing deferred recovery"); 1585 ubifs_msg(c, "completing deferred recovery");
1585 err = ubifs_write_rcvrd_mst_node(c); 1586 err = ubifs_write_rcvrd_mst_node(c);
1586 if (err) 1587 if (err)
1587 goto out; 1588 goto out;
@@ -1630,7 +1631,7 @@ static int ubifs_remount_rw(struct ubifs_info *c)
1630 if (IS_ERR(c->bgt)) { 1631 if (IS_ERR(c->bgt)) {
1631 err = PTR_ERR(c->bgt); 1632 err = PTR_ERR(c->bgt);
1632 c->bgt = NULL; 1633 c->bgt = NULL;
1633 ubifs_err("cannot spawn \"%s\", error %d", 1634 ubifs_err(c, "cannot spawn \"%s\", error %d",
1634 c->bgt_name, err); 1635 c->bgt_name, err);
1635 goto out; 1636 goto out;
1636 } 1637 }
@@ -1664,7 +1665,7 @@ static int ubifs_remount_rw(struct ubifs_info *c)
1664 1665
1665 if (c->need_recovery) { 1666 if (c->need_recovery) {
1666 c->need_recovery = 0; 1667 c->need_recovery = 0;
1667 ubifs_msg("deferred recovery completed"); 1668 ubifs_msg(c, "deferred recovery completed");
1668 } else { 1669 } else {
1669 /* 1670 /*
1670 * Do not run the debugging space check if the were doing 1671 * Do not run the debugging space check if the were doing
@@ -1752,8 +1753,7 @@ static void ubifs_put_super(struct super_block *sb)
1752 int i; 1753 int i;
1753 struct ubifs_info *c = sb->s_fs_info; 1754 struct ubifs_info *c = sb->s_fs_info;
1754 1755
1755 ubifs_msg("un-mount UBI device %d, volume %d", c->vi.ubi_num, 1756 ubifs_msg(c, "un-mount UBI device %d", c->vi.ubi_num);
1756 c->vi.vol_id);
1757 1757
1758 /* 1758 /*
1759 * The following asserts are only valid if there has not been a failure 1759 * The following asserts are only valid if there has not been a failure
@@ -1809,7 +1809,7 @@ static void ubifs_put_super(struct super_block *sb)
1809 * next mount, so we just print a message and 1809 * next mount, so we just print a message and
1810 * continue to unmount normally. 1810 * continue to unmount normally.
1811 */ 1811 */
1812 ubifs_err("failed to write master node, error %d", 1812 ubifs_err(c, "failed to write master node, error %d",
1813 err); 1813 err);
1814 } else { 1814 } else {
1815 for (i = 0; i < c->jhead_cnt; i++) 1815 for (i = 0; i < c->jhead_cnt; i++)
@@ -1834,17 +1834,17 @@ static int ubifs_remount_fs(struct super_block *sb, int *flags, char *data)
1834 1834
1835 err = ubifs_parse_options(c, data, 1); 1835 err = ubifs_parse_options(c, data, 1);
1836 if (err) { 1836 if (err) {
1837 ubifs_err("invalid or unknown remount parameter"); 1837 ubifs_err(c, "invalid or unknown remount parameter");
1838 return err; 1838 return err;
1839 } 1839 }
1840 1840
1841 if (c->ro_mount && !(*flags & MS_RDONLY)) { 1841 if (c->ro_mount && !(*flags & MS_RDONLY)) {
1842 if (c->ro_error) { 1842 if (c->ro_error) {
1843 ubifs_msg("cannot re-mount R/W due to prior errors"); 1843 ubifs_msg(c, "cannot re-mount R/W due to prior errors");
1844 return -EROFS; 1844 return -EROFS;
1845 } 1845 }
1846 if (c->ro_media) { 1846 if (c->ro_media) {
1847 ubifs_msg("cannot re-mount R/W - UBI volume is R/O"); 1847 ubifs_msg(c, "cannot re-mount R/W - UBI volume is R/O");
1848 return -EROFS; 1848 return -EROFS;
1849 } 1849 }
1850 err = ubifs_remount_rw(c); 1850 err = ubifs_remount_rw(c);
@@ -1852,7 +1852,7 @@ static int ubifs_remount_fs(struct super_block *sb, int *flags, char *data)
1852 return err; 1852 return err;
1853 } else if (!c->ro_mount && (*flags & MS_RDONLY)) { 1853 } else if (!c->ro_mount && (*flags & MS_RDONLY)) {
1854 if (c->ro_error) { 1854 if (c->ro_error) {
1855 ubifs_msg("cannot re-mount R/O due to prior errors"); 1855 ubifs_msg(c, "cannot re-mount R/O due to prior errors");
1856 return -EROFS; 1856 return -EROFS;
1857 } 1857 }
1858 ubifs_remount_ro(c); 1858 ubifs_remount_ro(c);
@@ -2104,8 +2104,8 @@ static struct dentry *ubifs_mount(struct file_system_type *fs_type, int flags,
2104 */ 2104 */
2105 ubi = open_ubi(name, UBI_READONLY); 2105 ubi = open_ubi(name, UBI_READONLY);
2106 if (IS_ERR(ubi)) { 2106 if (IS_ERR(ubi)) {
2107 ubifs_err("cannot open \"%s\", error %d", 2107 pr_err("UBIFS error (pid: %d): cannot open \"%s\", error %d",
2108 name, (int)PTR_ERR(ubi)); 2108 current->pid, name, (int)PTR_ERR(ubi));
2109 return ERR_CAST(ubi); 2109 return ERR_CAST(ubi);
2110 } 2110 }
2111 2111
@@ -2233,8 +2233,8 @@ static int __init ubifs_init(void)
2233 * UBIFS_BLOCK_SIZE. It is assumed that both are powers of 2. 2233 * UBIFS_BLOCK_SIZE. It is assumed that both are powers of 2.
2234 */ 2234 */
2235 if (PAGE_CACHE_SIZE < UBIFS_BLOCK_SIZE) { 2235 if (PAGE_CACHE_SIZE < UBIFS_BLOCK_SIZE) {
2236 ubifs_err("VFS page cache size is %u bytes, but UBIFS requires at least 4096 bytes", 2236 pr_err("UBIFS error (pid %d): VFS page cache size is %u bytes, but UBIFS requires at least 4096 bytes",
2237 (unsigned int)PAGE_CACHE_SIZE); 2237 current->pid, (unsigned int)PAGE_CACHE_SIZE);
2238 return -EINVAL; 2238 return -EINVAL;
2239 } 2239 }
2240 2240
@@ -2257,7 +2257,8 @@ static int __init ubifs_init(void)
2257 2257
2258 err = register_filesystem(&ubifs_fs_type); 2258 err = register_filesystem(&ubifs_fs_type);
2259 if (err) { 2259 if (err) {
2260 ubifs_err("cannot register file system, error %d", err); 2260 pr_err("UBIFS error (pid %d): cannot register file system, error %d",
2261 current->pid, err);
2261 goto out_dbg; 2262 goto out_dbg;
2262 } 2263 }
2263 return 0; 2264 return 0;
diff --git a/fs/ubifs/tnc.c b/fs/ubifs/tnc.c
index 6793db0754f6..957f5757f374 100644
--- a/fs/ubifs/tnc.c
+++ b/fs/ubifs/tnc.c
@@ -98,7 +98,7 @@ static int insert_old_idx(struct ubifs_info *c, int lnum, int offs)
98 else if (offs > o->offs) 98 else if (offs > o->offs)
99 p = &(*p)->rb_right; 99 p = &(*p)->rb_right;
100 else { 100 else {
101 ubifs_err("old idx added twice!"); 101 ubifs_err(c, "old idx added twice!");
102 kfree(old_idx); 102 kfree(old_idx);
103 return 0; 103 return 0;
104 } 104 }
@@ -447,7 +447,7 @@ static int try_read_node(const struct ubifs_info *c, void *buf, int type,
447 447
448 err = ubifs_leb_read(c, lnum, buf, offs, len, 1); 448 err = ubifs_leb_read(c, lnum, buf, offs, len, 1);
449 if (err) { 449 if (err) {
450 ubifs_err("cannot read node type %d from LEB %d:%d, error %d", 450 ubifs_err(c, "cannot read node type %d from LEB %d:%d, error %d",
451 type, lnum, offs, err); 451 type, lnum, offs, err);
452 return err; 452 return err;
453 } 453 }
@@ -1684,27 +1684,27 @@ static int validate_data_node(struct ubifs_info *c, void *buf,
1684 int err, len; 1684 int err, len;
1685 1685
1686 if (ch->node_type != UBIFS_DATA_NODE) { 1686 if (ch->node_type != UBIFS_DATA_NODE) {
1687 ubifs_err("bad node type (%d but expected %d)", 1687 ubifs_err(c, "bad node type (%d but expected %d)",
1688 ch->node_type, UBIFS_DATA_NODE); 1688 ch->node_type, UBIFS_DATA_NODE);
1689 goto out_err; 1689 goto out_err;
1690 } 1690 }
1691 1691
1692 err = ubifs_check_node(c, buf, zbr->lnum, zbr->offs, 0, 0); 1692 err = ubifs_check_node(c, buf, zbr->lnum, zbr->offs, 0, 0);
1693 if (err) { 1693 if (err) {
1694 ubifs_err("expected node type %d", UBIFS_DATA_NODE); 1694 ubifs_err(c, "expected node type %d", UBIFS_DATA_NODE);
1695 goto out; 1695 goto out;
1696 } 1696 }
1697 1697
1698 len = le32_to_cpu(ch->len); 1698 len = le32_to_cpu(ch->len);
1699 if (len != zbr->len) { 1699 if (len != zbr->len) {
1700 ubifs_err("bad node length %d, expected %d", len, zbr->len); 1700 ubifs_err(c, "bad node length %d, expected %d", len, zbr->len);
1701 goto out_err; 1701 goto out_err;
1702 } 1702 }
1703 1703
1704 /* Make sure the key of the read node is correct */ 1704 /* Make sure the key of the read node is correct */
1705 key_read(c, buf + UBIFS_KEY_OFFSET, &key1); 1705 key_read(c, buf + UBIFS_KEY_OFFSET, &key1);
1706 if (!keys_eq(c, &zbr->key, &key1)) { 1706 if (!keys_eq(c, &zbr->key, &key1)) {
1707 ubifs_err("bad key in node at LEB %d:%d", 1707 ubifs_err(c, "bad key in node at LEB %d:%d",
1708 zbr->lnum, zbr->offs); 1708 zbr->lnum, zbr->offs);
1709 dbg_tnck(&zbr->key, "looked for key "); 1709 dbg_tnck(&zbr->key, "looked for key ");
1710 dbg_tnck(&key1, "found node's key "); 1710 dbg_tnck(&key1, "found node's key ");
@@ -1716,7 +1716,7 @@ static int validate_data_node(struct ubifs_info *c, void *buf,
1716out_err: 1716out_err:
1717 err = -EINVAL; 1717 err = -EINVAL;
1718out: 1718out:
1719 ubifs_err("bad node at LEB %d:%d", zbr->lnum, zbr->offs); 1719 ubifs_err(c, "bad node at LEB %d:%d", zbr->lnum, zbr->offs);
1720 ubifs_dump_node(c, buf); 1720 ubifs_dump_node(c, buf);
1721 dump_stack(); 1721 dump_stack();
1722 return err; 1722 return err;
@@ -1741,7 +1741,7 @@ int ubifs_tnc_bulk_read(struct ubifs_info *c, struct bu_info *bu)
1741 len = bu->zbranch[bu->cnt - 1].offs; 1741 len = bu->zbranch[bu->cnt - 1].offs;
1742 len += bu->zbranch[bu->cnt - 1].len - offs; 1742 len += bu->zbranch[bu->cnt - 1].len - offs;
1743 if (len > bu->buf_len) { 1743 if (len > bu->buf_len) {
1744 ubifs_err("buffer too small %d vs %d", bu->buf_len, len); 1744 ubifs_err(c, "buffer too small %d vs %d", bu->buf_len, len);
1745 return -EINVAL; 1745 return -EINVAL;
1746 } 1746 }
1747 1747
@@ -1757,7 +1757,7 @@ int ubifs_tnc_bulk_read(struct ubifs_info *c, struct bu_info *bu)
1757 return -EAGAIN; 1757 return -EAGAIN;
1758 1758
1759 if (err && err != -EBADMSG) { 1759 if (err && err != -EBADMSG) {
1760 ubifs_err("failed to read from LEB %d:%d, error %d", 1760 ubifs_err(c, "failed to read from LEB %d:%d, error %d",
1761 lnum, offs, err); 1761 lnum, offs, err);
1762 dump_stack(); 1762 dump_stack();
1763 dbg_tnck(&bu->key, "key "); 1763 dbg_tnck(&bu->key, "key ");
@@ -3313,7 +3313,7 @@ int dbg_check_inode_size(struct ubifs_info *c, const struct inode *inode,
3313 3313
3314out_dump: 3314out_dump:
3315 block = key_block(c, key); 3315 block = key_block(c, key);
3316 ubifs_err("inode %lu has size %lld, but there are data at offset %lld", 3316 ubifs_err(c, "inode %lu has size %lld, but there are data at offset %lld",
3317 (unsigned long)inode->i_ino, size, 3317 (unsigned long)inode->i_ino, size,
3318 ((loff_t)block) << UBIFS_BLOCK_SHIFT); 3318 ((loff_t)block) << UBIFS_BLOCK_SHIFT);
3319 mutex_unlock(&c->tnc_mutex); 3319 mutex_unlock(&c->tnc_mutex);
diff --git a/fs/ubifs/tnc_commit.c b/fs/ubifs/tnc_commit.c
index 7a205e046776..b45345d701e7 100644
--- a/fs/ubifs/tnc_commit.c
+++ b/fs/ubifs/tnc_commit.c
@@ -53,7 +53,7 @@ static int make_idx_node(struct ubifs_info *c, struct ubifs_idx_node *idx,
53 br->offs = cpu_to_le32(zbr->offs); 53 br->offs = cpu_to_le32(zbr->offs);
54 br->len = cpu_to_le32(zbr->len); 54 br->len = cpu_to_le32(zbr->len);
55 if (!zbr->lnum || !zbr->len) { 55 if (!zbr->lnum || !zbr->len) {
56 ubifs_err("bad ref in znode"); 56 ubifs_err(c, "bad ref in znode");
57 ubifs_dump_znode(c, znode); 57 ubifs_dump_znode(c, znode);
58 if (zbr->znode) 58 if (zbr->znode)
59 ubifs_dump_znode(c, zbr->znode); 59 ubifs_dump_znode(c, zbr->znode);
@@ -384,7 +384,7 @@ static int layout_in_gaps(struct ubifs_info *c, int cnt)
384 * Do not print scary warnings if the debugging 384 * Do not print scary warnings if the debugging
385 * option which forces in-the-gaps is enabled. 385 * option which forces in-the-gaps is enabled.
386 */ 386 */
387 ubifs_warn("out of space"); 387 ubifs_warn(c, "out of space");
388 ubifs_dump_budg(c, &c->bi); 388 ubifs_dump_budg(c, &c->bi);
389 ubifs_dump_lprops(c); 389 ubifs_dump_lprops(c);
390 } 390 }
@@ -441,7 +441,7 @@ static int layout_in_empty_space(struct ubifs_info *c)
441 /* Determine the index node position */ 441 /* Determine the index node position */
442 if (lnum == -1) { 442 if (lnum == -1) {
443 if (c->ileb_nxt >= c->ileb_cnt) { 443 if (c->ileb_nxt >= c->ileb_cnt) {
444 ubifs_err("out of space"); 444 ubifs_err(c, "out of space");
445 return -ENOSPC; 445 return -ENOSPC;
446 } 446 }
447 lnum = c->ilebs[c->ileb_nxt++]; 447 lnum = c->ilebs[c->ileb_nxt++];
@@ -855,7 +855,7 @@ static int write_index(struct ubifs_info *c)
855 br->offs = cpu_to_le32(zbr->offs); 855 br->offs = cpu_to_le32(zbr->offs);
856 br->len = cpu_to_le32(zbr->len); 856 br->len = cpu_to_le32(zbr->len);
857 if (!zbr->lnum || !zbr->len) { 857 if (!zbr->lnum || !zbr->len) {
858 ubifs_err("bad ref in znode"); 858 ubifs_err(c, "bad ref in znode");
859 ubifs_dump_znode(c, znode); 859 ubifs_dump_znode(c, znode);
860 if (zbr->znode) 860 if (zbr->znode)
861 ubifs_dump_znode(c, zbr->znode); 861 ubifs_dump_znode(c, zbr->znode);
@@ -875,7 +875,7 @@ static int write_index(struct ubifs_info *c)
875 875
876 if (lnum != znode->lnum || offs != znode->offs || 876 if (lnum != znode->lnum || offs != znode->offs ||
877 len != znode->len) { 877 len != znode->len) {
878 ubifs_err("inconsistent znode posn"); 878 ubifs_err(c, "inconsistent znode posn");
879 return -EINVAL; 879 return -EINVAL;
880 } 880 }
881 881
@@ -973,7 +973,7 @@ static int write_index(struct ubifs_info *c)
973 973
974 if (lnum != c->dbg->new_ihead_lnum || 974 if (lnum != c->dbg->new_ihead_lnum ||
975 buf_offs != c->dbg->new_ihead_offs) { 975 buf_offs != c->dbg->new_ihead_offs) {
976 ubifs_err("inconsistent ihead"); 976 ubifs_err(c, "inconsistent ihead");
977 return -EINVAL; 977 return -EINVAL;
978 } 978 }
979 979
diff --git a/fs/ubifs/tnc_misc.c b/fs/ubifs/tnc_misc.c
index f6bf8995c7b1..93f5b7859e6f 100644
--- a/fs/ubifs/tnc_misc.c
+++ b/fs/ubifs/tnc_misc.c
@@ -293,9 +293,9 @@ static int read_znode(struct ubifs_info *c, int lnum, int offs, int len,
293 lnum, offs, znode->level, znode->child_cnt); 293 lnum, offs, znode->level, znode->child_cnt);
294 294
295 if (znode->child_cnt > c->fanout || znode->level > UBIFS_MAX_LEVELS) { 295 if (znode->child_cnt > c->fanout || znode->level > UBIFS_MAX_LEVELS) {
296 ubifs_err("current fanout %d, branch count %d", 296 ubifs_err(c, "current fanout %d, branch count %d",
297 c->fanout, znode->child_cnt); 297 c->fanout, znode->child_cnt);
298 ubifs_err("max levels %d, znode level %d", 298 ubifs_err(c, "max levels %d, znode level %d",
299 UBIFS_MAX_LEVELS, znode->level); 299 UBIFS_MAX_LEVELS, znode->level);
300 err = 1; 300 err = 1;
301 goto out_dump; 301 goto out_dump;
@@ -316,7 +316,7 @@ static int read_znode(struct ubifs_info *c, int lnum, int offs, int len,
316 if (zbr->lnum < c->main_first || 316 if (zbr->lnum < c->main_first ||
317 zbr->lnum >= c->leb_cnt || zbr->offs < 0 || 317 zbr->lnum >= c->leb_cnt || zbr->offs < 0 ||
318 zbr->offs + zbr->len > c->leb_size || zbr->offs & 7) { 318 zbr->offs + zbr->len > c->leb_size || zbr->offs & 7) {
319 ubifs_err("bad branch %d", i); 319 ubifs_err(c, "bad branch %d", i);
320 err = 2; 320 err = 2;
321 goto out_dump; 321 goto out_dump;
322 } 322 }
@@ -328,7 +328,7 @@ static int read_znode(struct ubifs_info *c, int lnum, int offs, int len,
328 case UBIFS_XENT_KEY: 328 case UBIFS_XENT_KEY:
329 break; 329 break;
330 default: 330 default:
331 ubifs_err("bad key type at slot %d: %d", 331 ubifs_err(c, "bad key type at slot %d: %d",
332 i, key_type(c, &zbr->key)); 332 i, key_type(c, &zbr->key));
333 err = 3; 333 err = 3;
334 goto out_dump; 334 goto out_dump;
@@ -340,17 +340,17 @@ static int read_znode(struct ubifs_info *c, int lnum, int offs, int len,
340 type = key_type(c, &zbr->key); 340 type = key_type(c, &zbr->key);
341 if (c->ranges[type].max_len == 0) { 341 if (c->ranges[type].max_len == 0) {
342 if (zbr->len != c->ranges[type].len) { 342 if (zbr->len != c->ranges[type].len) {
343 ubifs_err("bad target node (type %d) length (%d)", 343 ubifs_err(c, "bad target node (type %d) length (%d)",
344 type, zbr->len); 344 type, zbr->len);
345 ubifs_err("have to be %d", c->ranges[type].len); 345 ubifs_err(c, "have to be %d", c->ranges[type].len);
346 err = 4; 346 err = 4;
347 goto out_dump; 347 goto out_dump;
348 } 348 }
349 } else if (zbr->len < c->ranges[type].min_len || 349 } else if (zbr->len < c->ranges[type].min_len ||
350 zbr->len > c->ranges[type].max_len) { 350 zbr->len > c->ranges[type].max_len) {
351 ubifs_err("bad target node (type %d) length (%d)", 351 ubifs_err(c, "bad target node (type %d) length (%d)",
352 type, zbr->len); 352 type, zbr->len);
353 ubifs_err("have to be in range of %d-%d", 353 ubifs_err(c, "have to be in range of %d-%d",
354 c->ranges[type].min_len, 354 c->ranges[type].min_len,
355 c->ranges[type].max_len); 355 c->ranges[type].max_len);
356 err = 5; 356 err = 5;
@@ -370,12 +370,12 @@ static int read_znode(struct ubifs_info *c, int lnum, int offs, int len,
370 370
371 cmp = keys_cmp(c, key1, key2); 371 cmp = keys_cmp(c, key1, key2);
372 if (cmp > 0) { 372 if (cmp > 0) {
373 ubifs_err("bad key order (keys %d and %d)", i, i + 1); 373 ubifs_err(c, "bad key order (keys %d and %d)", i, i + 1);
374 err = 6; 374 err = 6;
375 goto out_dump; 375 goto out_dump;
376 } else if (cmp == 0 && !is_hash_key(c, key1)) { 376 } else if (cmp == 0 && !is_hash_key(c, key1)) {
377 /* These can only be keys with colliding hash */ 377 /* These can only be keys with colliding hash */
378 ubifs_err("keys %d and %d are not hashed but equivalent", 378 ubifs_err(c, "keys %d and %d are not hashed but equivalent",
379 i, i + 1); 379 i, i + 1);
380 err = 7; 380 err = 7;
381 goto out_dump; 381 goto out_dump;
@@ -386,7 +386,7 @@ static int read_znode(struct ubifs_info *c, int lnum, int offs, int len,
386 return 0; 386 return 0;
387 387
388out_dump: 388out_dump:
389 ubifs_err("bad indexing node at LEB %d:%d, error %d", lnum, offs, err); 389 ubifs_err(c, "bad indexing node at LEB %d:%d, error %d", lnum, offs, err);
390 ubifs_dump_node(c, idx); 390 ubifs_dump_node(c, idx);
391 kfree(idx); 391 kfree(idx);
392 return -EINVAL; 392 return -EINVAL;
@@ -482,7 +482,7 @@ int ubifs_tnc_read_node(struct ubifs_info *c, struct ubifs_zbranch *zbr,
482 /* Make sure the key of the read node is correct */ 482 /* Make sure the key of the read node is correct */
483 key_read(c, node + UBIFS_KEY_OFFSET, &key1); 483 key_read(c, node + UBIFS_KEY_OFFSET, &key1);
484 if (!keys_eq(c, key, &key1)) { 484 if (!keys_eq(c, key, &key1)) {
485 ubifs_err("bad key in node at LEB %d:%d", 485 ubifs_err(c, "bad key in node at LEB %d:%d",
486 zbr->lnum, zbr->offs); 486 zbr->lnum, zbr->offs);
487 dbg_tnck(key, "looked for key "); 487 dbg_tnck(key, "looked for key ");
488 dbg_tnck(&key1, "but found node's key "); 488 dbg_tnck(&key1, "but found node's key ");
diff --git a/fs/ubifs/ubifs.h b/fs/ubifs/ubifs.h
index 2911d2d23456..de759022f3d6 100644
--- a/fs/ubifs/ubifs.h
+++ b/fs/ubifs/ubifs.h
@@ -43,15 +43,19 @@
43#define UBIFS_VERSION 1 43#define UBIFS_VERSION 1
44 44
45/* Normal UBIFS messages */ 45/* Normal UBIFS messages */
46#define ubifs_msg(fmt, ...) pr_notice("UBIFS: " fmt "\n", ##__VA_ARGS__) 46#define ubifs_msg(c, fmt, ...) \
47 pr_notice("UBIFS (ubi%d:%d): " fmt "\n", \
48 (c)->vi.ubi_num, (c)->vi.vol_id, ##__VA_ARGS__)
47/* UBIFS error messages */ 49/* UBIFS error messages */
48#define ubifs_err(fmt, ...) \ 50#define ubifs_err(c, fmt, ...) \
49 pr_err("UBIFS error (pid %d): %s: " fmt "\n", current->pid, \ 51 pr_err("UBIFS error (ubi%d:%d pid %d): %s: " fmt "\n", \
52 (c)->vi.ubi_num, (c)->vi.vol_id, current->pid, \
50 __func__, ##__VA_ARGS__) 53 __func__, ##__VA_ARGS__)
51/* UBIFS warning messages */ 54/* UBIFS warning messages */
52#define ubifs_warn(fmt, ...) \ 55#define ubifs_warn(c, fmt, ...) \
53 pr_warn("UBIFS warning (pid %d): %s: " fmt "\n", \ 56 pr_warn("UBIFS warning (ubi%d:%d pid %d): %s: " fmt "\n", \
54 current->pid, __func__, ##__VA_ARGS__) 57 (c)->vi.ubi_num, (c)->vi.vol_id, current->pid, \
58 __func__, ##__VA_ARGS__)
55/* 59/*
56 * A variant of 'ubifs_err()' which takes the UBIFS file-sytem description 60 * A variant of 'ubifs_err()' which takes the UBIFS file-sytem description
57 * object as an argument. 61 * object as an argument.
@@ -59,7 +63,7 @@
59#define ubifs_errc(c, fmt, ...) \ 63#define ubifs_errc(c, fmt, ...) \
60 do { \ 64 do { \
61 if (!(c)->probing) \ 65 if (!(c)->probing) \
62 ubifs_err(fmt, ##__VA_ARGS__); \ 66 ubifs_err(c, fmt, ##__VA_ARGS__); \
63 } while (0) 67 } while (0)
64 68
65/* UBIFS file system VFS magic number */ 69/* UBIFS file system VFS magic number */
@@ -1787,10 +1791,10 @@ long ubifs_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
1787/* compressor.c */ 1791/* compressor.c */
1788int __init ubifs_compressors_init(void); 1792int __init ubifs_compressors_init(void);
1789void ubifs_compressors_exit(void); 1793void ubifs_compressors_exit(void);
1790void ubifs_compress(const void *in_buf, int in_len, void *out_buf, int *out_len, 1794void ubifs_compress(const struct ubifs_info *c, const void *in_buf, int in_len,
1791 int *compr_type); 1795 void *out_buf, int *out_len, int *compr_type);
1792int ubifs_decompress(const void *buf, int len, void *out, int *out_len, 1796int ubifs_decompress(const struct ubifs_info *c, const void *buf, int len,
1793 int compr_type); 1797 void *out, int *out_len, int compr_type);
1794 1798
1795#include "debug.h" 1799#include "debug.h"
1796#include "misc.h" 1800#include "misc.h"
diff --git a/fs/ubifs/xattr.c b/fs/ubifs/xattr.c
index a92be244a6fb..3659b1934500 100644
--- a/fs/ubifs/xattr.c
+++ b/fs/ubifs/xattr.c
@@ -108,7 +108,7 @@ static int create_xattr(struct ubifs_info *c, struct inode *host,
108 .dirtied_ino_d = ALIGN(host_ui->data_len, 8) }; 108 .dirtied_ino_d = ALIGN(host_ui->data_len, 8) };
109 109
110 if (host_ui->xattr_cnt >= MAX_XATTRS_PER_INODE) { 110 if (host_ui->xattr_cnt >= MAX_XATTRS_PER_INODE) {
111 ubifs_err("inode %lu already has too many xattrs (%d), cannot create more", 111 ubifs_err(c, "inode %lu already has too many xattrs (%d), cannot create more",
112 host->i_ino, host_ui->xattr_cnt); 112 host->i_ino, host_ui->xattr_cnt);
113 return -ENOSPC; 113 return -ENOSPC;
114 } 114 }
@@ -120,7 +120,7 @@ static int create_xattr(struct ubifs_info *c, struct inode *host,
120 */ 120 */
121 names_len = host_ui->xattr_names + host_ui->xattr_cnt + nm->len + 1; 121 names_len = host_ui->xattr_names + host_ui->xattr_cnt + nm->len + 1;
122 if (names_len > XATTR_LIST_MAX) { 122 if (names_len > XATTR_LIST_MAX) {
123 ubifs_err("cannot add one more xattr name to inode %lu, total names length would become %d, max. is %d", 123 ubifs_err(c, "cannot add one more xattr name to inode %lu, total names length would become %d, max. is %d",
124 host->i_ino, names_len, XATTR_LIST_MAX); 124 host->i_ino, names_len, XATTR_LIST_MAX);
125 return -ENOSPC; 125 return -ENOSPC;
126 } 126 }
@@ -288,13 +288,13 @@ static struct inode *iget_xattr(struct ubifs_info *c, ino_t inum)
288 288
289 inode = ubifs_iget(c->vfs_sb, inum); 289 inode = ubifs_iget(c->vfs_sb, inum);
290 if (IS_ERR(inode)) { 290 if (IS_ERR(inode)) {
291 ubifs_err("dead extended attribute entry, error %d", 291 ubifs_err(c, "dead extended attribute entry, error %d",
292 (int)PTR_ERR(inode)); 292 (int)PTR_ERR(inode));
293 return inode; 293 return inode;
294 } 294 }
295 if (ubifs_inode(inode)->xattr) 295 if (ubifs_inode(inode)->xattr)
296 return inode; 296 return inode;
297 ubifs_err("corrupt extended attribute entry"); 297 ubifs_err(c, "corrupt extended attribute entry");
298 iput(inode); 298 iput(inode);
299 return ERR_PTR(-EINVAL); 299 return ERR_PTR(-EINVAL);
300} 300}
@@ -412,7 +412,7 @@ ssize_t ubifs_getxattr(struct dentry *dentry, const char *name, void *buf,
412 if (buf) { 412 if (buf) {
413 /* If @buf is %NULL we are supposed to return the length */ 413 /* If @buf is %NULL we are supposed to return the length */
414 if (ui->data_len > size) { 414 if (ui->data_len > size) {
415 ubifs_err("buffer size %zd, xattr len %d", 415 ubifs_err(c, "buffer size %zd, xattr len %d",
416 size, ui->data_len); 416 size, ui->data_len);
417 err = -ERANGE; 417 err = -ERANGE;
418 goto out_iput; 418 goto out_iput;
@@ -485,7 +485,7 @@ ssize_t ubifs_listxattr(struct dentry *dentry, char *buffer, size_t size)
485 485
486 kfree(pxent); 486 kfree(pxent);
487 if (err != -ENOENT) { 487 if (err != -ENOENT) {
488 ubifs_err("cannot find next direntry, error %d", err); 488 ubifs_err(c, "cannot find next direntry, error %d", err);
489 return err; 489 return err;
490 } 490 }
491 491
@@ -657,8 +657,10 @@ int ubifs_init_security(struct inode *dentry, struct inode *inode,
657 &init_xattrs, 0); 657 &init_xattrs, 0);
658 mutex_unlock(&inode->i_mutex); 658 mutex_unlock(&inode->i_mutex);
659 659
660 if (err) 660 if (err) {
661 ubifs_err("cannot initialize security for inode %lu, error %d", 661 struct ubifs_info *c = dentry->i_sb->s_fs_info;
662 ubifs_err(c, "cannot initialize security for inode %lu, error %d",
662 inode->i_ino, err); 663 inode->i_ino, err);
664 }
663 return err; 665 return err;
664} 666}
generated by cgit v1.2.2 (git 2.25.0) at 2024-12-19 12:00:21 -0500