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