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