xref: /openbmc/linux/fs/hfsplus/super.c (revision 9d749629)
1 /*
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 
10 #include <linux/module.h>
11 #include <linux/init.h>
12 #include <linux/pagemap.h>
13 #include <linux/blkdev.h>
14 #include <linux/fs.h>
15 #include <linux/slab.h>
16 #include <linux/vfs.h>
17 #include <linux/nls.h>
18 
19 static struct inode *hfsplus_alloc_inode(struct super_block *sb);
20 static void hfsplus_destroy_inode(struct inode *inode);
21 
22 #include "hfsplus_fs.h"
23 
24 static int hfsplus_system_read_inode(struct inode *inode)
25 {
26 	struct hfsplus_vh *vhdr = HFSPLUS_SB(inode->i_sb)->s_vhdr;
27 
28 	switch (inode->i_ino) {
29 	case HFSPLUS_EXT_CNID:
30 		hfsplus_inode_read_fork(inode, &vhdr->ext_file);
31 		inode->i_mapping->a_ops = &hfsplus_btree_aops;
32 		break;
33 	case HFSPLUS_CAT_CNID:
34 		hfsplus_inode_read_fork(inode, &vhdr->cat_file);
35 		inode->i_mapping->a_ops = &hfsplus_btree_aops;
36 		break;
37 	case HFSPLUS_ALLOC_CNID:
38 		hfsplus_inode_read_fork(inode, &vhdr->alloc_file);
39 		inode->i_mapping->a_ops = &hfsplus_aops;
40 		break;
41 	case HFSPLUS_START_CNID:
42 		hfsplus_inode_read_fork(inode, &vhdr->start_file);
43 		break;
44 	case HFSPLUS_ATTR_CNID:
45 		hfsplus_inode_read_fork(inode, &vhdr->attr_file);
46 		inode->i_mapping->a_ops = &hfsplus_btree_aops;
47 		break;
48 	default:
49 		return -EIO;
50 	}
51 
52 	return 0;
53 }
54 
55 struct inode *hfsplus_iget(struct super_block *sb, unsigned long ino)
56 {
57 	struct hfs_find_data fd;
58 	struct inode *inode;
59 	int err;
60 
61 	inode = iget_locked(sb, ino);
62 	if (!inode)
63 		return ERR_PTR(-ENOMEM);
64 	if (!(inode->i_state & I_NEW))
65 		return inode;
66 
67 	INIT_LIST_HEAD(&HFSPLUS_I(inode)->open_dir_list);
68 	mutex_init(&HFSPLUS_I(inode)->extents_lock);
69 	HFSPLUS_I(inode)->flags = 0;
70 	HFSPLUS_I(inode)->extent_state = 0;
71 	HFSPLUS_I(inode)->rsrc_inode = NULL;
72 	atomic_set(&HFSPLUS_I(inode)->opencnt, 0);
73 
74 	if (inode->i_ino >= HFSPLUS_FIRSTUSER_CNID ||
75 	    inode->i_ino == HFSPLUS_ROOT_CNID) {
76 		err = hfs_find_init(HFSPLUS_SB(inode->i_sb)->cat_tree, &fd);
77 		if (!err) {
78 			err = hfsplus_find_cat(inode->i_sb, inode->i_ino, &fd);
79 			if (!err)
80 				err = hfsplus_cat_read_inode(inode, &fd);
81 			hfs_find_exit(&fd);
82 		}
83 	} else {
84 		err = hfsplus_system_read_inode(inode);
85 	}
86 
87 	if (err) {
88 		iget_failed(inode);
89 		return ERR_PTR(err);
90 	}
91 
92 	unlock_new_inode(inode);
93 	return inode;
94 }
95 
96 static int hfsplus_system_write_inode(struct inode *inode)
97 {
98 	struct hfsplus_sb_info *sbi = HFSPLUS_SB(inode->i_sb);
99 	struct hfsplus_vh *vhdr = sbi->s_vhdr;
100 	struct hfsplus_fork_raw *fork;
101 	struct hfs_btree *tree = NULL;
102 
103 	switch (inode->i_ino) {
104 	case HFSPLUS_EXT_CNID:
105 		fork = &vhdr->ext_file;
106 		tree = sbi->ext_tree;
107 		break;
108 	case HFSPLUS_CAT_CNID:
109 		fork = &vhdr->cat_file;
110 		tree = sbi->cat_tree;
111 		break;
112 	case HFSPLUS_ALLOC_CNID:
113 		fork = &vhdr->alloc_file;
114 		break;
115 	case HFSPLUS_START_CNID:
116 		fork = &vhdr->start_file;
117 		break;
118 	case HFSPLUS_ATTR_CNID:
119 		fork = &vhdr->attr_file;
120 		tree = sbi->attr_tree;
121 	default:
122 		return -EIO;
123 	}
124 
125 	if (fork->total_size != cpu_to_be64(inode->i_size)) {
126 		set_bit(HFSPLUS_SB_WRITEBACKUP, &sbi->flags);
127 		hfsplus_mark_mdb_dirty(inode->i_sb);
128 	}
129 	hfsplus_inode_write_fork(inode, fork);
130 	if (tree) {
131 		int err = hfs_btree_write(tree);
132 		if (err) {
133 			printk(KERN_ERR "hfs: b-tree write err: %d, ino %lu\n",
134 					err, inode->i_ino);
135 			return err;
136 		}
137 	}
138 	return 0;
139 }
140 
141 static int hfsplus_write_inode(struct inode *inode,
142 		struct writeback_control *wbc)
143 {
144 	int err;
145 
146 	dprint(DBG_INODE, "hfsplus_write_inode: %lu\n", inode->i_ino);
147 
148 	err = hfsplus_ext_write_extent(inode);
149 	if (err)
150 		return err;
151 
152 	if (inode->i_ino >= HFSPLUS_FIRSTUSER_CNID ||
153 	    inode->i_ino == HFSPLUS_ROOT_CNID)
154 		return hfsplus_cat_write_inode(inode);
155 	else
156 		return hfsplus_system_write_inode(inode);
157 }
158 
159 static void hfsplus_evict_inode(struct inode *inode)
160 {
161 	dprint(DBG_INODE, "hfsplus_evict_inode: %lu\n", inode->i_ino);
162 	truncate_inode_pages(&inode->i_data, 0);
163 	clear_inode(inode);
164 	if (HFSPLUS_IS_RSRC(inode)) {
165 		HFSPLUS_I(HFSPLUS_I(inode)->rsrc_inode)->rsrc_inode = NULL;
166 		iput(HFSPLUS_I(inode)->rsrc_inode);
167 	}
168 }
169 
170 static int hfsplus_sync_fs(struct super_block *sb, int wait)
171 {
172 	struct hfsplus_sb_info *sbi = HFSPLUS_SB(sb);
173 	struct hfsplus_vh *vhdr = sbi->s_vhdr;
174 	int write_backup = 0;
175 	int error, error2;
176 
177 	if (!wait)
178 		return 0;
179 
180 	dprint(DBG_SUPER, "hfsplus_sync_fs\n");
181 
182 	/*
183 	 * Explicitly write out the special metadata inodes.
184 	 *
185 	 * While these special inodes are marked as hashed and written
186 	 * out peridocically by the flusher threads we redirty them
187 	 * during writeout of normal inodes, and thus the life lock
188 	 * prevents us from getting the latest state to disk.
189 	 */
190 	error = filemap_write_and_wait(sbi->cat_tree->inode->i_mapping);
191 	error2 = filemap_write_and_wait(sbi->ext_tree->inode->i_mapping);
192 	if (!error)
193 		error = error2;
194 	error2 = filemap_write_and_wait(sbi->alloc_file->i_mapping);
195 	if (!error)
196 		error = error2;
197 
198 	mutex_lock(&sbi->vh_mutex);
199 	mutex_lock(&sbi->alloc_mutex);
200 	vhdr->free_blocks = cpu_to_be32(sbi->free_blocks);
201 	vhdr->next_cnid = cpu_to_be32(sbi->next_cnid);
202 	vhdr->folder_count = cpu_to_be32(sbi->folder_count);
203 	vhdr->file_count = cpu_to_be32(sbi->file_count);
204 
205 	if (test_and_clear_bit(HFSPLUS_SB_WRITEBACKUP, &sbi->flags)) {
206 		memcpy(sbi->s_backup_vhdr, sbi->s_vhdr, sizeof(*sbi->s_vhdr));
207 		write_backup = 1;
208 	}
209 
210 	error2 = hfsplus_submit_bio(sb,
211 				   sbi->part_start + HFSPLUS_VOLHEAD_SECTOR,
212 				   sbi->s_vhdr_buf, NULL, WRITE_SYNC);
213 	if (!error)
214 		error = error2;
215 	if (!write_backup)
216 		goto out;
217 
218 	error2 = hfsplus_submit_bio(sb,
219 				  sbi->part_start + sbi->sect_count - 2,
220 				  sbi->s_backup_vhdr_buf, NULL, WRITE_SYNC);
221 	if (!error)
222 		error2 = error;
223 out:
224 	mutex_unlock(&sbi->alloc_mutex);
225 	mutex_unlock(&sbi->vh_mutex);
226 
227 	if (!test_bit(HFSPLUS_SB_NOBARRIER, &sbi->flags))
228 		blkdev_issue_flush(sb->s_bdev, GFP_KERNEL, NULL);
229 
230 	return error;
231 }
232 
233 static void delayed_sync_fs(struct work_struct *work)
234 {
235 	int err;
236 	struct hfsplus_sb_info *sbi;
237 
238 	sbi = container_of(work, struct hfsplus_sb_info, sync_work.work);
239 
240 	spin_lock(&sbi->work_lock);
241 	sbi->work_queued = 0;
242 	spin_unlock(&sbi->work_lock);
243 
244 	err = hfsplus_sync_fs(sbi->alloc_file->i_sb, 1);
245 	if (err)
246 		printk(KERN_ERR "hfs: delayed sync fs err %d\n", err);
247 }
248 
249 void hfsplus_mark_mdb_dirty(struct super_block *sb)
250 {
251 	struct hfsplus_sb_info *sbi = HFSPLUS_SB(sb);
252 	unsigned long delay;
253 
254 	if (sb->s_flags & MS_RDONLY)
255 		return;
256 
257 	spin_lock(&sbi->work_lock);
258 	if (!sbi->work_queued) {
259 		delay = msecs_to_jiffies(dirty_writeback_interval * 10);
260 		queue_delayed_work(system_long_wq, &sbi->sync_work, delay);
261 		sbi->work_queued = 1;
262 	}
263 	spin_unlock(&sbi->work_lock);
264 }
265 
266 static void hfsplus_put_super(struct super_block *sb)
267 {
268 	struct hfsplus_sb_info *sbi = HFSPLUS_SB(sb);
269 
270 	dprint(DBG_SUPER, "hfsplus_put_super\n");
271 
272 	cancel_delayed_work_sync(&sbi->sync_work);
273 
274 	if (!(sb->s_flags & MS_RDONLY) && sbi->s_vhdr) {
275 		struct hfsplus_vh *vhdr = sbi->s_vhdr;
276 
277 		vhdr->modify_date = hfsp_now2mt();
278 		vhdr->attributes |= cpu_to_be32(HFSPLUS_VOL_UNMNT);
279 		vhdr->attributes &= cpu_to_be32(~HFSPLUS_VOL_INCNSTNT);
280 
281 		hfsplus_sync_fs(sb, 1);
282 	}
283 
284 	hfs_btree_close(sbi->cat_tree);
285 	hfs_btree_close(sbi->ext_tree);
286 	iput(sbi->alloc_file);
287 	iput(sbi->hidden_dir);
288 	kfree(sbi->s_vhdr_buf);
289 	kfree(sbi->s_backup_vhdr_buf);
290 	unload_nls(sbi->nls);
291 	kfree(sb->s_fs_info);
292 	sb->s_fs_info = NULL;
293 }
294 
295 static int hfsplus_statfs(struct dentry *dentry, struct kstatfs *buf)
296 {
297 	struct super_block *sb = dentry->d_sb;
298 	struct hfsplus_sb_info *sbi = HFSPLUS_SB(sb);
299 	u64 id = huge_encode_dev(sb->s_bdev->bd_dev);
300 
301 	buf->f_type = HFSPLUS_SUPER_MAGIC;
302 	buf->f_bsize = sb->s_blocksize;
303 	buf->f_blocks = sbi->total_blocks << sbi->fs_shift;
304 	buf->f_bfree = sbi->free_blocks << sbi->fs_shift;
305 	buf->f_bavail = buf->f_bfree;
306 	buf->f_files = 0xFFFFFFFF;
307 	buf->f_ffree = 0xFFFFFFFF - sbi->next_cnid;
308 	buf->f_fsid.val[0] = (u32)id;
309 	buf->f_fsid.val[1] = (u32)(id >> 32);
310 	buf->f_namelen = HFSPLUS_MAX_STRLEN;
311 
312 	return 0;
313 }
314 
315 static int hfsplus_remount(struct super_block *sb, int *flags, char *data)
316 {
317 	if ((*flags & MS_RDONLY) == (sb->s_flags & MS_RDONLY))
318 		return 0;
319 	if (!(*flags & MS_RDONLY)) {
320 		struct hfsplus_vh *vhdr = HFSPLUS_SB(sb)->s_vhdr;
321 		int force = 0;
322 
323 		if (!hfsplus_parse_options_remount(data, &force))
324 			return -EINVAL;
325 
326 		if (!(vhdr->attributes & cpu_to_be32(HFSPLUS_VOL_UNMNT))) {
327 			printk(KERN_WARNING "hfs: filesystem was "
328 					"not cleanly unmounted, "
329 					"running fsck.hfsplus is recommended.  "
330 					"leaving read-only.\n");
331 			sb->s_flags |= MS_RDONLY;
332 			*flags |= MS_RDONLY;
333 		} else if (force) {
334 			/* nothing */
335 		} else if (vhdr->attributes &
336 				cpu_to_be32(HFSPLUS_VOL_SOFTLOCK)) {
337 			printk(KERN_WARNING "hfs: filesystem is marked locked, "
338 					"leaving read-only.\n");
339 			sb->s_flags |= MS_RDONLY;
340 			*flags |= MS_RDONLY;
341 		} else if (vhdr->attributes &
342 				cpu_to_be32(HFSPLUS_VOL_JOURNALED)) {
343 			printk(KERN_WARNING "hfs: filesystem is "
344 					"marked journaled, "
345 					"leaving read-only.\n");
346 			sb->s_flags |= MS_RDONLY;
347 			*flags |= MS_RDONLY;
348 		}
349 	}
350 	return 0;
351 }
352 
353 static const struct super_operations hfsplus_sops = {
354 	.alloc_inode	= hfsplus_alloc_inode,
355 	.destroy_inode	= hfsplus_destroy_inode,
356 	.write_inode	= hfsplus_write_inode,
357 	.evict_inode	= hfsplus_evict_inode,
358 	.put_super	= hfsplus_put_super,
359 	.sync_fs	= hfsplus_sync_fs,
360 	.statfs		= hfsplus_statfs,
361 	.remount_fs	= hfsplus_remount,
362 	.show_options	= hfsplus_show_options,
363 };
364 
365 static int hfsplus_fill_super(struct super_block *sb, void *data, int silent)
366 {
367 	struct hfsplus_vh *vhdr;
368 	struct hfsplus_sb_info *sbi;
369 	hfsplus_cat_entry entry;
370 	struct hfs_find_data fd;
371 	struct inode *root, *inode;
372 	struct qstr str;
373 	struct nls_table *nls = NULL;
374 	u64 last_fs_block, last_fs_page;
375 	int err;
376 
377 	err = -ENOMEM;
378 	sbi = kzalloc(sizeof(*sbi), GFP_KERNEL);
379 	if (!sbi)
380 		goto out;
381 
382 	sb->s_fs_info = sbi;
383 	mutex_init(&sbi->alloc_mutex);
384 	mutex_init(&sbi->vh_mutex);
385 	spin_lock_init(&sbi->work_lock);
386 	INIT_DELAYED_WORK(&sbi->sync_work, delayed_sync_fs);
387 	hfsplus_fill_defaults(sbi);
388 
389 	err = -EINVAL;
390 	if (!hfsplus_parse_options(data, sbi)) {
391 		printk(KERN_ERR "hfs: unable to parse mount options\n");
392 		goto out_unload_nls;
393 	}
394 
395 	/* temporarily use utf8 to correctly find the hidden dir below */
396 	nls = sbi->nls;
397 	sbi->nls = load_nls("utf8");
398 	if (!sbi->nls) {
399 		printk(KERN_ERR "hfs: unable to load nls for utf8\n");
400 		goto out_unload_nls;
401 	}
402 
403 	/* Grab the volume header */
404 	if (hfsplus_read_wrapper(sb)) {
405 		if (!silent)
406 			printk(KERN_WARNING "hfs: unable to find HFS+ superblock\n");
407 		goto out_unload_nls;
408 	}
409 	vhdr = sbi->s_vhdr;
410 
411 	/* Copy parts of the volume header into the superblock */
412 	sb->s_magic = HFSPLUS_VOLHEAD_SIG;
413 	if (be16_to_cpu(vhdr->version) < HFSPLUS_MIN_VERSION ||
414 	    be16_to_cpu(vhdr->version) > HFSPLUS_CURRENT_VERSION) {
415 		printk(KERN_ERR "hfs: wrong filesystem version\n");
416 		goto out_free_vhdr;
417 	}
418 	sbi->total_blocks = be32_to_cpu(vhdr->total_blocks);
419 	sbi->free_blocks = be32_to_cpu(vhdr->free_blocks);
420 	sbi->next_cnid = be32_to_cpu(vhdr->next_cnid);
421 	sbi->file_count = be32_to_cpu(vhdr->file_count);
422 	sbi->folder_count = be32_to_cpu(vhdr->folder_count);
423 	sbi->data_clump_blocks =
424 		be32_to_cpu(vhdr->data_clump_sz) >> sbi->alloc_blksz_shift;
425 	if (!sbi->data_clump_blocks)
426 		sbi->data_clump_blocks = 1;
427 	sbi->rsrc_clump_blocks =
428 		be32_to_cpu(vhdr->rsrc_clump_sz) >> sbi->alloc_blksz_shift;
429 	if (!sbi->rsrc_clump_blocks)
430 		sbi->rsrc_clump_blocks = 1;
431 
432 	err = -EFBIG;
433 	last_fs_block = sbi->total_blocks - 1;
434 	last_fs_page = (last_fs_block << sbi->alloc_blksz_shift) >>
435 			PAGE_CACHE_SHIFT;
436 
437 	if ((last_fs_block > (sector_t)(~0ULL) >> (sbi->alloc_blksz_shift - 9)) ||
438 	    (last_fs_page > (pgoff_t)(~0ULL))) {
439 		printk(KERN_ERR "hfs: filesystem size too large.\n");
440 		goto out_free_vhdr;
441 	}
442 
443 	/* Set up operations so we can load metadata */
444 	sb->s_op = &hfsplus_sops;
445 	sb->s_maxbytes = MAX_LFS_FILESIZE;
446 
447 	if (!(vhdr->attributes & cpu_to_be32(HFSPLUS_VOL_UNMNT))) {
448 		printk(KERN_WARNING "hfs: Filesystem was "
449 				"not cleanly unmounted, "
450 				"running fsck.hfsplus is recommended.  "
451 				"mounting read-only.\n");
452 		sb->s_flags |= MS_RDONLY;
453 	} else if (test_and_clear_bit(HFSPLUS_SB_FORCE, &sbi->flags)) {
454 		/* nothing */
455 	} else if (vhdr->attributes & cpu_to_be32(HFSPLUS_VOL_SOFTLOCK)) {
456 		printk(KERN_WARNING "hfs: Filesystem is marked locked, mounting read-only.\n");
457 		sb->s_flags |= MS_RDONLY;
458 	} else if ((vhdr->attributes & cpu_to_be32(HFSPLUS_VOL_JOURNALED)) &&
459 			!(sb->s_flags & MS_RDONLY)) {
460 		printk(KERN_WARNING "hfs: write access to "
461 				"a journaled filesystem is not supported, "
462 				"use the force option at your own risk, "
463 				"mounting read-only.\n");
464 		sb->s_flags |= MS_RDONLY;
465 	}
466 
467 	err = -EINVAL;
468 
469 	/* Load metadata objects (B*Trees) */
470 	sbi->ext_tree = hfs_btree_open(sb, HFSPLUS_EXT_CNID);
471 	if (!sbi->ext_tree) {
472 		printk(KERN_ERR "hfs: failed to load extents file\n");
473 		goto out_free_vhdr;
474 	}
475 	sbi->cat_tree = hfs_btree_open(sb, HFSPLUS_CAT_CNID);
476 	if (!sbi->cat_tree) {
477 		printk(KERN_ERR "hfs: failed to load catalog file\n");
478 		goto out_close_ext_tree;
479 	}
480 
481 	inode = hfsplus_iget(sb, HFSPLUS_ALLOC_CNID);
482 	if (IS_ERR(inode)) {
483 		printk(KERN_ERR "hfs: failed to load allocation file\n");
484 		err = PTR_ERR(inode);
485 		goto out_close_cat_tree;
486 	}
487 	sbi->alloc_file = inode;
488 
489 	/* Load the root directory */
490 	root = hfsplus_iget(sb, HFSPLUS_ROOT_CNID);
491 	if (IS_ERR(root)) {
492 		printk(KERN_ERR "hfs: failed to load root directory\n");
493 		err = PTR_ERR(root);
494 		goto out_put_alloc_file;
495 	}
496 
497 	sb->s_d_op = &hfsplus_dentry_operations;
498 	sb->s_root = d_make_root(root);
499 	if (!sb->s_root) {
500 		err = -ENOMEM;
501 		goto out_put_alloc_file;
502 	}
503 
504 	str.len = sizeof(HFSP_HIDDENDIR_NAME) - 1;
505 	str.name = HFSP_HIDDENDIR_NAME;
506 	err = hfs_find_init(sbi->cat_tree, &fd);
507 	if (err)
508 		goto out_put_root;
509 	hfsplus_cat_build_key(sb, fd.search_key, HFSPLUS_ROOT_CNID, &str);
510 	if (!hfs_brec_read(&fd, &entry, sizeof(entry))) {
511 		hfs_find_exit(&fd);
512 		if (entry.type != cpu_to_be16(HFSPLUS_FOLDER))
513 			goto out_put_root;
514 		inode = hfsplus_iget(sb, be32_to_cpu(entry.folder.id));
515 		if (IS_ERR(inode)) {
516 			err = PTR_ERR(inode);
517 			goto out_put_root;
518 		}
519 		sbi->hidden_dir = inode;
520 	} else
521 		hfs_find_exit(&fd);
522 
523 	if (!(sb->s_flags & MS_RDONLY)) {
524 		/*
525 		 * H+LX == hfsplusutils, H+Lx == this driver, H+lx is unused
526 		 * all three are registered with Apple for our use
527 		 */
528 		vhdr->last_mount_vers = cpu_to_be32(HFSP_MOUNT_VERSION);
529 		vhdr->modify_date = hfsp_now2mt();
530 		be32_add_cpu(&vhdr->write_count, 1);
531 		vhdr->attributes &= cpu_to_be32(~HFSPLUS_VOL_UNMNT);
532 		vhdr->attributes |= cpu_to_be32(HFSPLUS_VOL_INCNSTNT);
533 		hfsplus_sync_fs(sb, 1);
534 
535 		if (!sbi->hidden_dir) {
536 			mutex_lock(&sbi->vh_mutex);
537 			sbi->hidden_dir = hfsplus_new_inode(sb, S_IFDIR);
538 			if (!sbi->hidden_dir) {
539 				mutex_unlock(&sbi->vh_mutex);
540 				err = -ENOMEM;
541 				goto out_put_root;
542 			}
543 			err = hfsplus_create_cat(sbi->hidden_dir->i_ino, root,
544 						 &str, sbi->hidden_dir);
545 			mutex_unlock(&sbi->vh_mutex);
546 			if (err)
547 				goto out_put_hidden_dir;
548 
549 			hfsplus_mark_inode_dirty(sbi->hidden_dir,
550 						 HFSPLUS_I_CAT_DIRTY);
551 		}
552 	}
553 
554 	unload_nls(sbi->nls);
555 	sbi->nls = nls;
556 	return 0;
557 
558 out_put_hidden_dir:
559 	iput(sbi->hidden_dir);
560 out_put_root:
561 	dput(sb->s_root);
562 	sb->s_root = NULL;
563 out_put_alloc_file:
564 	iput(sbi->alloc_file);
565 out_close_cat_tree:
566 	hfs_btree_close(sbi->cat_tree);
567 out_close_ext_tree:
568 	hfs_btree_close(sbi->ext_tree);
569 out_free_vhdr:
570 	kfree(sbi->s_vhdr_buf);
571 	kfree(sbi->s_backup_vhdr_buf);
572 out_unload_nls:
573 	unload_nls(sbi->nls);
574 	unload_nls(nls);
575 	kfree(sbi);
576 out:
577 	return err;
578 }
579 
580 MODULE_AUTHOR("Brad Boyer");
581 MODULE_DESCRIPTION("Extended Macintosh Filesystem");
582 MODULE_LICENSE("GPL");
583 
584 static struct kmem_cache *hfsplus_inode_cachep;
585 
586 static struct inode *hfsplus_alloc_inode(struct super_block *sb)
587 {
588 	struct hfsplus_inode_info *i;
589 
590 	i = kmem_cache_alloc(hfsplus_inode_cachep, GFP_KERNEL);
591 	return i ? &i->vfs_inode : NULL;
592 }
593 
594 static void hfsplus_i_callback(struct rcu_head *head)
595 {
596 	struct inode *inode = container_of(head, struct inode, i_rcu);
597 
598 	kmem_cache_free(hfsplus_inode_cachep, HFSPLUS_I(inode));
599 }
600 
601 static void hfsplus_destroy_inode(struct inode *inode)
602 {
603 	call_rcu(&inode->i_rcu, hfsplus_i_callback);
604 }
605 
606 #define HFSPLUS_INODE_SIZE	sizeof(struct hfsplus_inode_info)
607 
608 static struct dentry *hfsplus_mount(struct file_system_type *fs_type,
609 			  int flags, const char *dev_name, void *data)
610 {
611 	return mount_bdev(fs_type, flags, dev_name, data, hfsplus_fill_super);
612 }
613 
614 static struct file_system_type hfsplus_fs_type = {
615 	.owner		= THIS_MODULE,
616 	.name		= "hfsplus",
617 	.mount		= hfsplus_mount,
618 	.kill_sb	= kill_block_super,
619 	.fs_flags	= FS_REQUIRES_DEV,
620 };
621 
622 static void hfsplus_init_once(void *p)
623 {
624 	struct hfsplus_inode_info *i = p;
625 
626 	inode_init_once(&i->vfs_inode);
627 }
628 
629 static int __init init_hfsplus_fs(void)
630 {
631 	int err;
632 
633 	hfsplus_inode_cachep = kmem_cache_create("hfsplus_icache",
634 		HFSPLUS_INODE_SIZE, 0, SLAB_HWCACHE_ALIGN,
635 		hfsplus_init_once);
636 	if (!hfsplus_inode_cachep)
637 		return -ENOMEM;
638 	err = register_filesystem(&hfsplus_fs_type);
639 	if (err)
640 		kmem_cache_destroy(hfsplus_inode_cachep);
641 	return err;
642 }
643 
644 static void __exit exit_hfsplus_fs(void)
645 {
646 	unregister_filesystem(&hfsplus_fs_type);
647 
648 	/*
649 	 * Make sure all delayed rcu free inodes are flushed before we
650 	 * destroy cache.
651 	 */
652 	rcu_barrier();
653 	kmem_cache_destroy(hfsplus_inode_cachep);
654 }
655 
656 module_init(init_hfsplus_fs)
657 module_exit(exit_hfsplus_fs)
658