hollalinux
/
linux-sg2042
mirror of https://github.com/sophgo/linux-riscv.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

hfsplus: over 80 character lines clean-up 

Match coding style line length limitation where checkpatch.pl
reported over-80-character-line warnings.

Signed-off-by: Anton Salikhmetov <alexo@tuxera.com>
Signed-off-by: Christoph Hellwig <hch@tuxera.com>
This commit is contained in:
Anton Salikhmetov 2010-12-16 18:08:38 +02:00 committed by Christoph Hellwig
parent 596276c357
commit 2753cc281c
16 changed files with 260 additions and 123 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
fs/hfsplus/bfind.c
View File

@ -22,7 +22,8 @@ int hfs_find_init(struct hfs_btree *tree, struct hfs_find_data *fd)
return -ENOMEM; return -ENOMEM;
fd->search_key = ptr; fd->search_key = ptr;
fd->key = ptr + tree->max_key_len + 2; fd->key = ptr + tree->max_key_len + 2;
dprint(DBG_BNODE_REFS, "find_init: %d (%p)\n", tree->cnid, __builtin_return_address(0)); dprint(DBG_BNODE_REFS, "find_init: %d (%p)\n",
tree->cnid, __builtin_return_address(0));
mutex_lock(&tree->tree_lock); mutex_lock(&tree->tree_lock);
return 0; return 0;
} }
@ -31,7 +32,8 @@ void hfs_find_exit(struct hfs_find_data *fd)
{ {
hfs_bnode_put(fd->bnode); hfs_bnode_put(fd->bnode);
kfree(fd->search_key); kfree(fd->search_key);
dprint(DBG_BNODE_REFS, "find_exit: %d (%p)\n", fd->tree->cnid, __builtin_return_address(0)); dprint(DBG_BNODE_REFS, "find_exit: %d (%p)\n",
fd->tree->cnid, __builtin_return_address(0));
mutex_unlock(&fd->tree->tree_lock); mutex_unlock(&fd->tree->tree_lock);
fd->tree = NULL; fd->tree = NULL;
} }

3
fs/hfsplus/bitmap.c
View File

