URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [fs/] [befs/] [debug.c] - Blame information for rev 1765

Details | Compare with Previous | View Log


/*
 *  linux/fs/befs/debug.c
 *
 * Copyright (C) 2001 Will Dyson (will_dyson at pobox.com)
 *
 * With help from the ntfs-tng driver by Anton Altparmakov
 *
 * Copyright (C) 1999  Makoto Kato (m_kato@ga2.so-net.ne.jp)
 *
 * debug functions
 */
 
#ifdef __KERNEL__
 
#include <stdarg.h>
#include <linux/string.h>
#include <linux/spinlock.h>
#include <linux/kernel.h>
#include <linux/fs.h>
 
#endif                          /* __KERNEL__ */
 
#include "befs.h"
#include "endian.h"
 
#define ERRBUFSIZE 1024
 
void
befs_error(const struct super_block *sb, const char *fmt, ...)
{
        va_list args;
        char err_buf[ERRBUFSIZE];
 
        va_start(args, fmt);
        vsnprintf(err_buf, ERRBUFSIZE, fmt, args);
        va_end(args);
 
        printk(KERN_ERR "BeFS(%s): %s\n", bdevname(sb->s_dev), err_buf);
 
        befs_debug(sb, err_buf);
}
 
void
befs_warning(const struct super_block *sb, const char *fmt, ...)
{
        va_list args;
        char err_buf[ERRBUFSIZE];
 
        va_start(args, fmt);
        vsnprintf(err_buf, ERRBUFSIZE, fmt, args);
        va_end(args);
 
        printk(KERN_WARNING "BeFS(%s): %s\n", bdevname(sb->s_dev), err_buf);
 
        befs_debug(sb, err_buf);
}
 
void
befs_debug(const struct super_block *sb, const char *fmt, ...)
{
#ifdef CONFIG_BEFS_DEBUG
 
        va_list args;
        char err_buf[ERRBUFSIZE];
 
        if (BEFS_SB(sb)->mount_opts.debug) {
                va_start(args, fmt);
                vsnprintf(err_buf, ERRBUFSIZE, fmt, args);
                va_end(args);
 
                printk(KERN_DEBUG "BeFS(%s): %s\n",
                       bdevname(sb->s_dev), err_buf);
        }
#endif                          //CONFIG_BEFS_DEBUG
}
 
void
befs_dump_inode(const struct super_block *sb, befs_inode * inode)
{
#ifdef CONFIG_BEFS_DEBUG
 
        befs_block_run tmp_run;
 
        befs_debug(sb, "befs_inode infomation");
 
        befs_debug(sb, "  magic1 %08x", fs32_to_cpu(sb, inode->magic1));
 
        tmp_run = fsrun_to_cpu(sb, inode->inode_num);
        befs_debug(sb, "  inode_num %u, %hu, %hu",
                   tmp_run.allocation_group, tmp_run.start, tmp_run.len);
 
        befs_debug(sb, "  uid %u", fs32_to_cpu(sb, inode->uid));
        befs_debug(sb, "  gid %u", fs32_to_cpu(sb, inode->gid));
        befs_debug(sb, "  mode %08x", fs32_to_cpu(sb, inode->mode));
        befs_debug(sb, "  flags %08x", fs32_to_cpu(sb, inode->flags));
        befs_debug(sb, "  create_time %Lu",
                   fs64_to_cpu(sb, inode->create_time));
        befs_debug(sb, "  last_modified_time %Lu",
                   fs64_to_cpu(sb, inode->last_modified_time));
 
        tmp_run = fsrun_to_cpu(sb, inode->parent);
        befs_debug(sb, "  parent [%u, %hu, %hu]",
                   tmp_run.allocation_group, tmp_run.start, tmp_run.len);
 
        tmp_run = fsrun_to_cpu(sb, inode->attributes);
        befs_debug(sb, "  attributes [%u, %hu, %hu]",
                   tmp_run.allocation_group, tmp_run.start, tmp_run.len);
 
        befs_debug(sb, "  type %08x", fs32_to_cpu(sb, inode->type));
        befs_debug(sb, "  inode_size %u", fs32_to_cpu(sb, inode->inode_size));
 
        if (S_ISLNK(inode->mode)) {
                befs_debug(sb, "  Symbolic link [%s]", inode->data.symlink);
        } else {
                int i;
 
                for (i = 0; i < BEFS_NUM_DIRECT_BLOCKS; i++) {
                        tmp_run =
                            fsrun_to_cpu(sb, inode->data.datastream.direct[i]);
                        befs_debug(sb, "  direct %d [%u, %hu, %hu]", i,
                                   tmp_run.allocation_group, tmp_run.start,
                                   tmp_run.len);
                }
                befs_debug(sb, "  max_direct_range %Lu",
                           fs64_to_cpu(sb,
                                       inode->data.datastream.
                                       max_direct_range));
 
                tmp_run = fsrun_to_cpu(sb, inode->data.datastream.indirect);
                befs_debug(sb, "  indirect [%u, %hu, %hu]",
                           tmp_run.allocation_group,
                           tmp_run.start, tmp_run.len);
 
                befs_debug(sb, "  max_indirect_range %Lu",
                           fs64_to_cpu(sb,
                                       inode->data.datastream.
                                       max_indirect_range));
 
                tmp_run =
                    fsrun_to_cpu(sb, inode->data.datastream.double_indirect);
                befs_debug(sb, "  double indirect [%u, %hu, %hu]",
                           tmp_run.allocation_group, tmp_run.start,
                           tmp_run.len);
 
                befs_debug(sb, "  max_double_indirect_range %Lu",
                           fs64_to_cpu(sb,
                                       inode->data.datastream.
                                       max_double_indirect_range));
 
                befs_debug(sb, "  size %Lu",
                           fs64_to_cpu(sb, inode->data.datastream.size));
        }
 
#endif                          //CONFIG_BEFS_DEBUG
}
 
