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