Root/
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/fs.h> |
14 | #include <linux/slab.h> |
15 | #include <linux/smp_lock.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 | struct inode *hfsplus_iget(struct super_block *sb, unsigned long ino) |
25 | { |
26 | struct hfs_find_data fd; |
27 | struct hfsplus_vh *vhdr; |
28 | struct inode *inode; |
29 | long err = -EIO; |
30 | |
31 | inode = iget_locked(sb, ino); |
32 | if (!inode) |
33 | return ERR_PTR(-ENOMEM); |
34 | if (!(inode->i_state & I_NEW)) |
35 | return inode; |
36 | |
37 | INIT_LIST_HEAD(&HFSPLUS_I(inode).open_dir_list); |
38 | mutex_init(&HFSPLUS_I(inode).extents_lock); |
39 | HFSPLUS_I(inode).flags = 0; |
40 | HFSPLUS_I(inode).rsrc_inode = NULL; |
41 | atomic_set(&HFSPLUS_I(inode).opencnt, 0); |
42 | |
43 | if (inode->i_ino >= HFSPLUS_FIRSTUSER_CNID) { |
44 | read_inode: |
45 | hfs_find_init(HFSPLUS_SB(inode->i_sb).cat_tree, &fd); |
46 | err = hfsplus_find_cat(inode->i_sb, inode->i_ino, &fd); |
47 | if (!err) |
48 | err = hfsplus_cat_read_inode(inode, &fd); |
49 | hfs_find_exit(&fd); |
50 | if (err) |
51 | goto bad_inode; |
52 | goto done; |
53 | } |
54 | vhdr = HFSPLUS_SB(inode->i_sb).s_vhdr; |
55 | switch(inode->i_ino) { |
56 | case HFSPLUS_ROOT_CNID: |
57 | goto read_inode; |
58 | case HFSPLUS_EXT_CNID: |
59 | hfsplus_inode_read_fork(inode, &vhdr->ext_file); |
60 | inode->i_mapping->a_ops = &hfsplus_btree_aops; |
61 | break; |
62 | case HFSPLUS_CAT_CNID: |
63 | hfsplus_inode_read_fork(inode, &vhdr->cat_file); |
64 | inode->i_mapping->a_ops = &hfsplus_btree_aops; |
65 | break; |
66 | case HFSPLUS_ALLOC_CNID: |
67 | hfsplus_inode_read_fork(inode, &vhdr->alloc_file); |
68 | inode->i_mapping->a_ops = &hfsplus_aops; |
69 | break; |
70 | case HFSPLUS_START_CNID: |
71 | hfsplus_inode_read_fork(inode, &vhdr->start_file); |
72 | break; |
73 | case HFSPLUS_ATTR_CNID: |
74 | hfsplus_inode_read_fork(inode, &vhdr->attr_file); |
75 | inode->i_mapping->a_ops = &hfsplus_btree_aops; |
76 | break; |
77 | default: |
78 | goto bad_inode; |
79 | } |
80 | |
81 | done: |
82 | unlock_new_inode(inode); |
83 | return inode; |
84 | |
85 | bad_inode: |
86 | iget_failed(inode); |
87 | return ERR_PTR(err); |
88 | } |
89 | |
90 | static int hfsplus_write_inode(struct inode *inode, |
91 | struct writeback_control *wbc) |
92 | { |
93 | struct hfsplus_vh *vhdr; |
94 | int ret = 0; |
95 | |
96 | dprint(DBG_INODE, "hfsplus_write_inode: %lu\n", inode->i_ino); |
97 | hfsplus_ext_write_extent(inode); |
98 | if (inode->i_ino >= HFSPLUS_FIRSTUSER_CNID) { |
99 | return hfsplus_cat_write_inode(inode); |
100 | } |
101 | vhdr = HFSPLUS_SB(inode->i_sb).s_vhdr; |
102 | switch (inode->i_ino) { |
103 | case HFSPLUS_ROOT_CNID: |
104 | ret = hfsplus_cat_write_inode(inode); |
105 | break; |
106 | case HFSPLUS_EXT_CNID: |
107 | if (vhdr->ext_file.total_size != cpu_to_be64(inode->i_size)) { |
108 | HFSPLUS_SB(inode->i_sb).flags |= HFSPLUS_SB_WRITEBACKUP; |
109 | inode->i_sb->s_dirt = 1; |
110 | } |
111 | hfsplus_inode_write_fork(inode, &vhdr->ext_file); |
112 | hfs_btree_write(HFSPLUS_SB(inode->i_sb).ext_tree); |
113 | break; |
114 | case HFSPLUS_CAT_CNID: |
115 | if (vhdr->cat_file.total_size != cpu_to_be64(inode->i_size)) { |
116 | HFSPLUS_SB(inode->i_sb).flags |= HFSPLUS_SB_WRITEBACKUP; |
117 | inode->i_sb->s_dirt = 1; |
118 | } |
119 | hfsplus_inode_write_fork(inode, &vhdr->cat_file); |
120 | hfs_btree_write(HFSPLUS_SB(inode->i_sb).cat_tree); |
121 | break; |
122 | case HFSPLUS_ALLOC_CNID: |
123 | if (vhdr->alloc_file.total_size != cpu_to_be64(inode->i_size)) { |
124 | HFSPLUS_SB(inode->i_sb).flags |= HFSPLUS_SB_WRITEBACKUP; |
125 | inode->i_sb->s_dirt = 1; |
126 | } |
127 | hfsplus_inode_write_fork(inode, &vhdr->alloc_file); |
128 | break; |
129 | case HFSPLUS_START_CNID: |
130 | if (vhdr->start_file.total_size != cpu_to_be64(inode->i_size)) { |
131 | HFSPLUS_SB(inode->i_sb).flags |= HFSPLUS_SB_WRITEBACKUP; |
132 | inode->i_sb->s_dirt = 1; |
133 | } |
134 | hfsplus_inode_write_fork(inode, &vhdr->start_file); |
135 | break; |
136 | case HFSPLUS_ATTR_CNID: |
137 | if (vhdr->attr_file.total_size != cpu_to_be64(inode->i_size)) { |
138 | HFSPLUS_SB(inode->i_sb).flags |= HFSPLUS_SB_WRITEBACKUP; |
139 | inode->i_sb->s_dirt = 1; |
140 | } |
141 | hfsplus_inode_write_fork(inode, &vhdr->attr_file); |
142 | hfs_btree_write(HFSPLUS_SB(inode->i_sb).attr_tree); |
143 | break; |
144 | } |
145 | return ret; |
146 | } |
147 | |
148 | static void hfsplus_clear_inode(struct inode *inode) |
149 | { |
150 | dprint(DBG_INODE, "hfsplus_clear_inode: %lu\n", inode->i_ino); |
151 | if (HFSPLUS_IS_RSRC(inode)) { |
152 | HFSPLUS_I(HFSPLUS_I(inode).rsrc_inode).rsrc_inode = NULL; |
153 | iput(HFSPLUS_I(inode).rsrc_inode); |
154 | } |
155 | } |
156 | |
157 | static int hfsplus_sync_fs(struct super_block *sb, int wait) |
158 | { |
159 | struct hfsplus_vh *vhdr = HFSPLUS_SB(sb).s_vhdr; |
160 | |
161 | dprint(DBG_SUPER, "hfsplus_write_super\n"); |
162 | |
163 | lock_super(sb); |
164 | sb->s_dirt = 0; |
165 | |
166 | vhdr->free_blocks = cpu_to_be32(HFSPLUS_SB(sb).free_blocks); |
167 | vhdr->next_alloc = cpu_to_be32(HFSPLUS_SB(sb).next_alloc); |
168 | vhdr->next_cnid = cpu_to_be32(HFSPLUS_SB(sb).next_cnid); |
169 | vhdr->folder_count = cpu_to_be32(HFSPLUS_SB(sb).folder_count); |
170 | vhdr->file_count = cpu_to_be32(HFSPLUS_SB(sb).file_count); |
171 | |
172 | mark_buffer_dirty(HFSPLUS_SB(sb).s_vhbh); |
173 | if (HFSPLUS_SB(sb).flags & HFSPLUS_SB_WRITEBACKUP) { |
174 | if (HFSPLUS_SB(sb).sect_count) { |
175 | struct buffer_head *bh; |
176 | u32 block, offset; |
177 | |
178 | block = HFSPLUS_SB(sb).blockoffset; |
179 | block += (HFSPLUS_SB(sb).sect_count - 2) >> (sb->s_blocksize_bits - 9); |
180 | offset = ((HFSPLUS_SB(sb).sect_count - 2) << 9) & (sb->s_blocksize - 1); |
181 | printk(KERN_DEBUG "hfs: backup: %u,%u,%u,%u\n", HFSPLUS_SB(sb).blockoffset, |
182 | HFSPLUS_SB(sb).sect_count, block, offset); |
183 | bh = sb_bread(sb, block); |
184 | if (bh) { |
185 | vhdr = (struct hfsplus_vh *)(bh->b_data + offset); |
186 | if (be16_to_cpu(vhdr->signature) == HFSPLUS_VOLHEAD_SIG) { |
187 | memcpy(vhdr, HFSPLUS_SB(sb).s_vhdr, sizeof(*vhdr)); |
188 | mark_buffer_dirty(bh); |
189 | brelse(bh); |
190 | } else |
191 | printk(KERN_WARNING "hfs: backup not found!\n"); |
192 | } |
193 | } |
194 | HFSPLUS_SB(sb).flags &= ~HFSPLUS_SB_WRITEBACKUP; |
195 | } |
196 | unlock_super(sb); |
197 | return 0; |
198 | } |
199 | |
200 | static void hfsplus_write_super(struct super_block *sb) |
201 | { |
202 | if (!(sb->s_flags & MS_RDONLY)) |
203 | hfsplus_sync_fs(sb, 1); |
204 | else |
205 | sb->s_dirt = 0; |
206 | } |
207 | |
208 | static void hfsplus_put_super(struct super_block *sb) |
209 | { |
210 | dprint(DBG_SUPER, "hfsplus_put_super\n"); |
211 | if (!sb->s_fs_info) |
212 | return; |
213 | |
214 | lock_kernel(); |
215 | |
216 | if (sb->s_dirt) |
217 | hfsplus_write_super(sb); |
218 | if (!(sb->s_flags & MS_RDONLY) && HFSPLUS_SB(sb).s_vhdr) { |
219 | struct hfsplus_vh *vhdr = HFSPLUS_SB(sb).s_vhdr; |
220 | |
221 | vhdr->modify_date = hfsp_now2mt(); |
222 | vhdr->attributes |= cpu_to_be32(HFSPLUS_VOL_UNMNT); |
223 | vhdr->attributes &= cpu_to_be32(~HFSPLUS_VOL_INCNSTNT); |
224 | mark_buffer_dirty(HFSPLUS_SB(sb).s_vhbh); |
225 | sync_dirty_buffer(HFSPLUS_SB(sb).s_vhbh); |
226 | } |
227 | |
228 | hfs_btree_close(HFSPLUS_SB(sb).cat_tree); |
229 | hfs_btree_close(HFSPLUS_SB(sb).ext_tree); |
230 | iput(HFSPLUS_SB(sb).alloc_file); |
231 | iput(HFSPLUS_SB(sb).hidden_dir); |
232 | brelse(HFSPLUS_SB(sb).s_vhbh); |
233 | unload_nls(HFSPLUS_SB(sb).nls); |
234 | kfree(sb->s_fs_info); |
235 | sb->s_fs_info = NULL; |
236 | |
237 | unlock_kernel(); |
238 | } |
239 | |
240 | static int hfsplus_statfs(struct dentry *dentry, struct kstatfs *buf) |
241 | { |
242 | struct super_block *sb = dentry->d_sb; |
243 | u64 id = huge_encode_dev(sb->s_bdev->bd_dev); |
244 | |
245 | buf->f_type = HFSPLUS_SUPER_MAGIC; |
246 | buf->f_bsize = sb->s_blocksize; |
247 | buf->f_blocks = HFSPLUS_SB(sb).total_blocks << HFSPLUS_SB(sb).fs_shift; |
248 | buf->f_bfree = HFSPLUS_SB(sb).free_blocks << HFSPLUS_SB(sb).fs_shift; |
249 | buf->f_bavail = buf->f_bfree; |
250 | buf->f_files = 0xFFFFFFFF; |
251 | buf->f_ffree = 0xFFFFFFFF - HFSPLUS_SB(sb).next_cnid; |
252 | buf->f_fsid.val[0] = (u32)id; |
253 | buf->f_fsid.val[1] = (u32)(id >> 32); |
254 | buf->f_namelen = HFSPLUS_MAX_STRLEN; |
255 | |
256 | return 0; |
257 | } |
258 | |
259 | static int hfsplus_remount(struct super_block *sb, int *flags, char *data) |
260 | { |
261 | if ((*flags & MS_RDONLY) == (sb->s_flags & MS_RDONLY)) |
262 | return 0; |
263 | if (!(*flags & MS_RDONLY)) { |
264 | struct hfsplus_vh *vhdr = HFSPLUS_SB(sb).s_vhdr; |
265 | struct hfsplus_sb_info sbi; |
266 | |
267 | memset(&sbi, 0, sizeof(struct hfsplus_sb_info)); |
268 | sbi.nls = HFSPLUS_SB(sb).nls; |
269 | if (!hfsplus_parse_options(data, &sbi)) |
270 | return -EINVAL; |
271 | |
272 | if (!(vhdr->attributes & cpu_to_be32(HFSPLUS_VOL_UNMNT))) { |
273 | printk(KERN_WARNING "hfs: filesystem was not cleanly unmounted, " |
274 | "running fsck.hfsplus is recommended. leaving read-only.\n"); |
275 | sb->s_flags |= MS_RDONLY; |
276 | *flags |= MS_RDONLY; |
277 | } else if (sbi.flags & HFSPLUS_SB_FORCE) { |
278 | /* nothing */ |
279 | } else if (vhdr->attributes & cpu_to_be32(HFSPLUS_VOL_SOFTLOCK)) { |
280 | printk(KERN_WARNING "hfs: filesystem is marked locked, leaving read-only.\n"); |
281 | sb->s_flags |= MS_RDONLY; |
282 | *flags |= MS_RDONLY; |
283 | } else if (vhdr->attributes & cpu_to_be32(HFSPLUS_VOL_JOURNALED)) { |
284 | printk(KERN_WARNING "hfs: filesystem is marked journaled, leaving read-only.\n"); |
285 | sb->s_flags |= MS_RDONLY; |
286 | *flags |= MS_RDONLY; |
287 | } |
288 | } |
289 | return 0; |
290 | } |
291 | |
292 | static const struct super_operations hfsplus_sops = { |
293 | .alloc_inode = hfsplus_alloc_inode, |
294 | .destroy_inode = hfsplus_destroy_inode, |
295 | .write_inode = hfsplus_write_inode, |
296 | .clear_inode = hfsplus_clear_inode, |
297 | .put_super = hfsplus_put_super, |
298 | .write_super = hfsplus_write_super, |
299 | .sync_fs = hfsplus_sync_fs, |
300 | .statfs = hfsplus_statfs, |
301 | .remount_fs = hfsplus_remount, |
302 | .show_options = hfsplus_show_options, |
303 | }; |
304 | |
305 | static int hfsplus_fill_super(struct super_block *sb, void *data, int silent) |
306 | { |
307 | struct hfsplus_vh *vhdr; |
308 | struct hfsplus_sb_info *sbi; |
309 | hfsplus_cat_entry entry; |
310 | struct hfs_find_data fd; |
311 | struct inode *root, *inode; |
312 | struct qstr str; |
313 | struct nls_table *nls = NULL; |
314 | int err = -EINVAL; |
315 | |
316 | sbi = kzalloc(sizeof(*sbi), GFP_KERNEL); |
317 | if (!sbi) |
318 | return -ENOMEM; |
319 | |
320 | sb->s_fs_info = sbi; |
321 | INIT_HLIST_HEAD(&sbi->rsrc_inodes); |
322 | hfsplus_fill_defaults(sbi); |
323 | if (!hfsplus_parse_options(data, sbi)) { |
324 | printk(KERN_ERR "hfs: unable to parse mount options\n"); |
325 | err = -EINVAL; |
326 | goto cleanup; |
327 | } |
328 | |
329 | /* temporarily use utf8 to correctly find the hidden dir below */ |
330 | nls = sbi->nls; |
331 | sbi->nls = load_nls("utf8"); |
332 | if (!sbi->nls) { |
333 | printk(KERN_ERR "hfs: unable to load nls for utf8\n"); |
334 | err = -EINVAL; |
335 | goto cleanup; |
336 | } |
337 | |
338 | /* Grab the volume header */ |
339 | if (hfsplus_read_wrapper(sb)) { |
340 | if (!silent) |
341 | printk(KERN_WARNING "hfs: unable to find HFS+ superblock\n"); |
342 | err = -EINVAL; |
343 | goto cleanup; |
344 | } |
345 | vhdr = HFSPLUS_SB(sb).s_vhdr; |
346 | |
347 | /* Copy parts of the volume header into the superblock */ |
348 | sb->s_magic = HFSPLUS_VOLHEAD_SIG; |
349 | if (be16_to_cpu(vhdr->version) < HFSPLUS_MIN_VERSION || |
350 | be16_to_cpu(vhdr->version) > HFSPLUS_CURRENT_VERSION) { |
351 | printk(KERN_ERR "hfs: wrong filesystem version\n"); |
352 | goto cleanup; |
353 | } |
354 | HFSPLUS_SB(sb).total_blocks = be32_to_cpu(vhdr->total_blocks); |
355 | HFSPLUS_SB(sb).free_blocks = be32_to_cpu(vhdr->free_blocks); |
356 | HFSPLUS_SB(sb).next_alloc = be32_to_cpu(vhdr->next_alloc); |
357 | HFSPLUS_SB(sb).next_cnid = be32_to_cpu(vhdr->next_cnid); |
358 | HFSPLUS_SB(sb).file_count = be32_to_cpu(vhdr->file_count); |
359 | HFSPLUS_SB(sb).folder_count = be32_to_cpu(vhdr->folder_count); |
360 | HFSPLUS_SB(sb).data_clump_blocks = be32_to_cpu(vhdr->data_clump_sz) >> HFSPLUS_SB(sb).alloc_blksz_shift; |
361 | if (!HFSPLUS_SB(sb).data_clump_blocks) |
362 | HFSPLUS_SB(sb).data_clump_blocks = 1; |
363 | HFSPLUS_SB(sb).rsrc_clump_blocks = be32_to_cpu(vhdr->rsrc_clump_sz) >> HFSPLUS_SB(sb).alloc_blksz_shift; |
364 | if (!HFSPLUS_SB(sb).rsrc_clump_blocks) |
365 | HFSPLUS_SB(sb).rsrc_clump_blocks = 1; |
366 | |
367 | /* Set up operations so we can load metadata */ |
368 | sb->s_op = &hfsplus_sops; |
369 | sb->s_maxbytes = MAX_LFS_FILESIZE; |
370 | |
371 | if (!(vhdr->attributes & cpu_to_be32(HFSPLUS_VOL_UNMNT))) { |
372 | printk(KERN_WARNING "hfs: Filesystem was not cleanly unmounted, " |
373 | "running fsck.hfsplus is recommended. mounting read-only.\n"); |
374 | sb->s_flags |= MS_RDONLY; |
375 | } else if (sbi->flags & HFSPLUS_SB_FORCE) { |
376 | /* nothing */ |
377 | } else if (vhdr->attributes & cpu_to_be32(HFSPLUS_VOL_SOFTLOCK)) { |
378 | printk(KERN_WARNING "hfs: Filesystem is marked locked, mounting read-only.\n"); |
379 | sb->s_flags |= MS_RDONLY; |
380 | } else if ((vhdr->attributes & cpu_to_be32(HFSPLUS_VOL_JOURNALED)) && !(sb->s_flags & MS_RDONLY)) { |
381 | printk(KERN_WARNING "hfs: write access to a journaled filesystem is not supported, " |
382 | "use the force option at your own risk, mounting read-only.\n"); |
383 | sb->s_flags |= MS_RDONLY; |
384 | } |
385 | sbi->flags &= ~HFSPLUS_SB_FORCE; |
386 | |
387 | /* Load metadata objects (B*Trees) */ |
388 | HFSPLUS_SB(sb).ext_tree = hfs_btree_open(sb, HFSPLUS_EXT_CNID); |
389 | if (!HFSPLUS_SB(sb).ext_tree) { |
390 | printk(KERN_ERR "hfs: failed to load extents file\n"); |
391 | goto cleanup; |
392 | } |
393 | HFSPLUS_SB(sb).cat_tree = hfs_btree_open(sb, HFSPLUS_CAT_CNID); |
394 | if (!HFSPLUS_SB(sb).cat_tree) { |
395 | printk(KERN_ERR "hfs: failed to load catalog file\n"); |
396 | goto cleanup; |
397 | } |
398 | |
399 | inode = hfsplus_iget(sb, HFSPLUS_ALLOC_CNID); |
400 | if (IS_ERR(inode)) { |
401 | printk(KERN_ERR "hfs: failed to load allocation file\n"); |
402 | err = PTR_ERR(inode); |
403 | goto cleanup; |
404 | } |
405 | HFSPLUS_SB(sb).alloc_file = inode; |
406 | |
407 | /* Load the root directory */ |
408 | root = hfsplus_iget(sb, HFSPLUS_ROOT_CNID); |
409 | if (IS_ERR(root)) { |
410 | printk(KERN_ERR "hfs: failed to load root directory\n"); |
411 | err = PTR_ERR(root); |
412 | goto cleanup; |
413 | } |
414 | sb->s_root = d_alloc_root(root); |
415 | if (!sb->s_root) { |
416 | iput(root); |
417 | err = -ENOMEM; |
418 | goto cleanup; |
419 | } |
420 | sb->s_root->d_op = &hfsplus_dentry_operations; |
421 | |
422 | str.len = sizeof(HFSP_HIDDENDIR_NAME) - 1; |
423 | str.name = HFSP_HIDDENDIR_NAME; |
424 | hfs_find_init(HFSPLUS_SB(sb).cat_tree, &fd); |
425 | hfsplus_cat_build_key(sb, fd.search_key, HFSPLUS_ROOT_CNID, &str); |
426 | if (!hfs_brec_read(&fd, &entry, sizeof(entry))) { |
427 | hfs_find_exit(&fd); |
428 | if (entry.type != cpu_to_be16(HFSPLUS_FOLDER)) |
429 | goto cleanup; |
430 | inode = hfsplus_iget(sb, be32_to_cpu(entry.folder.id)); |
431 | if (IS_ERR(inode)) { |
432 | err = PTR_ERR(inode); |
433 | goto cleanup; |
434 | } |
435 | HFSPLUS_SB(sb).hidden_dir = inode; |
436 | } else |
437 | hfs_find_exit(&fd); |
438 | |
439 | if (sb->s_flags & MS_RDONLY) |
440 | goto out; |
441 | |
442 | /* H+LX == hfsplusutils, H+Lx == this driver, H+lx is unused |
443 | * all three are registered with Apple for our use |
444 | */ |
445 | vhdr->last_mount_vers = cpu_to_be32(HFSP_MOUNT_VERSION); |
446 | vhdr->modify_date = hfsp_now2mt(); |
447 | be32_add_cpu(&vhdr->write_count, 1); |
448 | vhdr->attributes &= cpu_to_be32(~HFSPLUS_VOL_UNMNT); |
449 | vhdr->attributes |= cpu_to_be32(HFSPLUS_VOL_INCNSTNT); |
450 | mark_buffer_dirty(HFSPLUS_SB(sb).s_vhbh); |
451 | sync_dirty_buffer(HFSPLUS_SB(sb).s_vhbh); |
452 | |
453 | if (!HFSPLUS_SB(sb).hidden_dir) { |
454 | printk(KERN_DEBUG "hfs: create hidden dir...\n"); |
455 | HFSPLUS_SB(sb).hidden_dir = hfsplus_new_inode(sb, S_IFDIR); |
456 | hfsplus_create_cat(HFSPLUS_SB(sb).hidden_dir->i_ino, sb->s_root->d_inode, |
457 | &str, HFSPLUS_SB(sb).hidden_dir); |
458 | mark_inode_dirty(HFSPLUS_SB(sb).hidden_dir); |
459 | } |
460 | out: |
461 | unload_nls(sbi->nls); |
462 | sbi->nls = nls; |
463 | return 0; |
464 | |
465 | cleanup: |
466 | hfsplus_put_super(sb); |
467 | unload_nls(nls); |
468 | return err; |
469 | } |
470 | |
471 | MODULE_AUTHOR("Brad Boyer"); |
472 | MODULE_DESCRIPTION("Extended Macintosh Filesystem"); |
473 | MODULE_LICENSE("GPL"); |
474 | |
475 | static struct kmem_cache *hfsplus_inode_cachep; |
476 | |
477 | static struct inode *hfsplus_alloc_inode(struct super_block *sb) |
478 | { |
479 | struct hfsplus_inode_info *i; |
480 | |
481 | i = kmem_cache_alloc(hfsplus_inode_cachep, GFP_KERNEL); |
482 | return i ? &i->vfs_inode : NULL; |
483 | } |
484 | |
485 | static void hfsplus_destroy_inode(struct inode *inode) |
486 | { |
487 | kmem_cache_free(hfsplus_inode_cachep, &HFSPLUS_I(inode)); |
488 | } |
489 | |
490 | #define HFSPLUS_INODE_SIZE sizeof(struct hfsplus_inode_info) |
491 | |
492 | static int hfsplus_get_sb(struct file_system_type *fs_type, |
493 | int flags, const char *dev_name, void *data, |
494 | struct vfsmount *mnt) |
495 | { |
496 | return get_sb_bdev(fs_type, flags, dev_name, data, hfsplus_fill_super, |
497 | mnt); |
498 | } |
499 | |
500 | static struct file_system_type hfsplus_fs_type = { |
501 | .owner = THIS_MODULE, |
502 | .name = "hfsplus", |
503 | .get_sb = hfsplus_get_sb, |
504 | .kill_sb = kill_block_super, |
505 | .fs_flags = FS_REQUIRES_DEV, |
506 | }; |
507 | |
508 | static void hfsplus_init_once(void *p) |
509 | { |
510 | struct hfsplus_inode_info *i = p; |
511 | |
512 | inode_init_once(&i->vfs_inode); |
513 | } |
514 | |
515 | static int __init init_hfsplus_fs(void) |
516 | { |
517 | int err; |
518 | |
519 | hfsplus_inode_cachep = kmem_cache_create("hfsplus_icache", |
520 | HFSPLUS_INODE_SIZE, 0, SLAB_HWCACHE_ALIGN, |
521 | hfsplus_init_once); |
522 | if (!hfsplus_inode_cachep) |
523 | return -ENOMEM; |
524 | err = register_filesystem(&hfsplus_fs_type); |
525 | if (err) |
526 | kmem_cache_destroy(hfsplus_inode_cachep); |
527 | return err; |
528 | } |
529 | |
530 | static void __exit exit_hfsplus_fs(void) |
531 | { |
532 | unregister_filesystem(&hfsplus_fs_type); |
533 | kmem_cache_destroy(hfsplus_inode_cachep); |
534 | } |
535 | |
536 | module_init(init_hfsplus_fs) |
537 | module_exit(exit_hfsplus_fs) |
538 |
Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master
Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9