Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
hfs/hfsplus: rework debug output subsystem
Currently, HFS/HFS+ has very obsolete and inconvenient
debug output subsystem. Also, the code is duplicated
in HFS and HFS+ driver. This patch introduces
linux/hfs_common.h for gathering common declarations,
inline functions, and common short methods. Currently,
this file contains only hfs_dbg() function that
employs pr_debug() with the goal to print a debug-level
messages conditionally.
So, now, it is possible to enable the debug output
by means of:
echo 'file extent.c +p' > /proc/dynamic_debug/control
echo 'func hfsplus_evict_inode +p' > /proc/dynamic_debug/control
And debug output looks like this:
hfs: pid 5831:fs/hfs/catalog.c:228 hfs_cat_delete(): delete_cat: 00,48
hfs: pid 5831:fs/hfs/extent.c:484 hfs_file_truncate(): truncate: 48, 409600 -> 0
hfs: pid 5831:fs/hfs/extent.c:212 hfs_dump_extent():
hfs: pid 5831:fs/hfs/extent.c:214 hfs_dump_extent(): 78:4
hfs: pid 5831:fs/hfs/extent.c:214 hfs_dump_extent(): 0:0
hfs: pid 5831:fs/hfs/extent.c:214 hfs_dump_extent(): 0:0
v4
Debug messages have been reworked and information about
new HFS/HFS+ shared declarations file has been added
to MAINTAINERS file.
v5
Yangtao Li suggested to clean up debug output and
fix several typos.
Signed-off-by: Viacheslav Dubeyko <slava@dubeyko.com>
cc: John Paul Adrian Glaubitz <glaubitz@physik.fu-berlin.de>
cc: Yangtao Li <frank.li@vivo.com>
cc: linux-fsdevel@vger.kernel.org
cc: Johannes Thumshirn <Johannes.Thumshirn@wdc.com>
Signed-off-by: Viacheslav Dubeyko <slava@dubeyko.com>
+128
-162
+2
MAINTAINERS
+2
MAINTAINERS
···
10794
10794
T: git git://git.kernel.org/pub/scm/linux/kernel/git/vdubeyko/hfs.git
10795
10795
F: Documentation/filesystems/hfs.rst
10796
10796
F: fs/hfs/
10797
+
F: include/linux/hfs_common.h
10797
10798
10798
10799
HFSPLUS FILESYSTEM
10799
10800
M: Viacheslav Dubeyko <slava@dubeyko.com>
···
10805
10804
T: git git://git.kernel.org/pub/scm/linux/kernel/git/vdubeyko/hfs.git
10806
10805
F: Documentation/filesystems/hfsplus.rst
10807
10806
F: fs/hfsplus/
10807
+
F: include/linux/hfs_common.h
10808
10808
10809
10809
HGA FRAMEBUFFER DRIVER
10810
10810
M: Ferenc Bakonyi <fero@drama.obuda.kando.hu>
+2
-2
fs/hfs/bfind.c
+2
-2
fs/hfs/bfind.c
···
26
26
return -ENOMEM;
27
27
fd->search_key = ptr;
28
28
fd->key = ptr + tree->max_key_len + 2;
29
-
hfs_dbg(BNODE_REFS, "find_init: %d (%p)\n",
29
+
hfs_dbg("cnid %d, caller %ps\n",
30
30
tree->cnid, __builtin_return_address(0));
31
31
switch (tree->cnid) {
32
32
case HFS_CAT_CNID:
···
48
48
{
49
49
hfs_bnode_put(fd->bnode);
50
50
kfree(fd->search_key);
51
-
hfs_dbg(BNODE_REFS, "find_exit: %d (%p)\n",
51
+
hfs_dbg("cnid %d, caller %ps\n",
52
52
fd->tree->cnid, __builtin_return_address(0));
53
53
mutex_unlock(&fd->tree->tree_lock);
54
54
fd->tree = NULL;
+2
-2
fs/hfs/bitmap.c
+2
-2
fs/hfs/bitmap.c
···
158
158
}
159
159
}
160
160
161
-
hfs_dbg(BITMAP, "alloc_bits: %u,%u\n", pos, *num_bits);
161
+
hfs_dbg("pos %u, num_bits %u\n", pos, *num_bits);
162
162
HFS_SB(sb)->free_ablocks -= *num_bits;
163
163
hfs_bitmap_dirty(sb);
164
164
out:
···
200
200
if (!count)
201
201
return 0;
202
202
203
-
hfs_dbg(BITMAP, "clear_bits: %u,%u\n", start, count);
203
+
hfs_dbg("start %u, count %u\n", start, count);
204
204
/* are all of the bits in range? */
205
205
if ((start + count) > HFS_SB(sb)->fs_ablocks)
206
206
return -2;
+14
-14
fs/hfs/bnode.c
+14
-14
fs/hfs/bnode.c
···
200
200
{
201
201
struct page *src_page, *dst_page;
202
202
203
-
hfs_dbg(BNODE_MOD, "copybytes: %u,%u,%u\n", dst, src, len);
203
+
hfs_dbg("dst %u, src %u, len %u\n", dst, src, len);
204
204
if (!len)
205
205
return;
206
206
···
221
221
struct page *page;
222
222
void *ptr;
223
223
224
-
hfs_dbg(BNODE_MOD, "movebytes: %u,%u,%u\n", dst, src, len);
224
+
hfs_dbg("dst %u, src %u, len %u\n", dst, src, len);
225
225
if (!len)
226
226
return;
227
227
···
243
243
__be32 cnid;
244
244
int i, off, key_off;
245
245
246
-
hfs_dbg(BNODE_MOD, "bnode: %d\n", node->this);
246
+
hfs_dbg("node %d\n", node->this);
247
247
hfs_bnode_read(node, &desc, 0, sizeof(desc));
248
-
hfs_dbg(BNODE_MOD, "%d, %d, %d, %d, %d\n",
248
+
hfs_dbg("next %d, prev %d, type %d, height %d, num_recs %d\n",
249
249
be32_to_cpu(desc.next), be32_to_cpu(desc.prev),
250
250
desc.type, desc.height, be16_to_cpu(desc.num_recs));
251
251
252
252
off = node->tree->node_size - 2;
253
253
for (i = be16_to_cpu(desc.num_recs); i >= 0; off -= 2, i--) {
254
254
key_off = hfs_bnode_read_u16(node, off);
255
-
hfs_dbg_cont(BNODE_MOD, " %d", key_off);
255
+
hfs_dbg(" key_off %d", key_off);
256
256
if (i && node->type == HFS_NODE_INDEX) {
257
257
int tmp;
258
258
···
260
260
tmp = (hfs_bnode_read_u8(node, key_off) | 1) + 1;
261
261
else
262
262
tmp = node->tree->max_key_len + 1;
263
-
hfs_dbg_cont(BNODE_MOD, " (%d,%d",
264
-
tmp, hfs_bnode_read_u8(node, key_off));
263
+
hfs_dbg(" (%d,%d",
264
+
tmp, hfs_bnode_read_u8(node, key_off));
265
265
hfs_bnode_read(node, &cnid, key_off + tmp, 4);
266
-
hfs_dbg_cont(BNODE_MOD, ",%d)", be32_to_cpu(cnid));
266
+
hfs_dbg(", cnid %d)", be32_to_cpu(cnid));
267
267
} else if (i && node->type == HFS_NODE_LEAF) {
268
268
int tmp;
269
269
270
270
tmp = hfs_bnode_read_u8(node, key_off);
271
-
hfs_dbg_cont(BNODE_MOD, " (%d)", tmp);
271
+
hfs_dbg(" (%d)", tmp);
272
272
}
273
273
}
274
-
hfs_dbg_cont(BNODE_MOD, "\n");
274
+
hfs_dbg("\n");
275
275
}
276
276
277
277
void hfs_bnode_unlink(struct hfs_bnode *node)
···
361
361
node->this = cnid;
362
362
set_bit(HFS_BNODE_NEW, &node->flags);
363
363
atomic_set(&node->refcnt, 1);
364
-
hfs_dbg(BNODE_REFS, "new_node(%d:%d): 1\n",
364
+
hfs_dbg("cnid %d, node %d, refcnt 1\n",
365
365
node->tree->cnid, node->this);
366
366
init_waitqueue_head(&node->lock_wq);
367
367
spin_lock(&tree->hash_lock);
···
401
401
{
402
402
struct hfs_bnode **p;
403
403
404
-
hfs_dbg(BNODE_REFS, "remove_node(%d:%d): %d\n",
404
+
hfs_dbg("cnid %d, node %d, refcnt %d\n",
405
405
node->tree->cnid, node->this, atomic_read(&node->refcnt));
406
406
for (p = &node->tree->node_hash[hfs_bnode_hash(node->this)];
407
407
*p && *p != node; p = &(*p)->next_hash)
···
546
546
{
547
547
if (node) {
548
548
atomic_inc(&node->refcnt);
549
-
hfs_dbg(BNODE_REFS, "get_node(%d:%d): %d\n",
549
+
hfs_dbg("cnid %d, node %d, refcnt %d\n",
550
550
node->tree->cnid, node->this,
551
551
atomic_read(&node->refcnt));
552
552
}
···
559
559
struct hfs_btree *tree = node->tree;
560
560
int i;
561
561
562
-
hfs_dbg(BNODE_REFS, "put_node(%d:%d): %d\n",
562
+
hfs_dbg("cnid %d, node %d, refcnt %d\n",
563
563
node->tree->cnid, node->this,
564
564
atomic_read(&node->refcnt));
565
565
BUG_ON(!atomic_read(&node->refcnt));
+4
-4
fs/hfs/brec.c
+4
-4
fs/hfs/brec.c
···
94
94
end_rec_off = tree->node_size - (node->num_recs + 1) * 2;
95
95
end_off = hfs_bnode_read_u16(node, end_rec_off);
96
96
end_rec_off -= 2;
97
-
hfs_dbg(BNODE_MOD, "insert_rec: %d, %d, %d, %d\n",
97
+
hfs_dbg("rec %d, size %d, end_off %d, end_rec_off %d\n",
98
98
rec, size, end_off, end_rec_off);
99
99
if (size > end_rec_off - end_off) {
100
100
if (new_node)
···
192
192
mark_inode_dirty(tree->inode);
193
193
}
194
194
hfs_bnode_dump(node);
195
-
hfs_dbg(BNODE_MOD, "remove_rec: %d, %d\n",
195
+
hfs_dbg("rec %d, len %d\n",
196
196
fd->record, fd->keylength + fd->entrylength);
197
197
if (!--node->num_recs) {
198
198
hfs_bnode_unlink(node);
···
261
261
if (IS_ERR(new_node))
262
262
return new_node;
263
263
hfs_bnode_get(node);
264
-
hfs_dbg(BNODE_MOD, "split_nodes: %d - %d - %d\n",
264
+
hfs_dbg("this %d, new %d, next %d\n",
265
265
node->this, new_node->this, node->next);
266
266
new_node->next = node->next;
267
267
new_node->prev = node->this;
···
397
397
newkeylen = (hfs_bnode_read_u8(node, 14) | 1) + 1;
398
398
else
399
399
fd->keylength = newkeylen = tree->max_key_len + 1;
400
-
hfs_dbg(BNODE_MOD, "update_rec: %d, %d, %d\n",
400
+
hfs_dbg("rec %d, keylength %d, newkeylen %d\n",
401
401
rec, fd->keylength, newkeylen);
402
402
403
403
rec_off = tree->node_size - (rec + 2) * 2;
+1
-1
fs/hfs/btree.c
+1
-1
fs/hfs/btree.c
+7
-7
fs/hfs/catalog.c
+7
-7
fs/hfs/catalog.c
···
87
87
int entry_size;
88
88
int err;
89
89
90
-
hfs_dbg(CAT_MOD, "create_cat: %s,%u(%d)\n",
90
+
hfs_dbg("name %s, cnid %u, i_nlink %d\n",
91
91
str->name, cnid, inode->i_nlink);
92
92
if (dir->i_size >= HFS_MAX_VALENCE)
93
93
return -ENOSPC;
···
238
238
s64 leaf_tail;
239
239
s64 node_id;
240
240
241
-
hfs_dbg(CAT_MOD, "correct next unused CNID: cnid %u, next_id %lld\n",
241
+
hfs_dbg("cnid %u, next_id %lld\n",
242
242
cnid, atomic64_read(&HFS_SB(sb)->next_id));
243
243
244
244
if ((cnid + 1) < atomic64_read(&HFS_SB(sb)->next_id)) {
···
274
274
return -ENOENT;
275
275
}
276
276
277
-
hfs_dbg(CAT_MOD, "node_id %lld, leaf_tail %lld, leaf_head %lld\n",
277
+
hfs_dbg("node %lld, leaf_tail %lld, leaf_head %lld\n",
278
278
node_id, leaf_tail, leaf_head);
279
279
280
280
hfs_bnode_dump(node);
···
309
309
310
310
if (rec.type == HFS_CDR_DIR) {
311
311
found_cnid = be32_to_cpu(rec.dir.DirID);
312
-
hfs_dbg(CAT_MOD, "found_cnid %u\n", found_cnid);
312
+
hfs_dbg("found_cnid %u\n", found_cnid);
313
313
hfs_set_next_unused_CNID(sb, cnid, found_cnid);
314
314
hfs_bnode_put(node);
315
315
return 0;
316
316
} else if (rec.type == HFS_CDR_FIL) {
317
317
found_cnid = be32_to_cpu(rec.file.FlNum);
318
-
hfs_dbg(CAT_MOD, "found_cnid %u\n", found_cnid);
318
+
hfs_dbg("found_cnid %u\n", found_cnid);
319
319
hfs_set_next_unused_CNID(sb, cnid, found_cnid);
320
320
hfs_bnode_put(node);
321
321
return 0;
···
343
343
struct hfs_readdir_data *rd;
344
344
int res, type;
345
345
346
-
hfs_dbg(CAT_MOD, "delete_cat: %s,%u\n", str ? str->name : NULL, cnid);
346
+
hfs_dbg("name %s, cnid %u\n", str ? str->name : NULL, cnid);
347
347
sb = dir->i_sb;
348
348
res = hfs_find_init(HFS_SB(sb)->cat_tree, &fd);
349
349
if (res)
···
417
417
int entry_size, type;
418
418
int err;
419
419
420
-
hfs_dbg(CAT_MOD, "rename_cat: %u - %lu,%s - %lu,%s\n",
420
+
hfs_dbg("cnid %u - (ino %lu, name %s) - (ino %lu, name %s)\n",
421
421
cnid, src_dir->i_ino, src_name->name,
422
422
dst_dir->i_ino, dst_name->name);
423
423
sb = src_dir->i_sb;
+10
-9
fs/hfs/extent.c
+10
-9
fs/hfs/extent.c
···
209
209
{
210
210
int i;
211
211
212
-
hfs_dbg(EXTENT, " ");
212
+
hfs_dbg("extent: ");
213
213
for (i = 0; i < 3; i++)
214
-
hfs_dbg_cont(EXTENT, " %u:%u",
215
-
be16_to_cpu(extent[i].block),
216
-
be16_to_cpu(extent[i].count));
217
-
hfs_dbg_cont(EXTENT, "\n");
214
+
hfs_dbg(" block %u, count %u",
215
+
be16_to_cpu(extent[i].block),
216
+
be16_to_cpu(extent[i].count));
217
+
hfs_dbg("\n");
218
218
}
219
219
220
220
static int hfs_add_extent(struct hfs_extent *extent, u16 offset,
···
411
411
goto out;
412
412
}
413
413
414
-
hfs_dbg(EXTENT, "extend %lu: %u,%u\n", inode->i_ino, start, len);
414
+
hfs_dbg("ino %lu, start %u, len %u\n", inode->i_ino, start, len);
415
415
if (HFS_I(inode)->alloc_blocks == HFS_I(inode)->first_blocks) {
416
416
if (!HFS_I(inode)->first_blocks) {
417
-
hfs_dbg(EXTENT, "first extents\n");
417
+
hfs_dbg("first_extent: start %u, len %u\n",
418
+
start, len);
418
419
/* no extents yet */
419
420
HFS_I(inode)->first_extents[0].block = cpu_to_be16(start);
420
421
HFS_I(inode)->first_extents[0].count = cpu_to_be16(len);
···
457
456
return res;
458
457
459
458
insert_extent:
460
-
hfs_dbg(EXTENT, "insert new extent\n");
459
+
hfs_dbg("insert new extent\n");
461
460
res = hfs_ext_write_extent(inode);
462
461
if (res)
463
462
goto out;
···
482
481
u32 size;
483
482
int res;
484
483
485
-
hfs_dbg(INODE, "truncate: %lu, %Lu -> %Lu\n",
484
+
hfs_dbg("ino %lu, phys_size %llu -> i_size %llu\n",
486
485
inode->i_ino, (long long)HFS_I(inode)->phys_size,
487
486
inode->i_size);
488
487
if (inode->i_size > HFS_I(inode)->phys_size) {
+1
-32
fs/hfs/hfs_fs.h
+1
-32
fs/hfs/hfs_fs.h
···
9
9
#ifndef _LINUX_HFS_FS_H
10
10
#define _LINUX_HFS_FS_H
11
11
12
-
#ifdef pr_fmt
13
-
#undef pr_fmt
14
-
#endif
15
-
16
-
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
17
-
18
12
#include <linux/slab.h>
19
13
#include <linux/types.h>
20
14
#include <linux/mutex.h>
···
18
24
19
25
#include <asm/byteorder.h>
20
26
#include <linux/uaccess.h>
27
+
#include <linux/hfs_common.h>
21
28
22
29
#include "hfs.h"
23
-
24
-
#define DBG_BNODE_REFS 0x00000001
25
-
#define DBG_BNODE_MOD 0x00000002
26
-
#define DBG_CAT_MOD 0x00000004
27
-
#define DBG_INODE 0x00000008
28
-
#define DBG_SUPER 0x00000010
29
-
#define DBG_EXTENT 0x00000020
30
-
#define DBG_BITMAP 0x00000040
31
-
32
-
//#define DBG_MASK (DBG_EXTENT|DBG_INODE|DBG_BNODE_MOD|DBG_CAT_MOD|DBG_BITMAP)
33
-
//#define DBG_MASK (DBG_BNODE_MOD|DBG_CAT_MOD|DBG_INODE)
34
-
//#define DBG_MASK (DBG_CAT_MOD|DBG_BNODE_REFS|DBG_INODE|DBG_EXTENT)
35
-
#define DBG_MASK (0)
36
-
37
-
#define hfs_dbg(flg, fmt, ...) \
38
-
do { \
39
-
if (DBG_##flg & DBG_MASK) \
40
-
printk(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__); \
41
-
} while (0)
42
-
43
-
#define hfs_dbg_cont(flg, fmt, ...) \
44
-
do { \
45
-
if (DBG_##flg & DBG_MASK) \
46
-
pr_cont(fmt, ##__VA_ARGS__); \
47
-
} while (0)
48
-
49
30
50
31
/*
51
32
* struct hfs_inode_info
+2
-2
fs/hfs/inode.c
+2
-2
fs/hfs/inode.c
···
249
249
{
250
250
struct super_block *sb = inode->i_sb;
251
251
252
-
hfs_dbg(INODE, "delete_inode: %lu\n", inode->i_ino);
252
+
hfs_dbg("ino %lu\n", inode->i_ino);
253
253
if (S_ISDIR(inode->i_mode)) {
254
254
BUG_ON(atomic64_read(&HFS_SB(sb)->folder_count) > U32_MAX);
255
255
atomic64_dec(&HFS_SB(sb)->folder_count);
···
436
436
hfs_cat_rec rec;
437
437
int res;
438
438
439
-
hfs_dbg(INODE, "hfs_write_inode: %lu\n", inode->i_ino);
439
+
hfs_dbg("ino %lu\n", inode->i_ino);
440
440
res = hfs_ext_write_extent(inode);
441
441
if (res)
442
442
return res;
+4
-4
fs/hfsplus/attributes.c
+4
-4
fs/hfsplus/attributes.c
···
139
139
{
140
140
int err = 0;
141
141
142
-
hfs_dbg(ATTR_MOD, "find_attr: %s,%d\n", name ? name : NULL, cnid);
142
+
hfs_dbg("name %s, cnid %d\n", name ? name : NULL, cnid);
143
143
144
144
if (!HFSPLUS_SB(sb)->attr_tree) {
145
145
pr_err("attributes file doesn't exist\n");
···
201
201
int entry_size;
202
202
int err;
203
203
204
-
hfs_dbg(ATTR_MOD, "create_attr: %s,%ld\n",
204
+
hfs_dbg("name %s, ino %ld\n",
205
205
name ? name : NULL, inode->i_ino);
206
206
207
207
if (!HFSPLUS_SB(sb)->attr_tree) {
···
310
310
struct super_block *sb = inode->i_sb;
311
311
struct hfs_find_data fd;
312
312
313
-
hfs_dbg(ATTR_MOD, "delete_attr: %s,%ld\n",
313
+
hfs_dbg("name %s, ino %ld\n",
314
314
name ? name : NULL, inode->i_ino);
315
315
316
316
if (!HFSPLUS_SB(sb)->attr_tree) {
···
356
356
int err = 0;
357
357
struct hfs_find_data fd;
358
358
359
-
hfs_dbg(ATTR_MOD, "delete_all_attrs: %d\n", cnid);
359
+
hfs_dbg("cnid %d\n", cnid);
360
360
361
361
if (!HFSPLUS_SB(dir->i_sb)->attr_tree) {
362
362
pr_err("attributes file doesn't exist\n");
+2
-2
fs/hfsplus/bfind.c
+2
-2
fs/hfsplus/bfind.c
···
23
23
return -ENOMEM;
24
24
fd->search_key = ptr;
25
25
fd->key = ptr + tree->max_key_len + 2;
26
-
hfs_dbg(BNODE_REFS, "find_init: %d (%p)\n",
26
+
hfs_dbg("cnid %d, caller %ps\n",
27
27
tree->cnid, __builtin_return_address(0));
28
28
mutex_lock_nested(&tree->tree_lock,
29
29
hfsplus_btree_lock_class(tree));
···
34
34
{
35
35
hfs_bnode_put(fd->bnode);
36
36
kfree(fd->search_key);
37
-
hfs_dbg(BNODE_REFS, "find_exit: %d (%p)\n",
37
+
hfs_dbg("cnid %d, caller %ps\n",
38
38
fd->tree->cnid, __builtin_return_address(0));
39
39
mutex_unlock(&fd->tree->tree_lock);
40
40
fd->tree = NULL;
+5
-5
fs/hfsplus/bitmap.c
+5
-5
fs/hfsplus/bitmap.c
···
31
31
if (!len)
32
32
return size;
33
33
34
-
hfs_dbg(BITMAP, "block_allocate: %u,%u,%u\n", size, offset, len);
34
+
hfs_dbg("size %u, offset %u, len %u\n", size, offset, len);
35
35
mutex_lock(&sbi->alloc_mutex);
36
36
mapping = sbi->alloc_file->i_mapping;
37
37
page = read_mapping_page(mapping, offset / PAGE_CACHE_BITS, NULL);
···
90
90
else
91
91
end = pptr + ((size + 31) & (PAGE_CACHE_BITS - 1)) / 32;
92
92
}
93
-
hfs_dbg(BITMAP, "bitmap full\n");
93
+
hfs_dbg("bitmap full\n");
94
94
start = size;
95
95
goto out;
96
96
97
97
found:
98
98
start = offset + (curr - pptr) * 32 + i;
99
99
if (start >= size) {
100
-
hfs_dbg(BITMAP, "bitmap full\n");
100
+
hfs_dbg("bitmap full\n");
101
101
goto out;
102
102
}
103
103
/* do any partial u32 at the start */
···
155
155
*max = offset + (curr - pptr) * 32 + i - start;
156
156
sbi->free_blocks -= *max;
157
157
hfsplus_mark_mdb_dirty(sb);
158
-
hfs_dbg(BITMAP, "-> %u,%u\n", start, *max);
158
+
hfs_dbg("start %u, max %u\n", start, *max);
159
159
out:
160
160
mutex_unlock(&sbi->alloc_mutex);
161
161
return start;
···
174
174
if (!count)
175
175
return 0;
176
176
177
-
hfs_dbg(BITMAP, "block_free: %u,%u\n", offset, count);
177
+
hfs_dbg("offset %u, count %u\n", offset, count);
178
178
/* are all of the bits in range? */
179
179
if ((offset + count) > sbi->total_blocks)
180
180
return -ENOENT;
+14
-14
fs/hfsplus/bnode.c
+14
-14
fs/hfsplus/bnode.c
···
173
173
struct page **src_page, **dst_page;
174
174
int l;
175
175
176
-
hfs_dbg(BNODE_MOD, "copybytes: %u,%u,%u\n", dst, src, len);
176
+
hfs_dbg("dst %u, src %u, len %u\n", dst, src, len);
177
177
if (!len)
178
178
return;
179
179
···
231
231
void *src_ptr, *dst_ptr;
232
232
int l;
233
233
234
-
hfs_dbg(BNODE_MOD, "movebytes: %u,%u,%u\n", dst, src, len);
234
+
hfs_dbg("dst %u, src %u, len %u\n", dst, src, len);
235
235
if (!len)
236
236
return;
237
237
···
351
351
__be32 cnid;
352
352
int i, off, key_off;
353
353
354
-
hfs_dbg(BNODE_MOD, "bnode: %d\n", node->this);
354
+
hfs_dbg("node %d\n", node->this);
355
355
hfs_bnode_read(node, &desc, 0, sizeof(desc));
356
-
hfs_dbg(BNODE_MOD, "%d, %d, %d, %d, %d\n",
356
+
hfs_dbg("next %d, prev %d, type %d, height %d, num_recs %d\n",
357
357
be32_to_cpu(desc.next), be32_to_cpu(desc.prev),
358
358
desc.type, desc.height, be16_to_cpu(desc.num_recs));
359
359
360
360
off = node->tree->node_size - 2;
361
361
for (i = be16_to_cpu(desc.num_recs); i >= 0; off -= 2, i--) {
362
362
key_off = hfs_bnode_read_u16(node, off);
363
-
hfs_dbg(BNODE_MOD, " %d", key_off);
363
+
hfs_dbg(" key_off %d", key_off);
364
364
if (i && node->type == HFS_NODE_INDEX) {
365
365
int tmp;
366
366
···
369
369
tmp = hfs_bnode_read_u16(node, key_off) + 2;
370
370
else
371
371
tmp = node->tree->max_key_len + 2;
372
-
hfs_dbg_cont(BNODE_MOD, " (%d", tmp);
372
+
hfs_dbg(" (%d", tmp);
373
373
hfs_bnode_read(node, &cnid, key_off + tmp, 4);
374
-
hfs_dbg_cont(BNODE_MOD, ",%d)", be32_to_cpu(cnid));
374
+
hfs_dbg(", cnid %d)", be32_to_cpu(cnid));
375
375
} else if (i && node->type == HFS_NODE_LEAF) {
376
376
int tmp;
377
377
378
378
tmp = hfs_bnode_read_u16(node, key_off);
379
-
hfs_dbg_cont(BNODE_MOD, " (%d)", tmp);
379
+
hfs_dbg(" (%d)", tmp);
380
380
}
381
381
}
382
-
hfs_dbg_cont(BNODE_MOD, "\n");
382
+
hfs_dbg("\n");
383
383
}
384
384
385
385
void hfs_bnode_unlink(struct hfs_bnode *node)
···
415
415
416
416
/* move down? */
417
417
if (!node->prev && !node->next)
418
-
hfs_dbg(BNODE_MOD, "hfs_btree_del_level\n");
418
+
hfs_dbg("btree delete level\n");
419
419
if (!node->parent) {
420
420
tree->root = 0;
421
421
tree->depth = 0;
···
470
470
node->this = cnid;
471
471
set_bit(HFS_BNODE_NEW, &node->flags);
472
472
atomic_set(&node->refcnt, 1);
473
-
hfs_dbg(BNODE_REFS, "new_node(%d:%d): 1\n",
473
+
hfs_dbg("cnid %d, node %d, refcnt 1\n",
474
474
node->tree->cnid, node->this);
475
475
init_waitqueue_head(&node->lock_wq);
476
476
spin_lock(&tree->hash_lock);
···
510
510
{
511
511
struct hfs_bnode **p;
512
512
513
-
hfs_dbg(BNODE_REFS, "remove_node(%d:%d): %d\n",
513
+
hfs_dbg("cnid %d, node %d, refcnt %d\n",
514
514
node->tree->cnid, node->this, atomic_read(&node->refcnt));
515
515
for (p = &node->tree->node_hash[hfs_bnode_hash(node->this)];
516
516
*p && *p != node; p = &(*p)->next_hash)
···
656
656
{
657
657
if (node) {
658
658
atomic_inc(&node->refcnt);
659
-
hfs_dbg(BNODE_REFS, "get_node(%d:%d): %d\n",
659
+
hfs_dbg("cnid %d, node %d, refcnt %d\n",
660
660
node->tree->cnid, node->this,
661
661
atomic_read(&node->refcnt));
662
662
}
···
669
669
struct hfs_btree *tree = node->tree;
670
670
int i;
671
671
672
-
hfs_dbg(BNODE_REFS, "put_node(%d:%d): %d\n",
672
+
hfs_dbg("cnid %d, node %d, refcnt %d\n",
673
673
node->tree->cnid, node->this,
674
674
atomic_read(&node->refcnt));
675
675
BUG_ON(!atomic_read(&node->refcnt));
+5
-5
fs/hfsplus/brec.c
+5
-5
fs/hfsplus/brec.c
···
92
92
end_rec_off = tree->node_size - (node->num_recs + 1) * 2;
93
93
end_off = hfs_bnode_read_u16(node, end_rec_off);
94
94
end_rec_off -= 2;
95
-
hfs_dbg(BNODE_MOD, "insert_rec: %d, %d, %d, %d\n",
95
+
hfs_dbg("rec %d, size %d, end_off %d, end_rec_off %d\n",
96
96
rec, size, end_off, end_rec_off);
97
97
if (size > end_rec_off - end_off) {
98
98
if (new_node)
···
193
193
mark_inode_dirty(tree->inode);
194
194
}
195
195
hfs_bnode_dump(node);
196
-
hfs_dbg(BNODE_MOD, "remove_rec: %d, %d\n",
196
+
hfs_dbg("rec %d, len %d\n",
197
197
fd->record, fd->keylength + fd->entrylength);
198
198
if (!--node->num_recs) {
199
199
hfs_bnode_unlink(node);
···
246
246
if (IS_ERR(new_node))
247
247
return new_node;
248
248
hfs_bnode_get(node);
249
-
hfs_dbg(BNODE_MOD, "split_nodes: %d - %d - %d\n",
249
+
hfs_dbg("this %d - new %d - next %d\n",
250
250
node->this, new_node->this, node->next);
251
251
new_node->next = node->next;
252
252
new_node->prev = node->this;
···
383
383
newkeylen = hfs_bnode_read_u16(node, 14) + 2;
384
384
else
385
385
fd->keylength = newkeylen = tree->max_key_len + 2;
386
-
hfs_dbg(BNODE_MOD, "update_rec: %d, %d, %d\n",
386
+
hfs_dbg("rec %d, keylength %d, newkeylen %d\n",
387
387
rec, fd->keylength, newkeylen);
388
388
389
389
rec_off = tree->node_size - (rec + 2) * 2;
···
395
395
end_off = hfs_bnode_read_u16(parent, end_rec_off);
396
396
if (end_rec_off - end_off < diff) {
397
397
398
-
hfs_dbg(BNODE_MOD, "splitting index node\n");
398
+
hfs_dbg("splitting index node\n");
399
399
fd->bnode = parent;
400
400
new_node = hfs_bnode_split(fd);
401
401
if (IS_ERR(new_node))
+2
-2
fs/hfsplus/btree.c
+2
-2
fs/hfsplus/btree.c
···
434
434
kunmap_local(data);
435
435
nidx = node->next;
436
436
if (!nidx) {
437
-
hfs_dbg(BNODE_MOD, "create new bmap node\n");
437
+
hfs_dbg("create new bmap node\n");
438
438
next_node = hfs_bmap_new_bmap(node, idx);
439
439
} else
440
440
next_node = hfs_bnode_find(tree, nidx);
···
460
460
u32 nidx;
461
461
u8 *data, byte, m;
462
462
463
-
hfs_dbg(BNODE_MOD, "btree_free_node: %u\n", node->this);
463
+
hfs_dbg("node %u\n", node->this);
464
464
BUG_ON(!node->this);
465
465
tree = node->tree;
466
466
nidx = node->this;
+3
-3
fs/hfsplus/catalog.c
+3
-3
fs/hfsplus/catalog.c
···
259
259
int entry_size;
260
260
int err;
261
261
262
-
hfs_dbg(CAT_MOD, "create_cat: %s,%u(%d)\n",
262
+
hfs_dbg("name %s, cnid %u, i_nlink %d\n",
263
263
str->name, cnid, inode->i_nlink);
264
264
err = hfs_find_init(HFSPLUS_SB(sb)->cat_tree, &fd);
265
265
if (err)
···
336
336
int err, off;
337
337
u16 type;
338
338
339
-
hfs_dbg(CAT_MOD, "delete_cat: %s,%u\n", str ? str->name : NULL, cnid);
339
+
hfs_dbg("name %s, cnid %u\n", str ? str->name : NULL, cnid);
340
340
err = hfs_find_init(HFSPLUS_SB(sb)->cat_tree, &fd);
341
341
if (err)
342
342
return err;
···
441
441
int entry_size, type;
442
442
int err;
443
443
444
-
hfs_dbg(CAT_MOD, "rename_cat: %u - %lu,%s - %lu,%s\n",
444
+
hfs_dbg("cnid %u - ino %lu, name %s - ino %lu, name %s\n",
445
445
cnid, src_dir->i_ino, src_name->name,
446
446
dst_dir->i_ino, dst_name->name);
447
447
err = hfs_find_init(HFSPLUS_SB(sb)->cat_tree, &src_fd);
+13
-14
fs/hfsplus/extents.c
+13
-14
fs/hfsplus/extents.c
···
275
275
mutex_unlock(&hip->extents_lock);
276
276
277
277
done:
278
-
hfs_dbg(EXTENT, "get_block(%lu): %llu - %u\n",
278
+
hfs_dbg("ino %lu, iblock %llu - dblock %u\n",
279
279
inode->i_ino, (long long)iblock, dblock);
280
280
281
281
mask = (1 << sbi->fs_shift) - 1;
···
298
298
{
299
299
int i;
300
300
301
-
hfs_dbg(EXTENT, " ");
301
+
hfs_dbg("extent ");
302
302
for (i = 0; i < 8; i++)
303
-
hfs_dbg_cont(EXTENT, " %u:%u",
304
-
be32_to_cpu(extent[i].start_block),
305
-
be32_to_cpu(extent[i].block_count));
306
-
hfs_dbg_cont(EXTENT, "\n");
303
+
hfs_dbg(" start_block %u, block_count %u",
304
+
be32_to_cpu(extent[i].start_block),
305
+
be32_to_cpu(extent[i].block_count));
306
+
hfs_dbg("\n");
307
307
}
308
308
309
309
static int hfsplus_add_extent(struct hfsplus_extent *extent, u32 offset,
···
359
359
if (count <= block_nr) {
360
360
err = hfsplus_block_free(sb, start, count);
361
361
if (err) {
362
-
pr_err("can't free extent\n");
363
-
hfs_dbg(EXTENT, " start: %u count: %u\n",
362
+
pr_err("can't free extent: start %u, count %u\n",
364
363
start, count);
365
364
}
366
365
extent->block_count = 0;
···
369
370
count -= block_nr;
370
371
err = hfsplus_block_free(sb, start + count, block_nr);
371
372
if (err) {
372
-
pr_err("can't free extent\n");
373
-
hfs_dbg(EXTENT, " start: %u count: %u\n",
373
+
pr_err("can't free extent: start %u, count %u\n",
374
374
start, count);
375
375
}
376
376
extent->block_count = cpu_to_be32(count);
···
476
478
goto out;
477
479
}
478
480
479
-
hfs_dbg(EXTENT, "extend %lu: %u,%u\n", inode->i_ino, start, len);
481
+
hfs_dbg("ino %lu, start %u, len %u\n", inode->i_ino, start, len);
480
482
481
483
if (hip->alloc_blocks <= hip->first_blocks) {
482
484
if (!hip->first_blocks) {
483
-
hfs_dbg(EXTENT, "first extents\n");
485
+
hfs_dbg("first_extent: start %u, len %u\n",
486
+
start, len);
484
487
/* no extents yet */
485
488
hip->first_extents[0].start_block = cpu_to_be32(start);
486
489
hip->first_extents[0].block_count = cpu_to_be32(len);
···
520
521
return res;
521
522
522
523
insert_extent:
523
-
hfs_dbg(EXTENT, "insert new extent\n");
524
+
hfs_dbg("insert new extent\n");
524
525
res = hfsplus_ext_write_extent_locked(inode);
525
526
if (res)
526
527
goto out;
···
545
546
u32 alloc_cnt, blk_cnt, start;
546
547
int res;
547
548
548
-
hfs_dbg(INODE, "truncate: %lu, %llu -> %llu\n",
549
+
hfs_dbg("ino %lu, phys_size %llu -> i_size %llu\n",
549
550
inode->i_ino, (long long)hip->phys_size, inode->i_size);
550
551
551
552
if (inode->i_size > hip->phys_size) {
+1
-34
fs/hfsplus/hfsplus_fs.h
+1
-34
fs/hfsplus/hfsplus_fs.h
···
11
11
#ifndef _LINUX_HFSPLUS_FS_H
12
12
#define _LINUX_HFSPLUS_FS_H
13
13
14
-
#ifdef pr_fmt
15
-
#undef pr_fmt
16
-
#endif
17
-
18
-
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
19
-
20
14
#include <linux/fs.h>
21
15
#include <linux/mutex.h>
22
16
#include <linux/buffer_head.h>
23
17
#include <linux/blkdev.h>
24
18
#include <linux/fs_context.h>
19
+
#include <linux/hfs_common.h>
25
20
#include "hfsplus_raw.h"
26
-
27
-
#define DBG_BNODE_REFS 0x00000001
28
-
#define DBG_BNODE_MOD 0x00000002
29
-
#define DBG_CAT_MOD 0x00000004
30
-
#define DBG_INODE 0x00000008
31
-
#define DBG_SUPER 0x00000010
32
-
#define DBG_EXTENT 0x00000020
33
-
#define DBG_BITMAP 0x00000040
34
-
#define DBG_ATTR_MOD 0x00000080
35
-
36
-
#if 0
37
-
#define DBG_MASK (DBG_EXTENT|DBG_INODE|DBG_BNODE_MOD)
38
-
#define DBG_MASK (DBG_BNODE_MOD|DBG_CAT_MOD|DBG_INODE)
39
-
#define DBG_MASK (DBG_CAT_MOD|DBG_BNODE_REFS|DBG_INODE|DBG_EXTENT)
40
-
#endif
41
-
#define DBG_MASK (0)
42
-
43
-
#define hfs_dbg(flg, fmt, ...) \
44
-
do { \
45
-
if (DBG_##flg & DBG_MASK) \
46
-
printk(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__); \
47
-
} while (0)
48
-
49
-
#define hfs_dbg_cont(flg, fmt, ...) \
50
-
do { \
51
-
if (DBG_##flg & DBG_MASK) \
52
-
pr_cont(fmt, ##__VA_ARGS__); \
53
-
} while (0)
54
21
55
22
/* Runtime config options */
56
23
#define HFSPLUS_DEF_CR_TYPE 0x3F3F3F3F /* '????' */
+12
-4
fs/hfsplus/super.c
+12
-4
fs/hfsplus/super.c
···
163
163
{
164
164
int err;
165
165
166
-
hfs_dbg(INODE, "hfsplus_write_inode: %lu\n", inode->i_ino);
166
+
hfs_dbg("ino %lu\n", inode->i_ino);
167
167
168
168
err = hfsplus_ext_write_extent(inode);
169
169
if (err)
···
178
178
179
179
static void hfsplus_evict_inode(struct inode *inode)
180
180
{
181
-
hfs_dbg(INODE, "hfsplus_evict_inode: %lu\n", inode->i_ino);
181
+
hfs_dbg("ino %lu\n", inode->i_ino);
182
182
truncate_inode_pages_final(&inode->i_data);
183
183
clear_inode(inode);
184
184
if (HFSPLUS_IS_RSRC(inode)) {
···
197
197
if (!wait)
198
198
return 0;
199
199
200
-
hfs_dbg(SUPER, "hfsplus_sync_fs\n");
200
+
hfs_dbg("starting...\n");
201
201
202
202
/*
203
203
* Explicitly write out the special metadata inodes.
···
228
228
vhdr->folder_count = cpu_to_be32(sbi->folder_count);
229
229
vhdr->file_count = cpu_to_be32(sbi->file_count);
230
230
231
+
hfs_dbg("free_blocks %u, next_cnid %u, folder_count %u, file_count %u\n",
232
+
sbi->free_blocks, sbi->next_cnid,
233
+
sbi->folder_count, sbi->file_count);
234
+
231
235
if (test_and_clear_bit(HFSPLUS_SB_WRITEBACKUP, &sbi->flags)) {
232
236
memcpy(sbi->s_backup_vhdr, sbi->s_vhdr, sizeof(*sbi->s_vhdr));
233
237
write_backup = 1;
···
256
252
257
253
if (!test_bit(HFSPLUS_SB_NOBARRIER, &sbi->flags))
258
254
blkdev_issue_flush(sb->s_bdev);
255
+
256
+
hfs_dbg("finished: err %d\n", error);
259
257
260
258
return error;
261
259
}
···
307
301
{
308
302
struct hfsplus_sb_info *sbi = HFSPLUS_SB(sb);
309
303
310
-
hfs_dbg(SUPER, "hfsplus_put_super\n");
304
+
hfs_dbg("starting...\n");
311
305
312
306
cancel_delayed_work_sync(&sbi->sync_work);
313
307
···
329
323
kfree(sbi->s_vhdr_buf);
330
324
kfree(sbi->s_backup_vhdr_buf);
331
325
call_rcu(&sbi->rcu, delayed_free);
326
+
327
+
hfs_dbg("finished\n");
332
328
}
333
329
334
330
static int hfsplus_statfs(struct dentry *dentry, struct kstatfs *buf)
+2
-2
fs/hfsplus/xattr.c
+2
-2
fs/hfsplus/xattr.c
···
64
64
u32 used_bmp_bytes;
65
65
u64 tmp;
66
66
67
-
hfs_dbg(ATTR_MOD, "init_hdr_attr_file: clump %u, node_size %u\n",
67
+
hfs_dbg("clump %u, node_size %u\n",
68
68
clump_size, node_size);
69
69
70
70
/* The end of the node contains list of record offsets */
···
132
132
struct page *page;
133
133
int old_state = HFSPLUS_EMPTY_ATTR_TREE;
134
134
135
-
hfs_dbg(ATTR_MOD, "create_attr_file: ino %d\n", HFSPLUS_ATTR_CNID);
135
+
hfs_dbg("ino %d\n", HFSPLUS_ATTR_CNID);
136
136
137
137
check_attr_tree_state_again:
138
138
switch (atomic_read(&sbi->attr_tree_state)) {
+20
include/linux/hfs_common.h
+20
include/linux/hfs_common.h
···
1
+
/* SPDX-License-Identifier: GPL-2.0 */
2
+
/*
3
+
* HFS/HFS+ common definitions, inline functions,
4
+
* and shared functionality.
5
+
*/
6
+
7
+
#ifndef _HFS_COMMON_H_
8
+
#define _HFS_COMMON_H_
9
+
10
+
#ifdef pr_fmt
11
+
#undef pr_fmt
12
+
#endif
13
+
14
+
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
15
+
16
+
#define hfs_dbg(fmt, ...) \
17
+
pr_debug("pid %d:%s:%d %s(): " fmt, \
18
+
current->pid, __FILE__, __LINE__, __func__, ##__VA_ARGS__) \
19
+
20
+
#endif /* _HFS_COMMON_H_ */