From: Vyacheslav Dubeyko <[email protected]> Subject: [PATCH 21/24] nilfs2: implement hexdump of internal structures option
This patch implements DBG_HEX_DUMP flag using. This flag requests writing in system log hexdumps of internal structures. Signed-off-by: Vyacheslav Dubeyko <[email protected]> CC: Ryusuke Konishi <[email protected]> --- fs/nilfs2/btree.c | 126 +++++++++++++++++++++++++++++++++++++++++++++++++ fs/nilfs2/cpfile.c | 10 ++++ fs/nilfs2/dat.c | 5 ++ fs/nilfs2/direct.c | 28 +++++++++++ fs/nilfs2/ifile.c | 2 + fs/nilfs2/inode.c | 5 ++ fs/nilfs2/recovery.c | 20 ++++++++ fs/nilfs2/segment.c | 84 +++++++++++++++++++++++++++++++++ fs/nilfs2/sufile.c | 6 +++ fs/nilfs2/the_nilfs.c | 2 + 10 files changed, 288 insertions(+) diff --git a/fs/nilfs2/btree.c b/fs/nilfs2/btree.c index 9116be3..bf297ba 100644 --- a/fs/nilfs2/btree.c +++ b/fs/nilfs2/btree.c @@ -75,6 +75,8 @@ static int nilfs_btree_get_new_block(const struct nilfs_bmap *btree, nilfs2_debug((DBG_BTREE | DBG_DUMP_STACK | DBG_SPAM), "i_ino %lu, ptr %llu\n", btnc->host->i_ino, ptr); + nilfs2_hexdump((DBG_BTREE | DBG_HEX_DUMP | DBG_SPAM), + "btree: ", btree, sizeof(struct nilfs_bmap)); bh = nilfs_btnode_create_block(btnc, ptr); if (!bh) @@ -184,6 +186,10 @@ static void nilfs_btree_node_init(struct nilfs_btree_node *node, int flags, nilfs2_debug((DBG_BTREE | DBG_DUMP_STACK), "node %p, flags %d, level %d, nchildren %d, ncmax %d\n", node, flags, level, nchildren, ncmax); + nilfs2_hexdump((DBG_BTREE | DBG_HEX_DUMP), + "keys: ", keys, nchildren * sizeof(__u64)); + nilfs2_hexdump((DBG_BTREE | DBG_HEX_DUMP), + "ptrs: ", ptrs, nchildren * sizeof(__u64)); nilfs_btree_node_set_flags(node, flags); nilfs_btree_node_set_level(node, level); @@ -195,6 +201,9 @@ static void nilfs_btree_node_init(struct nilfs_btree_node *node, int flags, dkeys[i] = cpu_to_le64(keys[i]); dptrs[i] = cpu_to_le64(ptrs[i]); } + + nilfs2_hexdump((DBG_BTREE | DBG_HEX_DUMP), + "node: ", node, sizeof(struct nilfs_btree_node)); } /* Assume the buffer heads corresponding to left and right are locked. */ @@ -209,6 +218,10 @@ static void nilfs_btree_node_move_left(struct nilfs_btree_node *left, nilfs2_debug((DBG_BTREE | DBG_DUMP_STACK), "left %p, right %p, n %d, lncmax %d, rncmax %d\n", left, right, n, lncmax, rncmax); + nilfs2_hexdump((DBG_BTREE | DBG_HEX_DUMP), + "left node: ", left, sizeof(struct nilfs_btree_node)); + nilfs2_hexdump((DBG_BTREE | DBG_HEX_DUMP), + "right node: ", right, sizeof(struct nilfs_btree_node)); ldkeys = nilfs_btree_node_dkeys(left); ldptrs = nilfs_btree_node_dptrs(left, lncmax); @@ -241,6 +254,10 @@ static void nilfs_btree_node_move_right(struct nilfs_btree_node *left, nilfs2_debug((DBG_BTREE | DBG_DUMP_STACK), "left %p, right %p, n %d, lncmax %d, rncmax %d\n", left, right, n, lncmax, rncmax); + nilfs2_hexdump((DBG_BTREE | DBG_HEX_DUMP), + "left node: ", left, sizeof(struct nilfs_btree_node)); + nilfs2_hexdump((DBG_BTREE | DBG_HEX_DUMP), + "right node: ", right, sizeof(struct nilfs_btree_node)); ldkeys = nilfs_btree_node_dkeys(left); ldptrs = nilfs_btree_node_dptrs(left, lncmax); @@ -286,6 +303,9 @@ static void nilfs_btree_node_insert(struct nilfs_btree_node *node, int index, dptrs[index] = cpu_to_le64(ptr); nchildren++; nilfs_btree_node_set_nchildren(node, nchildren); + + nilfs2_hexdump((DBG_BTREE | DBG_HEX_DUMP), + "node: ", node, sizeof(struct nilfs_btree_node)); } /* Assume that the buffer head corresponding to node is locked. */ @@ -322,6 +342,8 @@ static void nilfs_btree_node_delete(struct nilfs_btree_node *node, int index, nilfs_btree_node_set_nchildren(node, nchildren); nilfs2_debug(DBG_BTREE, "key %llu, ptr %llu\n", key, ptr); + nilfs2_hexdump((DBG_BTREE | DBG_HEX_DUMP), + "node: ", node, sizeof(struct nilfs_btree_node)); } static int nilfs_btree_node_lookup(const struct nilfs_btree_node *node, @@ -333,6 +355,8 @@ static int nilfs_btree_node_lookup(const struct nilfs_btree_node *node, nilfs2_debug((DBG_BTREE | DBG_DUMP_STACK), "node %p, key %llu, indexp %p\n", node, key, indexp); + nilfs2_hexdump((DBG_BTREE | DBG_HEX_DUMP), + "node: ", node, sizeof(struct nilfs_btree_node)); /* binary search */ low = 0; @@ -484,6 +508,8 @@ static int __nilfs_btree_get_block(const struct nilfs_bmap *btree, __u64 ptr, nilfs2_debug((DBG_BTREE | DBG_DUMP_STACK | DBG_SPAM), "btree ino %lu, ptr %llu, bhp %p, ra %p\n", btree->b_inode->i_ino, ptr, bhp, ra); + nilfs2_hexdump((DBG_BTREE | DBG_HEX_DUMP | DBG_SPAM), + "btree: ", btree, sizeof(struct nilfs_bmap)); ret = nilfs_btnode_submit_block(btnc, ptr, 0, READ, &bh, &submit_ptr); if (ret) { @@ -550,6 +576,8 @@ static int nilfs_btree_do_lookup(const struct nilfs_bmap *btree, nilfs2_debug((DBG_BTREE | DBG_DUMP_STACK), "btree ino %lu, path %p, key %llu, ptrp %p, minlevel %d, ra %d\n", btree->b_inode->i_ino, path, key, ptrp, minlevel, readahead); + nilfs2_hexdump((DBG_BTREE | DBG_HEX_DUMP), + "btree: ", btree, sizeof(struct nilfs_bmap)); node = nilfs_btree_get_root(btree); level = nilfs_btree_node_get_level(node); @@ -616,6 +644,8 @@ static int nilfs_btree_do_lookup_last(const struct nilfs_bmap *btree, nilfs2_debug((DBG_BTREE | DBG_DUMP_STACK), "btree ino %lu, path %p, keyp %p, ptrp %p\n", btree->b_inode->i_ino, path, keyp, ptrp); + nilfs2_hexdump((DBG_BTREE | DBG_HEX_DUMP), + "btree: ", btree, sizeof(struct nilfs_bmap)); node = nilfs_btree_get_root(btree); index = nilfs_btree_node_get_nchildren(node) - 1; @@ -661,6 +691,8 @@ static int nilfs_btree_lookup(const struct nilfs_bmap *btree, nilfs2_debug((DBG_BTREE | DBG_DUMP_STACK), "btree ino %lu, key %llu, level %d, ptrp %p\n", btree->b_inode->i_ino, key, level, ptrp); + nilfs2_hexdump((DBG_BTREE | DBG_HEX_DUMP), + "btree: ", btree, sizeof(struct nilfs_bmap)); path = nilfs_btree_alloc_path(); if (path == NULL) @@ -688,6 +720,8 @@ static int nilfs_btree_lookup_contig(const struct nilfs_bmap *btree, nilfs2_debug((DBG_BTREE | DBG_DUMP_STACK), "btree ino %lu, key %llu, ptrp %p, maxblocks %u\n", btree->b_inode->i_ino, key, ptrp, maxblocks); + nilfs2_hexdump((DBG_BTREE | DBG_HEX_DUMP), + "btree: ", btree, sizeof(struct nilfs_bmap)); path = nilfs_btree_alloc_path(); if (path == NULL) @@ -769,6 +803,8 @@ static void nilfs_btree_promote_key(struct nilfs_bmap *btree, nilfs2_debug((DBG_BTREE | DBG_DUMP_STACK | DBG_SPAM), "btree ino %lu, level %d, key %llu\n", btree->b_inode->i_ino, level, key); + nilfs2_hexdump((DBG_BTREE | DBG_HEX_DUMP | DBG_SPAM), + "btree: ", btree, sizeof(struct nilfs_bmap)); if (level < nilfs_btree_height(btree) - 1) { do { @@ -798,6 +834,8 @@ static void nilfs_btree_do_insert(struct nilfs_bmap *btree, nilfs2_debug((DBG_BTREE | DBG_DUMP_STACK), "btree ino %lu, level %d, keyp %p, ptrp %p\n", btree->b_inode->i_ino, level, keyp, ptrp); + nilfs2_hexdump((DBG_BTREE | DBG_HEX_DUMP), + "btree: ", btree, sizeof(struct nilfs_bmap)); if (level < nilfs_btree_height(btree) - 1) { node = nilfs_btree_get_nonroot_node(path, level); @@ -829,6 +867,8 @@ static void nilfs_btree_carry_left(struct nilfs_bmap *btree, nilfs2_debug((DBG_BTREE | DBG_DUMP_STACK), "btree ino %lu, level %d, keyp %p, ptrp %p\n", btree->b_inode->i_ino, level, keyp, ptrp); + nilfs2_hexdump((DBG_BTREE | DBG_HEX_DUMP), + "btree: ", btree, sizeof(struct nilfs_bmap)); node = nilfs_btree_get_nonroot_node(path, level); left = nilfs_btree_get_sib_node(path, level); @@ -879,6 +919,8 @@ static void nilfs_btree_carry_right(struct nilfs_bmap *btree, nilfs2_debug((DBG_BTREE | DBG_DUMP_STACK), "btree ino %lu, level %d, keyp %p, ptrp %p\n", btree->b_inode->i_ino, level, keyp, ptrp); + nilfs2_hexdump((DBG_BTREE | DBG_HEX_DUMP), + "btree: ", btree, sizeof(struct nilfs_bmap)); node = nilfs_btree_get_nonroot_node(path, level); right = nilfs_btree_get_sib_node(path, level); @@ -932,6 +974,8 @@ static void nilfs_btree_split(struct nilfs_bmap *btree, nilfs2_debug((DBG_BTREE | DBG_DUMP_STACK), "btree ino %lu, level %d, keyp %p, ptrp %p\n", btree->b_inode->i_ino, level, keyp, ptrp); + nilfs2_hexdump((DBG_BTREE | DBG_HEX_DUMP), + "btree: ", btree, sizeof(struct nilfs_bmap)); node = nilfs_btree_get_nonroot_node(path, level); right = nilfs_btree_get_sib_node(path, level); @@ -989,6 +1033,8 @@ static void nilfs_btree_grow(struct nilfs_bmap *btree, nilfs2_debug((DBG_BTREE | DBG_DUMP_STACK), "btree ino %lu, level %d, keyp %p, ptrp %p\n", btree->b_inode->i_ino, level, keyp, ptrp); + nilfs2_hexdump((DBG_BTREE | DBG_HEX_DUMP), + "btree: ", btree, sizeof(struct nilfs_bmap)); root = nilfs_btree_get_root(btree); child = nilfs_btree_get_sib_node(path, level); @@ -1020,6 +1066,8 @@ static __u64 nilfs_btree_find_near(const struct nilfs_bmap *btree, nilfs2_debug((DBG_BTREE | DBG_DUMP_STACK | DBG_SPAM), "btree ino %lu\n", btree->b_inode->i_ino); + nilfs2_hexdump((DBG_BTREE | DBG_HEX_DUMP | DBG_SPAM), + "btree: ", btree, sizeof(struct nilfs_bmap)); if (path == NULL) return NILFS_BMAP_INVALID_PTR; @@ -1053,6 +1101,8 @@ static __u64 nilfs_btree_find_target_v(const struct nilfs_bmap *btree, nilfs2_debug((DBG_BTREE | DBG_DUMP_STACK | DBG_SPAM), "btree ino %lu, key %llu\n", btree->b_inode->i_ino, key); + nilfs2_hexdump((DBG_BTREE | DBG_HEX_DUMP | DBG_SPAM), + "btree: ", btree, sizeof(struct nilfs_bmap)); ptr = nilfs_bmap_find_target_seq(btree, key); if (ptr != NILFS_BMAP_INVALID_PTR) @@ -1082,6 +1132,10 @@ static int nilfs_btree_prepare_insert(struct nilfs_bmap *btree, nilfs2_debug((DBG_BTREE | DBG_DUMP_STACK), "btree ino %lu, levelp %p, key %llu, ptr %llu, stats %p\n", btree->b_inode->i_ino, levelp, key, ptr, stats); + nilfs2_hexdump((DBG_BTREE | DBG_HEX_DUMP), + "btree: ", btree, sizeof(struct nilfs_bmap)); + nilfs2_hexdump((DBG_BTREE | DBG_HEX_DUMP), + "stats: ", stats, sizeof(struct nilfs_bmap_stats)); stats->bs_nblocks = 0; level = NILFS_BTREE_LEVEL_DATA; @@ -1231,6 +1285,8 @@ static void nilfs_btree_commit_insert(struct nilfs_bmap *btree, nilfs2_debug((DBG_BTREE | DBG_DUMP_STACK), "btree ino %lu, maxlevel %d, key %llu, ptr %llu\n", btree->b_inode->i_ino, maxlevel, key, ptr); + nilfs2_hexdump((DBG_BTREE | DBG_HEX_DUMP), + "btree: ", btree, sizeof(struct nilfs_bmap)); set_buffer_nilfs_volatile((struct buffer_head *)((unsigned long)ptr)); ptr = path[NILFS_BTREE_LEVEL_DATA].bp_newreq.bpr_ptr; @@ -1258,6 +1314,8 @@ static int nilfs_btree_insert(struct nilfs_bmap *btree, __u64 key, __u64 ptr) nilfs2_debug((DBG_BTREE | DBG_DUMP_STACK), "btree ino %lu, key %llu, ptr %llu\n", btree->b_inode->i_ino, key, ptr); + nilfs2_hexdump((DBG_BTREE | DBG_HEX_DUMP), + "btree: ", btree, sizeof(struct nilfs_bmap)); path = nilfs_btree_alloc_path(); if (path == NULL) @@ -1292,6 +1350,8 @@ static void nilfs_btree_do_delete(struct nilfs_bmap *btree, nilfs2_debug((DBG_BTREE | DBG_DUMP_STACK), "btree ino %lu, level %d, keyp %p, ptrp %p\n", btree->b_inode->i_ino, level, keyp, ptrp); + nilfs2_hexdump((DBG_BTREE | DBG_HEX_DUMP), + "btree: ", btree, sizeof(struct nilfs_bmap)); if (level < nilfs_btree_height(btree) - 1) { node = nilfs_btree_get_nonroot_node(path, level); @@ -1321,6 +1381,8 @@ static void nilfs_btree_borrow_left(struct nilfs_bmap *btree, nilfs2_debug((DBG_BTREE | DBG_DUMP_STACK), "btree ino %lu, level %d, keyp %p, ptrp %p\n", btree->b_inode->i_ino, level, keyp, ptrp); + nilfs2_hexdump((DBG_BTREE | DBG_HEX_DUMP), + "btree: ", btree, sizeof(struct nilfs_bmap)); nilfs_btree_do_delete(btree, path, level, keyp, ptrp); @@ -1357,6 +1419,8 @@ static void nilfs_btree_borrow_right(struct nilfs_bmap *btree, nilfs2_debug((DBG_BTREE | DBG_DUMP_STACK), "btree ino %lu, level %d, keyp %p, ptrp %p\n", btree->b_inode->i_ino, level, keyp, ptrp); + nilfs2_hexdump((DBG_BTREE | DBG_HEX_DUMP), + "btree: ", btree, sizeof(struct nilfs_bmap)); nilfs_btree_do_delete(btree, path, level, keyp, ptrp); @@ -1394,6 +1458,8 @@ static void nilfs_btree_concat_left(struct nilfs_bmap *btree, nilfs2_debug((DBG_BTREE | DBG_DUMP_STACK), "btree ino %lu, level %d, keyp %p, ptrp %p\n", btree->b_inode->i_ino, level, keyp, ptrp); + nilfs2_hexdump((DBG_BTREE | DBG_HEX_DUMP), + "btree: ", btree, sizeof(struct nilfs_bmap)); nilfs_btree_do_delete(btree, path, level, keyp, ptrp); @@ -1424,6 +1490,8 @@ static void nilfs_btree_concat_right(struct nilfs_bmap *btree, nilfs2_debug((DBG_BTREE | DBG_DUMP_STACK), "btree ino %lu, level %d, keyp %p, ptrp %p\n", btree->b_inode->i_ino, level, keyp, ptrp); + nilfs2_hexdump((DBG_BTREE | DBG_HEX_DUMP), + "btree: ", btree, sizeof(struct nilfs_bmap)); nilfs_btree_do_delete(btree, path, level, keyp, ptrp); @@ -1453,6 +1521,8 @@ static void nilfs_btree_shrink(struct nilfs_bmap *btree, nilfs2_debug((DBG_BTREE | DBG_DUMP_STACK), "btree ino %lu, level %d, keyp %p, ptrp %p\n", btree->b_inode->i_ino, level, keyp, ptrp); + nilfs2_hexdump((DBG_BTREE | DBG_HEX_DUMP), + "btree: ", btree, sizeof(struct nilfs_bmap)); nilfs_btree_do_delete(btree, path, level, keyp, ptrp); @@ -1491,6 +1561,10 @@ static int nilfs_btree_prepare_delete(struct nilfs_bmap *btree, nilfs2_debug((DBG_BTREE | DBG_DUMP_STACK), "btree ino %lu, levelp %p, stats %p, dat %p\n", btree->b_inode->i_ino, levelp, stats, dat); + nilfs2_hexdump((DBG_BTREE | DBG_HEX_DUMP), + "btree: ", btree, sizeof(struct nilfs_bmap)); + nilfs2_hexdump((DBG_BTREE | DBG_HEX_DUMP), + "stats: ", stats, sizeof(struct nilfs_bmap_stats)); ret = 0; stats->bs_nblocks = 0; @@ -1646,6 +1720,8 @@ static int nilfs_btree_delete(struct nilfs_bmap *btree, __u64 key) nilfs2_debug((DBG_BTREE | DBG_DUMP_STACK), "btree ino %lu, key %llu\n", btree->b_inode->i_ino, key); + nilfs2_hexdump((DBG_BTREE | DBG_HEX_DUMP), + "btree: ", btree, sizeof(struct nilfs_bmap)); path = nilfs_btree_alloc_path(); if (path == NULL) @@ -1678,6 +1754,8 @@ static int nilfs_btree_last_key(const struct nilfs_bmap *btree, __u64 *keyp) nilfs2_debug((DBG_BTREE | DBG_DUMP_STACK), "btree ino %lu, keyp %p\n", btree->b_inode->i_ino, keyp); + nilfs2_hexdump((DBG_BTREE | DBG_HEX_DUMP), + "btree: ", btree, sizeof(struct nilfs_bmap)); path = nilfs_btree_alloc_path(); if (path == NULL) @@ -1701,6 +1779,8 @@ static int nilfs_btree_check_delete(struct nilfs_bmap *btree, __u64 key) nilfs2_debug((DBG_BTREE | DBG_DUMP_STACK), "btree ino %lu, key %llu\n", btree->b_inode->i_ino, key); + nilfs2_hexdump((DBG_BTREE | DBG_HEX_DUMP), + "btree: ", btree, sizeof(struct nilfs_bmap)); root = nilfs_btree_get_root(btree); switch (nilfs_btree_height(btree)) { @@ -1746,6 +1826,8 @@ static int nilfs_btree_gather_data(struct nilfs_bmap *btree, nilfs2_debug((DBG_BTREE | DBG_DUMP_STACK), "btree ino %lu, keys %p, ptrs %p, nitems %d\n", btree->b_inode->i_ino, keys, ptrs, nitems); + nilfs2_hexdump((DBG_BTREE | DBG_HEX_DUMP), + "btree: ", btree, sizeof(struct nilfs_bmap)); root = nilfs_btree_get_root(btree); switch (nilfs_btree_height(btree)) { @@ -1800,6 +1882,10 @@ nilfs_btree_prepare_convert_and_insert(struct nilfs_bmap *btree, __u64 key, nilfs2_debug((DBG_BTREE | DBG_DUMP_STACK), "btree ino %lu, key %llu, dreq %p, nreq %p, bhp %p, stats %p\n", btree->b_inode->i_ino, key, dreq, nreq, bhp, stats); + nilfs2_hexdump((DBG_BTREE | DBG_HEX_DUMP), + "btree: ", btree, sizeof(struct nilfs_bmap)); + nilfs2_hexdump((DBG_BTREE | DBG_HEX_DUMP), + "stats: ", stats, sizeof(struct nilfs_bmap_stats)); stats->bs_nblocks = 0; @@ -1861,6 +1947,8 @@ nilfs_btree_commit_convert_and_insert(struct nilfs_bmap *btree, "btree ino %lu, key %llu, ptr %llu, keys %p," " ptrs %p, n %d, dreq %p, nreq %p, bh %p\n", btree->b_inode->i_ino, key, ptr, keys, ptrs, n, dreq, nreq, bh); + nilfs2_hexdump((DBG_BTREE | DBG_HEX_DUMP), + "btree: ", btree, sizeof(struct nilfs_bmap)); /* free resources */ if (btree->b_ops->bop_clear != NULL) @@ -1933,6 +2021,8 @@ int nilfs_btree_convert_and_insert(struct nilfs_bmap *btree, nilfs2_debug((DBG_BTREE | DBG_DUMP_STACK), "btree ino %lu, key %llu, ptr %llu, keys %p, ptrs %p, n %d\n", btree->b_inode->i_ino, key, ptr, keys, ptrs, n); + nilfs2_hexdump((DBG_BTREE | DBG_HEX_DUMP), + "btree: ", btree, sizeof(struct nilfs_bmap)); if (n + 1 <= NILFS_BTREE_ROOT_NCHILDREN_MAX) { di = &dreq; @@ -1979,6 +2069,8 @@ static int nilfs_btree_prepare_update_v(struct nilfs_bmap *btree, nilfs2_debug((DBG_BTREE | DBG_DUMP_STACK), "btree ino %lu, level %d, dat %p\n", btree->b_inode->i_ino, level, dat); + nilfs2_hexdump((DBG_BTREE | DBG_HEX_DUMP), + "btree: ", btree, sizeof(struct nilfs_bmap)); parent = nilfs_btree_get_node(btree, path, level + 1, &ncmax); path[level].bp_oldreq.bpr_ptr = @@ -2018,6 +2110,8 @@ static void nilfs_btree_commit_update_v(struct nilfs_bmap *btree, nilfs2_debug((DBG_BTREE | DBG_DUMP_STACK), "btree ino %lu, level %d, dat %p\n", btree->b_inode->i_ino, level, dat); + nilfs2_hexdump((DBG_BTREE | DBG_HEX_DUMP), + "btree: ", btree, sizeof(struct nilfs_bmap)); nilfs_dat_commit_update(dat, &path[level].bp_oldreq.bpr_req, &path[level].bp_newreq.bpr_req, @@ -2043,6 +2137,8 @@ static void nilfs_btree_abort_update_v(struct nilfs_bmap *btree, nilfs2_debug((DBG_BTREE | DBG_DUMP_STACK), "btree ino %lu, level %d, dat %p\n", btree->b_inode->i_ino, level, dat); + nilfs2_hexdump((DBG_BTREE | DBG_HEX_DUMP), + "btree: ", btree, sizeof(struct nilfs_bmap)); nilfs_dat_abort_update(dat, &path[level].bp_oldreq.bpr_req, &path[level].bp_newreq.bpr_req); @@ -2062,6 +2158,8 @@ static int nilfs_btree_prepare_propagate_v(struct nilfs_bmap *btree, nilfs2_debug((DBG_BTREE | DBG_DUMP_STACK), "btree ino %lu, minlevel %d, maxlevelp %p, dat %p\n", btree->b_inode->i_ino, minlevel, maxlevelp, dat); + nilfs2_hexdump((DBG_BTREE | DBG_HEX_DUMP), + "btree: ", btree, sizeof(struct nilfs_bmap)); level = minlevel; if (!buffer_nilfs_volatile(path[level].bp_bh)) { @@ -2102,6 +2200,8 @@ static void nilfs_btree_commit_propagate_v(struct nilfs_bmap *btree, nilfs2_debug((DBG_BTREE | DBG_DUMP_STACK), "btree ino %lu, minlevel %d, maxlevel %d, bh %p, dat %p\n", btree->b_inode->i_ino, minlevel, maxlevel, bh, dat); + nilfs2_hexdump((DBG_BTREE | DBG_HEX_DUMP), + "btree: ", btree, sizeof(struct nilfs_bmap)); if (!buffer_nilfs_volatile(path[minlevel].bp_bh)) nilfs_btree_commit_update_v(btree, path, minlevel, dat); @@ -2123,6 +2223,8 @@ static int nilfs_btree_propagate_v(struct nilfs_bmap *btree, nilfs2_debug((DBG_BTREE | DBG_DUMP_STACK), "btree ino %lu, level %d, bh %p\n", btree->b_inode->i_ino, level, bh); + nilfs2_hexdump((DBG_BTREE | DBG_HEX_DUMP), + "btree: ", btree, sizeof(struct nilfs_bmap)); get_bh(bh); path[level].bp_bh = bh; @@ -2160,6 +2262,8 @@ static int nilfs_btree_propagate(struct nilfs_bmap *btree, nilfs2_debug((DBG_BTREE | DBG_DUMP_STACK), "btree ino %lu, bh %p\n", btree->b_inode->i_ino, bh); + nilfs2_hexdump((DBG_BTREE | DBG_HEX_DUMP), + "btree: ", btree, sizeof(struct nilfs_bmap)); WARN_ON(!buffer_dirty(bh)); @@ -2213,6 +2317,8 @@ static void nilfs_btree_add_dirty_buffer(struct nilfs_bmap *btree, nilfs2_debug((DBG_BTREE | DBG_DUMP_STACK), "btree ino %lu, lists %p, bh %p\n", btree->b_inode->i_ino, lists, bh); + nilfs2_hexdump((DBG_BTREE | DBG_HEX_DUMP), + "btree: ", btree, sizeof(struct nilfs_bmap)); get_bh(bh); node = (struct nilfs_btree_node *)bh->b_data; @@ -2253,6 +2359,8 @@ static void nilfs_btree_lookup_dirty_buffers(struct nilfs_bmap *btree, nilfs2_debug((DBG_BTREE | DBG_DUMP_STACK), "btree ino %lu, listp %p\n", btree->b_inode->i_ino, listp); + nilfs2_hexdump((DBG_BTREE | DBG_HEX_DUMP), + "btree: ", btree, sizeof(struct nilfs_bmap)); for (level = NILFS_BTREE_LEVEL_NODE_MIN; level < NILFS_BTREE_LEVEL_MAX; @@ -2296,6 +2404,10 @@ static int nilfs_btree_assign_p(struct nilfs_bmap *btree, nilfs2_debug((DBG_BTREE | DBG_DUMP_STACK), "btree ino %lu, level %d, bh %p, blocknr %lu, binfo %p\n", btree->b_inode->i_ino, level, bh, blocknr, binfo); + nilfs2_hexdump((DBG_BTREE | DBG_HEX_DUMP), + "btree: ", btree, sizeof(struct nilfs_bmap)); + nilfs2_hexdump((DBG_BTREE | DBG_HEX_DUMP), + "binfo: ", binfo, sizeof(union nilfs_binfo)); parent = nilfs_btree_get_node(btree, path, level + 1, &ncmax); ptr = nilfs_btree_node_get_ptr(parent, path[level + 1].bp_index, @@ -2343,6 +2455,10 @@ static int nilfs_btree_assign_v(struct nilfs_bmap *btree, nilfs2_debug((DBG_BTREE | DBG_DUMP_STACK), "btree ino %lu, level %d, bh %p, blocknr %lu, binfo %p\n", btree->b_inode->i_ino, level, bh, blocknr, binfo); + nilfs2_hexdump((DBG_BTREE | DBG_HEX_DUMP), + "btree: ", btree, sizeof(struct nilfs_bmap)); + nilfs2_hexdump((DBG_BTREE | DBG_HEX_DUMP), + "binfo: ", binfo, sizeof(union nilfs_binfo)); parent = nilfs_btree_get_node(btree, path, level + 1, &ncmax); ptr = nilfs_btree_node_get_ptr(parent, path[level + 1].bp_index, @@ -2374,6 +2490,10 @@ static int nilfs_btree_assign(struct nilfs_bmap *btree, nilfs2_debug((DBG_BTREE | DBG_DUMP_STACK), "btree ino %lu, bh %p, blocknr %lu, binfo %p\n", btree->b_inode->i_ino, bh, blocknr, binfo); + nilfs2_hexdump((DBG_BTREE | DBG_HEX_DUMP), + "btree: ", btree, sizeof(struct nilfs_bmap)); + nilfs2_hexdump((DBG_BTREE | DBG_HEX_DUMP), + "binfo: ", binfo, sizeof(union nilfs_binfo)); path = nilfs_btree_alloc_path(); if (path == NULL) @@ -2416,6 +2536,10 @@ static int nilfs_btree_assign_gc(struct nilfs_bmap *btree, nilfs2_debug((DBG_BTREE | DBG_DUMP_STACK), "btree ino %lu, bh %p, blocknr %lu, binfo %p\n", btree->b_inode->i_ino, bh, blocknr, binfo); + nilfs2_hexdump((DBG_BTREE | DBG_HEX_DUMP), + "btree: ", btree, sizeof(struct nilfs_bmap)); + nilfs2_hexdump((DBG_BTREE | DBG_HEX_DUMP), + "binfo: ", binfo, sizeof(union nilfs_binfo)); ret = nilfs_dat_move(nilfs_bmap_get_dat(btree), (*bh)->b_blocknr, blocknr); @@ -2445,6 +2569,8 @@ static int nilfs_btree_mark(struct nilfs_bmap *btree, __u64 key, int level) nilfs2_debug((DBG_BTREE | DBG_DUMP_STACK), "btree ino %lu, key %llu, level %d\n", btree->b_inode->i_ino, key, level); + nilfs2_hexdump((DBG_BTREE | DBG_HEX_DUMP), + "btree: ", btree, sizeof(struct nilfs_bmap)); path = nilfs_btree_alloc_path(); if (path == NULL) diff --git a/fs/nilfs2/cpfile.c b/fs/nilfs2/cpfile.c index 490c839..f5231f7 100644 --- a/fs/nilfs2/cpfile.c +++ b/fs/nilfs2/cpfile.c @@ -404,6 +404,10 @@ static void nilfs_cpfile_checkpoint_to_cpinfo(struct inode *cpfile, nilfs2_debug((DBG_CPFILE | DBG_DUMP_STACK), "i_ino %lu, cp %p, ci %p\n", cpfile->i_ino, cp, ci); + nilfs2_hexdump((DBG_CPFILE | DBG_HEX_DUMP), + "checkpoint: ", cp, sizeof(struct nilfs_checkpoint)); + nilfs2_hexdump((DBG_CPFILE | DBG_HEX_DUMP), + "cpinfo: ", ci, sizeof(struct nilfs_cpinfo)); ci->ci_flags = le32_to_cpu(cp->cp_flags); ci->ci_cno = le64_to_cpu(cp->cp_cno); @@ -989,6 +993,10 @@ int nilfs_cpfile_get_stat(struct inode *cpfile, struct nilfs_cpstat *cpstat) out_sem: up_read(&NILFS_MDT(cpfile)->mi_sem); + + nilfs2_hexdump((DBG_CPFILE | DBG_HEX_DUMP), + "cpstat: ", cpstat, sizeof(struct nilfs_cpstat)); + return ret; } @@ -1008,6 +1016,8 @@ int nilfs_cpfile_read(struct super_block *sb, size_t cpsize, nilfs2_debug((DBG_CPFILE | DBG_DUMP_STACK), "sb %p, cpsize %zu, raw_inode %p, inodep %p\n", sb, cpsize, raw_inode, inodep); + nilfs2_hexdump((DBG_CPFILE | DBG_HEX_DUMP), + "raw_inode: ", raw_inode, sizeof(struct nilfs_inode)); cpfile = nilfs_iget_locked(sb, NULL, NILFS_CPFILE_INO); if (unlikely(!cpfile)) diff --git a/fs/nilfs2/dat.c b/fs/nilfs2/dat.c index 4b7875e..5443c6b 100644 --- a/fs/nilfs2/dat.c +++ b/fs/nilfs2/dat.c @@ -547,6 +547,9 @@ ssize_t nilfs_dat_get_vinfo(struct inode *dat, void *buf, unsigned visz, brelse(entry_bh); } + nilfs2_hexdump((DBG_DAT | DBG_HEX_DUMP | DBG_SPAM), + "vinfo: ", buf, nvi * sizeof(struct nilfs_vinfo)); + return nvi; } @@ -568,6 +571,8 @@ int nilfs_dat_read(struct super_block *sb, size_t entry_size, nilfs2_debug((DBG_DAT | DBG_DUMP_STACK), "sb %p, entry_size %zu, raw_inode %p, inodep %p\n", sb, entry_size, raw_inode, inodep); + nilfs2_hexdump((DBG_DAT | DBG_HEX_DUMP), + "raw_inode: ", raw_inode, sizeof(struct nilfs_inode)); dat = nilfs_iget_locked(sb, NULL, NILFS_DAT_INO); if (unlikely(!dat)) diff --git a/fs/nilfs2/direct.c b/fs/nilfs2/direct.c index 5569184..093dcb7 100644 --- a/fs/nilfs2/direct.c +++ b/fs/nilfs2/direct.c @@ -53,6 +53,8 @@ static int nilfs_direct_lookup(const struct nilfs_bmap *direct, nilfs2_debug((DBG_DIRECT | DBG_DUMP_STACK), "i_ino %lu, key %llu, level %d, ptrp %p\n", direct->b_inode->i_ino, key, level, ptrp); + nilfs2_hexdump((DBG_DIRECT | DBG_HEX_DUMP), + "bmap: ", direct, sizeof(struct nilfs_bmap)); if (key > NILFS_DIRECT_KEY_MAX || level != 1) return -ENOENT; @@ -78,6 +80,8 @@ static int nilfs_direct_lookup_contig(const struct nilfs_bmap *direct, nilfs2_debug((DBG_DIRECT | DBG_DUMP_STACK), "i_ino %lu, key %llu, ptrp %p, maxblocks %u\n", direct->b_inode->i_ino, key, ptrp, maxblocks); + nilfs2_hexdump((DBG_DIRECT | DBG_HEX_DUMP), + "bmap: ", direct, sizeof(struct nilfs_bmap)); if (key > NILFS_DIRECT_KEY_MAX) return -ENOENT; @@ -122,6 +126,8 @@ nilfs_direct_find_target_v(const struct nilfs_bmap *direct, __u64 key) nilfs2_debug((DBG_DIRECT | DBG_DUMP_STACK), "i_ino %lu, key %llu\n", direct->b_inode->i_ino, key); + nilfs2_hexdump((DBG_DIRECT | DBG_HEX_DUMP), + "bmap: ", direct, sizeof(struct nilfs_bmap)); ptr = nilfs_bmap_find_target_seq(direct, key); if (ptr != NILFS_BMAP_INVALID_PTR) @@ -142,6 +148,8 @@ static int nilfs_direct_insert(struct nilfs_bmap *bmap, __u64 key, __u64 ptr) nilfs2_debug((DBG_DIRECT | DBG_DUMP_STACK), "i_ino %lu, key %llu, ptr %llu\n", bmap->b_inode->i_ino, key, ptr); + nilfs2_hexdump((DBG_DIRECT | DBG_HEX_DUMP), + "bmap: ", bmap, sizeof(struct nilfs_bmap)); if (key > NILFS_DIRECT_KEY_MAX) return -ENOENT; @@ -181,6 +189,8 @@ static int nilfs_direct_delete(struct nilfs_bmap *bmap, __u64 key) nilfs2_debug((DBG_DIRECT | DBG_DUMP_STACK), "i_ino %lu, key %llu\n", bmap->b_inode->i_ino, key); + nilfs2_hexdump((DBG_DIRECT | DBG_HEX_DUMP), + "bmap: ", bmap, sizeof(struct nilfs_bmap)); if (key > NILFS_DIRECT_KEY_MAX || nilfs_direct_get_ptr(bmap, key) == NILFS_BMAP_INVALID_PTR) @@ -231,6 +241,8 @@ static int nilfs_direct_gather_data(struct nilfs_bmap *direct, nilfs2_debug((DBG_DIRECT | DBG_DUMP_STACK), "i_ino %lu, keys %p, ptrs %p, nitems %d\n", direct->b_inode->i_ino, keys, ptrs, nitems); + nilfs2_hexdump((DBG_DIRECT | DBG_HEX_DUMP), + "bmap: ", direct, sizeof(struct nilfs_bmap)); if (nitems > NILFS_DIRECT_NBLOCKS) nitems = NILFS_DIRECT_NBLOCKS; @@ -255,6 +267,8 @@ int nilfs_direct_delete_and_convert(struct nilfs_bmap *bmap, nilfs2_debug((DBG_DIRECT | DBG_DUMP_STACK), "i_ino %lu, keys %p, ptrs %p, n %d\n", bmap->b_inode->i_ino, keys, ptrs, n); + nilfs2_hexdump((DBG_DIRECT | DBG_HEX_DUMP), + "bmap: ", bmap, sizeof(struct nilfs_bmap)); /* no need to allocate any resource for conversion */ @@ -295,6 +309,8 @@ static int nilfs_direct_propagate(struct nilfs_bmap *bmap, nilfs2_debug((DBG_DIRECT | DBG_DUMP_STACK), "i_ino %lu, bh %p\n", bmap->b_inode->i_ino, bh); + nilfs2_hexdump((DBG_DIRECT | DBG_HEX_DUMP), + "bmap: ", bmap, sizeof(struct nilfs_bmap)); if (!NILFS_BMAP_USE_VBN(bmap)) return 0; @@ -332,6 +348,10 @@ static int nilfs_direct_assign_v(struct nilfs_bmap *direct, "i_ino %lu, key %llu, ptr %llu, " "bh %p, blocknr %lu, binfo %p\n", direct->b_inode->i_ino, key, ptr, bh, blocknr, binfo); + nilfs2_hexdump((DBG_DIRECT | DBG_HEX_DUMP), + "bmap: ", direct, sizeof(struct nilfs_bmap)); + nilfs2_hexdump((DBG_DIRECT | DBG_HEX_DUMP), + "binfo: ", binfo, sizeof(union nilfs_binfo)); req.bpr_ptr = ptr; ret = nilfs_dat_prepare_start(dat, &req.bpr_req); @@ -353,6 +373,10 @@ static int nilfs_direct_assign_p(struct nilfs_bmap *direct, "i_ino %lu, key %llu, ptr %llu, " "bh %p, blocknr %lu, binfo %p\n", direct->b_inode->i_ino, key, ptr, bh, blocknr, binfo); + nilfs2_hexdump((DBG_DIRECT | DBG_HEX_DUMP), + "bmap: ", direct, sizeof(struct nilfs_bmap)); + nilfs2_hexdump((DBG_DIRECT | DBG_HEX_DUMP), + "binfo: ", binfo, sizeof(union nilfs_binfo)); nilfs_direct_set_ptr(direct, key, blocknr); @@ -373,6 +397,10 @@ static int nilfs_direct_assign(struct nilfs_bmap *bmap, nilfs2_debug((DBG_DIRECT | DBG_DUMP_STACK), "i_ino %lu, bh %p, blocknr %lu, binfo %p\n", bmap->b_inode->i_ino, bh, blocknr, binfo); + nilfs2_hexdump((DBG_DIRECT | DBG_HEX_DUMP), + "bmap: ", bmap, sizeof(struct nilfs_bmap)); + nilfs2_hexdump((DBG_DIRECT | DBG_HEX_DUMP), + "binfo: ", binfo, sizeof(union nilfs_binfo)); key = nilfs_bmap_data_get_key(bmap, *bh); if (unlikely(key > NILFS_DIRECT_KEY_MAX)) { diff --git a/fs/nilfs2/ifile.c b/fs/nilfs2/ifile.c index 61ebbe6..9196e28 100644 --- a/fs/nilfs2/ifile.c +++ b/fs/nilfs2/ifile.c @@ -190,6 +190,8 @@ int nilfs_ifile_read(struct super_block *sb, struct nilfs_root *root, nilfs2_debug((DBG_IFILE | DBG_DUMP_STACK), "sb %p, root %p, inode_size %zu, raw_inode %p, inodep %p\n", sb, root, inode_size, raw_inode, inodep); + nilfs2_hexdump((DBG_IFILE | DBG_HEX_DUMP), + "raw_inode: ", raw_inode, sizeof(struct nilfs_inode)); ifile = nilfs_iget_locked(sb, root, NILFS_IFILE_INO); if (unlikely(!ifile)) diff --git a/fs/nilfs2/inode.c b/fs/nilfs2/inode.c index ca594f2..f921caf 100644 --- a/fs/nilfs2/inode.c +++ b/fs/nilfs2/inode.c @@ -511,6 +511,8 @@ int nilfs_read_inode_common(struct inode *inode, nilfs2_debug((DBG_INODE | DBG_DUMP_STACK), "i_ino %lu\n", inode->i_ino); + nilfs2_hexdump((DBG_INODE | DBG_HEX_DUMP), + "raw_inode: ", raw_inode, sizeof(struct nilfs_inode)); inode->i_mode = le16_to_cpu(raw_inode->i_mode); i_uid_write(inode, le32_to_cpu(raw_inode->i_uid)); @@ -760,6 +762,9 @@ void nilfs_write_inode_common(struct inode *inode, cpu_to_le64(huge_encode_dev(inode->i_rdev)); /* When extending inode, nilfs->ns_inode_size should be checked for substitutions of appended fields */ + + nilfs2_hexdump((DBG_INODE | DBG_HEX_DUMP), + "raw_inode: ", raw_inode, sizeof(struct nilfs_inode)); } void nilfs_update_inode(struct inode *inode, struct buffer_head *ibh) diff --git a/fs/nilfs2/recovery.c b/fs/nilfs2/recovery.c index f880f6a..40b5274 100644 --- a/fs/nilfs2/recovery.c +++ b/fs/nilfs2/recovery.c @@ -474,6 +474,9 @@ static int nilfs_prepare_segment_for_recovery(struct the_nilfs *nilfs, nilfs2_debug((DBG_RECOVERY | DBG_DUMP_STACK), "nilfs %p, sb %p, ri %p\n", nilfs, sb, ri); + nilfs2_hexdump((DBG_RECOVERY | DBG_HEX_DUMP), + "recovery info: ", + ri, sizeof(struct nilfs_recovery_info)); segnum[0] = nilfs->ns_segnum; segnum[1] = nilfs->ns_nextnum; @@ -532,6 +535,9 @@ static int nilfs_recovery_copy_block(struct the_nilfs *nilfs, nilfs2_debug((DBG_RECOVERY | DBG_DUMP_STACK), "nilfs %p, rb %p, i_ino %lu\n", nilfs, rb, page->mapping->host->i_ino); + nilfs2_hexdump((DBG_RECOVERY | DBG_HEX_DUMP), + "recovery block: ", + rb, sizeof(struct nilfs_recovery_block)); bh_org = __bread(nilfs->ns_bdev, rb->blocknr, nilfs->ns_blocksize); if (unlikely(!bh_org)) @@ -650,6 +656,9 @@ static int nilfs_do_roll_forward(struct the_nilfs *nilfs, nilfs2_debug((DBG_RECOVERY | DBG_DUMP_STACK), "nilfs %p, sb %p, root %p, ri %p\n", nilfs, sb, root, ri); + nilfs2_hexdump((DBG_RECOVERY | DBG_HEX_DUMP), + "recovery info: ", + ri, sizeof(struct nilfs_recovery_info)); pseg_start = ri->ri_lsegs_start; seg_seq = ri->ri_lsegs_start_seq; @@ -761,6 +770,9 @@ static void nilfs_finish_roll_forward(struct the_nilfs *nilfs, nilfs2_debug((DBG_RECOVERY | DBG_DUMP_STACK), "nilfs %p, ri %p\n", nilfs, ri); + nilfs2_hexdump((DBG_RECOVERY | DBG_HEX_DUMP), + "recovery info: ", + ri, sizeof(struct nilfs_recovery_info)); if (nilfs_get_segnum_of_block(nilfs, ri->ri_lsegs_start) != nilfs_get_segnum_of_block(nilfs, ri->ri_super_root)) @@ -807,6 +819,9 @@ int nilfs_salvage_orphan_logs(struct the_nilfs *nilfs, nilfs2_debug((DBG_RECOVERY | DBG_DUMP_STACK), "nilfs %p, sb %p, ri %p\n", nilfs, sb, ri); + nilfs2_hexdump((DBG_RECOVERY | DBG_HEX_DUMP), + "recovery info: ", + ri, sizeof(struct nilfs_recovery_info)); if (ri->ri_lsegs_start == 0 || ri->ri_lsegs_end == 0) return 0; @@ -1018,6 +1033,11 @@ int nilfs_search_super_root(struct the_nilfs *nilfs, nilfs->ns_last_pseg = sr_pseg_start; nilfs->ns_last_seq = nilfs->ns_seg_seq; nilfs->ns_last_cno = ri->ri_cno; + + nilfs2_hexdump((DBG_RECOVERY | DBG_HEX_DUMP), + "recovery info: ", + ri, sizeof(struct nilfs_recovery_info)); + return 0; failed: diff --git a/fs/nilfs2/segment.c b/fs/nilfs2/segment.c index 605639f..81271b3 100644 --- a/fs/nilfs2/segment.c +++ b/fs/nilfs2/segment.c @@ -377,6 +377,8 @@ static void *nilfs_segctor_map_segsum_entry(struct nilfs_sc_info *sci, nilfs2_debug((DBG_SEGMENT | DBG_DUMP_STACK), "sci %p, segnum %llu, ssp->offset %u, bytes %u\n", sci, segbuf->sb_segnum, ssp->offset, bytes); + nilfs2_hexdump((DBG_SEGMENT | DBG_HEX_DUMP), + "sc_info: ", sci, sizeof(struct nilfs_sc_info)); if (unlikely(ssp->offset + bytes > blocksize)) { ssp->offset = 0; @@ -404,6 +406,8 @@ static int nilfs_segctor_reset_segment_buffer(struct nilfs_sc_info *sci) nilfs2_debug((DBG_SEGMENT | DBG_DUMP_STACK), "sci %p, segnum %llu, cno %llu\n", sci, segbuf->sb_segnum, sci->sc_cno); + nilfs2_hexdump((DBG_SEGMENT | DBG_HEX_DUMP), + "sc_info: ", sci, sizeof(struct nilfs_sc_info)); if (nilfs_doing_gc()) flags = NILFS_SS_GC; @@ -422,6 +426,8 @@ static int nilfs_segctor_reset_segment_buffer(struct nilfs_sc_info *sci) static int nilfs_segctor_feed_segment(struct nilfs_sc_info *sci) { nilfs2_debug((DBG_SEGMENT | DBG_DUMP_STACK), "sci %p\n", sci); + nilfs2_hexdump((DBG_SEGMENT | DBG_HEX_DUMP), + "sc_info: ", sci, sizeof(struct nilfs_sc_info)); sci->sc_nblk_this_inc += sci->sc_curseg->sb_sum.nblocks; if (NILFS_SEGBUF_IS_LAST(sci->sc_curseg, &sci->sc_segbufs)) @@ -438,6 +444,8 @@ static int nilfs_segctor_add_super_root(struct nilfs_sc_info *sci) nilfs2_debug((DBG_SEGMENT | DBG_DUMP_STACK), "sci %p, segnum %llu\n", sci, segbuf->sb_segnum); + nilfs2_hexdump((DBG_SEGMENT | DBG_HEX_DUMP), + "sc_info: ", sci, sizeof(struct nilfs_sc_info)); if (segbuf->sb_sum.nblocks >= segbuf->sb_rest_blocks) { err = nilfs_segctor_feed_segment(sci); @@ -471,6 +479,8 @@ static void nilfs_segctor_begin_finfo(struct nilfs_sc_info *sci, { nilfs2_debug((DBG_SEGMENT | DBG_DUMP_STACK), "sci %p, i_ino %lu\n", sci, inode->i_ino); + nilfs2_hexdump((DBG_SEGMENT | DBG_HEX_DUMP), + "sc_info: ", sci, sizeof(struct nilfs_sc_info)); sci->sc_curseg->sb_sum.nfinfo++; sci->sc_binfo_ptr = sci->sc_finfo_ptr; @@ -494,6 +504,8 @@ static void nilfs_segctor_end_finfo(struct nilfs_sc_info *sci, nilfs2_debug((DBG_SEGMENT | DBG_DUMP_STACK), "sci %p, i_ino %lu, segnum %llu\n", sci, inode->i_ino, sci->sc_curseg->sb_segnum); + nilfs2_hexdump((DBG_SEGMENT | DBG_HEX_DUMP), + "sc_info: ", sci, sizeof(struct nilfs_sc_info)); if (sci->sc_blk_cnt == 0) return; @@ -533,6 +545,8 @@ static int nilfs_segctor_add_file_block(struct nilfs_sc_info *sci, "sci %p, ino %lu, segnum %llu, bh %p, binfo_size %u\n", sci, inode->i_ino, sci->sc_curseg->sb_segnum, bh, binfo_size); + nilfs2_hexdump((DBG_SEGMENT | DBG_HEX_DUMP), + "sc_info: ", sci, sizeof(struct nilfs_sc_info)); retry: segbuf = sci->sc_curseg; @@ -571,6 +585,8 @@ static int nilfs_collect_file_data(struct nilfs_sc_info *sci, nilfs2_debug((DBG_SEGMENT | DBG_DUMP_STACK), "sci %p, i_ino %lu, bh %p\n", sci, inode->i_ino, bh); + nilfs2_hexdump((DBG_SEGMENT | DBG_HEX_DUMP), + "sc_info: ", sci, sizeof(struct nilfs_sc_info)); err = nilfs_bmap_propagate(NILFS_I(inode)->i_bmap, bh); if (err < 0) @@ -589,6 +605,8 @@ static int nilfs_collect_file_node(struct nilfs_sc_info *sci, { nilfs2_debug((DBG_SEGMENT | DBG_DUMP_STACK), "sci %p, i_ino %lu, bh %p\n", sci, inode->i_ino, bh); + nilfs2_hexdump((DBG_SEGMENT | DBG_HEX_DUMP), + "sc_info: ", sci, sizeof(struct nilfs_sc_info)); return nilfs_bmap_propagate(NILFS_I(inode)->i_bmap, bh); } @@ -599,6 +617,8 @@ static int nilfs_collect_file_bmap(struct nilfs_sc_info *sci, { nilfs2_debug((DBG_SEGMENT | DBG_DUMP_STACK), "sci %p, i_ino %lu, bh %p\n", sci, inode->i_ino, bh); + nilfs2_hexdump((DBG_SEGMENT | DBG_HEX_DUMP), + "sc_info: ", sci, sizeof(struct nilfs_sc_info)); WARN_ON(!buffer_dirty(bh)); return nilfs_segctor_add_file_block(sci, bh, inode, sizeof(__le64)); @@ -637,6 +657,8 @@ static int nilfs_collect_dat_data(struct nilfs_sc_info *sci, nilfs2_debug((DBG_SEGMENT | DBG_DUMP_STACK), "sci %p, i_ino %lu, bh %p\n", sci, inode->i_ino, bh); + nilfs2_hexdump((DBG_SEGMENT | DBG_HEX_DUMP), + "sc_info: ", sci, sizeof(struct nilfs_sc_info)); err = nilfs_bmap_propagate(NILFS_I(inode)->i_bmap, bh); if (err < 0) @@ -888,6 +910,8 @@ static int nilfs_segctor_create_checkpoint(struct nilfs_sc_info *sci) int err; nilfs2_debug((DBG_SEGMENT | DBG_DUMP_STACK), "sci %p\n", sci); + nilfs2_hexdump((DBG_SEGMENT | DBG_HEX_DUMP), + "sc_info: ", sci, sizeof(struct nilfs_sc_info)); /* XXX: this interface will be changed */ err = nilfs_cpfile_get_checkpoint(nilfs->ns_cpfile, nilfs->ns_cno, 1, @@ -914,6 +938,8 @@ static int nilfs_segctor_fill_in_checkpoint(struct nilfs_sc_info *sci) int err; nilfs2_debug((DBG_SEGMENT | DBG_DUMP_STACK), "sci %p\n", sci); + nilfs2_hexdump((DBG_SEGMENT | DBG_HEX_DUMP), + "sc_info: ", sci, sizeof(struct nilfs_sc_info)); err = nilfs_cpfile_get_checkpoint(nilfs->ns_cpfile, nilfs->ns_cno, 0, &raw_cp, &bh_cp); @@ -971,6 +997,8 @@ static void nilfs_segctor_fill_in_file_bmap(struct nilfs_sc_info *sci) struct nilfs_inode_info *ii; nilfs2_debug((DBG_SEGMENT | DBG_DUMP_STACK), "sci %p\n", sci); + nilfs2_hexdump((DBG_SEGMENT | DBG_HEX_DUMP), + "sc_info: ", sci, sizeof(struct nilfs_sc_info)); list_for_each_entry(ii, &sci->sc_dirty_files, i_dirty) { nilfs_fill_in_file_bmap(sci->sc_root->ifile, ii); @@ -987,6 +1015,8 @@ static void nilfs_segctor_fill_in_super_root(struct nilfs_sc_info *sci, nilfs2_debug((DBG_SEGMENT | DBG_DUMP_STACK), "sci %p, nilfs %p\n", sci, nilfs); + nilfs2_hexdump((DBG_SEGMENT | DBG_HEX_DUMP), + "sc_info: ", sci, sizeof(struct nilfs_sc_info)); bh_sr = NILFS_LAST_SEGBUF(&sci->sc_segbufs)->sb_super_root; raw_sr = (struct nilfs_super_root *)bh_sr->b_data; @@ -1048,6 +1078,8 @@ static int nilfs_segctor_apply_buffers(struct nilfs_sc_info *sci, nilfs2_debug((DBG_SEGMENT | DBG_DUMP_STACK), "sci %p, i_ino %lu, listp %p, collect %p\n", sci, inode->i_ino, listp, collect); + nilfs2_hexdump((DBG_SEGMENT | DBG_HEX_DUMP), + "sc_info: ", sci, sizeof(struct nilfs_sc_info)); if (collect) { list_for_each_entry_safe(bh, n, listp, b_assoc_buffers) { @@ -1088,6 +1120,8 @@ static int nilfs_segctor_scan_file(struct nilfs_sc_info *sci, nilfs2_debug((DBG_SEGMENT | DBG_DUMP_STACK), "sci %p, i_ino %lu, sc_ops %p\n", sci, inode->i_ino, sc_ops); + nilfs2_hexdump((DBG_SEGMENT | DBG_HEX_DUMP), + "sc_info: ", sci, sizeof(struct nilfs_sc_info)); if (!(sci->sc_stage.flags & NILFS_CF_NODE)) { size_t n, rest = nilfs_segctor_buffer_rest(sci); @@ -1143,6 +1177,8 @@ static int nilfs_segctor_scan_file_dsync(struct nilfs_sc_info *sci, nilfs2_debug((DBG_SEGMENT | DBG_DUMP_STACK), "sci %p, i_ino %lu\n", sci, inode->i_ino); + nilfs2_hexdump((DBG_SEGMENT | DBG_HEX_DUMP), + "sc_info: ", sci, sizeof(struct nilfs_sc_info)); n = nilfs_lookup_dirty_data_buffers(inode, &data_buffers, rest + 1, sci->sc_dsync_start, @@ -1169,6 +1205,8 @@ static int nilfs_segctor_collect_blocks(struct nilfs_sc_info *sci, int mode) nilfs2_debug((DBG_SEGMENT | DBG_DUMP_STACK), "sci %p, sci->sc_stage.scnt %d, mode %#x\n", sci, sci->sc_stage.scnt, mode); + nilfs2_hexdump((DBG_SEGMENT | DBG_HEX_DUMP), + "sc_info: ", sci, sizeof(struct nilfs_sc_info)); switch (sci->sc_stage.scnt) { case NILFS_ST_INIT: @@ -1331,6 +1369,8 @@ static int nilfs_segctor_begin_construction(struct nilfs_sc_info *sci, nilfs2_debug((DBG_SEGMENT | DBG_DUMP_STACK), "sci %p, nilfs %p\n", sci, nilfs); + nilfs2_hexdump((DBG_SEGMENT | DBG_HEX_DUMP), + "sc_info: ", sci, sizeof(struct nilfs_sc_info)); segbuf = nilfs_segbuf_new(sci->sc_super); if (unlikely(!segbuf)) @@ -1396,6 +1436,8 @@ static int nilfs_segctor_extend_segments(struct nilfs_sc_info *sci, nilfs2_debug((DBG_SEGMENT | DBG_DUMP_STACK), "sci %p, nilfs %p, nadd %d\n", sci, nilfs, nadd); + nilfs2_hexdump((DBG_SEGMENT | DBG_HEX_DUMP), + "sc_info: ", sci, sizeof(struct nilfs_sc_info)); prev = NILFS_LAST_SEGBUF(&sci->sc_segbufs); /* @@ -1534,6 +1576,8 @@ static void nilfs_segctor_truncate_segments(struct nilfs_sc_info *sci, nilfs2_debug((DBG_SEGMENT | DBG_DUMP_STACK), "sci %p, last %p, sufile %p\n", sci, last, sufile); + nilfs2_hexdump((DBG_SEGMENT | DBG_HEX_DUMP), + "sc_info: ", sci, sizeof(struct nilfs_sc_info)); list_for_each_entry_continue(segbuf, &sci->sc_segbufs, sb_list) { sci->sc_segbuf_nblocks -= segbuf->sb_rest_blocks; @@ -1552,6 +1596,8 @@ static int nilfs_segctor_collect(struct nilfs_sc_info *sci, nilfs2_debug((DBG_SEGMENT | DBG_DUMP_STACK), "sci %p, nilfs %p, mode %#x\n", sci, nilfs, mode); + nilfs2_hexdump((DBG_SEGMENT | DBG_HEX_DUMP), + "sc_info: ", sci, sizeof(struct nilfs_sc_info)); /* Collection retry loop */ for (;;) { @@ -1625,6 +1671,8 @@ nilfs_segctor_update_payload_blocknr(struct nilfs_sc_info *sci, nilfs2_debug((DBG_SEGMENT | DBG_DUMP_STACK), "sci %p, segbuf %p, mode %#x\n", sci, segbuf, mode); + nilfs2_hexdump((DBG_SEGMENT | DBG_HEX_DUMP), + "sc_info: ", sci, sizeof(struct nilfs_sc_info)); if (!nfinfo) goto out; @@ -1689,6 +1737,8 @@ static int nilfs_segctor_assign(struct nilfs_sc_info *sci, int mode) nilfs2_debug((DBG_SEGMENT | DBG_DUMP_STACK), "sci %p, mode %#x\n", sci, mode); + nilfs2_hexdump((DBG_SEGMENT | DBG_HEX_DUMP), + "sc_info: ", sci, sizeof(struct nilfs_sc_info)); list_for_each_entry(segbuf, &sci->sc_segbufs, sb_list) { err = nilfs_segctor_update_payload_blocknr(sci, segbuf, mode); @@ -1721,6 +1771,8 @@ static void nilfs_segctor_prepare_write(struct nilfs_sc_info *sci) struct page *bd_page = NULL, *fs_page = NULL; nilfs2_debug((DBG_SEGMENT | DBG_DUMP_STACK), "sci %p\n", sci); + nilfs2_hexdump((DBG_SEGMENT | DBG_HEX_DUMP), + "sc_info: ", sci, sizeof(struct nilfs_sc_info)); list_for_each_entry(segbuf, &sci->sc_segbufs, sb_list) { struct buffer_head *bh; @@ -1772,6 +1824,8 @@ static int nilfs_segctor_write(struct nilfs_sc_info *sci, nilfs2_debug((DBG_SEGMENT | DBG_DUMP_STACK), "sci %p, nilfs %p\n", sci, nilfs); + nilfs2_hexdump((DBG_SEGMENT | DBG_HEX_DUMP), + "sc_info: ", sci, sizeof(struct nilfs_sc_info)); ret = nilfs_write_logs(&sci->sc_segbufs, nilfs); list_splice_tail_init(&sci->sc_segbufs, &sci->sc_write_logs); @@ -1878,6 +1932,8 @@ static void nilfs_segctor_abort_construction(struct nilfs_sc_info *sci, nilfs2_debug((DBG_SEGMENT | DBG_DUMP_STACK), "sci %p, nilfs %p, err %d\n", sci, nilfs, err); + nilfs2_hexdump((DBG_SEGMENT | DBG_HEX_DUMP), + "sc_info: ", sci, sizeof(struct nilfs_sc_info)); list_splice_tail_init(&sci->sc_write_logs, &logs); ret = nilfs_wait_on_logs(&logs); @@ -1917,6 +1973,8 @@ static void nilfs_segctor_complete_write(struct nilfs_sc_info *sci) int update_sr = false; nilfs2_debug((DBG_SEGMENT | DBG_DUMP_STACK), "sci %p\n", sci); + nilfs2_hexdump((DBG_SEGMENT | DBG_HEX_DUMP), + "sc_info: ", sci, sizeof(struct nilfs_sc_info)); list_for_each_entry(segbuf, &sci->sc_write_logs, sb_list) { struct buffer_head *bh; @@ -2012,6 +2070,8 @@ static int nilfs_segctor_wait(struct nilfs_sc_info *sci) int ret; nilfs2_debug((DBG_SEGMENT | DBG_DUMP_STACK), "sci %p\n", sci); + nilfs2_hexdump((DBG_SEGMENT | DBG_HEX_DUMP), + "sc_info: ", sci, sizeof(struct nilfs_sc_info)); ret = nilfs_wait_on_logs(&sci->sc_write_logs); if (!ret) { @@ -2029,6 +2089,8 @@ static int nilfs_segctor_collect_dirty_files(struct nilfs_sc_info *sci, nilfs2_debug((DBG_SEGMENT | DBG_DUMP_STACK), "sci %p, nilfs %p\n", sci, nilfs); + nilfs2_hexdump((DBG_SEGMENT | DBG_HEX_DUMP), + "sc_info: ", sci, sizeof(struct nilfs_sc_info)); spin_lock(&nilfs->ns_inode_lock); retry: @@ -2075,6 +2137,8 @@ static void nilfs_segctor_drop_written_files(struct nilfs_sc_info *sci, nilfs2_debug((DBG_SEGMENT | DBG_DUMP_STACK), "sci %p, nilfs %p\n", sci, nilfs); + nilfs2_hexdump((DBG_SEGMENT | DBG_HEX_DUMP), + "sc_info: ", sci, sizeof(struct nilfs_sc_info)); spin_lock(&nilfs->ns_inode_lock); list_for_each_entry_safe(ii, n, &sci->sc_dirty_files, i_dirty) { @@ -2103,6 +2167,8 @@ static int nilfs_segctor_do_construct(struct nilfs_sc_info *sci, int mode) nilfs2_debug((DBG_SEGMENT | DBG_DUMP_STACK), "sci %p, mode %#x\n", sci, mode); + nilfs2_hexdump((DBG_SEGMENT | DBG_HEX_DUMP), + "sc_info: ", sci, sizeof(struct nilfs_sc_info)); sci->sc_stage.scnt = NILFS_ST_INIT; sci->sc_cno = nilfs->ns_cno; @@ -2261,6 +2327,8 @@ static int nilfs_segctor_sync(struct nilfs_sc_info *sci) int err = 0; nilfs2_debug((DBG_SEGMENT | DBG_DUMP_STACK), "sci %p\n", sci); + nilfs2_hexdump((DBG_SEGMENT | DBG_HEX_DUMP), + "sc_info: ", sci, sizeof(struct nilfs_sc_info)); spin_lock(&sci->sc_state_lock); init_wait(&wait_req.wq); @@ -2478,6 +2546,8 @@ static int nilfs_segctor_construct(struct nilfs_sc_info *sci, int mode) nilfs2_debug((DBG_SEGMENT | DBG_DUMP_STACK), "sci %p, mode %#x\n", sci, mode); + nilfs2_hexdump((DBG_SEGMENT | DBG_HEX_DUMP), + "sc_info: ", sci, sizeof(struct nilfs_sc_info)); nilfs_segctor_accept(sci); @@ -2545,6 +2615,8 @@ int nilfs_clean_segments(struct super_block *sb, struct nilfs_argv *argv, nilfs2_debug((DBG_SEGMENT | DBG_DUMP_STACK), "sb %p, argv %p, kbufs %p\n", sb, argv, kbufs); + nilfs2_hexdump((DBG_SEGMENT | DBG_HEX_DUMP), + "argv: ", argv, sizeof(struct nilfs_argv)); if (unlikely(!sci)) return -EROFS; @@ -2602,6 +2674,8 @@ static void nilfs_segctor_thread_construct(struct nilfs_sc_info *sci, int mode) nilfs2_debug((DBG_SEGMENT | DBG_DUMP_STACK), "sci %p, mode %#x\n", sci, mode); + nilfs2_hexdump((DBG_SEGMENT | DBG_HEX_DUMP), + "sc_info: ", sci, sizeof(struct nilfs_sc_info)); nilfs_transaction_lock(sci->sc_super, &ti, 0); nilfs_segctor_construct(sci, mode); @@ -2623,6 +2697,8 @@ static void nilfs_segctor_do_immediate_flush(struct nilfs_sc_info *sci) int err; nilfs2_debug((DBG_SEGMENT | DBG_DUMP_STACK), "sci %p\n", sci); + nilfs2_hexdump((DBG_SEGMENT | DBG_HEX_DUMP), + "sc_info: ", sci, sizeof(struct nilfs_sc_info)); spin_lock(&sci->sc_state_lock); mode = (sci->sc_flush_request & FLUSH_DAT_BIT) ? @@ -2746,6 +2822,8 @@ static int nilfs_segctor_start_thread(struct nilfs_sc_info *sci) struct task_struct *t; nilfs2_debug((DBG_SEGMENT | DBG_DUMP_STACK), "sci %p\n", sci); + nilfs2_hexdump((DBG_SEGMENT | DBG_HEX_DUMP), + "sc_info: ", sci, sizeof(struct nilfs_sc_info)); t = kthread_run(nilfs_segctor_thread, sci, "segctord"); if (IS_ERR(t)) { @@ -2766,6 +2844,8 @@ static void nilfs_segctor_kill_thread(struct nilfs_sc_info *sci) sci->sc_state |= NILFS_SEGCTOR_QUIT; nilfs2_debug((DBG_SEGMENT | DBG_DUMP_STACK), "sci %p\n", sci); + nilfs2_hexdump((DBG_SEGMENT | DBG_HEX_DUMP), + "sc_info: ", sci, sizeof(struct nilfs_sc_info)); while (sci->sc_task) { wake_up(&sci->sc_wait_daemon); @@ -2822,6 +2902,8 @@ static void nilfs_segctor_write_out(struct nilfs_sc_info *sci) int ret, retrycount = NILFS_SC_CLEANUP_RETRY; nilfs2_debug((DBG_SEGMENT | DBG_DUMP_STACK), "sci %p\n", sci); + nilfs2_hexdump((DBG_SEGMENT | DBG_HEX_DUMP), + "sc_info: ", sci, sizeof(struct nilfs_sc_info)); /* The segctord thread was stopped and its timer was removed. But some tasks remain. */ @@ -2849,6 +2931,8 @@ static void nilfs_segctor_destroy(struct nilfs_sc_info *sci) int flag; nilfs2_debug((DBG_SEGMENT | DBG_DUMP_STACK), "sci %p\n", sci); + nilfs2_hexdump((DBG_SEGMENT | DBG_HEX_DUMP), + "sc_info: ", sci, sizeof(struct nilfs_sc_info)); up_write(&nilfs->ns_segctor_sem); diff --git a/fs/nilfs2/sufile.c b/fs/nilfs2/sufile.c index b9980fa8..e9921c6 100644 --- a/fs/nilfs2/sufile.c +++ b/fs/nilfs2/sufile.c @@ -194,6 +194,8 @@ int nilfs_sufile_updatev(struct inode *sufile, __u64 *segnumv, size_t nsegs, "sufile ino %lu, segnumv %p, nsegs %zu, " "create %d, ndone %p, dofunc %p\n", sufile->i_ino, segnumv, nsegs, create, ndone, dofunc); + nilfs2_hexdump((DBG_SUFILE | DBG_HEX_DUMP), + "segnumv: ", segnumv, nsegs * sizeof(__u64)); if (unlikely(nsegs == 0)) goto out; @@ -628,6 +630,8 @@ int nilfs_sufile_get_stat(struct inode *sufile, struct nilfs_sustat *sustat) nilfs2_debug((DBG_SUFILE | DBG_DUMP_STACK), "sufile ino %lu, sustat %p\n", sufile->i_ino, sustat); + nilfs2_hexdump((DBG_SUFILE | DBG_HEX_DUMP), + "sustat: ", sustat, sizeof(struct nilfs_sustat)); down_read(&NILFS_MDT(sufile)->mi_sem); @@ -963,6 +967,8 @@ int nilfs_sufile_read(struct super_block *sb, size_t susize, nilfs2_debug((DBG_SUFILE | DBG_DUMP_STACK), "sb %p, susize %zu, raw_inode %p, inodep %p\n", sb, susize, raw_inode, inodep); + nilfs2_hexdump((DBG_SUFILE | DBG_HEX_DUMP), + "raw_inode: ", raw_inode, sizeof(struct nilfs_inode)); sufile = nilfs_iget_locked(sb, NULL, NILFS_SUFILE_INO); if (unlikely(!sufile)) diff --git a/fs/nilfs2/the_nilfs.c b/fs/nilfs2/the_nilfs.c index 600bee5..7cc3c64 100644 --- a/fs/nilfs2/the_nilfs.c +++ b/fs/nilfs2/the_nilfs.c @@ -682,6 +682,8 @@ int nilfs_discard_segments(struct the_nilfs *nilfs, __u64 *segnump, nilfs2_debug((DBG_THE_NILFS | DBG_DUMP_STACK), "nilfs %p, segnump %p, nsegs %zu\n", nilfs, segnump, nsegs); + nilfs2_hexdump((DBG_THE_NILFS | DBG_HEX_DUMP), + "segnums: ", segnump, nsegs * sizeof(__u64)); sects_per_block = (1 << nilfs->ns_blocksize_bits) / bdev_logical_block_size(nilfs->ns_bdev); -- 1.7.9.5 -- To unsubscribe from this list: send the line "unsubscribe linux-nilfs" in the body of a message to [email protected] More majordomo info at http://vger.kernel.org/majordomo-info.html
