Merge git://git.infradead.org/~dwmw2/cafe-2.6
[linux-2.6] / fs / hfsplus / inode.c
1 /*
2  *  linux/fs/hfsplus/inode.c
3  *
4  * Copyright (C) 2001
5  * Brad Boyer (flar@allandria.com)
6  * (C) 2003 Ardis Technologies <roman@ardistech.com>
7  *
8  * Inode handling routines
9  */
10
11 #include <linux/mm.h>
12 #include <linux/fs.h>
13 #include <linux/pagemap.h>
14 #include <linux/mpage.h>
15
16 #include "hfsplus_fs.h"
17 #include "hfsplus_raw.h"
18
19 static int hfsplus_readpage(struct file *file, struct page *page)
20 {
21         return block_read_full_page(page, hfsplus_get_block);
22 }
23
24 static int hfsplus_writepage(struct page *page, struct writeback_control *wbc)
25 {
26         return block_write_full_page(page, hfsplus_get_block, wbc);
27 }
28
29 static int hfsplus_prepare_write(struct file *file, struct page *page, unsigned from, unsigned to)
30 {
31         return cont_prepare_write(page, from, to, hfsplus_get_block,
32                 &HFSPLUS_I(page->mapping->host).phys_size);
33 }
34
35 static sector_t hfsplus_bmap(struct address_space *mapping, sector_t block)
36 {
37         return generic_block_bmap(mapping, block, hfsplus_get_block);
38 }
39
40 static int hfsplus_releasepage(struct page *page, gfp_t mask)
41 {
42         struct inode *inode = page->mapping->host;
43         struct super_block *sb = inode->i_sb;
44         struct hfs_btree *tree;
45         struct hfs_bnode *node;
46         u32 nidx;
47         int i, res = 1;
48
49         switch (inode->i_ino) {
50         case HFSPLUS_EXT_CNID:
51                 tree = HFSPLUS_SB(sb).ext_tree;
52                 break;
53         case HFSPLUS_CAT_CNID:
54                 tree = HFSPLUS_SB(sb).cat_tree;
55                 break;
56         case HFSPLUS_ATTR_CNID:
57                 tree = HFSPLUS_SB(sb).attr_tree;
58                 break;
59         default:
60                 BUG();
61                 return 0;
62         }
63         if (tree->node_size >= PAGE_CACHE_SIZE) {
64                 nidx = page->index >> (tree->node_size_shift - PAGE_CACHE_SHIFT);
65                 spin_lock(&tree->hash_lock);
66                 node = hfs_bnode_findhash(tree, nidx);
67                 if (!node)
68                         ;
69                 else if (atomic_read(&node->refcnt))
70                         res = 0;
71                 if (res && node) {
72                         hfs_bnode_unhash(node);
73                         hfs_bnode_free(node);
74                 }
75                 spin_unlock(&tree->hash_lock);
76         } else {
77                 nidx = page->index << (PAGE_CACHE_SHIFT - tree->node_size_shift);
78                 i = 1 << (PAGE_CACHE_SHIFT - tree->node_size_shift);
79                 spin_lock(&tree->hash_lock);
80                 do {
81                         node = hfs_bnode_findhash(tree, nidx++);
82                         if (!node)
83                                 continue;
84                         if (atomic_read(&node->refcnt)) {
85                                 res = 0;
86                                 break;
87                         }
88                         hfs_bnode_unhash(node);
89                         hfs_bnode_free(node);
90                 } while (--i && nidx < tree->node_count);
91                 spin_unlock(&tree->hash_lock);
92         }
93         return res ? try_to_free_buffers(page) : 0;
94 }
95
96 static ssize_t hfsplus_direct_IO(int rw, struct kiocb *iocb,
97                 const struct iovec *iov, loff_t offset, unsigned long nr_segs)
98 {
99         struct file *file = iocb->ki_filp;
100         struct inode *inode = file->f_dentry->d_inode->i_mapping->host;
101
102         return blockdev_direct_IO(rw, iocb, inode, inode->i_sb->s_bdev, iov,
103                                   offset, nr_segs, hfsplus_get_block, NULL);
104 }
105
106 static int hfsplus_writepages(struct address_space *mapping,
107                               struct writeback_control *wbc)
108 {
109         return mpage_writepages(mapping, wbc, hfsplus_get_block);
110 }
111
112 const struct address_space_operations hfsplus_btree_aops = {
113         .readpage       = hfsplus_readpage,
114         .writepage      = hfsplus_writepage,
115         .sync_page      = block_sync_page,
116         .prepare_write  = hfsplus_prepare_write,
117         .commit_write   = generic_commit_write,
118         .bmap           = hfsplus_bmap,
119         .releasepage    = hfsplus_releasepage,
120 };
121
122 const struct address_space_operations hfsplus_aops = {
123         .readpage       = hfsplus_readpage,
124         .writepage      = hfsplus_writepage,
125         .sync_page      = block_sync_page,
126         .prepare_write  = hfsplus_prepare_write,
127         .commit_write   = generic_commit_write,
128         .bmap           = hfsplus_bmap,
129         .direct_IO      = hfsplus_direct_IO,
130         .writepages     = hfsplus_writepages,
131 };
132
133 static struct dentry *hfsplus_file_lookup(struct inode *dir, struct dentry *dentry,
134                                           struct nameidata *nd)
135 {
136         struct hfs_find_data fd;
137         struct super_block *sb = dir->i_sb;
138         struct inode *inode = NULL;
139         int err;
140
141         if (HFSPLUS_IS_RSRC(dir) || strcmp(dentry->d_name.name, "rsrc"))
142                 goto out;
143
144         inode = HFSPLUS_I(dir).rsrc_inode;
145         if (inode)
146                 goto out;
147
148         inode = new_inode(sb);
149         if (!inode)
150                 return ERR_PTR(-ENOMEM);
151
152         inode->i_ino = dir->i_ino;
153         INIT_LIST_HEAD(&HFSPLUS_I(inode).open_dir_list);
154         init_MUTEX(&HFSPLUS_I(inode).extents_lock);
155         HFSPLUS_I(inode).flags = HFSPLUS_FLG_RSRC;
156
157         hfs_find_init(HFSPLUS_SB(sb).cat_tree, &fd);
158         err = hfsplus_find_cat(sb, dir->i_ino, &fd);
159         if (!err)
160                 err = hfsplus_cat_read_inode(inode, &fd);
161         hfs_find_exit(&fd);
162         if (err) {
163                 iput(inode);
164                 return ERR_PTR(err);
165         }
166         HFSPLUS_I(inode).rsrc_inode = dir;
167         HFSPLUS_I(dir).rsrc_inode = inode;
168         igrab(dir);
169         hlist_add_head(&inode->i_hash, &HFSPLUS_SB(sb).rsrc_inodes);
170         mark_inode_dirty(inode);
171 out:
172         d_add(dentry, inode);
173         return NULL;
174 }
175
176 static void hfsplus_get_perms(struct inode *inode, struct hfsplus_perm *perms, int dir)
177 {
178         struct super_block *sb = inode->i_sb;
179         u16 mode;
180
181         mode = be16_to_cpu(perms->mode);
182
183         inode->i_uid = be32_to_cpu(perms->owner);
184         if (!inode->i_uid && !mode)
185                 inode->i_uid = HFSPLUS_SB(sb).uid;
186
187         inode->i_gid = be32_to_cpu(perms->group);
188         if (!inode->i_gid && !mode)
189                 inode->i_gid = HFSPLUS_SB(sb).gid;
190
191         if (dir) {
192                 mode = mode ? (mode & S_IALLUGO) :
193                         (S_IRWXUGO & ~(HFSPLUS_SB(sb).umask));
194                 mode |= S_IFDIR;
195         } else if (!mode)
196                 mode = S_IFREG | ((S_IRUGO|S_IWUGO) &
197                         ~(HFSPLUS_SB(sb).umask));
198         inode->i_mode = mode;
199
200         HFSPLUS_I(inode).rootflags = perms->rootflags;
201         HFSPLUS_I(inode).userflags = perms->userflags;
202         if (perms->rootflags & HFSPLUS_FLG_IMMUTABLE)
203                 inode->i_flags |= S_IMMUTABLE;
204         else
205                 inode->i_flags &= ~S_IMMUTABLE;
206         if (perms->rootflags & HFSPLUS_FLG_APPEND)
207                 inode->i_flags |= S_APPEND;
208         else
209                 inode->i_flags &= ~S_APPEND;
210 }
211
212 static void hfsplus_set_perms(struct inode *inode, struct hfsplus_perm *perms)
213 {
214         if (inode->i_flags & S_IMMUTABLE)
215                 perms->rootflags |= HFSPLUS_FLG_IMMUTABLE;
216         else
217                 perms->rootflags &= ~HFSPLUS_FLG_IMMUTABLE;
218         if (inode->i_flags & S_APPEND)
219                 perms->rootflags |= HFSPLUS_FLG_APPEND;
220         else
221                 perms->rootflags &= ~HFSPLUS_FLG_APPEND;
222         perms->userflags = HFSPLUS_I(inode).userflags;
223         perms->mode = cpu_to_be16(inode->i_mode);
224         perms->owner = cpu_to_be32(inode->i_uid);
225         perms->group = cpu_to_be32(inode->i_gid);
226         perms->dev = cpu_to_be32(HFSPLUS_I(inode).dev);
227 }
228
229 static int hfsplus_permission(struct inode *inode, int mask, struct nameidata *nd)
230 {
231         /* MAY_EXEC is also used for lookup, if no x bit is set allow lookup,
232          * open_exec has the same test, so it's still not executable, if a x bit
233          * is set fall back to standard permission check.
234          */
235         if (S_ISREG(inode->i_mode) && mask & MAY_EXEC && !(inode->i_mode & 0111))
236                 return 0;
237         return generic_permission(inode, mask, NULL);
238 }
239
240
241 static int hfsplus_file_open(struct inode *inode, struct file *file)
242 {
243         if (HFSPLUS_IS_RSRC(inode))
244                 inode = HFSPLUS_I(inode).rsrc_inode;
245         if (atomic_read(&file->f_count) != 1)
246                 return 0;
247         atomic_inc(&HFSPLUS_I(inode).opencnt);
248         return 0;
249 }
250
251 static int hfsplus_file_release(struct inode *inode, struct file *file)
252 {
253         struct super_block *sb = inode->i_sb;
254
255         if (HFSPLUS_IS_RSRC(inode))
256                 inode = HFSPLUS_I(inode).rsrc_inode;
257         if (atomic_read(&file->f_count) != 0)
258                 return 0;
259         if (atomic_dec_and_test(&HFSPLUS_I(inode).opencnt)) {
260                 mutex_lock(&inode->i_mutex);
261                 hfsplus_file_truncate(inode);
262                 if (inode->i_flags & S_DEAD) {
263                         hfsplus_delete_cat(inode->i_ino, HFSPLUS_SB(sb).hidden_dir, NULL);
264                         hfsplus_delete_inode(inode);
265                 }
266                 mutex_unlock(&inode->i_mutex);
267         }
268         return 0;
269 }
270
271 extern struct inode_operations hfsplus_dir_inode_operations;
272 extern struct file_operations hfsplus_dir_operations;
273
274 static struct inode_operations hfsplus_file_inode_operations = {
275         .lookup         = hfsplus_file_lookup,
276         .truncate       = hfsplus_file_truncate,
277         .permission     = hfsplus_permission,
278         .setxattr       = hfsplus_setxattr,
279         .getxattr       = hfsplus_getxattr,
280         .listxattr      = hfsplus_listxattr,
281 };
282
283 static const struct file_operations hfsplus_file_operations = {
284         .llseek         = generic_file_llseek,
285         .read           = do_sync_read,
286         .aio_read       = generic_file_aio_read,
287         .write          = do_sync_write,
288         .aio_write      = generic_file_aio_write,
289         .mmap           = generic_file_mmap,
290         .sendfile       = generic_file_sendfile,
291         .fsync          = file_fsync,
292         .open           = hfsplus_file_open,
293         .release        = hfsplus_file_release,
294         .ioctl          = hfsplus_ioctl,
295 };
296
297 struct inode *hfsplus_new_inode(struct super_block *sb, int mode)
298 {
299         struct inode *inode = new_inode(sb);
300         if (!inode)
301                 return NULL;
302
303         inode->i_ino = HFSPLUS_SB(sb).next_cnid++;
304         inode->i_mode = mode;
305         inode->i_uid = current->fsuid;
306         inode->i_gid = current->fsgid;
307         inode->i_nlink = 1;
308         inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME_SEC;
309         INIT_LIST_HEAD(&HFSPLUS_I(inode).open_dir_list);
310         init_MUTEX(&HFSPLUS_I(inode).extents_lock);
311         atomic_set(&HFSPLUS_I(inode).opencnt, 0);
312         HFSPLUS_I(inode).flags = 0;
313         memset(HFSPLUS_I(inode).first_extents, 0, sizeof(hfsplus_extent_rec));
314         memset(HFSPLUS_I(inode).cached_extents, 0, sizeof(hfsplus_extent_rec));
315         HFSPLUS_I(inode).alloc_blocks = 0;
316         HFSPLUS_I(inode).first_blocks = 0;
317         HFSPLUS_I(inode).cached_start = 0;
318         HFSPLUS_I(inode).cached_blocks = 0;
319         HFSPLUS_I(inode).phys_size = 0;
320         HFSPLUS_I(inode).fs_blocks = 0;
321         HFSPLUS_I(inode).rsrc_inode = NULL;
322         if (S_ISDIR(inode->i_mode)) {
323                 inode->i_size = 2;
324                 HFSPLUS_SB(sb).folder_count++;
325                 inode->i_op = &hfsplus_dir_inode_operations;
326                 inode->i_fop = &hfsplus_dir_operations;
327         } else if (S_ISREG(inode->i_mode)) {
328                 HFSPLUS_SB(sb).file_count++;
329                 inode->i_op = &hfsplus_file_inode_operations;
330                 inode->i_fop = &hfsplus_file_operations;
331                 inode->i_mapping->a_ops = &hfsplus_aops;
332                 HFSPLUS_I(inode).clump_blocks = HFSPLUS_SB(sb).data_clump_blocks;
333         } else if (S_ISLNK(inode->i_mode)) {
334                 HFSPLUS_SB(sb).file_count++;
335                 inode->i_op = &page_symlink_inode_operations;
336                 inode->i_mapping->a_ops = &hfsplus_aops;
337                 HFSPLUS_I(inode).clump_blocks = 1;
338         } else
339                 HFSPLUS_SB(sb).file_count++;
340         insert_inode_hash(inode);
341         mark_inode_dirty(inode);
342         sb->s_dirt = 1;
343
344         return inode;
345 }
346
347 void hfsplus_delete_inode(struct inode *inode)
348 {
349         struct super_block *sb = inode->i_sb;
350
351         if (S_ISDIR(inode->i_mode)) {
352                 HFSPLUS_SB(sb).folder_count--;
353                 sb->s_dirt = 1;
354                 return;
355         }
356         HFSPLUS_SB(sb).file_count--;
357         if (S_ISREG(inode->i_mode)) {
358                 if (!inode->i_nlink) {
359                         inode->i_size = 0;
360                         hfsplus_file_truncate(inode);
361                 }
362         } else if (S_ISLNK(inode->i_mode)) {
363                 inode->i_size = 0;
364                 hfsplus_file_truncate(inode);
365         }
366         sb->s_dirt = 1;
367 }
368
369 void hfsplus_inode_read_fork(struct inode *inode, struct hfsplus_fork_raw *fork)
370 {
371         struct super_block *sb = inode->i_sb;
372         u32 count;
373         int i;
374
375         memcpy(&HFSPLUS_I(inode).first_extents, &fork->extents,
376                sizeof(hfsplus_extent_rec));
377         for (count = 0, i = 0; i < 8; i++)
378                 count += be32_to_cpu(fork->extents[i].block_count);
379         HFSPLUS_I(inode).first_blocks = count;
380         memset(HFSPLUS_I(inode).cached_extents, 0, sizeof(hfsplus_extent_rec));
381         HFSPLUS_I(inode).cached_start = 0;
382         HFSPLUS_I(inode).cached_blocks = 0;
383
384         HFSPLUS_I(inode).alloc_blocks = be32_to_cpu(fork->total_blocks);
385         inode->i_size = HFSPLUS_I(inode).phys_size = be64_to_cpu(fork->total_size);
386         HFSPLUS_I(inode).fs_blocks = (inode->i_size + sb->s_blocksize - 1) >> sb->s_blocksize_bits;
387         inode_set_bytes(inode, HFSPLUS_I(inode).fs_blocks << sb->s_blocksize_bits);
388         HFSPLUS_I(inode).clump_blocks = be32_to_cpu(fork->clump_size) >> HFSPLUS_SB(sb).alloc_blksz_shift;
389         if (!HFSPLUS_I(inode).clump_blocks)
390                 HFSPLUS_I(inode).clump_blocks = HFSPLUS_IS_RSRC(inode) ? HFSPLUS_SB(sb).rsrc_clump_blocks :
391                                 HFSPLUS_SB(sb).data_clump_blocks;
392 }
393
394 void hfsplus_inode_write_fork(struct inode *inode, struct hfsplus_fork_raw *fork)
395 {
396         memcpy(&fork->extents, &HFSPLUS_I(inode).first_extents,
397                sizeof(hfsplus_extent_rec));
398         fork->total_size = cpu_to_be64(inode->i_size);
399         fork->total_blocks = cpu_to_be32(HFSPLUS_I(inode).alloc_blocks);
400 }
401
402 int hfsplus_cat_read_inode(struct inode *inode, struct hfs_find_data *fd)
403 {
404         hfsplus_cat_entry entry;
405         int res = 0;
406         u16 type;
407
408         type = hfs_bnode_read_u16(fd->bnode, fd->entryoffset);
409
410         HFSPLUS_I(inode).dev = 0;
411         if (type == HFSPLUS_FOLDER) {
412                 struct hfsplus_cat_folder *folder = &entry.folder;
413
414                 if (fd->entrylength < sizeof(struct hfsplus_cat_folder))
415                         /* panic? */;
416                 hfs_bnode_read(fd->bnode, &entry, fd->entryoffset,
417                                         sizeof(struct hfsplus_cat_folder));
418                 hfsplus_get_perms(inode, &folder->permissions, 1);
419                 inode->i_nlink = 1;
420                 inode->i_size = 2 + be32_to_cpu(folder->valence);
421                 inode->i_atime = hfsp_mt2ut(folder->access_date);
422                 inode->i_mtime = hfsp_mt2ut(folder->content_mod_date);
423                 inode->i_ctime = hfsp_mt2ut(folder->attribute_mod_date);
424                 HFSPLUS_I(inode).create_date = folder->create_date;
425                 HFSPLUS_I(inode).fs_blocks = 0;
426                 inode->i_op = &hfsplus_dir_inode_operations;
427                 inode->i_fop = &hfsplus_dir_operations;
428         } else if (type == HFSPLUS_FILE) {
429                 struct hfsplus_cat_file *file = &entry.file;
430
431                 if (fd->entrylength < sizeof(struct hfsplus_cat_file))
432                         /* panic? */;
433                 hfs_bnode_read(fd->bnode, &entry, fd->entryoffset,
434                                         sizeof(struct hfsplus_cat_file));
435
436                 hfsplus_inode_read_fork(inode, HFSPLUS_IS_DATA(inode) ?
437                                         &file->data_fork : &file->rsrc_fork);
438                 hfsplus_get_perms(inode, &file->permissions, 0);
439                 inode->i_nlink = 1;
440                 if (S_ISREG(inode->i_mode)) {
441                         if (file->permissions.dev)
442                                 inode->i_nlink = be32_to_cpu(file->permissions.dev);
443                         inode->i_op = &hfsplus_file_inode_operations;
444                         inode->i_fop = &hfsplus_file_operations;
445                         inode->i_mapping->a_ops = &hfsplus_aops;
446                 } else if (S_ISLNK(inode->i_mode)) {
447                         inode->i_op = &page_symlink_inode_operations;
448                         inode->i_mapping->a_ops = &hfsplus_aops;
449                 } else {
450                         init_special_inode(inode, inode->i_mode,
451                                            be32_to_cpu(file->permissions.dev));
452                 }
453                 inode->i_atime = hfsp_mt2ut(file->access_date);
454                 inode->i_mtime = hfsp_mt2ut(file->content_mod_date);
455                 inode->i_ctime = hfsp_mt2ut(file->attribute_mod_date);
456                 HFSPLUS_I(inode).create_date = file->create_date;
457         } else {
458                 printk(KERN_ERR "hfs: bad catalog entry used to create inode\n");
459                 res = -EIO;
460         }
461         return res;
462 }
463
464 int hfsplus_cat_write_inode(struct inode *inode)
465 {
466         struct inode *main_inode = inode;
467         struct hfs_find_data fd;
468         hfsplus_cat_entry entry;
469
470         if (HFSPLUS_IS_RSRC(inode))
471                 main_inode = HFSPLUS_I(inode).rsrc_inode;
472
473         if (!main_inode->i_nlink)
474                 return 0;
475
476         if (hfs_find_init(HFSPLUS_SB(main_inode->i_sb).cat_tree, &fd))
477                 /* panic? */
478                 return -EIO;
479
480         if (hfsplus_find_cat(main_inode->i_sb, main_inode->i_ino, &fd))
481                 /* panic? */
482                 goto out;
483
484         if (S_ISDIR(main_inode->i_mode)) {
485                 struct hfsplus_cat_folder *folder = &entry.folder;
486
487                 if (fd.entrylength < sizeof(struct hfsplus_cat_folder))
488                         /* panic? */;
489                 hfs_bnode_read(fd.bnode, &entry, fd.entryoffset,
490                                         sizeof(struct hfsplus_cat_folder));
491                 /* simple node checks? */
492                 hfsplus_set_perms(inode, &folder->permissions);
493                 folder->access_date = hfsp_ut2mt(inode->i_atime);
494                 folder->content_mod_date = hfsp_ut2mt(inode->i_mtime);
495                 folder->attribute_mod_date = hfsp_ut2mt(inode->i_ctime);
496                 folder->valence = cpu_to_be32(inode->i_size - 2);
497                 hfs_bnode_write(fd.bnode, &entry, fd.entryoffset,
498                                          sizeof(struct hfsplus_cat_folder));
499         } else if (HFSPLUS_IS_RSRC(inode)) {
500                 struct hfsplus_cat_file *file = &entry.file;
501                 hfs_bnode_read(fd.bnode, &entry, fd.entryoffset,
502                                sizeof(struct hfsplus_cat_file));
503                 hfsplus_inode_write_fork(inode, &file->rsrc_fork);
504                 hfs_bnode_write(fd.bnode, &entry, fd.entryoffset,
505                                 sizeof(struct hfsplus_cat_file));
506         } else {
507                 struct hfsplus_cat_file *file = &entry.file;
508
509                 if (fd.entrylength < sizeof(struct hfsplus_cat_file))
510                         /* panic? */;
511                 hfs_bnode_read(fd.bnode, &entry, fd.entryoffset,
512                                         sizeof(struct hfsplus_cat_file));
513                 hfsplus_inode_write_fork(inode, &file->data_fork);
514                 if (S_ISREG(inode->i_mode))
515                         HFSPLUS_I(inode).dev = inode->i_nlink;
516                 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
517                         HFSPLUS_I(inode).dev = kdev_t_to_nr(inode->i_rdev);
518                 hfsplus_set_perms(inode, &file->permissions);
519                 if ((file->permissions.rootflags | file->permissions.userflags) & HFSPLUS_FLG_IMMUTABLE)
520                         file->flags |= cpu_to_be16(HFSPLUS_FILE_LOCKED);
521                 else
522                         file->flags &= cpu_to_be16(~HFSPLUS_FILE_LOCKED);
523                 file->access_date = hfsp_ut2mt(inode->i_atime);
524                 file->content_mod_date = hfsp_ut2mt(inode->i_mtime);
525                 file->attribute_mod_date = hfsp_ut2mt(inode->i_ctime);
526                 hfs_bnode_write(fd.bnode, &entry, fd.entryoffset,
527                                          sizeof(struct hfsplus_cat_file));
528         }
529 out:
530         hfs_find_exit(&fd);
531         return 0;
532 }