@ -15,7 +15,8 @@
#define PAGE_CACHE_BITS (PAGE_CACHE_SIZE * 8) #define PAGE_CACHE_BITS (PAGE_CACHE_SIZE * 8)
int hfsplus_block_allocate(struct super_block *sb, u32 size, u32 offset, u32 *max) int hfsplus_block_allocate(struct super_block *sb, u32 size,
u32 offset, u32 *max)
{ {
struct hfsplus_sb_info *sbi = HFSPLUS_SB(sb); struct hfsplus_sb_info *sbi = HFSPLUS_SB(sb);
struct page *page; struct page *page;

41
fs/hfsplus/bnode.c
View File

@ -212,7 +212,8 @@ void hfs_bnode_move(struct hfs_bnode *node, int dst, int src, int len)
dst_page--; dst_page--;
} }
src -= len; src -= len;
memmove(kmap(*dst_page) + src, kmap(*src_page) + src, len); memmove(kmap(*dst_page) + src,
kmap(*src_page) + src, len);
kunmap(*src_page); kunmap(*src_page);
set_page_dirty(*dst_page); set_page_dirty(*dst_page);
kunmap(*dst_page); kunmap(*dst_page);
@ -250,14 +251,16 @@ void hfs_bnode_move(struct hfs_bnode *node, int dst, int src, int len)
if (src == dst) { if (src == dst) {
l = min(len, (int)PAGE_CACHE_SIZE - src); l = min(len, (int)PAGE_CACHE_SIZE - src);
memmove(kmap(*dst_page) + src, kmap(*src_page) + src, l); memmove(kmap(*dst_page) + src,
kmap(*src_page) + src, l);
kunmap(*src_page); kunmap(*src_page);
set_page_dirty(*dst_page); set_page_dirty(*dst_page);
kunmap(*dst_page); kunmap(*dst_page);
while ((len -= l) != 0) { while ((len -= l) != 0) {
l = min(len, (int)PAGE_CACHE_SIZE); l = min(len, (int)PAGE_CACHE_SIZE);
memmove(kmap(*++dst_page), kmap(*++src_page), l); memmove(kmap(*++dst_page),
kmap(*++src_page), l);
kunmap(*src_page); kunmap(*src_page);
set_page_dirty(*dst_page); set_page_dirty(*dst_page);
kunmap(*dst_page); kunmap(*dst_page);
@ -268,7 +271,8 @@ void hfs_bnode_move(struct hfs_bnode *node, int dst, int src, int len)
do { do {
src_ptr = kmap(*src_page) + src; src_ptr = kmap(*src_page) + src;
dst_ptr = kmap(*dst_page) + dst; dst_ptr = kmap(*dst_page) + dst;
if (PAGE_CACHE_SIZE - src < PAGE_CACHE_SIZE - dst) { if (PAGE_CACHE_SIZE - src <
PAGE_CACHE_SIZE - dst) {
l = PAGE_CACHE_SIZE - src; l = PAGE_CACHE_SIZE - src;
src = 0; src = 0;
dst += l; dst += l;
@ -340,7 +344,8 @@ void hfs_bnode_unlink(struct hfs_bnode *node)
return; return;
tmp->next = node->next; tmp->next = node->next;
cnid = cpu_to_be32(tmp->next); cnid = cpu_to_be32(tmp->next);
hfs_bnode_write(tmp, &cnid, offsetof(struct hfs_bnode_desc, next), 4); hfs_bnode_write(tmp, &cnid,
offsetof(struct hfs_bnode_desc, next), 4);
hfs_bnode_put(tmp); hfs_bnode_put(tmp);
} else if (node->type == HFS_NODE_LEAF) } else if (node->type == HFS_NODE_LEAF)
tree->leaf_head = node->next; tree->leaf_head = node->next;
@ -351,7 +356,8 @@ void hfs_bnode_unlink(struct hfs_bnode *node)
return; return;
tmp->prev = node->prev; tmp->prev = node->prev;
cnid = cpu_to_be32(tmp->prev); cnid = cpu_to_be32(tmp->prev);
hfs_bnode_write(tmp, &cnid, offsetof(struct hfs_bnode_desc, prev), 4); hfs_bnode_write(tmp, &cnid,
offsetof(struct hfs_bnode_desc, prev), 4);
hfs_bnode_put(tmp); hfs_bnode_put(tmp);
} else if (node->type == HFS_NODE_LEAF) } else if (node->type == HFS_NODE_LEAF)
tree->leaf_tail = node->prev; tree->leaf_tail = node->prev;
@ -379,7 +385,9 @@ struct hfs_bnode *hfs_bnode_findhash(struct hfs_btree *tree, u32 cnid)
struct hfs_bnode *node; struct hfs_bnode *node;
if (cnid >= tree->node_count) { if (cnid >= tree->node_count) {
printk(KERN_ERR "hfs: request for non-existent node %d in B*Tree\n", cnid); printk(KERN_ERR "hfs: request for non-existent node "
"%d in B*Tree\n",
cnid);
return NULL; return NULL;
} }
@ -402,7 +410,9 @@ static struct hfs_bnode *__hfs_bnode_create(struct hfs_btree *tree, u32 cnid)
loff_t off; loff_t off;
if (cnid >= tree->node_count) { if (cnid >= tree->node_count) {
printk(KERN_ERR "hfs: request for non-existent node %d in B*Tree\n", cnid); printk(KERN_ERR "hfs: request for non-existent node "
"%d in B*Tree\n",
cnid);
return NULL; return NULL;
} }
@ -429,7 +439,8 @@ static struct hfs_bnode *__hfs_bnode_create(struct hfs_btree *tree, u32 cnid)
} else { } else {
spin_unlock(&tree->hash_lock); spin_unlock(&tree->hash_lock);
kfree(node); kfree(node);
wait_event(node2->lock_wq, !test_bit(HFS_BNODE_NEW, &node2->flags)); wait_event(node2->lock_wq,
!test_bit(HFS_BNODE_NEW, &node2->flags));
return node2; return node2;
} }
spin_unlock(&tree->hash_lock); spin_unlock(&tree->hash_lock);
@ -483,7 +494,8 @@ struct hfs_bnode *hfs_bnode_find(struct hfs_btree *tree, u32 num)
if (node) { if (node) {
hfs_bnode_get(node); hfs_bnode_get(node);
spin_unlock(&tree->hash_lock); spin_unlock(&tree->hash_lock);
wait_event(node->lock_wq, !test_bit(HFS_BNODE_NEW, &node->flags)); wait_event(node->lock_wq,
!test_bit(HFS_BNODE_NEW, &node->flags));
if (test_bit(HFS_BNODE_ERROR, &node->flags)) if (test_bit(HFS_BNODE_ERROR, &node->flags))
goto node_error; goto node_error;
return node; return node;
@ -497,7 +509,8 @@ struct hfs_bnode *hfs_bnode_find(struct hfs_btree *tree, u32 num)
if (!test_bit(HFS_BNODE_NEW, &node->flags)) if (!test_bit(HFS_BNODE_NEW, &node->flags))
return node; return node;
desc = (struct hfs_bnode_desc *)(kmap(node->page[0]) + node->page_offset); desc = (struct hfs_bnode_desc *)(kmap(node->page[0]) +
node->page_offset);
node->prev = be32_to_cpu(desc->prev); node->prev = be32_to_cpu(desc->prev);
node->next = be32_to_cpu(desc->next); node->next = be32_to_cpu(desc->next);
node->num_recs = be16_to_cpu(desc->num_recs); node->num_recs = be16_to_cpu(desc->num_recs);
@ -607,7 +620,8 @@ void hfs_bnode_get(struct hfs_bnode *node)
if (node) { if (node) {
atomic_inc(&node->refcnt); atomic_inc(&node->refcnt);
dprint(DBG_BNODE_REFS, "get_node(%d:%d): %d\n", dprint(DBG_BNODE_REFS, "get_node(%d:%d): %d\n",
node->tree->cnid, node->this, atomic_read(&node->refcnt)); node->tree->cnid, node->this,
atomic_read(&node->refcnt));
} }
} }
@ -619,7 +633,8 @@ void hfs_bnode_put(struct hfs_bnode *node)
int i; int i;
dprint(DBG_BNODE_REFS, "put_node(%d:%d): %d\n", dprint(DBG_BNODE_REFS, "put_node(%d:%d): %d\n",
node->tree->cnid, node->this, atomic_read(&node->refcnt)); node->tree->cnid, node->this,
atomic_read(&node->refcnt));
BUG_ON(!atomic_read(&node->refcnt)); BUG_ON(!atomic_read(&node->refcnt));
if (!atomic_dec_and_lock(&node->refcnt, &tree->hash_lock)) if (!atomic_dec_and_lock(&node->refcnt, &tree->hash_lock))
return; return;

26
fs/hfsplus/brec.c
View File

@ -39,7 +39,8 @@ u16 hfs_brec_keylen(struct hfs_bnode *node, u16 rec)
!(node->tree->attributes & HFS_TREE_VARIDXKEYS)) { !(node->tree->attributes & HFS_TREE_VARIDXKEYS)) {
retval = node->tree->max_key_len + 2; retval = node->tree->max_key_len + 2;
} else { } else {
recoff = hfs_bnode_read_u16(node, node->tree->node_size - (rec + 1) * 2); recoff = hfs_bnode_read_u16(node,
node->tree->node_size - (rec + 1) * 2);
if (!recoff) if (!recoff)
return 0; return 0;
@ -84,7 +85,8 @@ again:
end_rec_off = tree->node_size - (node->num_recs + 1) * 2; end_rec_off = tree->node_size - (node->num_recs + 1) * 2;
end_off = hfs_bnode_read_u16(node, end_rec_off); end_off = hfs_bnode_read_u16(node, end_rec_off);
end_rec_off -= 2; end_rec_off -= 2;
dprint(DBG_BNODE_MOD, "insert_rec: %d, %d, %d, %d\n", rec, size, end_off, end_rec_off); dprint(DBG_BNODE_MOD, "insert_rec: %d, %d, %d, %d\n",
rec, size, end_off, end_rec_off);
if (size > end_rec_off - end_off) { if (size > end_rec_off - end_off) {
if (new_node) if (new_node)
panic("not enough room!\n"); panic("not enough room!\n");
@ -99,7 +101,9 @@ again:
} }
node->num_recs++; node->num_recs++;
/* write new last offset */ /* write new last offset */
hfs_bnode_write_u16(node, offsetof(struct hfs_bnode_desc, num_recs), node->num_recs); hfs_bnode_write_u16(node,
offsetof(struct hfs_bnode_desc, num_recs),
node->num_recs);
hfs_bnode_write_u16(node, end_rec_off, end_off + size); hfs_bnode_write_u16(node, end_rec_off, end_off + size);
data_off = end_off; data_off = end_off;
data_rec_off = end_rec_off + 2; data_rec_off = end_rec_off + 2;
@ -151,7 +155,8 @@ skip:
if (tree->attributes & HFS_TREE_VARIDXKEYS) if (tree->attributes & HFS_TREE_VARIDXKEYS)
key_len = be16_to_cpu(fd->search_key->key_len) + 2; key_len = be16_to_cpu(fd->search_key->key_len) + 2;
else { else {
fd->search_key->key_len = cpu_to_be16(tree->max_key_len); fd->search_key->key_len =
cpu_to_be16(tree->max_key_len);
key_len = tree->max_key_len + 2; key_len = tree->max_key_len + 2;
} }
goto again; goto again;
@ -180,7 +185,8 @@ again:
mark_inode_dirty(tree->inode); mark_inode_dirty(tree->inode);
} }
hfs_bnode_dump(node); hfs_bnode_dump(node);
dprint(DBG_BNODE_MOD, "remove_rec: %d, %d\n", fd->record, fd->keylength + fd->entrylength); dprint(DBG_BNODE_MOD, "remove_rec: %d, %d\n",
fd->record, fd->keylength + fd->entrylength);
if (!--node->num_recs) { if (!--node->num_recs) {
hfs_bnode_unlink(node); hfs_bnode_unlink(node);
if (!node->parent) if (!node->parent)
@ -194,7 +200,9 @@ again:
__hfs_brec_find(node, fd); __hfs_brec_find(node, fd);
goto again; goto again;
} }
hfs_bnode_write_u16(node, offsetof(struct hfs_bnode_desc, num_recs), node->num_recs); hfs_bnode_write_u16(node,
offsetof(struct hfs_bnode_desc, num_recs),
node->num_recs);
if (rec_off == end_off) if (rec_off == end_off)
goto skip; goto skip;
@ -364,7 +372,8 @@ again:
newkeylen = hfs_bnode_read_u16(node, 14) + 2; newkeylen = hfs_bnode_read_u16(node, 14) + 2;
else else
fd->keylength = newkeylen = tree->max_key_len + 2; fd->keylength = newkeylen = tree->max_key_len + 2;
dprint(DBG_BNODE_MOD, "update_rec: %d, %d, %d\n", rec, fd->keylength, newkeylen); dprint(DBG_BNODE_MOD, "update_rec: %d, %d, %d\n",
rec, fd->keylength, newkeylen);
rec_off = tree->node_size - (rec + 2) * 2; rec_off = tree->node_size - (rec + 2) * 2;
end_rec_off = tree->node_size - (parent->num_recs + 1) * 2; end_rec_off = tree->node_size - (parent->num_recs + 1) * 2;
@ -383,7 +392,8 @@ again:
parent = fd->bnode; parent = fd->bnode;
rec = fd->record; rec = fd->record;
rec_off = tree->node_size - (rec + 2) * 2; rec_off = tree->node_size - (rec + 2) * 2;
end_rec_off = tree->node_size - (parent->num_recs + 1) * 2; end_rec_off = tree->node_size -
(parent->num_recs + 1) * 2;
} }
} }

31
fs/hfsplus/btree.c
View File

