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