GNU Linux-libre 4.9.308-gnu1
[releases.git] / 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 }