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         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         befs_debug(sb, "  inode_size %u", fs32_to_cpu(sb, sup->inode_size));
 173
 174         befs_debug(sb, "  magic2 %08x", fs32_to_cpu(sb, sup->magic2));
 175         befs_debug(sb, "  blocks_per_ag %u",
 176                    fs32_to_cpu(sb, sup->blocks_per_ag));
 177         befs_debug(sb, "  ag_shift %u", fs32_to_cpu(sb, sup->ag_shift));
 178         befs_debug(sb, "  num_ags %u", fs32_to_cpu(sb, sup->num_ags));
 179
 180         befs_debug(sb, "  flags %08x", fs32_to_cpu(sb, sup->flags));
 181
 182         tmp_run = fsrun_to_cpu(sb, sup->log_blocks);
 183         befs_debug(sb, "  log_blocks %u, %hu, %hu",
 184                    tmp_run.allocation_group, tmp_run.start, tmp_run.len);
 185
 186         befs_debug(sb, "  log_start %lld", fs64_to_cpu(sb, sup->log_start));
 187         befs_debug(sb, "  log_end %lld", fs64_to_cpu(sb, sup->log_end));
 188
 189         befs_debug(sb, "  magic3 %08x", fs32_to_cpu(sb, sup->magic3));
 190
 191         tmp_run = fsrun_to_cpu(sb, sup->root_dir);
 192         befs_debug(sb, "  root_dir %u, %hu, %hu",
 193                    tmp_run.allocation_group, tmp_run.start, tmp_run.len);
 194
 195         tmp_run = fsrun_to_cpu(sb, sup->indices);
 196         befs_debug(sb, "  indices %u, %hu, %hu",
 197                    tmp_run.allocation_group, tmp_run.start, tmp_run.len);
 198
 199 #endif                          //CONFIG_BEFS_DEBUG
 200 }
 201
 202 #if 0
 203 /* unused */
 204 void
 205 befs_dump_small_data(const struct super_block *sb, befs_small_data * sd)
 206 {
 207 }
 208
 209 /* unused */
 210 void
 211 befs_dump_run(const struct super_block *sb, befs_disk_block_run run)
 212 {
 213 #ifdef CONFIG_BEFS_DEBUG
 214
 215         befs_block_run n = fsrun_to_cpu(sb, run);
 216
 217         befs_debug(sb, "[%u, %hu, %hu]", n.allocation_group, n.start, n.len);
 218
 219 #endif                          //CONFIG_BEFS_DEBUG
 220 }
 221 #endif  /*  0  */
 222
 223 void
 224 befs_dump_index_entry(const struct super_block *sb, befs_disk_btree_super * super)
 225 {
 226 #ifdef CONFIG_BEFS_DEBUG
 227
 228         befs_debug(sb, "Btree super structure");
 229         befs_debug(sb, "  magic %08x", fs32_to_cpu(sb, super->magic));
 230         befs_debug(sb, "  node_size %u", fs32_to_cpu(sb, super->node_size));
 231         befs_debug(sb, "  max_depth %08x", fs32_to_cpu(sb, super->max_depth));
 232
 233         befs_debug(sb, "  data_type %08x", fs32_to_cpu(sb, super->data_type));
 234         befs_debug(sb, "  root_node_pointer %016LX",
 235                    fs64_to_cpu(sb, super->root_node_ptr));
 236         befs_debug(sb, "  free_node_pointer %016LX",
 237                    fs64_to_cpu(sb, super->free_node_ptr));
 238         befs_debug(sb, "  maximum size %016LX",
 239                    fs64_to_cpu(sb, super->max_size));
 240
 241 #endif                          //CONFIG_BEFS_DEBUG
 242 }
 243
 244 void
 245 befs_dump_index_node(const struct super_block *sb, befs_btree_nodehead * node)
 246 {
 247 #ifdef CONFIG_BEFS_DEBUG
 248
 249         befs_debug(sb, "Btree node structure");
 250         befs_debug(sb, "  left %016LX", fs64_to_cpu(sb, node->left));
 251         befs_debug(sb, "  right %016LX", fs64_to_cpu(sb, node->right));
 252         befs_debug(sb, "  overflow %016LX", fs64_to_cpu(sb, node->overflow));
 253         befs_debug(sb, "  all_key_count %hu",
 254                    fs16_to_cpu(sb, node->all_key_count));
 255         befs_debug(sb, "  all_key_length %hu",
 256                    fs16_to_cpu(sb, node->all_key_length));
 257
 258 #endif                          //CONFIG_BEFS_DEBUG
 259 }