@ -51,7 +51,8 @@ struct hfs_btree *hfs_btree_open(struct super_block *sb, u32 id)
goto free_inode; goto free_inode;
/* Load the header */ /* Load the header */
head = (struct hfs_btree_header_rec *)(kmap(page) + sizeof(struct hfs_bnode_desc)); head = (struct hfs_btree_header_rec *)(kmap(page) +
sizeof(struct hfs_bnode_desc));
tree->root = be32_to_cpu(head->root); tree->root = be32_to_cpu(head->root);
tree->leaf_count = be32_to_cpu(head->leaf_count); tree->leaf_count = be32_to_cpu(head->leaf_count);
tree->leaf_head = be32_to_cpu(head->leaf_head); tree->leaf_head = be32_to_cpu(head->leaf_head);
@ -115,7 +116,9 @@ struct hfs_btree *hfs_btree_open(struct super_block *sb, u32 id)
tree->node_size_shift = ffs(size) - 1; tree->node_size_shift = ffs(size) - 1;
tree->pages_per_bnode = (tree->node_size + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT; tree->pages_per_bnode =
(tree->node_size + PAGE_CACHE_SIZE - 1) >>
PAGE_CACHE_SHIFT;
kunmap(page); kunmap(page);
page_cache_release(page); page_cache_release(page);
@ -144,8 +147,10 @@ void hfs_btree_close(struct hfs_btree *tree)
while ((node = tree->node_hash[i])) { while ((node = tree->node_hash[i])) {
tree->node_hash[i] = node->next_hash; tree->node_hash[i] = node->next_hash;
if (atomic_read(&node->refcnt)) if (atomic_read(&node->refcnt))
printk(KERN_CRIT "hfs: node %d:%d still has %d user(s)!\n", printk(KERN_CRIT "hfs: node %d:%d "
node->tree->cnid, node->this, atomic_read(&node->refcnt)); "still has %d user(s)!\n",
node->tree->cnid, node->this,
atomic_read(&node->refcnt));
hfs_bnode_free(node); hfs_bnode_free(node);
tree->node_hash_cnt--; tree->node_hash_cnt--;
} }
@ -166,7 +171,8 @@ void hfs_btree_write(struct hfs_btree *tree)
return; return;
/* Load the header */ /* Load the header */
page = node->page[0]; page = node->page[0];
head = (struct hfs_btree_header_rec *)(kmap(page) + sizeof(struct hfs_bnode_desc)); head = (struct hfs_btree_header_rec *)(kmap(page) +
sizeof(struct hfs_bnode_desc));
head->root = cpu_to_be32(tree->root); head->root = cpu_to_be32(tree->root);
head->leaf_count = cpu_to_be32(tree->leaf_count); head->leaf_count = cpu_to_be32(tree->leaf_count);
@ -272,7 +278,8 @@ struct hfs_bnode *hfs_bmap_alloc(struct hfs_btree *tree)
tree->free_nodes--; tree->free_nodes--;
mark_inode_dirty(tree->inode); mark_inode_dirty(tree->inode);
hfs_bnode_put(node); hfs_bnode_put(node);
return hfs_bnode_create(tree, idx); return hfs_bnode_create(tree,
idx);
} }
} }
} }
@ -329,7 +336,9 @@ void hfs_bmap_free(struct hfs_bnode *node)
hfs_bnode_put(node); hfs_bnode_put(node);
if (!i) { if (!i) {
/* panic */; /* panic */;
printk(KERN_CRIT "hfs: unable to free bnode %u. bmap not found!\n", node->this); printk(KERN_CRIT "hfs: unable to free bnode %u. "
"bmap not found!\n",
node->this);
return; return;
} }
node = hfs_bnode_find(tree, i); node = hfs_bnode_find(tree, i);
@ -337,7 +346,9 @@ void hfs_bmap_free(struct hfs_bnode *node)
return; return;
if (node->type != HFS_NODE_MAP) { if (node->type != HFS_NODE_MAP) {
/* panic */; /* panic */;
printk(KERN_CRIT "hfs: invalid bmap found! (%u,%d)\n", node->this, node->type); printk(KERN_CRIT "hfs: invalid bmap found! "
"(%u,%d)\n",
node->this, node->type);
hfs_bnode_put(node); hfs_bnode_put(node);
return; return;
} }
@ -350,7 +361,9 @@ void hfs_bmap_free(struct hfs_bnode *node)
m = 1 << (~nidx & 7); m = 1 << (~nidx & 7);
byte = data[off]; byte = data[off];
if (!(byte & m)) { if (!(byte & m)) {
printk(KERN_CRIT "hfs: trying to free free bnode %u(%d)\n", node->this, node->type); printk(KERN_CRIT "hfs: trying to free free bnode "
"%u(%d)\n",
node->this, node->type);
kunmap(page); kunmap(page);
hfs_bnode_put(node); hfs_bnode_put(node);
return; return;

75
fs/hfsplus/catalog.c
View File

@ -91,7 +91,8 @@ void hfsplus_cat_set_perms(struct inode *inode, struct hfsplus_perm *perms)
perms->dev = 0; perms->dev = 0;
} }
static int hfsplus_cat_build_record(hfsplus_cat_entry *entry, u32 cnid, struct inode *inode) static int hfsplus_cat_build_record(hfsplus_cat_entry *entry,
u32 cnid, struct inode *inode)
{ {
struct hfsplus_sb_info *sbi = HFSPLUS_SB(inode->i_sb); struct hfsplus_sb_info *sbi = HFSPLUS_SB(inode->i_sb);
@ -128,20 +129,32 @@ static int hfsplus_cat_build_record(hfsplus_cat_entry *entry, u32 cnid, struct i
if (cnid == inode->i_ino) { if (cnid == inode->i_ino) {
hfsplus_cat_set_perms(inode, &file->permissions); hfsplus_cat_set_perms(inode, &file->permissions);
if (S_ISLNK(inode->i_mode)) { if (S_ISLNK(inode->i_mode)) {
file->user_info.fdType = cpu_to_be32(HFSP_SYMLINK_TYPE); file->user_info.fdType =
file->user_info.fdCreator = cpu_to_be32(HFSP_SYMLINK_CREATOR); cpu_to_be32(HFSP_SYMLINK_TYPE);
file->user_info.fdCreator =
cpu_to_be32(HFSP_SYMLINK_CREATOR);
} else { } else {
file->user_info.fdType = cpu_to_be32(sbi->type); file->user_info.fdType =
file->user_info.fdCreator = cpu_to_be32(sbi->creator); cpu_to_be32(sbi->type);
file->user_info.fdCreator =
cpu_to_be32(sbi->creator);
} }
if ((file->permissions.rootflags | file->permissions.userflags) & HFSPLUS_FLG_IMMUTABLE) if (HFSPLUS_FLG_IMMUTABLE &
file->flags |= cpu_to_be16(HFSPLUS_FILE_LOCKED); (file->permissions.rootflags |
file->permissions.userflags))
file->flags |=
cpu_to_be16(HFSPLUS_FILE_LOCKED);
} else { } else {
file->user_info.fdType = cpu_to_be32(HFSP_HARDLINK_TYPE); file->user_info.fdType =
file->user_info.fdCreator = cpu_to_be32(HFSP_HFSPLUS_CREATOR); cpu_to_be32(HFSP_HARDLINK_TYPE);
file->user_info.fdFlags = cpu_to_be16(0x100); file->user_info.fdCreator =
file->create_date = HFSPLUS_I(sbi->hidden_dir)->create_date; cpu_to_be32(HFSP_HFSPLUS_CREATOR);
file->permissions.dev = cpu_to_be32(HFSPLUS_I(inode)->linkid); file->user_info.fdFlags =
cpu_to_be16(0x100);
file->create_date =
HFSPLUS_I(sbi->hidden_dir)->create_date;
file->permissions.dev =
cpu_to_be32(HFSPLUS_I(inode)->linkid);
} }
return sizeof(*file); return sizeof(*file);
} }
@ -182,12 +195,14 @@ int hfsplus_find_cat(struct super_block *sb, u32 cnid,
return -EIO; return -EIO;
} }
hfsplus_cat_build_key_uni(fd->search_key, be32_to_cpu(tmp.thread.parentID), hfsplus_cat_build_key_uni(fd->search_key,
&tmp.thread.nodeName); be32_to_cpu(tmp.thread.parentID),
&tmp.thread.nodeName);
return hfs_brec_find(fd); return hfs_brec_find(fd);
} }
int hfsplus_create_cat(u32 cnid, struct inode *dir, struct qstr *str, struct inode *inode) int hfsplus_create_cat(u32 cnid, struct inode *dir,
struct qstr *str, struct inode *inode)
{ {
struct super_block *sb = dir->i_sb; struct super_block *sb = dir->i_sb;
struct hfs_find_data fd; struct hfs_find_data fd;
@ -195,13 +210,15 @@ int hfsplus_create_cat(u32 cnid, struct inode *dir, struct qstr *str, struct ino
int entry_size; int entry_size;
int err; int err;
dprint(DBG_CAT_MOD, "create_cat: %s,%u(%d)\n", str->name, cnid, inode->i_nlink); dprint(DBG_CAT_MOD, "create_cat: %s,%u(%d)\n",
str->name, cnid, inode->i_nlink);
hfs_find_init(HFSPLUS_SB(sb)->cat_tree, &fd); hfs_find_init(HFSPLUS_SB(sb)->cat_tree, &fd);
hfsplus_cat_build_key(sb, fd.search_key, cnid, NULL); hfsplus_cat_build_key(sb, fd.search_key, cnid, NULL);
entry_size = hfsplus_fill_cat_thread(sb, &entry, S_ISDIR(inode->i_mode) ? entry_size = hfsplus_fill_cat_thread(sb, &entry,
S_ISDIR(inode->i_mode) ?
HFSPLUS_FOLDER_THREAD : HFSPLUS_FILE_THREAD, HFSPLUS_FOLDER_THREAD : HFSPLUS_FILE_THREAD,
dir->i_ino, str); dir->i_ino, str);
err = hfs_brec_find(&fd); err = hfs_brec_find(&fd);
if (err != -ENOENT) { if (err != -ENOENT) {
if (!err) if (!err)
@ -250,7 +267,8 @@ int hfsplus_delete_cat(u32 cnid, struct inode *dir, struct qstr *str)
int err, off; int err, off;
u16 type; u16 type;
dprint(DBG_CAT_MOD, "delete_cat: %s,%u\n", str ? str->name : NULL, cnid); dprint(DBG_CAT_MOD, "delete_cat: %s,%u\n",
str ? str->name : NULL, cnid);
hfs_find_init(HFSPLUS_SB(sb)->cat_tree, &fd); hfs_find_init(HFSPLUS_SB(sb)->cat_tree, &fd);
if (!str) { if (!str) {
@ -261,11 +279,15 @@ int hfsplus_delete_cat(u32 cnid, struct inode *dir, struct qstr *str)
if (err) if (err)
goto out; goto out;
off = fd.entryoffset + offsetof(struct hfsplus_cat_thread, nodeName); off = fd.entryoffset +
offsetof(struct hfsplus_cat_thread, nodeName);
fd.search_key->cat.parent = cpu_to_be32(dir->i_ino); fd.search_key->cat.parent = cpu_to_be32(dir->i_ino);
hfs_bnode_read(fd.bnode, &fd.search_key->cat.name.length, off, 2); hfs_bnode_read(fd.bnode,
&fd.search_key->cat.name.length, off, 2);
len = be16_to_cpu(fd.search_key->cat.name.length) * 2; len = be16_to_cpu(fd.search_key->cat.name.length) * 2;
hfs_bnode_read(fd.bnode, &fd.search_key->cat.name.unicode, off + 2, len); hfs_bnode_read(fd.bnode,
&fd.search_key->cat.name.unicode,
off + 2, len);
fd.search_key->key_len = cpu_to_be16(6 + len); fd.search_key->key_len = cpu_to_be16(6 + len);
} else } else
hfsplus_cat_build_key(sb, fd.search_key, dir->i_ino, str); hfsplus_cat_build_key(sb, fd.search_key, dir->i_ino, str);
@ -282,7 +304,8 @@ int hfsplus_delete_cat(u32 cnid, struct inode *dir, struct qstr *str)
hfsplus_free_fork(sb, cnid, &fork, HFSPLUS_TYPE_DATA); hfsplus_free_fork(sb, cnid, &fork, HFSPLUS_TYPE_DATA);
#endif #endif
off = fd.entryoffset + offsetof(struct hfsplus_cat_file, rsrc_fork); off = fd.entryoffset +
offsetof(struct hfsplus_cat_file, rsrc_fork);
hfs_bnode_read(fd.bnode, &fork, off, sizeof(fork)); hfs_bnode_read(fd.bnode, &fork, off, sizeof(fork));
hfsplus_free_fork(sb, cnid, &fork, HFSPLUS_TYPE_RSRC); hfsplus_free_fork(sb, cnid, &fork, HFSPLUS_TYPE_RSRC);
} }
@ -326,7 +349,8 @@ int hfsplus_rename_cat(u32 cnid,
int entry_size, type; int entry_size, type;
int err = 0; int err = 0;
dprint(DBG_CAT_MOD, "rename_cat: %u - %lu,%s - %lu,%s\n", cnid, src_dir->i_ino, src_name->name, dprint(DBG_CAT_MOD, "rename_cat: %u - %lu,%s - %lu,%s\n",
cnid, src_dir->i_ino, src_name->name,
dst_dir->i_ino, dst_name->name); dst_dir->i_ino, dst_name->name);
hfs_find_init(HFSPLUS_SB(sb)->cat_tree, &src_fd); hfs_find_init(HFSPLUS_SB(sb)->cat_tree, &src_fd);
dst_fd = src_fd; dst_fd = src_fd;
@ -378,7 +402,8 @@ int hfsplus_rename_cat(u32 cnid,
/* create new thread entry */ /* create new thread entry */
hfsplus_cat_build_key(sb, dst_fd.search_key, cnid, NULL); hfsplus_cat_build_key(sb, dst_fd.search_key, cnid, NULL);
entry_size = hfsplus_fill_cat_thread(sb, &entry, type, dst_dir->i_ino, dst_name); entry_size = hfsplus_fill_cat_thread(sb, &entry, type,
dst_dir->i_ino, dst_name);
err = hfs_brec_find(&dst_fd); err = hfs_brec_find(&dst_fd);
if (err != -ENOENT) { if (err != -ENOENT) {
if (!err) if (!err)

34
fs/hfsplus/dir.c
View File

@ -66,11 +66,17 @@ again:
goto fail; goto fail;
} }
cnid = be32_to_cpu(entry.file.id); cnid = be32_to_cpu(entry.file.id);
if (entry.file.user_info.fdType == cpu_to_be32(HFSP_HARDLINK_TYPE) && if (entry.file.user_info.fdType ==
entry.file.user_info.fdCreator == cpu_to_be32(HFSP_HFSPLUS_CREATOR) && cpu_to_be32(HFSP_HARDLINK_TYPE) &&
(entry.file.create_date == HFSPLUS_I(HFSPLUS_SB(sb)->hidden_dir)->create_date || entry.file.user_info.fdCreator ==
entry.file.create_date == HFSPLUS_I(sb->s_root->d_inode)->create_date) && cpu_to_be32(HFSP_HFSPLUS_CREATOR) &&
HFSPLUS_SB(sb)->hidden_dir) { (entry.file.create_date ==
HFSPLUS_I(HFSPLUS_SB(sb)->hidden_dir)->
create_date ||
entry.file.create_date ==
HFSPLUS_I(sb->s_root->d_inode)->
create_date) &&
HFSPLUS_SB(sb)->hidden_dir) {
struct qstr str; struct qstr str;
char name[32]; char name[32];
@ -83,11 +89,13 @@ again:
linkid = 0; linkid = 0;
} else { } else {
dentry->d_fsdata = (void *)(unsigned long)cnid; dentry->d_fsdata = (void *)(unsigned long)cnid;
linkid = be32_to_cpu(entry.file.permissions.dev); linkid =
be32_to_cpu(entry.file.permissions.dev);
str.len = sprintf(name, "iNode%d", linkid); str.len = sprintf(name, "iNode%d", linkid);
str.name = name; str.name = name;
hfsplus_cat_build_key(sb, fd.search_key, hfsplus_cat_build_key(sb, fd.search_key,
HFSPLUS_SB(sb)->hidden_dir->i_ino, &str); HFSPLUS_SB(sb)->hidden_dir->i_ino,
&str);
goto again; goto again;
} }
} else if (!dentry->d_fsdata) } else if (!dentry->d_fsdata)
@ -139,7 +147,8 @@ static int hfsplus_readdir(struct file *filp, void *dirent, filldir_t filldir)
filp->f_pos++; filp->f_pos++;
/* fall through */ /* fall through */
case 1: case 1:
hfs_bnode_read(fd.bnode, &entry, fd.entryoffset, fd.entrylength); hfs_bnode_read(fd.bnode, &entry, fd.entryoffset,
fd.entrylength);
if (be16_to_cpu(entry.type) != HFSPLUS_FOLDER_THREAD) { if (be16_to_cpu(entry.type) != HFSPLUS_FOLDER_THREAD) {
printk(KERN_ERR "hfs: bad catalog folder thread\n"); printk(KERN_ERR "hfs: bad catalog folder thread\n");
err = -EIO; err = -EIO;
@ -169,14 +178,16 @@ static int hfsplus_readdir(struct file *filp, void *dirent, filldir_t filldir)
err = -EIO; err = -EIO;
goto out; goto out;
} }
hfs_bnode_read(fd.bnode, &entry, fd.entryoffset, fd.entrylength); hfs_bnode_read(fd.bnode, &entry, fd.entryoffset,
fd.entrylength);
type = be16_to_cpu(entry.type); type = be16_to_cpu(entry.type);
len = HFSPLUS_MAX_STRLEN; len = HFSPLUS_MAX_STRLEN;
err = hfsplus_uni2asc(sb, &fd.key->cat.name, strbuf, &len); err = hfsplus_uni2asc(sb, &fd.key->cat.name, strbuf, &len);
if (err) if (err)
goto out; goto out;
if (type == HFSPLUS_FOLDER) { if (type == HFSPLUS_FOLDER) {
if (fd.entrylength < sizeof(struct hfsplus_cat_folder)) { if (fd.entrylength <
sizeof(struct hfsplus_cat_folder)) {
printk(KERN_ERR "hfs: small dir entry\n"); printk(KERN_ERR "hfs: small dir entry\n");
err = -EIO; err = -EIO;
goto out; goto out;
@ -273,7 +284,8 @@ static int hfsplus_link(struct dentry *src_dentry, struct inode *dst_dir,
HFSPLUS_I(inode)->linkid = id; HFSPLUS_I(inode)->linkid = id;
cnid = sbi->next_cnid++; cnid = sbi->next_cnid++;
src_dentry->d_fsdata = (void *)(unsigned long)cnid; src_dentry->d_fsdata = (void *)(unsigned long)cnid;
res = hfsplus_create_cat(cnid, src_dir, &src_dentry->d_name, inode); res = hfsplus_create_cat(cnid, src_dir,
&src_dentry->d_name, inode);
if (res) if (res)
/* panic? */ /* panic? */
goto out; goto out;

28
fs/hfsplus/extents.c
View File

@ -83,7 +83,8 @@ static u32 hfsplus_ext_lastblock(struct hfsplus_extent *ext)
return be32_to_cpu(ext->start_block) + be32_to_cpu(ext->block_count); return be32_to_cpu(ext->start_block) + be32_to_cpu(ext->block_count);
} }
static void __hfsplus_ext_write_extent(struct inode *inode, struct hfs_find_data *fd) static void __hfsplus_ext_write_extent(struct inode *inode,
struct hfs_find_data *fd)
{ {
struct hfsplus_inode_info *hip = HFSPLUS_I(inode); struct hfsplus_inode_info *hip = HFSPLUS_I(inode);
int res; int res;
@ -152,11 +153,13 @@ static inline int __hfsplus_ext_read_extent(struct hfs_find_data *fd,
return -ENOENT; return -ENOENT;
if (fd->entrylength != sizeof(hfsplus_extent_rec)) if (fd->entrylength != sizeof(hfsplus_extent_rec))
return -EIO; return -EIO;
hfs_bnode_read(fd->bnode, extent, fd->entryoffset, sizeof(hfsplus_extent_rec)); hfs_bnode_read(fd->bnode, extent, fd->entryoffset,
sizeof(hfsplus_extent_rec));
return 0; return 0;
} }
static inline int __hfsplus_ext_cache_extent(struct hfs_find_data *fd, struct inode *inode, u32 block) static inline int __hfsplus_ext_cache_extent(struct hfs_find_data *fd,
struct inode *inode, u32 block)
{ {
struct hfsplus_inode_info *hip = HFSPLUS_I(inode); struct hfsplus_inode_info *hip = HFSPLUS_I(inode);
int res; int res;
@ -172,7 +175,8 @@ static inline int __hfsplus_ext_cache_extent(struct hfs_find_data *fd, struct in
HFSPLUS_TYPE_DATA); HFSPLUS_TYPE_DATA);
if (!res) { if (!res) {
hip->cached_start = be32_to_cpu(fd->key->ext.start_block); hip->cached_start = be32_to_cpu(fd->key->ext.start_block);
hip->cached_blocks = hfsplus_ext_block_count(hip->cached_extents); hip->cached_blocks =
hfsplus_ext_block_count(hip->cached_extents);
} else { } else {
hip->cached_start = hip->cached_blocks = 0; hip->cached_start = hip->cached_blocks = 0;
hip->extent_state &= ~(HFSPLUS_EXT_DIRTY | HFSPLUS_EXT_NEW); hip->extent_state &= ~(HFSPLUS_EXT_DIRTY | HFSPLUS_EXT_NEW);
@ -249,9 +253,12 @@ int hfsplus_get_block(struct inode *inode, sector_t iblock,
mutex_unlock(&hip->extents_lock); mutex_unlock(&hip->extents_lock);
done: done:
dprint(DBG_EXTENT, "get_block(%lu): %llu - %u\n", inode->i_ino, (long long)iblock, dblock); dprint(DBG_EXTENT, "get_block(%lu): %llu - %u\n",
inode->i_ino, (long long)iblock, dblock);
mask = (1 << sbi->fs_shift) - 1; mask = (1 << sbi->fs_shift) - 1;
map_bh(bh_result, sb, (dblock << sbi->fs_shift) + sbi->blockoffset + (iblock & mask)); map_bh(bh_result, sb,
(dblock << sbi->fs_shift) + sbi->blockoffset +
(iblock & mask));
if (create) { if (create) {
set_buffer_new(bh_result); set_buffer_new(bh_result);
hip->phys_size += sb->s_blocksize; hip->phys_size += sb->s_blocksize;
@ -342,7 +349,8 @@ found:
} }
} }
int hfsplus_free_fork(struct super_block *sb, u32 cnid, struct hfsplus_fork_raw *fork, int type) int hfsplus_free_fork(struct super_block *sb, u32 cnid,
struct hfsplus_fork_raw *fork, int type)
{ {
struct hfs_find_data fd; struct hfs_find_data fd;
hfsplus_extent_rec ext_entry; hfsplus_extent_rec ext_entry;
@ -497,7 +505,8 @@ void hfsplus_file_truncate(struct inode *inode)
&page, &fsdata); &page, &fsdata);
if (res) if (res)
return; return;
res = pagecache_write_end(NULL, mapping, size, 0, 0, page, fsdata); res = pagecache_write_end(NULL, mapping, size,
0, 0, page, fsdata);
if (res < 0) if (res < 0)
return; return;
mark_inode_dirty(inode); mark_inode_dirty(inode);
@ -543,7 +552,8 @@ void hfsplus_file_truncate(struct inode *inode)
hip->alloc_blocks = blk_cnt; hip->alloc_blocks = blk_cnt;
out: out:
hip->phys_size = inode->i_size; hip->phys_size = inode->i_size;
hip->fs_blocks = (inode->i_size + sb->s_blocksize - 1) >> sb->s_blocksize_bits; hip->fs_blocks = (inode->i_size + sb->s_blocksize - 1) >>
sb->s_blocksize_bits;
inode_set_bytes(inode, hip->fs_blocks << sb->s_blocksize_bits); inode_set_bytes(inode, hip->fs_blocks << sb->s_blocksize_bits);
hfsplus_mark_inode_dirty(inode, HFSPLUS_I_ALLOC_DIRTY); hfsplus_mark_inode_dirty(inode, HFSPLUS_I_ALLOC_DIRTY);
} }

30
fs/hfsplus/hfsplus_fs.h
View File

@ -37,7 +37,8 @@
#define HFSPLUS_TYPE_DATA 0x00 #define HFSPLUS_TYPE_DATA 0x00
#define HFSPLUS_TYPE_RSRC 0xFF #define HFSPLUS_TYPE_RSRC 0xFF
typedef int (*btree_keycmp)(const hfsplus_btree_key *, const hfsplus_btree_key *); typedef int (*btree_keycmp)(const hfsplus_btree_key *,
const hfsplus_btree_key *);
#define NODE_HASH_SIZE 256 #define NODE_HASH_SIZE 256
@ -352,9 +353,12 @@ int hfs_brec_read(struct hfs_find_data *, void *, int);
int hfs_brec_goto(struct hfs_find_data *, int); int hfs_brec_goto(struct hfs_find_data *, int);
/* catalog.c */ /* catalog.c */
int hfsplus_cat_case_cmp_key(const hfsplus_btree_key *, const hfsplus_btree_key *); int hfsplus_cat_case_cmp_key(const hfsplus_btree_key *,
int hfsplus_cat_bin_cmp_key(const hfsplus_btree_key *, const hfsplus_btree_key *); const hfsplus_btree_key *);
void hfsplus_cat_build_key(struct super_block *sb, hfsplus_btree_key *, u32, struct qstr *); int hfsplus_cat_bin_cmp_key(const hfsplus_btree_key *,
const hfsplus_btree_key *);
void hfsplus_cat_build_key(struct super_block *sb,
hfsplus_btree_key *, u32, struct qstr *);
int hfsplus_find_cat(struct super_block *, u32, struct hfs_find_data *); int hfsplus_find_cat(struct super_block *, u32, struct hfs_find_data *);
int hfsplus_create_cat(u32, struct inode *, struct qstr *, struct inode *); int hfsplus_create_cat(u32, struct inode *, struct qstr *, struct inode *);
int hfsplus_delete_cat(u32, struct inode *, struct qstr *); int hfsplus_delete_cat(u32, struct inode *, struct qstr *);
@ -370,7 +374,8 @@ extern const struct file_operations hfsplus_dir_operations;
int hfsplus_ext_cmp_key(const hfsplus_btree_key *, const hfsplus_btree_key *); int hfsplus_ext_cmp_key(const hfsplus_btree_key *, const hfsplus_btree_key *);
void hfsplus_ext_write_extent(struct inode *); void hfsplus_ext_write_extent(struct inode *);
int hfsplus_get_block(struct inode *, sector_t, struct buffer_head *, int); int hfsplus_get_block(struct inode *, sector_t, struct buffer_head *, int);
int hfsplus_free_fork(struct super_block *, u32, struct hfsplus_fork_raw *, int); int hfsplus_free_fork(struct super_block *, u32,
struct hfsplus_fork_raw *, int);
int hfsplus_file_extend(struct inode *); int hfsplus_file_extend(struct inode *);
void hfsplus_file_truncate(struct inode *); void hfsplus_file_truncate(struct inode *);
@ -411,12 +416,17 @@ extern u16 hfsplus_decompose_table[];
extern u16 hfsplus_compose_table[]; extern u16 hfsplus_compose_table[];
/* unicode.c */ /* unicode.c */
int hfsplus_strcasecmp(const struct hfsplus_unistr *, const struct hfsplus_unistr *); int hfsplus_strcasecmp(const struct hfsplus_unistr *,
int hfsplus_strcmp(const struct hfsplus_unistr *, const struct hfsplus_unistr *); const struct hfsplus_unistr *);
int hfsplus_uni2asc(struct super_block *, const struct hfsplus_unistr *, char *, int *); int hfsplus_strcmp(const struct hfsplus_unistr *,
int hfsplus_asc2uni(struct super_block *, struct hfsplus_unistr *, const char *, int); const struct hfsplus_unistr *);
int hfsplus_uni2asc(struct super_block *,
const struct hfsplus_unistr *, char *, int *);
int hfsplus_asc2uni(struct super_block *,
struct hfsplus_unistr *, const char *, int);
int hfsplus_hash_dentry(struct dentry *dentry, struct qstr *str); int hfsplus_hash_dentry(struct dentry *dentry, struct qstr *str);
int hfsplus_compare_dentry(struct dentry *dentry, struct qstr *s1, struct qstr *s2); int hfsplus_compare_dentry(struct dentry *dentry,
struct qstr *s1, struct qstr *s2);
/* wrapper.c */ /* wrapper.c */
int hfsplus_read_wrapper(struct super_block *); int hfsplus_read_wrapper(struct super_block *);

3
fs/hfsplus/hfsplus_raw.h
View File

@ -36,7 +36,8 @@
#define HFSP_WRAPOFF_EMBEDSIG 0x7C #define HFSP_WRAPOFF_EMBEDSIG 0x7C
#define HFSP_WRAPOFF_EMBEDEXT 0x7E #define HFSP_WRAPOFF_EMBEDEXT 0x7E
#define HFSP_HIDDENDIR_NAME "\xe2\x90\x80\xe2\x90\x80\xe2\x90\x80\xe2\x90\x80HFS+ Private Data" #define HFSP_HIDDENDIR_NAME \
"\xe2\x90\x80\xe2\x90\x80\xe2\x90\x80\xe2\x90\x80HFS+ Private Data"
#define HFSP_HARDLINK_TYPE 0x686c6e6b /* 'hlnk' */ #define HFSP_HARDLINK_TYPE 0x686c6e6b /* 'hlnk' */
#define HFSP_HFSPLUS_CREATOR 0x6866732b /* 'hfs+' */ #define HFSP_HFSPLUS_CREATOR 0x6866732b /* 'hfs+' */

26
fs/hfsplus/inode.c
View File

@ -78,7 +78,8 @@ static int hfsplus_releasepage(struct page *page, gfp_t mask)
if (!tree) if (!tree)
return 0; return 0;
if (tree->node_size >= PAGE_CACHE_SIZE) { if (tree->node_size >= PAGE_CACHE_SIZE) {
nidx = page->index >> (tree->node_size_shift - PAGE_CACHE_SHIFT); nidx = page->index >>
(tree->node_size_shift - PAGE_CACHE_SHIFT);
spin_lock(&tree->hash_lock); spin_lock(&tree->hash_lock);
node = hfs_bnode_findhash(tree, nidx); node = hfs_bnode_findhash(tree, nidx);
if (!node) if (!node)
@ -91,7 +92,8 @@ static int hfsplus_releasepage(struct page *page, gfp_t mask)
} }
spin_unlock(&tree->hash_lock); spin_unlock(&tree->hash_lock);
} else { } else {
nidx = page->index << (PAGE_CACHE_SHIFT - tree->node_size_shift); nidx = page->index <<
(PAGE_CACHE_SHIFT - tree->node_size_shift);
i = 1 << (PAGE_CACHE_SHIFT - tree->node_size_shift); i = 1 << (PAGE_CACHE_SHIFT - tree->node_size_shift);
spin_lock(&tree->hash_lock); spin_lock(&tree->hash_lock);
do { do {
@ -167,8 +169,8 @@ const struct dentry_operations hfsplus_dentry_operations = {
.d_compare = hfsplus_compare_dentry, .d_compare = hfsplus_compare_dentry,
}; };
static struct dentry *hfsplus_file_lookup(struct inode *dir, struct dentry *dentry, static struct dentry *hfsplus_file_lookup(struct inode *dir,
struct nameidata *nd) struct dentry *dentry, struct nameidata *nd)
{ {
struct hfs_find_data fd; struct hfs_find_data fd;
struct super_block *sb = dir->i_sb; struct super_block *sb = dir->i_sb;
@ -222,7 +224,8 @@ out:
return NULL; return NULL;
} }
static void hfsplus_get_perms(struct inode *inode, struct hfsplus_perm *perms, int dir) static void hfsplus_get_perms(struct inode *inode,
struct hfsplus_perm *perms, int dir)
{ {
struct hfsplus_sb_info *sbi = HFSPLUS_SB(inode->i_sb); struct hfsplus_sb_info *sbi = HFSPLUS_SB(inode->i_sb);
u16 mode; u16 mode;
@ -324,7 +327,8 @@ int hfsplus_file_fsync(struct file *file, int datasync)
error = filemap_write_and_wait(sbi->cat_tree->inode->i_mapping); error = filemap_write_and_wait(sbi->cat_tree->inode->i_mapping);
if (test_and_clear_bit(HFSPLUS_I_EXT_DIRTY, &hip->flags)) { if (test_and_clear_bit(HFSPLUS_I_EXT_DIRTY, &hip->flags)) {
error2 = filemap_write_and_wait(sbi->ext_tree->inode->i_mapping); error2 =
filemap_write_and_wait(sbi->ext_tree->inode->i_mapping);
if (!error) if (!error)
error = error2; error = error2;
} }
@ -472,7 +476,8 @@ void hfsplus_inode_read_fork(struct inode *inode, struct hfsplus_fork_raw *fork)
} }
} }
void hfsplus_inode_write_fork(struct inode *inode, struct hfsplus_fork_raw *fork) void hfsplus_inode_write_fork(struct inode *inode,
struct hfsplus_fork_raw *fork)
{ {
memcpy(&fork->extents, &HFSPLUS_I(inode)->first_extents, memcpy(&fork->extents, &HFSPLUS_I(inode)->first_extents,
sizeof(hfsplus_extent_rec)); sizeof(hfsplus_extent_rec));
@ -520,7 +525,8 @@ int hfsplus_cat_read_inode(struct inode *inode, struct hfs_find_data *fd)
inode->i_nlink = 1; inode->i_nlink = 1;
if (S_ISREG(inode->i_mode)) { if (S_ISREG(inode->i_mode)) {
if (file->permissions.dev) if (file->permissions.dev)
inode->i_nlink = be32_to_cpu(file->permissions.dev); inode->i_nlink =
be32_to_cpu(file->permissions.dev);
inode->i_op = &hfsplus_file_inode_operations; inode->i_op = &hfsplus_file_inode_operations;
inode->i_fop = &hfsplus_file_operations; inode->i_fop = &hfsplus_file_operations;
inode->i_mapping->a_ops = &hfsplus_aops; inode->i_mapping->a_ops = &hfsplus_aops;
@ -593,7 +599,9 @@ int hfsplus_cat_write_inode(struct inode *inode)
sizeof(struct hfsplus_cat_file)); sizeof(struct hfsplus_cat_file));
hfsplus_inode_write_fork(inode, &file->data_fork); hfsplus_inode_write_fork(inode, &file->data_fork);
hfsplus_cat_set_perms(inode, &file->permissions); hfsplus_cat_set_perms(inode, &file->permissions);
if ((file->permissions.rootflags | file->permissions.userflags) & HFSPLUS_FLG_IMMUTABLE) if (HFSPLUS_FLG_IMMUTABLE &
(file->permissions.rootflags |
file->permissions.userflags))
file->flags |= cpu_to_be16(HFSPLUS_FILE_LOCKED); file->flags |= cpu_to_be16(HFSPLUS_FILE_LOCKED);
else else
file->flags &= cpu_to_be16(~HFSPLUS_FILE_LOCKED); file->flags &= cpu_to_be16(~HFSPLUS_FILE_LOCKED);

7
fs/hfsplus/options.c
View File

@ -165,7 +165,9 @@ int hfsplus_parse_options(char *input, struct hfsplus_sb_info *sbi)
if (p) if (p)
sbi->nls = load_nls(p); sbi->nls = load_nls(p);
if (!sbi->nls) { if (!sbi->nls) {
printk(KERN_ERR "hfs: unable to load nls mapping \"%s\"\n", p); printk(KERN_ERR "hfs: unable to load "
"nls mapping \"%s\"\n",
p);
kfree(p); kfree(p);
return 0; return 0;
} }
@ -212,7 +214,8 @@ int hfsplus_show_options(struct seq_file *seq, struct vfsmount *mnt)
seq_printf(seq, ",creator=%.4s", (char *)&sbi->creator); seq_printf(seq, ",creator=%.4s", (char *)&sbi->creator);
if (sbi->type != HFSPLUS_DEF_CR_TYPE) if (sbi->type != HFSPLUS_DEF_CR_TYPE)
seq_printf(seq, ",type=%.4s", (char *)&sbi->type); seq_printf(seq, ",type=%.4s", (char *)&sbi->type);
seq_printf(seq, ",umask=%o,uid=%u,gid=%u", sbi->umask, sbi->uid, sbi->gid); seq_printf(seq, ",umask=%o,uid=%u,gid=%u", sbi->umask,
sbi->uid, sbi->gid);
if (sbi->part >= 0) if (sbi->part >= 0)
seq_printf(seq, ",part=%u", sbi->part); seq_printf(seq, ",part=%u", sbi->part);
if (sbi->session >= 0) if (sbi->session >= 0)

3
fs/hfsplus/part_tbl.c
View File

@ -2,7 +2,8 @@
* linux/fs/hfsplus/part_tbl.c * linux/fs/hfsplus/part_tbl.c
* *
* Copyright (C) 1996-1997 Paul H. Hargrove * Copyright (C) 1996-1997 Paul H. Hargrove
* This file may be distributed under the terms of the GNU General Public License. * This file may be distributed under the terms of
* the GNU General Public License.
* *
* Original code to handle the new style Mac partition table based on * Original code to handle the new style Mac partition table based on
* a patch contributed by Holger Schemel (aeglos@valinor.owl.de). * a patch contributed by Holger Schemel (aeglos@valinor.owl.de).

34
fs/hfsplus/super.c
View File

@ -290,18 +290,25 @@ static int hfsplus_remount(struct super_block *sb, int *flags, char *data)
return -EINVAL; return -EINVAL;
if (!(vhdr->attributes & cpu_to_be32(HFSPLUS_VOL_UNMNT))) { if (!(vhdr->attributes & cpu_to_be32(HFSPLUS_VOL_UNMNT))) {
printk(KERN_WARNING "hfs: filesystem was not cleanly unmounted, " printk(KERN_WARNING "hfs: filesystem was "
"running fsck.hfsplus is recommended. leaving read-only.\n"); "not cleanly unmounted, "
"running fsck.hfsplus is recommended. "
"leaving read-only.\n");
sb->s_flags |= MS_RDONLY; sb->s_flags |= MS_RDONLY;
*flags |= MS_RDONLY; *flags |= MS_RDONLY;
} else if (force) { } else if (force) {
/* nothing */ /* nothing */
} else if (vhdr->attributes & cpu_to_be32(HFSPLUS_VOL_SOFTLOCK)) { } else if (vhdr->attributes &
printk(KERN_WARNING "hfs: filesystem is marked locked, leaving read-only.\n"); cpu_to_be32(HFSPLUS_VOL_SOFTLOCK)) {
printk(KERN_WARNING "hfs: filesystem is marked locked, "
"leaving read-only.\n");
sb->s_flags |= MS_RDONLY; sb->s_flags |= MS_RDONLY;
*flags |= MS_RDONLY; *flags |= MS_RDONLY;
} else if (vhdr->attributes & cpu_to_be32(HFSPLUS_VOL_JOURNALED)) { } else if (vhdr->attributes &
printk(KERN_WARNING "hfs: filesystem is marked journaled, leaving read-only.\n"); cpu_to_be32(HFSPLUS_VOL_JOURNALED)) {
printk(KERN_WARNING "hfs: filesystem is "
"marked journaled, "
"leaving read-only.\n");
sb->s_flags |= MS_RDONLY; sb->s_flags |= MS_RDONLY;
*flags |= MS_RDONLY; *flags |= MS_RDONLY;
} }
@ -391,17 +398,22 @@ static int hfsplus_fill_super(struct super_block *sb, void *data, int silent)
sb->s_maxbytes = MAX_LFS_FILESIZE; sb->s_maxbytes = MAX_LFS_FILESIZE;
if (!(vhdr->attributes & cpu_to_be32(HFSPLUS_VOL_UNMNT))) { if (!(vhdr->attributes & cpu_to_be32(HFSPLUS_VOL_UNMNT))) {
printk(KERN_WARNING "hfs: Filesystem was not cleanly unmounted, " printk(KERN_WARNING "hfs: Filesystem was "
"running fsck.hfsplus is recommended. mounting read-only.\n"); "not cleanly unmounted, "
"running fsck.hfsplus is recommended. "
"mounting read-only.\n");
sb->s_flags |= MS_RDONLY; sb->s_flags |= MS_RDONLY;
} else if (test_and_clear_bit(HFSPLUS_SB_FORCE, &sbi->flags)) { } else if (test_and_clear_bit(HFSPLUS_SB_FORCE, &sbi->flags)) {
/* nothing */ /* nothing */
} else if (vhdr->attributes & cpu_to_be32(HFSPLUS_VOL_SOFTLOCK)) { } else if (vhdr->attributes & cpu_to_be32(HFSPLUS_VOL_SOFTLOCK)) {
printk(KERN_WARNING "hfs: Filesystem is marked locked, mounting read-only.\n"); printk(KERN_WARNING "hfs: Filesystem is marked locked, mounting read-only.\n");
sb->s_flags |= MS_RDONLY; sb->s_flags |= MS_RDONLY;
} else if ((vhdr->attributes & cpu_to_be32(HFSPLUS_VOL_JOURNALED)) && !(sb->s_flags & MS_RDONLY)) { } else if ((vhdr->attributes & cpu_to_be32(HFSPLUS_VOL_JOURNALED)) &&
printk(KERN_WARNING "hfs: write access to a journaled filesystem is not supported, " !(sb->s_flags & MS_RDONLY)) {
"use the force option at your own risk, mounting read-only.\n"); printk(KERN_WARNING "hfs: write access to "
"a journaled filesystem is not supported, "
"use the force option at your own risk, "
"mounting read-only.\n");
sb->s_flags |= MS_RDONLY; sb->s_flags |= MS_RDONLY;
} }

21
fs/hfsplus/unicode.c
View File

@ -118,7 +118,9 @@ static u16 *hfsplus_compose_lookup(u16 *p, u16 cc)
return NULL; return NULL;
} }
int hfsplus_uni2asc(struct super_block *sb, const struct hfsplus_unistr *ustr, char *astr, int *len_p) int hfsplus_uni2asc(struct super_block *sb,
const struct hfsplus_unistr *ustr,
char *astr, int *len_p)
{ {
const hfsplus_unichr *ip; const hfsplus_unichr *ip;
struct nls_table *nls = HFSPLUS_SB(sb)->nls; struct nls_table *nls = HFSPLUS_SB(sb)->nls;
@ -171,7 +173,8 @@ int hfsplus_uni2asc(struct super_block *sb, const struct hfsplus_unistr *ustr, c
goto same; goto same;
c1 = be16_to_cpu(*ip); c1 = be16_to_cpu(*ip);
if (likely(compose)) if (likely(compose))
ce1 = hfsplus_compose_lookup(hfsplus_compose_table, c1); ce1 = hfsplus_compose_lookup(
hfsplus_compose_table, c1);
if (ce1) if (ce1)
break; break;
switch (c0) { switch (c0) {
@ -199,7 +202,8 @@ int hfsplus_uni2asc(struct super_block *sb, const struct hfsplus_unistr *ustr, c
if (ce2) { if (ce2) {
i = 1; i = 1;
while (i < ustrlen) { while (i < ustrlen) {
ce1 = hfsplus_compose_lookup(ce2, be16_to_cpu(ip[i])); ce1 = hfsplus_compose_lookup(ce2,
be16_to_cpu(ip[i]));
if (!ce1) if (!ce1)
break; break;
i++; i++;
@ -363,7 +367,8 @@ int hfsplus_hash_dentry(struct dentry *dentry, struct qstr *str)
* Composed unicode characters are decomposed and case-folding is performed * Composed unicode characters are decomposed and case-folding is performed
* if the appropriate bits are (un)set on the superblock. * if the appropriate bits are (un)set on the superblock.
*/ */
int hfsplus_compare_dentry(struct dentry *dentry, struct qstr *s1, struct qstr *s2) int hfsplus_compare_dentry(struct dentry *dentry,
struct qstr *s1, struct qstr *s2)
{ {
struct super_block *sb = dentry->d_sb; struct super_block *sb = dentry->d_sb;
int casefold, decompose, size; int casefold, decompose, size;
@ -388,7 +393,9 @@ int hfsplus_compare_dentry(struct dentry *dentry, struct qstr *s1, struct qstr *
astr1 += size; astr1 += size;
len1 -= size; len1 -= size;
if (!decompose || !(dstr1 = decompose_unichar(c, &dsize1))) { if (decompose)
dstr1 = decompose_unichar(c, &dsize1);
if (!decompose || !dstr1) {
c1 = c; c1 = c;
dstr1 = &c1; dstr1 = &c1;
dsize1 = 1; dsize1 = 1;
@ -400,7 +407,9 @@ int hfsplus_compare_dentry(struct dentry *dentry, struct qstr *s1, struct qstr *
astr2 += size; astr2 += size;
len2 -= size; len2 -= size;
if (!decompose || !(dstr2 = decompose_unichar(c, &dsize2))) { if (decompose)
dstr2 = decompose_unichar(c, &dsize2);
if (!decompose || !dstr2) {
c2 = c; c2 = c;
dstr2 = &c2; dstr2 = &c2;
dsize2 = 1; dsize2 = 1;

15
fs/hfsplus/wrapper.c
View File

@ -74,12 +74,14 @@ static int hfsplus_read_mdb(void *bufptr, struct hfsplus_wd *wd)
!(attrib & HFSP_WRAP_ATTRIB_SPARED)) !(attrib & HFSP_WRAP_ATTRIB_SPARED))
return 0; return 0;
wd->ablk_size = be32_to_cpu(*(__be32 *)(bufptr + HFSP_WRAPOFF_ABLKSIZE)); wd->ablk_size =
be32_to_cpu(*(__be32 *)(bufptr + HFSP_WRAPOFF_ABLKSIZE));
if (wd->ablk_size < HFSPLUS_SECTOR_SIZE) if (wd->ablk_size < HFSPLUS_SECTOR_SIZE)
return 0; return 0;
if (wd->ablk_size % HFSPLUS_SECTOR_SIZE) if (wd->ablk_size % HFSPLUS_SECTOR_SIZE)
return 0; return 0;
wd->ablk_start = be16_to_cpu(*(__be16 *)(bufptr + HFSP_WRAPOFF_ABLKSTART)); wd->ablk_start =
be16_to_cpu(*(__be16 *)(bufptr + HFSP_WRAPOFF_ABLKSTART));
extent = get_unaligned_be32(bufptr + HFSP_WRAPOFF_EMBEDEXT); extent = get_unaligned_be32(bufptr + HFSP_WRAPOFF_EMBEDEXT);
wd->embed_start = (extent >> 16) & 0xFFFF; wd->embed_start = (extent >> 16) & 0xFFFF;
@ -102,7 +104,8 @@ static int hfsplus_get_last_session(struct super_block *sb,
if (HFSPLUS_SB(sb)->session >= 0) { if (HFSPLUS_SB(sb)->session >= 0) {
te.cdte_track = HFSPLUS_SB(sb)->session; te.cdte_track = HFSPLUS_SB(sb)->session;
te.cdte_format = CDROM_LBA; te.cdte_format = CDROM_LBA;
res = ioctl_by_bdev(sb->s_bdev, CDROMREADTOCENTRY, (unsigned long)&te); res = ioctl_by_bdev(sb->s_bdev,
CDROMREADTOCENTRY, (unsigned long)&te);
if (!res && (te.cdte_ctrl & CDROM_DATA_TRACK) == 4) { if (!res && (te.cdte_ctrl & CDROM_DATA_TRACK) == 4) {
*start = (sector_t)te.cdte_addr.lba << 2; *start = (sector_t)te.cdte_addr.lba << 2;
return 0; return 0;
@ -111,7 +114,8 @@ static int hfsplus_get_last_session(struct super_block *sb,
return -EINVAL; return -EINVAL;
} }
ms_info.addr_format = CDROM_LBA; ms_info.addr_format = CDROM_LBA;
res = ioctl_by_bdev(sb->s_bdev, CDROMMULTISESSION, (unsigned long)&ms_info); res = ioctl_by_bdev(sb->s_bdev, CDROMMULTISESSION,
(unsigned long)&ms_info);
if (!res && ms_info.xa_flag) if (!res && ms_info.xa_flag)
*start = (sector_t)ms_info.addr.lba << 2; *start = (sector_t)ms_info.addr.lba << 2;
return 0; return 0;
@ -212,7 +216,8 @@ reread:
blocksize >>= 1; blocksize >>= 1;
if (sb_set_blocksize(sb, blocksize) != blocksize) { if (sb_set_blocksize(sb, blocksize) != blocksize) {
printk(KERN_ERR "hfs: unable to set blocksize to %u!\n", blocksize); printk(KERN_ERR "hfs: unable to set blocksize to %u!\n",
blocksize);
goto out_free_backup_vhdr; goto out_free_backup_vhdr;
} }