| 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 ([email protected]) |
| 10 |
* |
| 11 |
* debug functions |
| 12 |
*/ |
| 13 |
|
| 14 |
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt |
| 15 |
#ifdef __KERNEL__ |
| 16 |
|
| 17 |
#include <linux/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 |
} |