blob: 9a88d7536103e2c1c70f3824b42d367d3eac848f [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * linux/fs/hfsplus/super.c
3 *
4 * Copyright (C) 2001
5 * Brad Boyer (flar@allandria.com)
6 * (C) 2003 Ardis Technologies <roman@ardistech.com>
7 *
8 */
9
Linus Torvalds1da177e2005-04-16 15:20:36 -070010#include <linux/module.h>
11#include <linux/init.h>
12#include <linux/pagemap.h>
13#include <linux/fs.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070014#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070015#include <linux/vfs.h>
16#include <linux/nls.h>
17
18static struct inode *hfsplus_alloc_inode(struct super_block *sb);
19static void hfsplus_destroy_inode(struct inode *inode);
20
21#include "hfsplus_fs.h"
22
Christoph Hellwigfc4fff82010-10-01 05:43:41 +020023static int hfsplus_system_read_inode(struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -070024{
Christoph Hellwigfc4fff82010-10-01 05:43:41 +020025 struct hfsplus_vh *vhdr = HFSPLUS_SB(inode->i_sb)->s_vhdr;
David Howells63525392008-02-07 00:15:40 -080026
Christoph Hellwigfc4fff82010-10-01 05:43:41 +020027 switch (inode->i_ino) {
Linus Torvalds1da177e2005-04-16 15:20:36 -070028 case HFSPLUS_EXT_CNID:
29 hfsplus_inode_read_fork(inode, &vhdr->ext_file);
30 inode->i_mapping->a_ops = &hfsplus_btree_aops;
31 break;
32 case HFSPLUS_CAT_CNID:
33 hfsplus_inode_read_fork(inode, &vhdr->cat_file);
34 inode->i_mapping->a_ops = &hfsplus_btree_aops;
35 break;
36 case HFSPLUS_ALLOC_CNID:
37 hfsplus_inode_read_fork(inode, &vhdr->alloc_file);
38 inode->i_mapping->a_ops = &hfsplus_aops;
39 break;
40 case HFSPLUS_START_CNID:
41 hfsplus_inode_read_fork(inode, &vhdr->start_file);
42 break;
43 case HFSPLUS_ATTR_CNID:
44 hfsplus_inode_read_fork(inode, &vhdr->attr_file);
45 inode->i_mapping->a_ops = &hfsplus_btree_aops;
46 break;
47 default:
Christoph Hellwigfc4fff82010-10-01 05:43:41 +020048 return -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -070049 }
50
Christoph Hellwigfc4fff82010-10-01 05:43:41 +020051 return 0;
52}
53
54struct inode *hfsplus_iget(struct super_block *sb, unsigned long ino)
55{
56 struct hfs_find_data fd;
57 struct inode *inode;
58 int err;
59
60 inode = iget_locked(sb, ino);
61 if (!inode)
62 return ERR_PTR(-ENOMEM);
63 if (!(inode->i_state & I_NEW))
64 return inode;
65
66 INIT_LIST_HEAD(&HFSPLUS_I(inode)->open_dir_list);
67 mutex_init(&HFSPLUS_I(inode)->extents_lock);
68 HFSPLUS_I(inode)->flags = 0;
69 HFSPLUS_I(inode)->rsrc_inode = NULL;
70 atomic_set(&HFSPLUS_I(inode)->opencnt, 0);
71
72 if (inode->i_ino >= HFSPLUS_FIRSTUSER_CNID ||
73 inode->i_ino == HFSPLUS_ROOT_CNID) {
74 hfs_find_init(HFSPLUS_SB(inode->i_sb)->cat_tree, &fd);
75 err = hfsplus_find_cat(inode->i_sb, inode->i_ino, &fd);
76 if (!err)
77 err = hfsplus_cat_read_inode(inode, &fd);
78 hfs_find_exit(&fd);
79 } else {
80 err = hfsplus_system_read_inode(inode);
81 }
82
83 if (err) {
84 iget_failed(inode);
85 return ERR_PTR(err);
86 }
87
David Howells63525392008-02-07 00:15:40 -080088 unlock_new_inode(inode);
89 return inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -070090}
91
Christoph Hellwigb5080f72010-10-01 05:43:43 +020092static int hfsplus_system_write_inode(struct inode *inode)
93{
94 struct hfsplus_sb_info *sbi = HFSPLUS_SB(inode->i_sb);
95 struct hfsplus_vh *vhdr = sbi->s_vhdr;
96 struct hfsplus_fork_raw *fork;
97 struct hfs_btree *tree = NULL;
98
99 switch (inode->i_ino) {
100 case HFSPLUS_EXT_CNID:
101 fork = &vhdr->ext_file;
102 tree = sbi->ext_tree;
103 break;
104 case HFSPLUS_CAT_CNID:
105 fork = &vhdr->cat_file;
106 tree = sbi->cat_tree;
107 break;
108 case HFSPLUS_ALLOC_CNID:
109 fork = &vhdr->alloc_file;
110 break;
111 case HFSPLUS_START_CNID:
112 fork = &vhdr->start_file;
113 break;
114 case HFSPLUS_ATTR_CNID:
115 fork = &vhdr->attr_file;
116 tree = sbi->attr_tree;
117 default:
118 return -EIO;
119 }
120
121 if (fork->total_size != cpu_to_be64(inode->i_size)) {
Christoph Hellwig84adede2010-10-01 05:45:20 +0200122 set_bit(HFSPLUS_SB_WRITEBACKUP, &sbi->flags);
Christoph Hellwigb5080f72010-10-01 05:43:43 +0200123 inode->i_sb->s_dirt = 1;
124 }
125 hfsplus_inode_write_fork(inode, fork);
126 if (tree)
127 hfs_btree_write(tree);
128 return 0;
129}
130
Christoph Hellwiga9185b42010-03-05 09:21:37 +0100131static int hfsplus_write_inode(struct inode *inode,
132 struct writeback_control *wbc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700134 dprint(DBG_INODE, "hfsplus_write_inode: %lu\n", inode->i_ino);
Christoph Hellwigb5080f72010-10-01 05:43:43 +0200135
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136 hfsplus_ext_write_extent(inode);
Christoph Hellwigb5080f72010-10-01 05:43:43 +0200137
138 if (inode->i_ino >= HFSPLUS_FIRSTUSER_CNID ||
139 inode->i_ino == HFSPLUS_ROOT_CNID)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140 return hfsplus_cat_write_inode(inode);
Christoph Hellwigb5080f72010-10-01 05:43:43 +0200141 else
142 return hfsplus_system_write_inode(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143}
144
Al Virob57922d2010-06-07 14:34:48 -0400145static void hfsplus_evict_inode(struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146{
Al Virob57922d2010-06-07 14:34:48 -0400147 dprint(DBG_INODE, "hfsplus_evict_inode: %lu\n", inode->i_ino);
148 truncate_inode_pages(&inode->i_data, 0);
149 end_writeback(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150 if (HFSPLUS_IS_RSRC(inode)) {
Christoph Hellwig6af502d2010-10-01 05:43:31 +0200151 HFSPLUS_I(HFSPLUS_I(inode)->rsrc_inode)->rsrc_inode = NULL;
152 iput(HFSPLUS_I(inode)->rsrc_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154}
155
Al Virob5fc5102010-07-04 12:24:09 +0400156int hfsplus_sync_fs(struct super_block *sb, int wait)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157{
Christoph Hellwigdd73a012010-10-01 05:42:59 +0200158 struct hfsplus_sb_info *sbi = HFSPLUS_SB(sb);
159 struct hfsplus_vh *vhdr = sbi->s_vhdr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160
161 dprint(DBG_SUPER, "hfsplus_write_super\n");
Christoph Hellwigebc1ac12009-05-11 23:35:03 +0200162
Christoph Hellwig7ac9fb92010-10-01 05:45:08 +0200163 mutex_lock(&sbi->vh_mutex);
Christoph Hellwigdd73a012010-10-01 05:42:59 +0200164 mutex_lock(&sbi->alloc_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165 sb->s_dirt = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166
Christoph Hellwigdd73a012010-10-01 05:42:59 +0200167 vhdr->free_blocks = cpu_to_be32(sbi->free_blocks);
Christoph Hellwigdd73a012010-10-01 05:42:59 +0200168 vhdr->next_cnid = cpu_to_be32(sbi->next_cnid);
169 vhdr->folder_count = cpu_to_be32(sbi->folder_count);
170 vhdr->file_count = cpu_to_be32(sbi->file_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171
Christoph Hellwigdd73a012010-10-01 05:42:59 +0200172 mark_buffer_dirty(sbi->s_vhbh);
Christoph Hellwig84adede2010-10-01 05:45:20 +0200173 if (test_and_clear_bit(HFSPLUS_SB_WRITEBACKUP, &sbi->flags)) {
Christoph Hellwigdd73a012010-10-01 05:42:59 +0200174 if (sbi->sect_count) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700175 struct buffer_head *bh;
176 u32 block, offset;
177
Christoph Hellwigdd73a012010-10-01 05:42:59 +0200178 block = sbi->blockoffset;
179 block += (sbi->sect_count - 2) >> (sb->s_blocksize_bits - 9);
180 offset = ((sbi->sect_count - 2) << 9) & (sb->s_blocksize - 1);
181 printk(KERN_DEBUG "hfs: backup: %u,%u,%u,%u\n",
182 sbi->blockoffset, sbi->sect_count,
183 block, offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184 bh = sb_bread(sb, block);
185 if (bh) {
186 vhdr = (struct hfsplus_vh *)(bh->b_data + offset);
187 if (be16_to_cpu(vhdr->signature) == HFSPLUS_VOLHEAD_SIG) {
Christoph Hellwigdd73a012010-10-01 05:42:59 +0200188 memcpy(vhdr, sbi->s_vhdr, sizeof(*vhdr));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189 mark_buffer_dirty(bh);
190 brelse(bh);
191 } else
Roman Zippel634725a2006-01-18 17:43:05 -0800192 printk(KERN_WARNING "hfs: backup not found!\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193 }
194 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195 }
Christoph Hellwigdd73a012010-10-01 05:42:59 +0200196 mutex_unlock(&sbi->alloc_mutex);
Christoph Hellwig7ac9fb92010-10-01 05:45:08 +0200197 mutex_unlock(&sbi->vh_mutex);
Christoph Hellwig7fbc6df2009-06-08 10:05:12 +0200198 return 0;
199}
200
201static void hfsplus_write_super(struct super_block *sb)
202{
203 if (!(sb->s_flags & MS_RDONLY))
204 hfsplus_sync_fs(sb, 1);
205 else
206 sb->s_dirt = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207}
208
209static void hfsplus_put_super(struct super_block *sb)
210{
Christoph Hellwigdd73a012010-10-01 05:42:59 +0200211 struct hfsplus_sb_info *sbi = HFSPLUS_SB(sb);
212
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213 dprint(DBG_SUPER, "hfsplus_put_super\n");
Christoph Hellwigdd73a012010-10-01 05:42:59 +0200214
Colin Leroy945b0922005-05-01 08:59:16 -0700215 if (!sb->s_fs_info)
216 return;
Christoph Hellwig6cfd0142009-05-05 15:40:36 +0200217
Christoph Hellwig8c85e122009-04-28 18:00:26 +0200218 if (sb->s_dirt)
219 hfsplus_write_super(sb);
Christoph Hellwigdd73a012010-10-01 05:42:59 +0200220 if (!(sb->s_flags & MS_RDONLY) && sbi->s_vhdr) {
221 struct hfsplus_vh *vhdr = sbi->s_vhdr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222
223 vhdr->modify_date = hfsp_now2mt();
224 vhdr->attributes |= cpu_to_be32(HFSPLUS_VOL_UNMNT);
225 vhdr->attributes &= cpu_to_be32(~HFSPLUS_VOL_INCNSTNT);
Christoph Hellwigdd73a012010-10-01 05:42:59 +0200226 mark_buffer_dirty(sbi->s_vhbh);
227 sync_dirty_buffer(sbi->s_vhbh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228 }
229
Christoph Hellwigdd73a012010-10-01 05:42:59 +0200230 hfs_btree_close(sbi->cat_tree);
231 hfs_btree_close(sbi->ext_tree);
232 iput(sbi->alloc_file);
233 iput(sbi->hidden_dir);
234 brelse(sbi->s_vhbh);
235 unload_nls(sbi->nls);
Colin Leroy945b0922005-05-01 08:59:16 -0700236 kfree(sb->s_fs_info);
237 sb->s_fs_info = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238}
239
David Howells726c3342006-06-23 02:02:58 -0700240static int hfsplus_statfs(struct dentry *dentry, struct kstatfs *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241{
David Howells726c3342006-06-23 02:02:58 -0700242 struct super_block *sb = dentry->d_sb;
Christoph Hellwigdd73a012010-10-01 05:42:59 +0200243 struct hfsplus_sb_info *sbi = HFSPLUS_SB(sb);
Coly Li25564dd2009-04-02 16:59:36 -0700244 u64 id = huge_encode_dev(sb->s_bdev->bd_dev);
David Howells726c3342006-06-23 02:02:58 -0700245
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246 buf->f_type = HFSPLUS_SUPER_MAGIC;
247 buf->f_bsize = sb->s_blocksize;
Christoph Hellwigdd73a012010-10-01 05:42:59 +0200248 buf->f_blocks = sbi->total_blocks << sbi->fs_shift;
249 buf->f_bfree = sbi->free_blocks << sbi->fs_shift;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250 buf->f_bavail = buf->f_bfree;
251 buf->f_files = 0xFFFFFFFF;
Christoph Hellwigdd73a012010-10-01 05:42:59 +0200252 buf->f_ffree = 0xFFFFFFFF - sbi->next_cnid;
Coly Li25564dd2009-04-02 16:59:36 -0700253 buf->f_fsid.val[0] = (u32)id;
254 buf->f_fsid.val[1] = (u32)(id >> 32);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255 buf->f_namelen = HFSPLUS_MAX_STRLEN;
256
257 return 0;
258}
259
260static int hfsplus_remount(struct super_block *sb, int *flags, char *data)
261{
262 if ((*flags & MS_RDONLY) == (sb->s_flags & MS_RDONLY))
263 return 0;
264 if (!(*flags & MS_RDONLY)) {
Christoph Hellwigdd73a012010-10-01 05:42:59 +0200265 struct hfsplus_vh *vhdr = HFSPLUS_SB(sb)->s_vhdr;
Roman Zippelb0b623c2005-11-29 19:34:41 -0800266 struct hfsplus_sb_info sbi;
267
268 memset(&sbi, 0, sizeof(struct hfsplus_sb_info));
Christoph Hellwigdd73a012010-10-01 05:42:59 +0200269 sbi.nls = HFSPLUS_SB(sb)->nls;
Roman Zippelb0b623c2005-11-29 19:34:41 -0800270 if (!hfsplus_parse_options(data, &sbi))
271 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272
273 if (!(vhdr->attributes & cpu_to_be32(HFSPLUS_VOL_UNMNT))) {
Roman Zippel634725a2006-01-18 17:43:05 -0800274 printk(KERN_WARNING "hfs: filesystem was not cleanly unmounted, "
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275 "running fsck.hfsplus is recommended. leaving read-only.\n");
276 sb->s_flags |= MS_RDONLY;
277 *flags |= MS_RDONLY;
Christoph Hellwig84adede2010-10-01 05:45:20 +0200278 } else if (test_bit(HFSPLUS_SB_FORCE, &sbi.flags)) {
Roman Zippelb0b623c2005-11-29 19:34:41 -0800279 /* nothing */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700280 } else if (vhdr->attributes & cpu_to_be32(HFSPLUS_VOL_SOFTLOCK)) {
Roman Zippel634725a2006-01-18 17:43:05 -0800281 printk(KERN_WARNING "hfs: filesystem is marked locked, leaving read-only.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282 sb->s_flags |= MS_RDONLY;
283 *flags |= MS_RDONLY;
Roman Zippelb0b623c2005-11-29 19:34:41 -0800284 } else if (vhdr->attributes & cpu_to_be32(HFSPLUS_VOL_JOURNALED)) {
Roman Zippel634725a2006-01-18 17:43:05 -0800285 printk(KERN_WARNING "hfs: filesystem is marked journaled, leaving read-only.\n");
Roman Zippelb0b623c2005-11-29 19:34:41 -0800286 sb->s_flags |= MS_RDONLY;
287 *flags |= MS_RDONLY;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288 }
289 }
290 return 0;
291}
292
Josef 'Jeff' Sipekee9b6d62007-02-12 00:55:41 -0800293static const struct super_operations hfsplus_sops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294 .alloc_inode = hfsplus_alloc_inode,
295 .destroy_inode = hfsplus_destroy_inode,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296 .write_inode = hfsplus_write_inode,
Al Virob57922d2010-06-07 14:34:48 -0400297 .evict_inode = hfsplus_evict_inode,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298 .put_super = hfsplus_put_super,
299 .write_super = hfsplus_write_super,
Christoph Hellwig7fbc6df2009-06-08 10:05:12 +0200300 .sync_fs = hfsplus_sync_fs,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301 .statfs = hfsplus_statfs,
302 .remount_fs = hfsplus_remount,
Roman Zippel717dd80e2005-09-06 15:18:48 -0700303 .show_options = hfsplus_show_options,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304};
305
306static int hfsplus_fill_super(struct super_block *sb, void *data, int silent)
307{
308 struct hfsplus_vh *vhdr;
309 struct hfsplus_sb_info *sbi;
310 hfsplus_cat_entry entry;
311 struct hfs_find_data fd;
David Howells63525392008-02-07 00:15:40 -0800312 struct inode *root, *inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313 struct qstr str;
314 struct nls_table *nls = NULL;
315 int err = -EINVAL;
316
Wyatt Banksa5001a22007-07-15 23:40:50 -0700317 sbi = kzalloc(sizeof(*sbi), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318 if (!sbi)
319 return -ENOMEM;
320
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321 sb->s_fs_info = sbi;
Christoph Hellwig40bf48a2010-10-01 05:41:39 +0200322 mutex_init(&sbi->alloc_mutex);
Christoph Hellwig7ac9fb92010-10-01 05:45:08 +0200323 mutex_init(&sbi->vh_mutex);
Roman Zippel717dd80e2005-09-06 15:18:48 -0700324 hfsplus_fill_defaults(sbi);
325 if (!hfsplus_parse_options(data, sbi)) {
Roman Zippel634725a2006-01-18 17:43:05 -0800326 printk(KERN_ERR "hfs: unable to parse mount options\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327 err = -EINVAL;
328 goto cleanup;
329 }
330
331 /* temporarily use utf8 to correctly find the hidden dir below */
332 nls = sbi->nls;
333 sbi->nls = load_nls("utf8");
Joshua Kwanbd6a59b2006-01-06 00:09:45 -0800334 if (!sbi->nls) {
Roman Zippel634725a2006-01-18 17:43:05 -0800335 printk(KERN_ERR "hfs: unable to load nls for utf8\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336 err = -EINVAL;
337 goto cleanup;
338 }
339
340 /* Grab the volume header */
341 if (hfsplus_read_wrapper(sb)) {
342 if (!silent)
Roman Zippel634725a2006-01-18 17:43:05 -0800343 printk(KERN_WARNING "hfs: unable to find HFS+ superblock\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344 err = -EINVAL;
345 goto cleanup;
346 }
Christoph Hellwigdd73a012010-10-01 05:42:59 +0200347 vhdr = sbi->s_vhdr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348
349 /* Copy parts of the volume header into the superblock */
David Elliott2179d372006-01-18 17:43:08 -0800350 sb->s_magic = HFSPLUS_VOLHEAD_SIG;
351 if (be16_to_cpu(vhdr->version) < HFSPLUS_MIN_VERSION ||
352 be16_to_cpu(vhdr->version) > HFSPLUS_CURRENT_VERSION) {
Roman Zippel634725a2006-01-18 17:43:05 -0800353 printk(KERN_ERR "hfs: wrong filesystem version\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354 goto cleanup;
355 }
Christoph Hellwigdd73a012010-10-01 05:42:59 +0200356 sbi->total_blocks = be32_to_cpu(vhdr->total_blocks);
357 sbi->free_blocks = be32_to_cpu(vhdr->free_blocks);
Christoph Hellwigdd73a012010-10-01 05:42:59 +0200358 sbi->next_cnid = be32_to_cpu(vhdr->next_cnid);
359 sbi->file_count = be32_to_cpu(vhdr->file_count);
360 sbi->folder_count = be32_to_cpu(vhdr->folder_count);
361 sbi->data_clump_blocks =
362 be32_to_cpu(vhdr->data_clump_sz) >> sbi->alloc_blksz_shift;
363 if (!sbi->data_clump_blocks)
364 sbi->data_clump_blocks = 1;
365 sbi->rsrc_clump_blocks =
366 be32_to_cpu(vhdr->rsrc_clump_sz) >> sbi->alloc_blksz_shift;
367 if (!sbi->rsrc_clump_blocks)
368 sbi->rsrc_clump_blocks = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369
370 /* Set up operations so we can load metadata */
371 sb->s_op = &hfsplus_sops;
372 sb->s_maxbytes = MAX_LFS_FILESIZE;
373
374 if (!(vhdr->attributes & cpu_to_be32(HFSPLUS_VOL_UNMNT))) {
Roman Zippel634725a2006-01-18 17:43:05 -0800375 printk(KERN_WARNING "hfs: Filesystem was not cleanly unmounted, "
376 "running fsck.hfsplus is recommended. mounting read-only.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377 sb->s_flags |= MS_RDONLY;
Christoph Hellwig84adede2010-10-01 05:45:20 +0200378 } else if (test_and_clear_bit(HFSPLUS_SB_FORCE, &sbi->flags)) {
Roman Zippelb0b623c2005-11-29 19:34:41 -0800379 /* nothing */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380 } else if (vhdr->attributes & cpu_to_be32(HFSPLUS_VOL_SOFTLOCK)) {
Roman Zippel634725a2006-01-18 17:43:05 -0800381 printk(KERN_WARNING "hfs: Filesystem is marked locked, mounting read-only.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382 sb->s_flags |= MS_RDONLY;
Mike Crowe81a73712008-10-15 22:04:05 -0700383 } else if ((vhdr->attributes & cpu_to_be32(HFSPLUS_VOL_JOURNALED)) && !(sb->s_flags & MS_RDONLY)) {
Dave Jones355a4692008-04-29 16:01:22 -0400384 printk(KERN_WARNING "hfs: write access to a journaled filesystem is not supported, "
Roman Zippel634725a2006-01-18 17:43:05 -0800385 "use the force option at your own risk, mounting read-only.\n");
Roman Zippelb0b623c2005-11-29 19:34:41 -0800386 sb->s_flags |= MS_RDONLY;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387 }
388
389 /* Load metadata objects (B*Trees) */
Christoph Hellwigdd73a012010-10-01 05:42:59 +0200390 sbi->ext_tree = hfs_btree_open(sb, HFSPLUS_EXT_CNID);
391 if (!sbi->ext_tree) {
Roman Zippel634725a2006-01-18 17:43:05 -0800392 printk(KERN_ERR "hfs: failed to load extents file\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393 goto cleanup;
394 }
Christoph Hellwigdd73a012010-10-01 05:42:59 +0200395 sbi->cat_tree = hfs_btree_open(sb, HFSPLUS_CAT_CNID);
396 if (!sbi->cat_tree) {
Roman Zippel634725a2006-01-18 17:43:05 -0800397 printk(KERN_ERR "hfs: failed to load catalog file\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398 goto cleanup;
399 }
400
David Howells63525392008-02-07 00:15:40 -0800401 inode = hfsplus_iget(sb, HFSPLUS_ALLOC_CNID);
402 if (IS_ERR(inode)) {
Roman Zippel634725a2006-01-18 17:43:05 -0800403 printk(KERN_ERR "hfs: failed to load allocation file\n");
David Howells63525392008-02-07 00:15:40 -0800404 err = PTR_ERR(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405 goto cleanup;
406 }
Christoph Hellwigdd73a012010-10-01 05:42:59 +0200407 sbi->alloc_file = inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408
409 /* Load the root directory */
David Howells63525392008-02-07 00:15:40 -0800410 root = hfsplus_iget(sb, HFSPLUS_ROOT_CNID);
411 if (IS_ERR(root)) {
412 printk(KERN_ERR "hfs: failed to load root directory\n");
413 err = PTR_ERR(root);
414 goto cleanup;
415 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416 sb->s_root = d_alloc_root(root);
417 if (!sb->s_root) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418 iput(root);
David Howells63525392008-02-07 00:15:40 -0800419 err = -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420 goto cleanup;
421 }
Duane Griffind45bce82007-07-15 23:41:23 -0700422 sb->s_root->d_op = &hfsplus_dentry_operations;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423
424 str.len = sizeof(HFSP_HIDDENDIR_NAME) - 1;
425 str.name = HFSP_HIDDENDIR_NAME;
Christoph Hellwigdd73a012010-10-01 05:42:59 +0200426 hfs_find_init(sbi->cat_tree, &fd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427 hfsplus_cat_build_key(sb, fd.search_key, HFSPLUS_ROOT_CNID, &str);
428 if (!hfs_brec_read(&fd, &entry, sizeof(entry))) {
429 hfs_find_exit(&fd);
430 if (entry.type != cpu_to_be16(HFSPLUS_FOLDER))
431 goto cleanup;
David Howells63525392008-02-07 00:15:40 -0800432 inode = hfsplus_iget(sb, be32_to_cpu(entry.folder.id));
433 if (IS_ERR(inode)) {
434 err = PTR_ERR(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435 goto cleanup;
David Howells63525392008-02-07 00:15:40 -0800436 }
Christoph Hellwigdd73a012010-10-01 05:42:59 +0200437 sbi->hidden_dir = inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438 } else
439 hfs_find_exit(&fd);
440
441 if (sb->s_flags & MS_RDONLY)
442 goto out;
443
444 /* H+LX == hfsplusutils, H+Lx == this driver, H+lx is unused
445 * all three are registered with Apple for our use
446 */
447 vhdr->last_mount_vers = cpu_to_be32(HFSP_MOUNT_VERSION);
448 vhdr->modify_date = hfsp_now2mt();
Marcin Slusarz20c79e72008-04-30 00:54:47 -0700449 be32_add_cpu(&vhdr->write_count, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450 vhdr->attributes &= cpu_to_be32(~HFSPLUS_VOL_UNMNT);
451 vhdr->attributes |= cpu_to_be32(HFSPLUS_VOL_INCNSTNT);
Christoph Hellwigdd73a012010-10-01 05:42:59 +0200452 mark_buffer_dirty(sbi->s_vhbh);
453 sync_dirty_buffer(sbi->s_vhbh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454
Christoph Hellwigdd73a012010-10-01 05:42:59 +0200455 if (!sbi->hidden_dir) {
Roman Zippel634725a2006-01-18 17:43:05 -0800456 printk(KERN_DEBUG "hfs: create hidden dir...\n");
Christoph Hellwig7ac9fb92010-10-01 05:45:08 +0200457
458 mutex_lock(&sbi->vh_mutex);
Christoph Hellwigdd73a012010-10-01 05:42:59 +0200459 sbi->hidden_dir = hfsplus_new_inode(sb, S_IFDIR);
460 hfsplus_create_cat(sbi->hidden_dir->i_ino, sb->s_root->d_inode,
461 &str, sbi->hidden_dir);
Christoph Hellwig7ac9fb92010-10-01 05:45:08 +0200462 mutex_unlock(&sbi->vh_mutex);
463
Christoph Hellwigdd73a012010-10-01 05:42:59 +0200464 mark_inode_dirty(sbi->hidden_dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465 }
466out:
467 unload_nls(sbi->nls);
468 sbi->nls = nls;
469 return 0;
470
471cleanup:
472 hfsplus_put_super(sb);
Thomas Gleixner6d729e42009-08-16 21:05:08 +0000473 unload_nls(nls);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474 return err;
475}
476
477MODULE_AUTHOR("Brad Boyer");
478MODULE_DESCRIPTION("Extended Macintosh Filesystem");
479MODULE_LICENSE("GPL");
480
Christoph Lametere18b8902006-12-06 20:33:20 -0800481static struct kmem_cache *hfsplus_inode_cachep;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482
483static struct inode *hfsplus_alloc_inode(struct super_block *sb)
484{
485 struct hfsplus_inode_info *i;
486
Christoph Lametere94b1762006-12-06 20:33:17 -0800487 i = kmem_cache_alloc(hfsplus_inode_cachep, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700488 return i ? &i->vfs_inode : NULL;
489}
490
491static void hfsplus_destroy_inode(struct inode *inode)
492{
Christoph Hellwig6af502d2010-10-01 05:43:31 +0200493 kmem_cache_free(hfsplus_inode_cachep, HFSPLUS_I(inode));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700494}
495
496#define HFSPLUS_INODE_SIZE sizeof(struct hfsplus_inode_info)
497
David Howells454e2392006-06-23 02:02:57 -0700498static int hfsplus_get_sb(struct file_system_type *fs_type,
499 int flags, const char *dev_name, void *data,
500 struct vfsmount *mnt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501{
David Howells454e2392006-06-23 02:02:57 -0700502 return get_sb_bdev(fs_type, flags, dev_name, data, hfsplus_fill_super,
503 mnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504}
505
506static struct file_system_type hfsplus_fs_type = {
507 .owner = THIS_MODULE,
508 .name = "hfsplus",
509 .get_sb = hfsplus_get_sb,
510 .kill_sb = kill_block_super,
511 .fs_flags = FS_REQUIRES_DEV,
512};
513
Alexey Dobriyan51cc5062008-07-25 19:45:34 -0700514static void hfsplus_init_once(void *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515{
516 struct hfsplus_inode_info *i = p;
517
Christoph Lametera35afb82007-05-16 22:10:57 -0700518 inode_init_once(&i->vfs_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519}
520
521static int __init init_hfsplus_fs(void)
522{
523 int err;
524
525 hfsplus_inode_cachep = kmem_cache_create("hfsplus_icache",
526 HFSPLUS_INODE_SIZE, 0, SLAB_HWCACHE_ALIGN,
Paul Mundt20c2df82007-07-20 10:11:58 +0900527 hfsplus_init_once);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528 if (!hfsplus_inode_cachep)
529 return -ENOMEM;
530 err = register_filesystem(&hfsplus_fs_type);
531 if (err)
532 kmem_cache_destroy(hfsplus_inode_cachep);
533 return err;
534}
535
536static void __exit exit_hfsplus_fs(void)
537{
538 unregister_filesystem(&hfsplus_fs_type);
Alexey Dobriyan1a1d92c2006-09-27 01:49:40 -0700539 kmem_cache_destroy(hfsplus_inode_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700540}
541
542module_init(init_hfsplus_fs)
543module_exit(exit_hfsplus_fs)