Merge branch 'master'
[linux-2.6] / fs / hfsplus / dir.c
1 /*
2  *  linux/fs/hfsplus/dir.c
3  *
4  * Copyright (C) 2001
5  * Brad Boyer (flar@allandria.com)
6  * (C) 2003 Ardis Technologies <roman@ardistech.com>
7  *
8  * Handling of directories
9  */
10
11 #include <linux/errno.h>
12 #include <linux/fs.h>
13 #include <linux/sched.h>
14 #include <linux/slab.h>
15 #include <linux/random.h>
16
17 #include "hfsplus_fs.h"
18 #include "hfsplus_raw.h"
19
20 static inline void hfsplus_instantiate(struct dentry *dentry,
21                                        struct inode *inode, u32 cnid)
22 {
23         dentry->d_fsdata = (void *)(unsigned long)cnid;
24         d_instantiate(dentry, inode);
25 }
26
27 /* Find the entry inside dir named dentry->d_name */
28 static struct dentry *hfsplus_lookup(struct inode *dir, struct dentry *dentry,
29                                      struct nameidata *nd)
30 {
31         struct inode *inode = NULL;
32         struct hfs_find_data fd;
33         struct super_block *sb;
34         hfsplus_cat_entry entry;
35         int err;
36         u32 cnid, linkid = 0;
37         u16 type;
38
39         sb = dir->i_sb;
40         dentry->d_fsdata = NULL;
41         hfs_find_init(HFSPLUS_SB(sb).cat_tree, &fd);
42         hfsplus_cat_build_key(sb, fd.search_key, dir->i_ino, &dentry->d_name);
43 again:
44         err = hfs_brec_read(&fd, &entry, sizeof(entry));
45         if (err) {
46                 if (err == -ENOENT) {
47                         hfs_find_exit(&fd);
48                         /* No such entry */
49                         inode = NULL;
50                         goto out;
51                 }
52                 goto fail;
53         }
54         type = be16_to_cpu(entry.type);
55         if (type == HFSPLUS_FOLDER) {
56                 if (fd.entrylength < sizeof(struct hfsplus_cat_folder)) {
57                         err = -EIO;
58                         goto fail;
59                 }
60                 cnid = be32_to_cpu(entry.folder.id);
61                 dentry->d_fsdata = (void *)(unsigned long)cnid;
62         } else if (type == HFSPLUS_FILE) {
63                 if (fd.entrylength < sizeof(struct hfsplus_cat_file)) {
64                         err = -EIO;
65                         goto fail;
66                 }
67                 cnid = be32_to_cpu(entry.file.id);
68                 if (entry.file.user_info.fdType == cpu_to_be32(HFSP_HARDLINK_TYPE) &&
69                     entry.file.user_info.fdCreator == cpu_to_be32(HFSP_HFSPLUS_CREATOR)) {
70                         struct qstr str;
71                         char name[32];
72
73                         if (dentry->d_fsdata) {
74                                 err = -ENOENT;
75                                 inode = NULL;
76                                 goto out;
77                         }
78                         dentry->d_fsdata = (void *)(unsigned long)cnid;
79                         linkid = be32_to_cpu(entry.file.permissions.dev);
80                         str.len = sprintf(name, "iNode%d", linkid);
81                         str.name = name;
82                         hfsplus_cat_build_key(sb, fd.search_key, HFSPLUS_SB(sb).hidden_dir->i_ino, &str);
83                         goto again;
84                 } else if (!dentry->d_fsdata)
85                         dentry->d_fsdata = (void *)(unsigned long)cnid;
86         } else {
87                 printk("HFS+-fs: Illegal catalog entry type in lookup\n");
88                 err = -EIO;
89                 goto fail;
90         }
91         hfs_find_exit(&fd);
92         inode = iget(dir->i_sb, cnid);
93         if (!inode)
94                 return ERR_PTR(-EACCES);
95         if (S_ISREG(inode->i_mode))
96                 HFSPLUS_I(inode).dev = linkid;
97 out:
98         d_add(dentry, inode);
99         return NULL;
100 fail:
101         hfs_find_exit(&fd);
102         return ERR_PTR(err);
103 }
104
105 static int hfsplus_readdir(struct file *filp, void *dirent, filldir_t filldir)
106 {
107         struct inode *inode = filp->f_dentry->d_inode;
108         struct super_block *sb = inode->i_sb;
109         int len, err;
110         char strbuf[HFSPLUS_MAX_STRLEN + 1];
111         hfsplus_cat_entry entry;
112         struct hfs_find_data fd;
113         struct hfsplus_readdir_data *rd;
114         u16 type;
115
116         if (filp->f_pos >= inode->i_size)
117                 return 0;
118
119         hfs_find_init(HFSPLUS_SB(sb).cat_tree, &fd);
120         hfsplus_cat_build_key(sb, fd.search_key, inode->i_ino, NULL);
121         err = hfs_brec_find(&fd);
122         if (err)
123                 goto out;
124
125         switch ((u32)filp->f_pos) {
126         case 0:
127                 /* This is completely artificial... */
128                 if (filldir(dirent, ".", 1, 0, inode->i_ino, DT_DIR))
129                         goto out;
130                 filp->f_pos++;
131                 /* fall through */
132         case 1:
133                 hfs_bnode_read(fd.bnode, &entry, fd.entryoffset, fd.entrylength);
134                 if (be16_to_cpu(entry.type) != HFSPLUS_FOLDER_THREAD) {
135                         printk("HFS+-fs: bad catalog folder thread\n");
136                         err = -EIO;
137                         goto out;
138                 }
139                 if (fd.entrylength < HFSPLUS_MIN_THREAD_SZ) {
140                         printk("HFS+-fs: truncated catalog thread\n");
141                         err = -EIO;
142                         goto out;
143                 }
144                 if (filldir(dirent, "..", 2, 1,
145                             be32_to_cpu(entry.thread.parentID), DT_DIR))
146                         goto out;
147                 filp->f_pos++;
148                 /* fall through */
149         default:
150                 if (filp->f_pos >= inode->i_size)
151                         goto out;
152                 err = hfs_brec_goto(&fd, filp->f_pos - 1);
153                 if (err)
154                         goto out;
155         }
156
157         for (;;) {
158                 if (be32_to_cpu(fd.key->cat.parent) != inode->i_ino) {
159                         printk("HFS+-fs: walked past end of dir\n");
160                         err = -EIO;
161                         goto out;
162                 }
163                 hfs_bnode_read(fd.bnode, &entry, fd.entryoffset, fd.entrylength);
164                 type = be16_to_cpu(entry.type);
165                 len = HFSPLUS_MAX_STRLEN;
166                 err = hfsplus_uni2asc(sb, &fd.key->cat.name, strbuf, &len);
167                 if (err)
168                         goto out;
169                 if (type == HFSPLUS_FOLDER) {
170                         if (fd.entrylength < sizeof(struct hfsplus_cat_folder)) {
171                                 printk("HFS+-fs: small dir entry\n");
172                                 err = -EIO;
173                                 goto out;
174                         }
175                         if (HFSPLUS_SB(sb).hidden_dir &&
176                             HFSPLUS_SB(sb).hidden_dir->i_ino == be32_to_cpu(entry.folder.id))
177                                 goto next;
178                         if (filldir(dirent, strbuf, len, filp->f_pos,
179                                     be32_to_cpu(entry.folder.id), DT_DIR))
180                                 break;
181                 } else if (type == HFSPLUS_FILE) {
182                         if (fd.entrylength < sizeof(struct hfsplus_cat_file)) {
183                                 printk("HFS+-fs: small file entry\n");
184                                 err = -EIO;
185                                 goto out;
186                         }
187                         if (filldir(dirent, strbuf, len, filp->f_pos,
188                                     be32_to_cpu(entry.file.id), DT_REG))
189                                 break;
190                 } else {
191                         printk("HFS+-fs: bad catalog entry type\n");
192                         err = -EIO;
193                         goto out;
194                 }
195         next:
196                 filp->f_pos++;
197                 if (filp->f_pos >= inode->i_size)
198                         goto out;
199                 err = hfs_brec_goto(&fd, 1);
200                 if (err)
201                         goto out;
202         }
203         rd = filp->private_data;
204         if (!rd) {
205                 rd = kmalloc(sizeof(struct hfsplus_readdir_data), GFP_KERNEL);
206                 if (!rd) {
207                         err = -ENOMEM;
208                         goto out;
209                 }
210                 filp->private_data = rd;
211                 rd->file = filp;
212                 list_add(&rd->list, &HFSPLUS_I(inode).open_dir_list);
213         }
214         memcpy(&rd->key, fd.key, sizeof(struct hfsplus_cat_key));
215 out:
216         hfs_find_exit(&fd);
217         return err;
218 }
219
220 static int hfsplus_dir_release(struct inode *inode, struct file *file)
221 {
222         struct hfsplus_readdir_data *rd = file->private_data;
223         if (rd) {
224                 list_del(&rd->list);
225                 kfree(rd);
226         }
227         return 0;
228 }
229
230 static int hfsplus_create(struct inode *dir, struct dentry *dentry, int mode,
231                           struct nameidata *nd)
232 {
233         struct inode *inode;
234         int res;
235
236         inode = hfsplus_new_inode(dir->i_sb, mode);
237         if (!inode)
238                 return -ENOSPC;
239
240         res = hfsplus_create_cat(inode->i_ino, dir, &dentry->d_name, inode);
241         if (res) {
242                 inode->i_nlink = 0;
243                 hfsplus_delete_inode(inode);
244                 iput(inode);
245                 return res;
246         }
247         hfsplus_instantiate(dentry, inode, inode->i_ino);
248         mark_inode_dirty(inode);
249         return 0;
250 }
251
252 static int hfsplus_link(struct dentry *src_dentry, struct inode *dst_dir,
253                         struct dentry *dst_dentry)
254 {
255         struct super_block *sb = dst_dir->i_sb;
256         struct inode *inode = src_dentry->d_inode;
257         struct inode *src_dir = src_dentry->d_parent->d_inode;
258         struct qstr str;
259         char name[32];
260         u32 cnid, id;
261         int res;
262
263         if (HFSPLUS_IS_RSRC(inode))
264                 return -EPERM;
265
266         if (inode->i_ino == (u32)(unsigned long)src_dentry->d_fsdata) {
267                 for (;;) {
268                         get_random_bytes(&id, sizeof(cnid));
269                         id &= 0x3fffffff;
270                         str.name = name;
271                         str.len = sprintf(name, "iNode%d", id);
272                         res = hfsplus_rename_cat(inode->i_ino,
273                                                  src_dir, &src_dentry->d_name,
274                                                  HFSPLUS_SB(sb).hidden_dir, &str);
275                         if (!res)
276                                 break;
277                         if (res != -EEXIST)
278                                 return res;
279                 }
280                 HFSPLUS_I(inode).dev = id;
281                 cnid = HFSPLUS_SB(sb).next_cnid++;
282                 src_dentry->d_fsdata = (void *)(unsigned long)cnid;
283                 res = hfsplus_create_cat(cnid, src_dir, &src_dentry->d_name, inode);
284                 if (res)
285                         /* panic? */
286                         return res;
287                 HFSPLUS_SB(sb).file_count++;
288         }
289         cnid = HFSPLUS_SB(sb).next_cnid++;
290         res = hfsplus_create_cat(cnid, dst_dir, &dst_dentry->d_name, inode);
291         if (res)
292                 return res;
293
294         inode->i_nlink++;
295         hfsplus_instantiate(dst_dentry, inode, cnid);
296         atomic_inc(&inode->i_count);
297         inode->i_ctime = CURRENT_TIME_SEC;
298         mark_inode_dirty(inode);
299         HFSPLUS_SB(sb).file_count++;
300         sb->s_dirt = 1;
301
302         return 0;
303 }
304
305 static int hfsplus_unlink(struct inode *dir, struct dentry *dentry)
306 {
307         struct super_block *sb = dir->i_sb;
308         struct inode *inode = dentry->d_inode;
309         struct qstr str;
310         char name[32];
311         u32 cnid;
312         int res;
313
314         if (HFSPLUS_IS_RSRC(inode))
315                 return -EPERM;
316
317         cnid = (u32)(unsigned long)dentry->d_fsdata;
318         if (inode->i_ino == cnid &&
319             atomic_read(&HFSPLUS_I(inode).opencnt)) {
320                 str.name = name;
321                 str.len = sprintf(name, "temp%lu", inode->i_ino);
322                 res = hfsplus_rename_cat(inode->i_ino,
323                                          dir, &dentry->d_name,
324                                          HFSPLUS_SB(sb).hidden_dir, &str);
325                 if (!res)
326                         inode->i_flags |= S_DEAD;
327                 return res;
328         }
329         res = hfsplus_delete_cat(cnid, dir, &dentry->d_name);
330         if (res)
331                 return res;
332
333         inode->i_nlink--;
334         hfsplus_delete_inode(inode);
335         if (inode->i_ino != cnid && !inode->i_nlink) {
336                 if (!atomic_read(&HFSPLUS_I(inode).opencnt)) {
337                         res = hfsplus_delete_cat(inode->i_ino, HFSPLUS_SB(sb).hidden_dir, NULL);
338                         if (!res)
339                                 hfsplus_delete_inode(inode);
340                 } else
341                         inode->i_flags |= S_DEAD;
342         }
343         inode->i_ctime = CURRENT_TIME_SEC;
344         mark_inode_dirty(inode);
345
346         return res;
347 }
348
349 static int hfsplus_mkdir(struct inode *dir, struct dentry *dentry, int mode)
350 {
351         struct inode *inode;
352         int res;
353
354         inode = hfsplus_new_inode(dir->i_sb, S_IFDIR | mode);
355         if (!inode)
356                 return -ENOSPC;
357
358         res = hfsplus_create_cat(inode->i_ino, dir, &dentry->d_name, inode);
359         if (res) {
360                 inode->i_nlink = 0;
361                 hfsplus_delete_inode(inode);
362                 iput(inode);
363                 return res;
364         }
365         hfsplus_instantiate(dentry, inode, inode->i_ino);
366         mark_inode_dirty(inode);
367         return 0;
368 }
369
370 static int hfsplus_rmdir(struct inode *dir, struct dentry *dentry)
371 {
372         struct inode *inode;
373         int res;
374
375         inode = dentry->d_inode;
376         if (inode->i_size != 2)
377                 return -ENOTEMPTY;
378         res = hfsplus_delete_cat(inode->i_ino, dir, &dentry->d_name);
379         if (res)
380                 return res;
381         inode->i_nlink = 0;
382         inode->i_ctime = CURRENT_TIME_SEC;
383         hfsplus_delete_inode(inode);
384         mark_inode_dirty(inode);
385         return 0;
386 }
387
388 static int hfsplus_symlink(struct inode *dir, struct dentry *dentry,
389                            const char *symname)
390 {
391         struct super_block *sb;
392         struct inode *inode;
393         int res;
394
395         sb = dir->i_sb;
396         inode = hfsplus_new_inode(sb, S_IFLNK | S_IRWXUGO);
397         if (!inode)
398                 return -ENOSPC;
399
400         res = page_symlink(inode, symname, strlen(symname) + 1);
401         if (res) {
402                 inode->i_nlink = 0;
403                 hfsplus_delete_inode(inode);
404                 iput(inode);
405                 return res;
406         }
407
408         mark_inode_dirty(inode);
409         res = hfsplus_create_cat(inode->i_ino, dir, &dentry->d_name, inode);
410
411         if (!res) {
412                 hfsplus_instantiate(dentry, inode, inode->i_ino);
413                 mark_inode_dirty(inode);
414         }
415
416         return res;
417 }
418
419 static int hfsplus_mknod(struct inode *dir, struct dentry *dentry,
420                          int mode, dev_t rdev)
421 {
422         struct super_block *sb;
423         struct inode *inode;
424         int res;
425
426         sb = dir->i_sb;
427         inode = hfsplus_new_inode(sb, mode);
428         if (!inode)
429                 return -ENOSPC;
430
431         res = hfsplus_create_cat(inode->i_ino, dir, &dentry->d_name, inode);
432         if (res) {
433                 inode->i_nlink = 0;
434                 hfsplus_delete_inode(inode);
435                 iput(inode);
436                 return res;
437         }
438         init_special_inode(inode, mode, rdev);
439         hfsplus_instantiate(dentry, inode, inode->i_ino);
440         mark_inode_dirty(inode);
441
442         return 0;
443 }
444
445 static int hfsplus_rename(struct inode *old_dir, struct dentry *old_dentry,
446                           struct inode *new_dir, struct dentry *new_dentry)
447 {
448         int res;
449
450         /* Unlink destination if it already exists */
451         if (new_dentry->d_inode) {
452                 res = hfsplus_unlink(new_dir, new_dentry);
453                 if (res)
454                         return res;
455         }
456
457         res = hfsplus_rename_cat((u32)(unsigned long)old_dentry->d_fsdata,
458                                  old_dir, &old_dentry->d_name,
459                                  new_dir, &new_dentry->d_name);
460         if (!res)
461                 new_dentry->d_fsdata = old_dentry->d_fsdata;
462         return res;
463 }
464
465 struct inode_operations hfsplus_dir_inode_operations = {
466         .lookup         = hfsplus_lookup,
467         .create         = hfsplus_create,
468         .link           = hfsplus_link,
469         .unlink         = hfsplus_unlink,
470         .mkdir          = hfsplus_mkdir,
471         .rmdir          = hfsplus_rmdir,
472         .symlink        = hfsplus_symlink,
473         .mknod          = hfsplus_mknod,
474         .rename         = hfsplus_rename,
475 };
476
477 struct file_operations hfsplus_dir_operations = {
478         .read           = generic_read_dir,
479         .readdir        = hfsplus_readdir,
480         .ioctl          = hfsplus_ioctl,
481         .llseek         = generic_file_llseek,
482         .release        = hfsplus_dir_release,
483 };