fs/befs/debug.c

   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
  61         va_start(args, fmt);
  62         vaf.fmt = fmt;
  63         vaf.va = &args;
  64         pr_debug("(%s): %pV\n", sb->s_id, &vaf);
  65         va_end(args);
  66
  67 #endif                          //CONFIG_BEFS_DEBUG
  68 }
  69
  70 void
  71 befs_dump_inode(const struct super_block *sb, befs_inode *inode)
  72 {
  73 #ifdef CONFIG_BEFS_DEBUG
  74
  75         befs_block_run tmp_run;
  76
  77         befs_debug(sb, "befs_inode information");
  78
  79         befs_debug(sb, "  magic1 %08x", fs32_to_cpu(sb, inode->magic1));
  80
  81         tmp_run = fsrun_to_cpu(sb, inode->inode_num);
  82         befs_debug(sb, "  inode_num %u, %hu, %hu",
  83                    tmp_run.allocation_group, tmp_run.start, tmp_run.len);
  84
  85         befs_debug(sb, "  uid %u", fs32_to_cpu(sb, inode->uid));
  86         befs_debug(sb, "  gid %u", fs32_to_cpu(sb, inode->gid));
  87         befs_debug(sb, "  mode %08x", fs32_to_cpu(sb, inode->mode));
  88         befs_debug(sb, "  flags %08x", fs32_to_cpu(sb, inode->flags));
  89         befs_debug(sb, "  create_time %llu",
  90                    fs64_to_cpu(sb, inode->create_time));
  91         befs_debug(sb, "  last_modified_time %llu",
  92                    fs64_to_cpu(sb, inode->last_modified_time));
  93
  94         tmp_run = fsrun_to_cpu(sb, inode->parent);
  95         befs_debug(sb, "  parent [%u, %hu, %hu]",
  96                    tmp_run.allocation_group, tmp_run.start, tmp_run.len);
  97
  98         tmp_run = fsrun_to_cpu(sb, inode->attributes);
  99         befs_debug(sb, "  attributes [%u, %hu, %hu]",
 100                    tmp_run.allocation_group, tmp_run.start, tmp_run.len);
 101
 102         befs_debug(sb, "  type %08x", fs32_to_cpu(sb, inode->type));
 103         befs_debug(sb, "  inode_size %u", fs32_to_cpu(sb, inode->inode_size));
 104
 105         if (S_ISLNK(fs32_to_cpu(sb, inode->mode))) {
 106                 befs_debug(sb, "  Symbolic link [%s]", inode->data.symlink);
 107         } else {
 108                 int i;
 109
 110                 for (i = 0; i < BEFS_NUM_DIRECT_BLOCKS; i++) {
 111                         tmp_run =
 112                             fsrun_to_cpu(sb, inode->data.datastream.direct[i]);
 113                         befs_debug(sb, "  direct %d [%u, %hu, %hu]", i,
 114                                    tmp_run.allocation_group, tmp_run.start,
 115                                    tmp_run.len);
 116                 }
 117                 befs_debug(sb, "  max_direct_range %llu",
 118                            fs64_to_cpu(sb,
 119                                        inode->data.datastream.
 120                                        max_direct_range));
 121
 122                 tmp_run = fsrun_to_cpu(sb, inode->data.datastream.indirect);
 123                 befs_debug(sb, "  indirect [%u, %hu, %hu]",
 124                            tmp_run.allocation_group,
 125                            tmp_run.start, tmp_run.len);
 126
 127                 befs_debug(sb, "  max_indirect_range %llu",
 128                            fs64_to_cpu(sb,
 129                                        inode->data.datastream.
 130                                        max_indirect_range));
 131
 132                 tmp_run =
 133                     fsrun_to_cpu(sb, inode->data.datastream.double_indirect);
 134                 befs_debug(sb, "  double indirect [%u, %hu, %hu]",
 135                            tmp_run.allocation_group, tmp_run.start,
 136                            tmp_run.len);
 137
 138                 befs_debug(sb, "  max_double_indirect_range %llu",
 139                            fs64_to_cpu(sb,
 140                                        inode->data.datastream.
 141                                        max_double_indirect_range));
 142
 143                 befs_debug(sb, "  size %llu",
 144                            fs64_to_cpu(sb, inode->data.datastream.size));
 145         }
 146
 147 #endif                          //CONFIG_BEFS_DEBUG
 148 }
 149
 150 /*
 151  * Display super block structure for debug.
 152  */
 153
 154 void
 155 befs_dump_super_block(const struct super_block *sb, befs_super_block *sup)
 156 {
 157 #ifdef CONFIG_BEFS_DEBUG
 158
 159         befs_block_run tmp_run;
 160
 161         befs_debug(sb, "befs_super_block information");
 162
 163         befs_debug(sb, "  name %s", sup->name);
 164         befs_debug(sb, "  magic1 %08x", fs32_to_cpu(sb, sup->magic1));
 165         befs_debug(sb, "  fs_byte_order %08x",
 166                    fs32_to_cpu(sb, sup->fs_byte_order));
 167
 168         befs_debug(sb, "  block_size %u", fs32_to_cpu(sb, sup->block_size));
 169         befs_debug(sb, "  block_shift %u", fs32_to_cpu(sb, sup->block_shift));
 170
 171         befs_debug(sb, "  num_blocks %llu", fs64_to_cpu(sb, sup->num_blocks));
 172         befs_debug(sb, "  used_blocks %llu", fs64_to_cpu(sb, sup->used_blocks));
 173         befs_debug(sb, "  inode_size %u", fs32_to_cpu(sb, sup->inode_size));
 174
 175         befs_debug(sb, "  magic2 %08x", fs32_to_cpu(sb, sup->magic2));
 176         befs_debug(sb, "  blocks_per_ag %u",
 177                    fs32_to_cpu(sb, sup->blocks_per_ag));
 178         befs_debug(sb, "  ag_shift %u", fs32_to_cpu(sb, sup->ag_shift));
 179         befs_debug(sb, "  num_ags %u", fs32_to_cpu(sb, sup->num_ags));
 180
 181         befs_debug(sb, "  flags %08x", fs32_to_cpu(sb, sup->flags));
 182
 183         tmp_run = fsrun_to_cpu(sb, sup->log_blocks);
 184         befs_debug(sb, "  log_blocks %u, %hu, %hu",
 185                    tmp_run.allocation_group, tmp_run.start, tmp_run.len);
 186
 187         befs_debug(sb, "  log_start %lld", fs64_to_cpu(sb, sup->log_start));
 188         befs_debug(sb, "  log_end %lld", fs64_to_cpu(sb, sup->log_end));
 189
 190         befs_debug(sb, "  magic3 %08x", fs32_to_cpu(sb, sup->magic3));
 191
 192         tmp_run = fsrun_to_cpu(sb, sup->root_dir);
 193         befs_debug(sb, "  root_dir %u, %hu, %hu",
 194                    tmp_run.allocation_group, tmp_run.start, tmp_run.len);
 195
 196         tmp_run = fsrun_to_cpu(sb, sup->indices);
 197         befs_debug(sb, "  indices %u, %hu, %hu",
 198                    tmp_run.allocation_group, tmp_run.start, tmp_run.len);
 199
 200 #endif                          //CONFIG_BEFS_DEBUG
 201 }
 202
 203 #if 0
 204 /* unused */
 205 void
 206 befs_dump_small_data(const struct super_block *sb, befs_small_data *sd)
 207 {
 208 }
 209
 210 /* unused */
 211 void
 212 befs_dump_run(const struct super_block *sb, befs_disk_block_run run)
 213 {
 214 #ifdef CONFIG_BEFS_DEBUG
 215
 216         befs_block_run n = fsrun_to_cpu(sb, run);
 217
 218         befs_debug(sb, "[%u, %hu, %hu]", n.allocation_group, n.start, n.len);
 219
 220 #endif                          //CONFIG_BEFS_DEBUG
 221 }
 222 #endif  /*  0  */
 223
 224 void
 225 befs_dump_index_entry(const struct super_block *sb,
 226                       befs_disk_btree_super *super)
 227 {
 228 #ifdef CONFIG_BEFS_DEBUG
 229
 230         befs_debug(sb, "Btree super structure");
 231         befs_debug(sb, "  magic %08x", fs32_to_cpu(sb, super->magic));
 232         befs_debug(sb, "  node_size %u", fs32_to_cpu(sb, super->node_size));
 233         befs_debug(sb, "  max_depth %08x", fs32_to_cpu(sb, super->max_depth));
 234
 235         befs_debug(sb, "  data_type %08x", fs32_to_cpu(sb, super->data_type));
 236         befs_debug(sb, "  root_node_pointer %016LX",
 237                    fs64_to_cpu(sb, super->root_node_ptr));
 238         befs_debug(sb, "  free_node_pointer %016LX",
 239                    fs64_to_cpu(sb, super->free_node_ptr));
 240         befs_debug(sb, "  maximum size %016LX",
 241                    fs64_to_cpu(sb, super->max_size));
 242
 243 #endif                          //CONFIG_BEFS_DEBUG
 244 }
 245
 246 void
 247 befs_dump_index_node(const struct super_block *sb, befs_btree_nodehead *node)
 248 {
 249 #ifdef CONFIG_BEFS_DEBUG
 250
 251         befs_debug(sb, "Btree node structure");
 252         befs_debug(sb, "  left %016LX", fs64_to_cpu(sb, node->left));
 253         befs_debug(sb, "  right %016LX", fs64_to_cpu(sb, node->right));
 254         befs_debug(sb, "  overflow %016LX", fs64_to_cpu(sb, node->overflow));
 255         befs_debug(sb, "  all_key_count %hu",
 256                    fs16_to_cpu(sb, node->all_key_count));
 257         befs_debug(sb, "  all_key_length %hu",
 258                    fs16_to_cpu(sb, node->all_key_length));
 259
 260 #endif                          //CONFIG_BEFS_DEBUG
 261 }