1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * linux/fs/befs/debug.c 4 * 5 * Copyright (C) 2001 Will Dyson (will_dyson at pobox.com) 6 * 7 * With help from the ntfs-tng driver by Anton Altparmakov 8 * 9 * Copyright (C) 1999 Makoto Kato (m_kato@ga2.so-net.ne.jp) 10 * 11 * debug functions 12 */ 13 14 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 15 #ifdef __KERNEL__ 16 17 #include <stdarg.h> 18 #include <linux/string.h> 19 #include <linux/spinlock.h> 20 #include <linux/kernel.h> 21 #include <linux/fs.h> 22 #include <linux/slab.h> 23 24 #endif /* __KERNEL__ */ 25 26 #include "befs.h" 27 28 void 29 befs_error(const struct super_block *sb, const char *fmt, ...) 30 { 31 struct va_format vaf; 32 va_list args; 33 34 va_start(args, fmt); 35 vaf.fmt = fmt; 36 vaf.va = &args; 37 pr_err("(%s): %pV\n", sb->s_id, &vaf); 38 va_end(args); 39 } 40 41 void 42 befs_warning(const struct super_block *sb, const char *fmt, ...) 43 { 44 struct va_format vaf; 45 va_list args; 46 47 va_start(args, fmt); 48 vaf.fmt = fmt; 49 vaf.va = &args; 50 pr_warn("(%s): %pV\n", sb->s_id, &vaf); 51 va_end(args); 52 } 53 54 void 55 befs_debug(const struct super_block *sb, const char *fmt, ...) 56 { 57 #ifdef CONFIG_BEFS_DEBUG 58 59 struct va_format vaf; 60 va_list args; 61 62 va_start(args, fmt); 63 vaf.fmt = fmt; 64 vaf.va = &args; 65 pr_debug("(%s): %pV\n", sb->s_id, &vaf); 66 va_end(args); 67 68 #endif //CONFIG_BEFS_DEBUG 69 } 70 71 void 72 befs_dump_inode(const struct super_block *sb, befs_inode *inode) 73 { 74 #ifdef CONFIG_BEFS_DEBUG 75 76 befs_block_run tmp_run; 77 78 befs_debug(sb, "befs_inode information"); 79 80 befs_debug(sb, " magic1 %08x", fs32_to_cpu(sb, inode->magic1)); 81 82 tmp_run = fsrun_to_cpu(sb, inode->inode_num); 83 befs_debug(sb, " inode_num %u, %hu, %hu", 84 tmp_run.allocation_group, tmp_run.start, tmp_run.len); 85 86 befs_debug(sb, " uid %u", fs32_to_cpu(sb, inode->uid)); 87 befs_debug(sb, " gid %u", fs32_to_cpu(sb, inode->gid)); 88 befs_debug(sb, " mode %08x", fs32_to_cpu(sb, inode->mode)); 89 befs_debug(sb, " flags %08x", fs32_to_cpu(sb, inode->flags)); 90 befs_debug(sb, " create_time %llu", 91 fs64_to_cpu(sb, inode->create_time)); 92 befs_debug(sb, " last_modified_time %llu", 93 fs64_to_cpu(sb, inode->last_modified_time)); 94 95 tmp_run = fsrun_to_cpu(sb, inode->parent); 96 befs_debug(sb, " parent [%u, %hu, %hu]", 97 tmp_run.allocation_group, tmp_run.start, tmp_run.len); 98 99 tmp_run = fsrun_to_cpu(sb, inode->attributes); 100 befs_debug(sb, " attributes [%u, %hu, %hu]", 101 tmp_run.allocation_group, tmp_run.start, tmp_run.len); 102 103 befs_debug(sb, " type %08x", fs32_to_cpu(sb, inode->type)); 104 befs_debug(sb, " inode_size %u", fs32_to_cpu(sb, inode->inode_size)); 105 106 if (S_ISLNK(fs32_to_cpu(sb, inode->mode))) { 107 befs_debug(sb, " Symbolic link [%s]", inode->data.symlink); 108 } else { 109 int i; 110 111 for (i = 0; i < BEFS_NUM_DIRECT_BLOCKS; i++) { 112 tmp_run = 113 fsrun_to_cpu(sb, inode->data.datastream.direct[i]); 114 befs_debug(sb, " direct %d [%u, %hu, %hu]", i, 115 tmp_run.allocation_group, tmp_run.start, 116 tmp_run.len); 117 } 118 befs_debug(sb, " max_direct_range %llu", 119 fs64_to_cpu(sb, 120 inode->data.datastream. 121 max_direct_range)); 122 123 tmp_run = fsrun_to_cpu(sb, inode->data.datastream.indirect); 124 befs_debug(sb, " indirect [%u, %hu, %hu]", 125 tmp_run.allocation_group, 126 tmp_run.start, tmp_run.len); 127 128 befs_debug(sb, " max_indirect_range %llu", 129 fs64_to_cpu(sb, 130 inode->data.datastream. 131 max_indirect_range)); 132 133 tmp_run = 134 fsrun_to_cpu(sb, inode->data.datastream.double_indirect); 135 befs_debug(sb, " double indirect [%u, %hu, %hu]", 136 tmp_run.allocation_group, tmp_run.start, 137 tmp_run.len); 138 139 befs_debug(sb, " max_double_indirect_range %llu", 140 fs64_to_cpu(sb, 141 inode->data.datastream. 142 max_double_indirect_range)); 143 144 befs_debug(sb, " size %llu", 145 fs64_to_cpu(sb, inode->data.datastream.size)); 146 } 147 148 #endif //CONFIG_BEFS_DEBUG 149 } 150 151 /* 152 * Display super block structure for debug. 153 */ 154 155 void 156 befs_dump_super_block(const struct super_block *sb, befs_super_block *sup) 157 { 158 #ifdef CONFIG_BEFS_DEBUG 159 160 befs_block_run tmp_run; 161 162 befs_debug(sb, "befs_super_block information"); 163 164 befs_debug(sb, " name %s", sup->name); 165 befs_debug(sb, " magic1 %08x", fs32_to_cpu(sb, sup->magic1)); 166 befs_debug(sb, " fs_byte_order %08x", 167 fs32_to_cpu(sb, sup->fs_byte_order)); 168 169 befs_debug(sb, " block_size %u", fs32_to_cpu(sb, sup->block_size)); 170 befs_debug(sb, " block_shift %u", fs32_to_cpu(sb, sup->block_shift)); 171 172 befs_debug(sb, " num_blocks %llu", fs64_to_cpu(sb, sup->num_blocks)); 173 befs_debug(sb, " used_blocks %llu", fs64_to_cpu(sb, sup->used_blocks)); 174 befs_debug(sb, " inode_size %u", fs32_to_cpu(sb, sup->inode_size)); 175 176 befs_debug(sb, " magic2 %08x", fs32_to_cpu(sb, sup->magic2)); 177 befs_debug(sb, " blocks_per_ag %u", 178 fs32_to_cpu(sb, sup->blocks_per_ag)); 179 befs_debug(sb, " ag_shift %u", fs32_to_cpu(sb, sup->ag_shift)); 180 befs_debug(sb, " num_ags %u", fs32_to_cpu(sb, sup->num_ags)); 181 182 befs_debug(sb, " flags %08x", fs32_to_cpu(sb, sup->flags)); 183 184 tmp_run = fsrun_to_cpu(sb, sup->log_blocks); 185 befs_debug(sb, " log_blocks %u, %hu, %hu", 186 tmp_run.allocation_group, tmp_run.start, tmp_run.len); 187 188 befs_debug(sb, " log_start %lld", fs64_to_cpu(sb, sup->log_start)); 189 befs_debug(sb, " log_end %lld", fs64_to_cpu(sb, sup->log_end)); 190 191 befs_debug(sb, " magic3 %08x", fs32_to_cpu(sb, sup->magic3)); 192 193 tmp_run = fsrun_to_cpu(sb, sup->root_dir); 194 befs_debug(sb, " root_dir %u, %hu, %hu", 195 tmp_run.allocation_group, tmp_run.start, tmp_run.len); 196 197 tmp_run = fsrun_to_cpu(sb, sup->indices); 198 befs_debug(sb, " indices %u, %hu, %hu", 199 tmp_run.allocation_group, tmp_run.start, tmp_run.len); 200 201 #endif //CONFIG_BEFS_DEBUG 202 } 203 204 #if 0 205 /* unused */ 206 void 207 befs_dump_small_data(const struct super_block *sb, befs_small_data *sd) 208 { 209 } 210 211 /* unused */ 212 void 213 befs_dump_run(const struct super_block *sb, befs_disk_block_run run) 214 { 215 #ifdef CONFIG_BEFS_DEBUG 216 217 befs_block_run n = fsrun_to_cpu(sb, run); 218 219 befs_debug(sb, "[%u, %hu, %hu]", n.allocation_group, n.start, n.len); 220 221 #endif //CONFIG_BEFS_DEBUG 222 } 223 #endif /* 0 */ 224 225 void 226 befs_dump_index_entry(const struct super_block *sb, 227 befs_disk_btree_super *super) 228 { 229 #ifdef CONFIG_BEFS_DEBUG 230 231 befs_debug(sb, "Btree super structure"); 232 befs_debug(sb, " magic %08x", fs32_to_cpu(sb, super->magic)); 233 befs_debug(sb, " node_size %u", fs32_to_cpu(sb, super->node_size)); 234 befs_debug(sb, " max_depth %08x", fs32_to_cpu(sb, super->max_depth)); 235 236 befs_debug(sb, " data_type %08x", fs32_to_cpu(sb, super->data_type)); 237 befs_debug(sb, " root_node_pointer %016LX", 238 fs64_to_cpu(sb, super->root_node_ptr)); 239 befs_debug(sb, " free_node_pointer %016LX", 240 fs64_to_cpu(sb, super->free_node_ptr)); 241 befs_debug(sb, " maximum size %016LX", 242 fs64_to_cpu(sb, super->max_size)); 243 244 #endif //CONFIG_BEFS_DEBUG 245 } 246 247 void 248 befs_dump_index_node(const struct super_block *sb, befs_btree_nodehead *node) 249 { 250 #ifdef CONFIG_BEFS_DEBUG 251 252 befs_debug(sb, "Btree node structure"); 253 befs_debug(sb, " left %016LX", fs64_to_cpu(sb, node->left)); 254 befs_debug(sb, " right %016LX", fs64_to_cpu(sb, node->right)); 255 befs_debug(sb, " overflow %016LX", fs64_to_cpu(sb, node->overflow)); 256 befs_debug(sb, " all_key_count %hu", 257 fs16_to_cpu(sb, node->all_key_count)); 258 befs_debug(sb, " all_key_length %hu", 259 fs16_to_cpu(sb, node->all_key_length)); 260 261 #endif //CONFIG_BEFS_DEBUG 262 } 263