]> git.ipfire.org Git - thirdparty/xfsprogs-dev.git/blob - logprint/log_print_all.c
projects / thirdparty / xfsprogs-dev.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
xfs_logprint: Fix buffer overflow printing quotaoff
[thirdparty/xfsprogs-dev.git] / logprint / log_print_all.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Copyright (c) 2000-2003,2005 Silicon Graphics, Inc.
4 * All Rights Reserved.
5 */
6 #include "libxfs.h"
7 #include "libxlog.h"
8
9 #include "logprint.h"
10
11 /*
12 * Start is defined to be the block pointing to the oldest valid log record.
13 */
14 int
15 xlog_print_find_oldest(
16 struct xlog *log,
17 xfs_daddr_t *last_blk)
18 {
19 struct xfs_buf *bp;
20 xfs_daddr_t first_blk;
21 uint first_half_cycle, last_half_cycle;
22 int error = 0;
23
24 if (xlog_find_zeroed(log, &first_blk))
25 return 0;
26
27 first_blk = 0; /* read first block */
28 bp = xlog_get_bp(log, 1);
29 xlog_bread_noalign(log, 0, 1, bp);
30 first_half_cycle = xlog_get_cycle(bp->b_addr);
31 *last_blk = log->l_logBBsize-1; /* read last block */
32 xlog_bread_noalign(log, *last_blk, 1, bp);
33 last_half_cycle = xlog_get_cycle(bp->b_addr);
34 ASSERT(last_half_cycle != 0);
35
36 if (first_half_cycle == last_half_cycle) /* all cycle nos are same */
37 *last_blk = 0;
38 else /* have 1st and last; look for middle cycle */
39 error = xlog_find_cycle_start(log, bp, first_blk,
40 last_blk, last_half_cycle);
41
42 libxfs_buf_relse(bp);
43 return error;
44 }
45
46 void
47 xlog_recover_print_data(
48 char *p,
49 int len)
50 {
51 if (print_data) {
52 uint *dp = (uint *)p;
53 int nums = len >> 2;
54 int j = 0;
55
56 while (j < nums) {
57 if ((j % 8) == 0)
58 printf("%2x ", j);
59 printf("%8x ", *dp);
60 dp++;
61 j++;
62 if ((j % 8) == 0)
63 printf("\n");
64 }
65 printf("\n");
66 }
67 }
68
69 STATIC void
70 xlog_recover_print_buffer(
71 struct xlog_recover_item *item)
72 {
73 xfs_agi_t *agi;
74 xfs_agf_t *agf;
75 xfs_buf_log_format_t *f;
76 char *p;
77 int len, num, i;
78 xfs_daddr_t blkno;
79 struct xfs_disk_dquot *ddq;
80
81 f = (xfs_buf_log_format_t *)item->ri_buf[0].i_addr;
82 printf(" ");
83 ASSERT(f->blf_type == XFS_LI_BUF);
84 printf(_("BUF: #regs:%d start blkno:0x%llx len:%d bmap size:%d flags:0x%x\n"),
85 f->blf_size, (long long)f->blf_blkno, f->blf_len, f->blf_map_size, f->blf_flags);
86 blkno = (xfs_daddr_t)f->blf_blkno;
87 num = f->blf_size-1;
88 i = 1;
89 while (num-- > 0) {
90 p = item->ri_buf[i].i_addr;
91 len = item->ri_buf[i].i_len;
92 i++;
93 if (blkno == 0) { /* super block */
94 printf(_(" SUPER Block Buffer:\n"));
95 if (!print_buffer)
96 continue;
97 printf(_(" icount:%llu ifree:%llu "),
98 (unsigned long long)
99 be64_to_cpu(*(__be64 *)(p)),
100 (unsigned long long)
101 be64_to_cpu(*(__be64 *)(p+8)));
102 printf(_("fdblks:%llu frext:%llu\n"),
103 (unsigned long long)
104 be64_to_cpu(*(__be64 *)(p+16)),
105 (unsigned long long)
106 be64_to_cpu(*(__be64 *)(p+24)));
107 printf(_(" sunit:%u swidth:%u\n"),
108 be32_to_cpu(*(__be32 *)(p+56)),
109 be32_to_cpu(*(__be32 *)(p+60)));
110 } else if (be32_to_cpu(*(__be32 *)p) == XFS_AGI_MAGIC) {
111 int bucket, buckets;
112 agi = (xfs_agi_t *)p;
113 printf(_(" AGI Buffer: (XAGI)\n"));
114 if (!print_buffer)
115 continue;
116 printf(_(" ver:%d "),
117 be32_to_cpu(agi->agi_versionnum));
118 printf(_("seq#:%d len:%d cnt:%d root:%d\n"),
119 be32_to_cpu(agi->agi_seqno),
120 be32_to_cpu(agi->agi_length),
121 be32_to_cpu(agi->agi_count),
122 be32_to_cpu(agi->agi_root));
123 printf(_(" level:%d free#:0x%x newino:0x%x\n"),
124 be32_to_cpu(agi->agi_level),
125 be32_to_cpu(agi->agi_freecount),
126 be32_to_cpu(agi->agi_newino));
127 if (len == 128) {
128 buckets = 17;
129 } else if (len == 256) {
130 buckets = 32 + 17;
131 } else {
132 buckets = XFS_AGI_UNLINKED_BUCKETS;
133 }
134 for (bucket = 0; bucket < buckets;) {
135 int col;
136 printf(_("bucket[%d - %d]: "), bucket, bucket+3);
137 for (col = 0; col < 4; col++, bucket++) {
138 if (bucket < buckets) {
139 printf("0x%x ",
140 be32_to_cpu(agi->agi_unlinked[bucket]));
141 }
142 }
143 printf("\n");
144 }
145 } else if (be32_to_cpu(*(__be32 *)p) == XFS_AGF_MAGIC) {
146 agf = (xfs_agf_t *)p;
147 printf(_(" AGF Buffer: (XAGF)\n"));
148 if (!print_buffer)
149 continue;
150 printf(_(" ver:%d seq#:%d len:%d \n"),
151 be32_to_cpu(agf->agf_versionnum),
152 be32_to_cpu(agf->agf_seqno),
153 be32_to_cpu(agf->agf_length));
154 printf(_(" root BNO:%d CNT:%d\n"),
155 be32_to_cpu(agf->agf_roots[XFS_BTNUM_BNOi]),
156 be32_to_cpu(agf->agf_roots[XFS_BTNUM_CNTi]));
157 printf(_(" level BNO:%d CNT:%d\n"),
158 be32_to_cpu(agf->agf_levels[XFS_BTNUM_BNOi]),
159 be32_to_cpu(agf->agf_levels[XFS_BTNUM_CNTi]));
160 printf(_(" 1st:%d last:%d cnt:%d "
161 "freeblks:%d longest:%d\n"),
162 be32_to_cpu(agf->agf_flfirst),
163 be32_to_cpu(agf->agf_fllast),
164 be32_to_cpu(agf->agf_flcount),
165 be32_to_cpu(agf->agf_freeblks),
166 be32_to_cpu(agf->agf_longest));
167 } else if (*(uint *)p == XFS_DQUOT_MAGIC) {
168 ddq = (struct xfs_disk_dquot *)p;
169 printf(_(" DQUOT Buffer:\n"));
170 if (!print_buffer)
171 continue;
172 printf(_(" UIDs 0x%lx-0x%lx\n"),
173 (unsigned long)be32_to_cpu(ddq->d_id),
174 (unsigned long)be32_to_cpu(ddq->d_id) +
175 (BBTOB(f->blf_len) / sizeof(xfs_dqblk_t)) - 1);
176 } else {
177 printf(_(" BUF DATA\n"));
178 if (!print_buffer) continue;
179 xlog_recover_print_data(p, len);
180 }
181 }
182 }
183
184 STATIC void
185 xlog_recover_print_quotaoff(
186 struct xlog_recover_item *item)
187 {
188 xfs_qoff_logformat_t *qoff_f;
189
190 qoff_f = (xfs_qoff_logformat_t *)item->ri_buf[0].i_addr;
191
192 ASSERT(qoff_f);
193 printf(_("\tQUOTAOFF: #regs:%d type:"), qoff_f->qf_size);
194 if (qoff_f->qf_flags & XFS_UQUOTA_ACCT)
195 printf(" USER");
196 if (qoff_f->qf_flags & XFS_GQUOTA_ACCT)
197 printf(" GROUP");
198 if (qoff_f->qf_flags & XFS_PQUOTA_ACCT)
199 printf(" PROJECT");
200 printf("\n");
201 }
202
203 STATIC void
204 xlog_recover_print_dquot(
205 struct xlog_recover_item *item)
206 {
207 xfs_dq_logformat_t *f;
208 struct xfs_disk_dquot *d;
209
210 f = (xfs_dq_logformat_t *)item->ri_buf[0].i_addr;
211 ASSERT(f);
212 ASSERT(f->qlf_len == 1);
213 d = (struct xfs_disk_dquot *)item->ri_buf[1].i_addr;
214 printf(_("\tDQUOT: #regs:%d blkno:%lld boffset:%u id: %d\n"),
215 f->qlf_size, (long long)f->qlf_blkno, f->qlf_boffset, f->qlf_id);
216 if (!print_quota)
217 return;
218 printf(_("\t\tmagic 0x%x\tversion 0x%x\tID 0x%x (%d)\t\n"),
219 be16_to_cpu(d->d_magic),
220 d->d_version,
221 be32_to_cpu(d->d_id),
222 be32_to_cpu(d->d_id));
223 printf(_("\t\tblk_hard 0x%x\tblk_soft 0x%x\tino_hard 0x%x"
224 "\tino_soft 0x%x\n"),
225 (int)be64_to_cpu(d->d_blk_hardlimit),
226 (int)be64_to_cpu(d->d_blk_softlimit),
227 (int)be64_to_cpu(d->d_ino_hardlimit),
228 (int)be64_to_cpu(d->d_ino_softlimit));
229 printf(_("\t\tbcount 0x%x (%d) icount 0x%x (%d)\n"),
230 (int)be64_to_cpu(d->d_bcount),
231 (int)be64_to_cpu(d->d_bcount),
232 (int)be64_to_cpu(d->d_icount),
233 (int)be64_to_cpu(d->d_icount));
234 printf(_("\t\tbtimer 0x%x itimer 0x%x \n"),
235 (int)be32_to_cpu(d->d_btimer),
236 (int)be32_to_cpu(d->d_itimer));
237 }
238
239 STATIC void
240 xlog_recover_print_inode_core(
241 struct xfs_log_dinode *di)
242 {
243 printf(_(" CORE inode:\n"));
244 if (!print_inode)
245 return;
246 printf(_(" magic:%c%c mode:0x%x ver:%d format:%d\n"),
247 (di->di_magic>>8) & 0xff, di->di_magic & 0xff,
248 di->di_mode, di->di_version, di->di_format);
249 printf(_(" uid:%d gid:%d nlink:%d projid:0x%04x%04x\n"),
250 di->di_uid, di->di_gid, di->di_nlink,
251 di->di_projid_hi, di->di_projid_lo);
252 printf(_(" atime:%lld mtime:%lld ctime:%lld\n"),
253 xlog_extract_dinode_ts(di->di_atime),
254 xlog_extract_dinode_ts(di->di_mtime),
255 xlog_extract_dinode_ts(di->di_ctime));
256 printf(_(" flushiter:%d\n"), di->di_flushiter);
257 printf(_(" size:0x%llx nblks:0x%llx exsize:%d "
258 "nextents:%d anextents:%d\n"), (unsigned long long)
259 di->di_size, (unsigned long long)di->di_nblocks,
260 di->di_extsize, di->di_nextents, (int)di->di_anextents);
261 printf(_(" forkoff:%d dmevmask:0x%x dmstate:%d flags:0x%x "
262 "gen:%u\n"),
263 (int)di->di_forkoff, di->di_dmevmask, (int)di->di_dmstate,
264 (int)di->di_flags, di->di_gen);
265 if (di->di_version == 3) {
266 printf(_(" flags2 0x%llx cowextsize 0x%x\n"),
267 (unsigned long long)di->di_flags2, di->di_cowextsize);
268 }
269 }
270
271 STATIC void
272 xlog_recover_print_inode(
273 struct xlog_recover_item *item)
274 {
275 struct xfs_inode_log_format f_buf;
276 struct xfs_inode_log_format *f;
277 int attr_index;
278 int hasdata;
279 int hasattr;
280
281 ASSERT(item->ri_buf[0].i_len == sizeof(struct xfs_inode_log_format_32) ||
282 item->ri_buf[0].i_len == sizeof(struct xfs_inode_log_format));
283 f = xfs_inode_item_format_convert(item->ri_buf[0].i_addr, item->ri_buf[0].i_len, &f_buf);
284
285 printf(_(" INODE: #regs:%d ino:0x%llx flags:0x%x dsize:%d\n"),
286 f->ilf_size, (unsigned long long)f->ilf_ino, f->ilf_fields,
287 f->ilf_dsize);
288
289 /* core inode comes 2nd */
290 /* ASSERT len vs xfs_log_dinode_size() for V3 or V2 inodes */
291 ASSERT(item->ri_buf[1].i_len ==
292 offsetof(struct xfs_log_dinode, di_next_unlinked) ||
293 item->ri_buf[1].i_len == sizeof(struct xfs_log_dinode));
294 xlog_recover_print_inode_core((struct xfs_log_dinode *)
295 item->ri_buf[1].i_addr);
296
297 hasdata = (f->ilf_fields & XFS_ILOG_DFORK) != 0;
298 hasattr = (f->ilf_fields & XFS_ILOG_AFORK) != 0;
299 /* does anything come next */
300 switch (f->ilf_fields & (XFS_ILOG_DFORK|XFS_ILOG_DEV|XFS_ILOG_UUID)) {
301 case XFS_ILOG_DEXT:
302 ASSERT(f->ilf_size == 3 + hasattr);
303 printf(_(" DATA FORK EXTENTS inode data:\n"));
304 if (print_inode && print_data)
305 xlog_recover_print_data(item->ri_buf[2].i_addr,
306 item->ri_buf[2].i_len);
307 break;
308 case XFS_ILOG_DBROOT:
309 ASSERT(f->ilf_size == 3 + hasattr);
310 printf(_(" DATA FORK BTREE inode data:\n"));
311 if (print_inode && print_data)
312 xlog_recover_print_data(item->ri_buf[2].i_addr,
313 item->ri_buf[2].i_len);
314 break;
315 case XFS_ILOG_DDATA:
316 ASSERT(f->ilf_size == 3 + hasattr);
317 printf(_(" DATA FORK LOCAL inode data:\n"));
318 if (print_inode && print_data)
319 xlog_recover_print_data(item->ri_buf[2].i_addr,
320 item->ri_buf[2].i_len);
321 break;
322 case XFS_ILOG_DEV:
323 ASSERT(f->ilf_size == 2 + hasattr);
324 printf(_(" DEV inode: no extra region\n"));
325 break;
326 case XFS_ILOG_UUID:
327 ASSERT(f->ilf_size == 2 + hasattr);
328 printf(_(" UUID inode: no extra region\n"));
329 break;
330
331 case 0:
332 ASSERT(f->ilf_size == 2 + hasattr);
333 break;
334 default:
335 xlog_panic("xlog_print_trans_inode: illegal inode type");
336 }
337
338 if (hasattr) {
339 attr_index = 2 + hasdata;
340 switch (f->ilf_fields & XFS_ILOG_AFORK) {
341 case XFS_ILOG_AEXT:
342 ASSERT(f->ilf_size == 3 + hasdata);
343 printf(_(" ATTR FORK EXTENTS inode data:\n"));
344 if (print_inode && print_data)
345 xlog_recover_print_data(
346 item->ri_buf[attr_index].i_addr,
347 item->ri_buf[attr_index].i_len);
348 break;
349 case XFS_ILOG_ABROOT:
350 ASSERT(f->ilf_size == 3 + hasdata);
351 printf(_(" ATTR FORK BTREE inode data:\n"));
352 if (print_inode && print_data)
353 xlog_recover_print_data(
354 item->ri_buf[attr_index].i_addr,
355 item->ri_buf[attr_index].i_len);
356 break;
357 case XFS_ILOG_ADATA:
358 ASSERT(f->ilf_size == 3 + hasdata);
359 printf(_(" ATTR FORK LOCAL inode data:\n"));
360 if (print_inode && print_data)
361 xlog_recover_print_data(
362 item->ri_buf[attr_index].i_addr,
363 item->ri_buf[attr_index].i_len);
364 break;
365 default:
366 xlog_panic("%s: illegal inode log flag", __FUNCTION__);
367 }
368 }
369 }
370
371
372 STATIC void
373 xlog_recover_print_icreate(
374 struct xlog_recover_item *item)
375 {
376 struct xfs_icreate_log *icl;
377
378 icl = (struct xfs_icreate_log *)item->ri_buf[0].i_addr;
379
380 printf(_(" ICR: #ag: %d agbno: 0x%x len: %d\n"
381 " cnt: %d isize: %d gen: 0x%x\n"),
382 be32_to_cpu(icl->icl_ag), be32_to_cpu(icl->icl_agbno),
383 be32_to_cpu(icl->icl_length), be32_to_cpu(icl->icl_count),
384 be32_to_cpu(icl->icl_isize), be32_to_cpu(icl->icl_gen));
385 }
386
387 void
388 xlog_recover_print_logitem(
389 struct xlog_recover_item *item)
390 {
391 switch (ITEM_TYPE(item)) {
392 case XFS_LI_BUF:
393 xlog_recover_print_buffer(item);
394 break;
395 case XFS_LI_ICREATE:
396 xlog_recover_print_icreate(item);
397 break;
398 case XFS_LI_INODE:
399 xlog_recover_print_inode(item);
400 break;
401 case XFS_LI_EFD:
402 xlog_recover_print_efd(item);
403 break;
404 case XFS_LI_EFI:
405 xlog_recover_print_efi(item);
406 break;
407 case XFS_LI_RUD:
408 xlog_recover_print_rud(item);
409 break;
410 case XFS_LI_RUI:
411 xlog_recover_print_rui(item);
412 break;
413 case XFS_LI_CUD:
414 xlog_recover_print_cud(item);
415 break;
416 case XFS_LI_CUI:
417 xlog_recover_print_cui(item);
418 break;
419 case XFS_LI_BUD:
420 xlog_recover_print_bud(item);
421 break;
422 case XFS_LI_BUI:
423 xlog_recover_print_bui(item);
424 break;
425 case XFS_LI_DQUOT:
426 xlog_recover_print_dquot(item);
427 break;
428 case XFS_LI_QUOTAOFF:
429 xlog_recover_print_quotaoff(item);
430 break;
431 default:
432 printf(_("xlog_recover_print_logitem: illegal type\n"));
433 break;
434 }
435 }
436
437 static void
438 xlog_recover_print_item(
439 struct xlog_recover_item *item)
440 {
441 int i;
442
443 switch (ITEM_TYPE(item)) {
444 case XFS_LI_BUF:
445 printf("BUF");
446 break;
447 case XFS_LI_ICREATE:
448 printf("ICR");
449 break;
450 case XFS_LI_INODE:
451 printf("INO");
452 break;
453 case XFS_LI_EFD:
454 printf("EFD");
455 break;
456 case XFS_LI_EFI:
457 printf("EFI");
458 break;
459 case XFS_LI_RUD:
460 printf("RUD");
461 break;
462 case XFS_LI_RUI:
463 printf("RUI");
464 break;
465 case XFS_LI_CUD:
466 printf("CUD");
467 break;
468 case XFS_LI_CUI:
469 printf("CUI");
470 break;
471 case XFS_LI_BUD:
472 printf("BUD");
473 break;
474 case XFS_LI_BUI:
475 printf("BUI");
476 break;
477 case XFS_LI_DQUOT:
478 printf("DQ ");
479 break;
480 case XFS_LI_QUOTAOFF:
481 printf("QOFF");
482 break;
483 default:
484 cmn_err(CE_PANIC, _("%s: illegal type"), __FUNCTION__);
485 break;
486 }
487
488 /* type isn't filled in yet
489 printf(_("ITEM: type: %d cnt: %d total: %d "),
490 item->ri_type, item->ri_cnt, item->ri_total);
491 */
492 printf(_(": cnt:%d total:%d "), item->ri_cnt, item->ri_total);
493 for (i=0; i<item->ri_cnt; i++) {
494 printf(_("a:0x%lx len:%d "),
495 (long)item->ri_buf[i].i_addr, item->ri_buf[i].i_len);
496 }
497 printf("\n");
498 xlog_recover_print_logitem(item);
499 }
500
501 void
502 xlog_recover_print_trans(
503 struct xlog_recover *trans,
504 struct list_head *itemq,
505 int print)
506 {
507 struct xlog_recover_item *item;
508
509 if (print < 3)
510 return;
511
512 print_xlog_record_line();
513 xlog_recover_print_trans_head(trans);
514 list_for_each_entry(item, itemq, ri_list)
515 xlog_recover_print_item(item);
516 }
Unnamed repository; edit this file 'description' to name the repository.