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