debug.c (32f6ccc743b89bb4c51d4a868ffdb6ebda2909cf) debug.c (c4c0d19d39d26c5f58633f8fcca75f03b2854fc0)
1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * This file is part of UBIFS.
4 *
5 * Copyright (C) 2006-2008 Nokia Corporation
6 *
7 * Authors: Artem Bityutskiy (Битюцкий Артём)
8 * Adrian Hunter

--- 277 unchanged lines hidden (view full) ---

286 fname_len(&nm) = le16_to_cpu(dent->nlen);
287 kfree(pdent);
288 pdent = dent;
289 key_read(c, &dent->key, &key);
290 }
291 kfree(pdent);
292}
293
1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * This file is part of UBIFS.
4 *
5 * Copyright (C) 2006-2008 Nokia Corporation
6 *
7 * Authors: Artem Bityutskiy (Битюцкий Артём)
8 * Adrian Hunter

--- 277 unchanged lines hidden (view full) ---

286 fname_len(&nm) = le16_to_cpu(dent->nlen);
287 kfree(pdent);
288 pdent = dent;
289 key_read(c, &dent->key, &key);
290 }
291 kfree(pdent);
292}
293
294void ubifs_dump_node(const struct ubifs_info *c, const void *node)
294void ubifs_dump_node(const struct ubifs_info *c, const void *node, int node_len)
295{
295{
296 int i, n;
296 int i, n, type, safe_len, max_node_len, min_node_len;
297 union ubifs_key key;
298 const struct ubifs_ch *ch = node;
299 char key_buf[DBG_KEY_BUF_LEN];
300
301 /* If the magic is incorrect, just hexdump the first bytes */
302 if (le32_to_cpu(ch->magic) != UBIFS_NODE_MAGIC) {
303 pr_err("Not a node, first %zu bytes:", UBIFS_CH_SZ);
304 print_hex_dump(KERN_ERR, "", DUMP_PREFIX_OFFSET, 32, 1,
305 (void *)node, UBIFS_CH_SZ, 1);
306 return;
307 }
308
297 union ubifs_key key;
298 const struct ubifs_ch *ch = node;
299 char key_buf[DBG_KEY_BUF_LEN];
300
301 /* If the magic is incorrect, just hexdump the first bytes */
302 if (le32_to_cpu(ch->magic) != UBIFS_NODE_MAGIC) {
303 pr_err("Not a node, first %zu bytes:", UBIFS_CH_SZ);
304 print_hex_dump(KERN_ERR, "", DUMP_PREFIX_OFFSET, 32, 1,
305 (void *)node, UBIFS_CH_SZ, 1);
306 return;
307 }
308
309 /* Skip dumping unknown type node */
310 type = ch->node_type;
311 if (type < 0 || type >= UBIFS_NODE_TYPES_CNT) {
312 pr_err("node type %d was not recognized\n", type);
313 return;
314 }
315
309 spin_lock(&dbg_lock);
310 dump_ch(node);
311
316 spin_lock(&dbg_lock);
317 dump_ch(node);
318
312 switch (ch->node_type) {
319 if (c->ranges[type].max_len == 0) {
320 max_node_len = min_node_len = c->ranges[type].len;
321 } else {
322 max_node_len = c->ranges[type].max_len;
323 min_node_len = c->ranges[type].min_len;
324 }
325 safe_len = le32_to_cpu(ch->len);
326 safe_len = safe_len > 0 ? safe_len : 0;
327 safe_len = min3(safe_len, max_node_len, node_len);
328 if (safe_len < min_node_len) {
329 pr_err("node len(%d) is too short for %s, left %d bytes:\n",
330 safe_len, dbg_ntype(type),
331 safe_len > UBIFS_CH_SZ ?
332 safe_len - (int)UBIFS_CH_SZ : 0);
333 if (safe_len > UBIFS_CH_SZ)
334 print_hex_dump(KERN_ERR, "", DUMP_PREFIX_OFFSET, 32, 1,
335 (void *)node + UBIFS_CH_SZ,
336 safe_len - UBIFS_CH_SZ, 0);
337 goto out_unlock;
338 }
339 if (safe_len != le32_to_cpu(ch->len))
340 pr_err("\ttruncated node length %d\n", safe_len);
341
342 switch (type) {
313 case UBIFS_PAD_NODE:
314 {
315 const struct ubifs_pad_node *pad = node;
316
317 pr_err("\tpad_len %u\n", le32_to_cpu(pad->pad_len));
318 break;
319 }
320 case UBIFS_SB_NODE:

--- 127 unchanged lines hidden (view full) ---

448 pr_err("\tkey %s\n",
449 dbg_snprintf_key(c, &key, key_buf, DBG_KEY_BUF_LEN));
450 pr_err("\tinum %llu\n",
451 (unsigned long long)le64_to_cpu(dent->inum));
452 pr_err("\ttype %d\n", (int)dent->type);
453 pr_err("\tnlen %d\n", nlen);
454 pr_err("\tname ");
455
343 case UBIFS_PAD_NODE:
344 {
345 const struct ubifs_pad_node *pad = node;
346
347 pr_err("\tpad_len %u\n", le32_to_cpu(pad->pad_len));
348 break;
349 }
350 case UBIFS_SB_NODE:

--- 127 unchanged lines hidden (view full) ---

478 pr_err("\tkey %s\n",
479 dbg_snprintf_key(c, &key, key_buf, DBG_KEY_BUF_LEN));
480 pr_err("\tinum %llu\n",
481 (unsigned long long)le64_to_cpu(dent->inum));
482 pr_err("\ttype %d\n", (int)dent->type);
483 pr_err("\tnlen %d\n", nlen);
484 pr_err("\tname ");
485
456 if (nlen > UBIFS_MAX_NLEN)
486 if (nlen > UBIFS_MAX_NLEN ||
487 nlen > safe_len - UBIFS_DENT_NODE_SZ)
457 pr_err("(bad name length, not printing, bad or corrupted node)");
458 else {
459 for (i = 0; i < nlen && dent->name[i]; i++)
460 pr_cont("%c", isprint(dent->name[i]) ?
461 dent->name[i] : '?');
462 }
463 pr_cont("\n");
464
465 break;
466 }
467 case UBIFS_DATA_NODE:
468 {
469 const struct ubifs_data_node *dn = node;
488 pr_err("(bad name length, not printing, bad or corrupted node)");
489 else {
490 for (i = 0; i < nlen && dent->name[i]; i++)
491 pr_cont("%c", isprint(dent->name[i]) ?
492 dent->name[i] : '?');
493 }
494 pr_cont("\n");
495
496 break;
497 }
498 case UBIFS_DATA_NODE:
499 {
500 const struct ubifs_data_node *dn = node;
470 int dlen = le32_to_cpu(ch->len) - UBIFS_DATA_NODE_SZ;
471
472 key_read(c, &dn->key, &key);
473 pr_err("\tkey %s\n",
474 dbg_snprintf_key(c, &key, key_buf, DBG_KEY_BUF_LEN));
475 pr_err("\tsize %u\n", le32_to_cpu(dn->size));
476 pr_err("\tcompr_typ %d\n",
477 (int)le16_to_cpu(dn->compr_type));
501
502 key_read(c, &dn->key, &key);
503 pr_err("\tkey %s\n",
504 dbg_snprintf_key(c, &key, key_buf, DBG_KEY_BUF_LEN));
505 pr_err("\tsize %u\n", le32_to_cpu(dn->size));
506 pr_err("\tcompr_typ %d\n",
507 (int)le16_to_cpu(dn->compr_type));
478 pr_err("\tdata size %d\n", dlen);
479 pr_err("\tdata:\n");
508 pr_err("\tdata size %u\n",
509 le32_to_cpu(ch->len) - (unsigned int)UBIFS_DATA_NODE_SZ);
510 pr_err("\tdata (length = %d):\n",
511 safe_len - (int)UBIFS_DATA_NODE_SZ);
480 print_hex_dump(KERN_ERR, "\t", DUMP_PREFIX_OFFSET, 32, 1,
512 print_hex_dump(KERN_ERR, "\t", DUMP_PREFIX_OFFSET, 32, 1,
481 (void *)&dn->data, dlen, 0);
513 (void *)&dn->data,
514 safe_len - (int)UBIFS_DATA_NODE_SZ, 0);
482 break;
483 }
484 case UBIFS_TRUN_NODE:
485 {
486 const struct ubifs_trun_node *trun = node;
487
488 pr_err("\tinum %u\n", le32_to_cpu(trun->inum));
489 pr_err("\told_size %llu\n",
490 (unsigned long long)le64_to_cpu(trun->old_size));
491 pr_err("\tnew_size %llu\n",
492 (unsigned long long)le64_to_cpu(trun->new_size));
493 break;
494 }
495 case UBIFS_IDX_NODE:
496 {
497 const struct ubifs_idx_node *idx = node;
515 break;
516 }
517 case UBIFS_TRUN_NODE:
518 {
519 const struct ubifs_trun_node *trun = node;
520
521 pr_err("\tinum %u\n", le32_to_cpu(trun->inum));
522 pr_err("\told_size %llu\n",
523 (unsigned long long)le64_to_cpu(trun->old_size));
524 pr_err("\tnew_size %llu\n",
525 (unsigned long long)le64_to_cpu(trun->new_size));
526 break;
527 }
528 case UBIFS_IDX_NODE:
529 {
530 const struct ubifs_idx_node *idx = node;
531 int max_child_cnt = (safe_len - UBIFS_IDX_NODE_SZ) /
532 (ubifs_idx_node_sz(c, 1) -
533 UBIFS_IDX_NODE_SZ);
498
534
499 n = le16_to_cpu(idx->child_cnt);
500 pr_err("\tchild_cnt %d\n", n);
535 n = min_t(int, le16_to_cpu(idx->child_cnt), max_child_cnt);
536 pr_err("\tchild_cnt %d\n", (int)le16_to_cpu(idx->child_cnt));
501 pr_err("\tlevel %d\n", (int)le16_to_cpu(idx->level));
502 pr_err("\tBranches:\n");
503
504 for (i = 0; i < n && i < c->fanout - 1; i++) {
505 const struct ubifs_branch *br;
506
507 br = ubifs_idx_branch(c, idx, i);
508 key_read(c, &br->key, &key);

--- 11 unchanged lines hidden (view full) ---

520 {
521 const struct ubifs_orph_node *orph = node;
522
523 pr_err("\tcommit number %llu\n",
524 (unsigned long long)
525 le64_to_cpu(orph->cmt_no) & LLONG_MAX);
526 pr_err("\tlast node flag %llu\n",
527 (unsigned long long)(le64_to_cpu(orph->cmt_no)) >> 63);
537 pr_err("\tlevel %d\n", (int)le16_to_cpu(idx->level));
538 pr_err("\tBranches:\n");
539
540 for (i = 0; i < n && i < c->fanout - 1; i++) {
541 const struct ubifs_branch *br;
542
543 br = ubifs_idx_branch(c, idx, i);
544 key_read(c, &br->key, &key);

--- 11 unchanged lines hidden (view full) ---

556 {
557 const struct ubifs_orph_node *orph = node;
558
559 pr_err("\tcommit number %llu\n",
560 (unsigned long long)
561 le64_to_cpu(orph->cmt_no) & LLONG_MAX);
562 pr_err("\tlast node flag %llu\n",
563 (unsigned long long)(le64_to_cpu(orph->cmt_no)) >> 63);
528 n = (le32_to_cpu(ch->len) - UBIFS_ORPH_NODE_SZ) >> 3;
564 n = (safe_len - UBIFS_ORPH_NODE_SZ) >> 3;
529 pr_err("\t%d orphan inode numbers:\n", n);
530 for (i = 0; i < n; i++)
531 pr_err("\t ino %llu\n",
532 (unsigned long long)le64_to_cpu(orph->inos[i]));
533 break;
534 }
535 case UBIFS_AUTH_NODE:
536 {
537 break;
538 }
539 default:
565 pr_err("\t%d orphan inode numbers:\n", n);
566 for (i = 0; i < n; i++)
567 pr_err("\t ino %llu\n",
568 (unsigned long long)le64_to_cpu(orph->inos[i]));
569 break;
570 }
571 case UBIFS_AUTH_NODE:
572 {
573 break;
574 }
575 default:
540 pr_err("node type %d was not recognized\n",
541 (int)ch->node_type);
576 pr_err("node type %d was not recognized\n", type);
542 }
577 }
578
579out_unlock:
543 spin_unlock(&dbg_lock);
544}
545
546void ubifs_dump_budget_req(const struct ubifs_budget_req *req)
547{
548 spin_lock(&dbg_lock);
549 pr_err("Budgeting request: new_ino %d, dirtied_ino %d\n",
550 req->new_ino, req->dirtied_ino);

--- 2475 unchanged lines hidden --- 		580 spin_unlock(&dbg_lock);
581}
582
583void ubifs_dump_budget_req(const struct ubifs_budget_req *req)
584{
585 spin_lock(&dbg_lock);
586 pr_err("Budgeting request: new_ino %d, dirtied_ino %d\n",
587 req->new_ino, req->dirtied_ino);

--- 2475 unchanged lines hidden ---