/*
 * Display super block structure for debug.
 */
 
void
befs_dump_super_block(const struct super_block *sb, befs_super_block * sup)
{
#ifdef CONFIG_BEFS_DEBUG
 
        befs_block_run tmp_run;
 
        befs_debug(sb, "befs_super_block information");
 
        befs_debug(sb, "  name %s", sup->name);
        befs_debug(sb, "  magic1 %08x", fs32_to_cpu(sb, sup->magic1));
        befs_debug(sb, "  fs_byte_order %08x",
                   fs32_to_cpu(sb, sup->fs_byte_order));
 
        befs_debug(sb, "  block_size %u", fs32_to_cpu(sb, sup->block_size));
        befs_debug(sb, "  block_shift %u", fs32_to_cpu(sb, sup->block_shift));
 
        befs_debug(sb, "  num_blocks %Lu", fs64_to_cpu(sb, sup->num_blocks));
        befs_debug(sb, "  used_blocks %Lu", fs64_to_cpu(sb, sup->used_blocks));
 
        befs_debug(sb, "  magic2 %08x", fs32_to_cpu(sb, sup->magic2));
        befs_debug(sb, "  blocks_per_ag %u",
                   fs32_to_cpu(sb, sup->blocks_per_ag));
        befs_debug(sb, "  ag_shift %u", fs32_to_cpu(sb, sup->ag_shift));
        befs_debug(sb, "  num_ags %u", fs32_to_cpu(sb, sup->num_ags));
 
        befs_debug(sb, "  flags %08x", fs32_to_cpu(sb, sup->flags));
 
        tmp_run = fsrun_to_cpu(sb, sup->log_blocks);
        befs_debug(sb, "  log_blocks %u, %hu, %hu",
                   tmp_run.allocation_group, tmp_run.start, tmp_run.len);
 
        befs_debug(sb, "  log_start %Ld", fs64_to_cpu(sb, sup->log_start));
        befs_debug(sb, "  log_end %Ld", fs64_to_cpu(sb, sup->log_end));
 
        befs_debug(sb, "  magic3 %08x", fs32_to_cpu(sb, sup->magic3));
 
        tmp_run = fsrun_to_cpu(sb, sup->root_dir);
        befs_debug(sb, "  root_dir %u, %hu, %hu",
                   tmp_run.allocation_group, tmp_run.start, tmp_run.len);
 
        tmp_run = fsrun_to_cpu(sb, sup->indices);
        befs_debug(sb, "  indices %u, %hu, %hu",
                   tmp_run.allocation_group, tmp_run.start, tmp_run.len);
 
#endif                          //CONFIG_BEFS_DEBUG
}
 
void
befs_dump_small_data(const struct super_block *sb, befs_small_data * sd)
{
}
 
void
befs_dump_run(const struct super_block *sb, befs_block_run run)
{
#ifdef CONFIG_BEFS_DEBUG
 
        run = fsrun_to_cpu(sb, run);
 
        befs_debug(sb, "[%u, %hu, %hu]",
                   run.allocation_group, run.start, run.len);
 
#endif                          //CONFIG_BEFS_DEBUG
}
 
void
befs_dump_index_entry(const struct super_block *sb, befs_btree_super * super)
{
#ifdef CONFIG_BEFS_DEBUG
 
        befs_debug(sb, "Btree super structure");
        befs_debug(sb, "  magic %08x", fs32_to_cpu(sb, super->magic));
        befs_debug(sb, "  node_size %u", fs32_to_cpu(sb, super->node_size));
        befs_debug(sb, "  max_depth %08x", fs32_to_cpu(sb, super->max_depth));
 
        befs_debug(sb, "  data_type %08x", fs32_to_cpu(sb, super->data_type));
        befs_debug(sb, "  root_node_pointer %016LX",
                   fs64_to_cpu(sb, super->root_node_ptr));
        befs_debug(sb, "  free_node_pointer %016LX",
                   fs64_to_cpu(sb, super->free_node_ptr));
        befs_debug(sb, "  maximum size %016LX",
                   fs64_to_cpu(sb, super->max_size));
 
#endif                          //CONFIG_BEFS_DEBUG
}
 
void
befs_dump_index_node(const struct super_block *sb, befs_btree_nodehead * node)
{
#ifdef CONFIG_BEFS_DEBUG
 
        befs_debug(sb, "Btree node structure");
        befs_debug(sb, "  left %016LX", fs64_to_cpu(sb, node->left));
        befs_debug(sb, "  right %016LX", fs64_to_cpu(sb, node->right));
        befs_debug(sb, "  overflow %016LX", fs64_to_cpu(sb, node->overflow));
        befs_debug(sb, "  all_key_count %hu",
                   fs16_to_cpu(sb, node->all_key_count));
        befs_debug(sb, "  all_key_length %hu",
                   fs16_to_cpu(sb, node->all_key_length));
 
#endif                          //CONFIG_BEFS_DEBUG
}

Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [fs/] [befs/] [debug.c] - Blame information for rev 1765

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