37dd6b05b1b5bfe2b794123f3fac1eb5260e91ea
[karo-tx-linux.git] / fs / nilfs2 / namei.c
1 /*
2  * namei.c - NILFS pathname lookup operations.
3  *
4  * Copyright (C) 2005-2008 Nippon Telegraph and Telephone Corporation.
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
19  *
20  * Modified for NILFS by Amagai Yoshiji <amagai@osrg.net>,
21  *                       Ryusuke Konishi <ryusuke@osrg.net>
22  */
23 /*
24  *  linux/fs/ext2/namei.c
25  *
26  * Copyright (C) 1992, 1993, 1994, 1995
27  * Remy Card (card@masi.ibp.fr)
28  * Laboratoire MASI - Institut Blaise Pascal
29  * Universite Pierre et Marie Curie (Paris VI)
30  *
31  *  from
32  *
33  *  linux/fs/minix/namei.c
34  *
35  *  Copyright (C) 1991, 1992  Linus Torvalds
36  *
37  *  Big-endian to little-endian byte-swapping/bitmaps by
38  *        David S. Miller (davem@caip.rutgers.edu), 1995
39  */
40
41 #include <linux/pagemap.h>
42 #include "nilfs.h"
43 #include "export.h"
44
45 #define NILFS_FID_SIZE_NON_CONNECTABLE \
46         (offsetof(struct nilfs_fid, parent_gen) / 4)
47 #define NILFS_FID_SIZE_CONNECTABLE      (sizeof(struct nilfs_fid) / 4)
48
49 static inline int nilfs_add_nondir(struct dentry *dentry, struct inode *inode)
50 {
51         int err = nilfs_add_link(dentry, inode);
52         if (!err) {
53                 d_instantiate(dentry, inode);
54                 unlock_new_inode(inode);
55                 return 0;
56         }
57         inode_dec_link_count(inode);
58         unlock_new_inode(inode);
59         iput(inode);
60         return err;
61 }
62
63 /*
64  * Methods themselves.
65  */
66
67 static struct dentry *
68 nilfs_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
69 {
70         struct inode *inode;
71         ino_t ino;
72
73         if (dentry->d_name.len > NILFS_NAME_LEN)
74                 return ERR_PTR(-ENAMETOOLONG);
75
76         ino = nilfs_inode_by_name(dir, &dentry->d_name);
77         inode = ino ? nilfs_iget(dir->i_sb, NILFS_I(dir)->i_root, ino) : NULL;
78         return d_splice_alias(inode, dentry);
79 }
80
81 /*
82  * By the time this is called, we already have created
83  * the directory cache entry for the new file, but it
84  * is so far negative - it has no inode.
85  *
86  * If the create succeeds, we fill in the inode information
87  * with d_instantiate().
88  */
89 static int nilfs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
90                         bool excl)
91 {
92         struct inode *inode;
93         struct nilfs_transaction_info ti;
94         int err;
95
96         err = nilfs_transaction_begin(dir->i_sb, &ti, 1);
97         if (err)
98                 return err;
99         inode = nilfs_new_inode(dir, mode);
100         err = PTR_ERR(inode);
101         if (!IS_ERR(inode)) {
102                 inode->i_op = &nilfs_file_inode_operations;
103                 inode->i_fop = &nilfs_file_operations;
104                 inode->i_mapping->a_ops = &nilfs_aops;
105                 nilfs_mark_inode_dirty(inode);
106                 err = nilfs_add_nondir(dentry, inode);
107         }
108         if (!err)
109                 err = nilfs_transaction_commit(dir->i_sb);
110         else
111                 nilfs_transaction_abort(dir->i_sb);
112
113         return err;
114 }
115
116 static int
117 nilfs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode, dev_t rdev)
118 {
119         struct inode *inode;
120         struct nilfs_transaction_info ti;
121         int err;
122
123         if (!new_valid_dev(rdev))
124                 return -EINVAL;
125
126         err = nilfs_transaction_begin(dir->i_sb, &ti, 1);
127         if (err)
128                 return err;
129         inode = nilfs_new_inode(dir, mode);
130         err = PTR_ERR(inode);
131         if (!IS_ERR(inode)) {
132                 init_special_inode(inode, inode->i_mode, rdev);
133                 nilfs_mark_inode_dirty(inode);
134                 err = nilfs_add_nondir(dentry, inode);
135         }
136         if (!err)
137                 err = nilfs_transaction_commit(dir->i_sb);
138         else
139                 nilfs_transaction_abort(dir->i_sb);
140
141         return err;
142 }
143
144 static int nilfs_symlink(struct inode *dir, struct dentry *dentry,
145                          const char *symname)
146 {
147         struct nilfs_transaction_info ti;
148         struct super_block *sb = dir->i_sb;
149         unsigned l = strlen(symname)+1;
150         struct inode *inode;
151         int err;
152
153         if (l > sb->s_blocksize)
154                 return -ENAMETOOLONG;
155
156         err = nilfs_transaction_begin(dir->i_sb, &ti, 1);
157         if (err)
158                 return err;
159
160         inode = nilfs_new_inode(dir, S_IFLNK | S_IRWXUGO);
161         err = PTR_ERR(inode);
162         if (IS_ERR(inode))
163                 goto out;
164
165         /* slow symlink */
166         inode->i_op = &nilfs_symlink_inode_operations;
167         inode->i_mapping->a_ops = &nilfs_aops;
168         err = page_symlink(inode, symname, l);
169         if (err)
170                 goto out_fail;
171
172         /* mark_inode_dirty(inode); */
173         /* page_symlink() do this */
174
175         err = nilfs_add_nondir(dentry, inode);
176 out:
177         if (!err)
178                 err = nilfs_transaction_commit(dir->i_sb);
179         else
180                 nilfs_transaction_abort(dir->i_sb);
181
182         return err;
183
184 out_fail:
185         drop_nlink(inode);
186         nilfs_mark_inode_dirty(inode);
187         unlock_new_inode(inode);
188         iput(inode);
189         goto out;
190 }
191
192 static int nilfs_link(struct dentry *old_dentry, struct inode *dir,
193                       struct dentry *dentry)
194 {
195         struct inode *inode = d_inode(old_dentry);
196         struct nilfs_transaction_info ti;
197         int err;
198
199         err = nilfs_transaction_begin(dir->i_sb, &ti, 1);
200         if (err)
201                 return err;
202
203         inode->i_ctime = CURRENT_TIME;
204         inode_inc_link_count(inode);
205         ihold(inode);
206
207         err = nilfs_add_link(dentry, inode);
208         if (!err) {
209                 d_instantiate(dentry, inode);
210                 err = nilfs_transaction_commit(dir->i_sb);
211         } else {
212                 inode_dec_link_count(inode);
213                 iput(inode);
214                 nilfs_transaction_abort(dir->i_sb);
215         }
216
217         return err;
218 }
219
220 static int nilfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
221 {
222         struct inode *inode;
223         struct nilfs_transaction_info ti;
224         int err;
225
226         err = nilfs_transaction_begin(dir->i_sb, &ti, 1);
227         if (err)
228                 return err;
229
230         inc_nlink(dir);
231
232         inode = nilfs_new_inode(dir, S_IFDIR | mode);
233         err = PTR_ERR(inode);
234         if (IS_ERR(inode))
235                 goto out_dir;
236
237         inode->i_op = &nilfs_dir_inode_operations;
238         inode->i_fop = &nilfs_dir_operations;
239         inode->i_mapping->a_ops = &nilfs_aops;
240
241         inc_nlink(inode);
242
243         err = nilfs_make_empty(inode, dir);
244         if (err)
245                 goto out_fail;
246
247         err = nilfs_add_link(dentry, inode);
248         if (err)
249                 goto out_fail;
250
251         nilfs_mark_inode_dirty(inode);
252         d_instantiate(dentry, inode);
253         unlock_new_inode(inode);
254 out:
255         if (!err)
256                 err = nilfs_transaction_commit(dir->i_sb);
257         else
258                 nilfs_transaction_abort(dir->i_sb);
259
260         return err;
261
262 out_fail:
263         drop_nlink(inode);
264         drop_nlink(inode);
265         nilfs_mark_inode_dirty(inode);
266         unlock_new_inode(inode);
267         iput(inode);
268 out_dir:
269         drop_nlink(dir);
270         nilfs_mark_inode_dirty(dir);
271         goto out;
272 }
273
274 static int nilfs_do_unlink(struct inode *dir, struct dentry *dentry)
275 {
276         struct inode *inode;
277         struct nilfs_dir_entry *de;
278         struct page *page;
279         int err;
280
281         err = -ENOENT;
282         de = nilfs_find_entry(dir, &dentry->d_name, &page);
283         if (!de)
284                 goto out;
285
286         inode = d_inode(dentry);
287         err = -EIO;
288         if (le64_to_cpu(de->inode) != inode->i_ino)
289                 goto out;
290
291         if (!inode->i_nlink) {
292                 nilfs_warning(inode->i_sb, __func__,
293                               "deleting nonexistent file (%lu), %d\n",
294                               inode->i_ino, inode->i_nlink);
295                 set_nlink(inode, 1);
296         }
297         err = nilfs_delete_entry(de, page);
298         if (err)
299                 goto out;
300
301         inode->i_ctime = dir->i_ctime;
302         drop_nlink(inode);
303         err = 0;
304 out:
305         return err;
306 }
307
308 static int nilfs_unlink(struct inode *dir, struct dentry *dentry)
309 {
310         struct nilfs_transaction_info ti;
311         int err;
312
313         err = nilfs_transaction_begin(dir->i_sb, &ti, 0);
314         if (err)
315                 return err;
316
317         err = nilfs_do_unlink(dir, dentry);
318
319         if (!err) {
320                 nilfs_mark_inode_dirty(dir);
321                 nilfs_mark_inode_dirty(d_inode(dentry));
322                 err = nilfs_transaction_commit(dir->i_sb);
323         } else
324                 nilfs_transaction_abort(dir->i_sb);
325
326         return err;
327 }
328
329 static int nilfs_rmdir(struct inode *dir, struct dentry *dentry)
330 {
331         struct inode *inode = d_inode(dentry);
332         struct nilfs_transaction_info ti;
333         int err;
334
335         err = nilfs_transaction_begin(dir->i_sb, &ti, 0);
336         if (err)
337                 return err;
338
339         err = -ENOTEMPTY;
340         if (nilfs_empty_dir(inode)) {
341                 err = nilfs_do_unlink(dir, dentry);
342                 if (!err) {
343                         inode->i_size = 0;
344                         drop_nlink(inode);
345                         nilfs_mark_inode_dirty(inode);
346                         drop_nlink(dir);
347                         nilfs_mark_inode_dirty(dir);
348                 }
349         }
350         if (!err)
351                 err = nilfs_transaction_commit(dir->i_sb);
352         else
353                 nilfs_transaction_abort(dir->i_sb);
354
355         return err;
356 }
357
358 static int nilfs_rename(struct inode *old_dir, struct dentry *old_dentry,
359                         struct inode *new_dir,  struct dentry *new_dentry)
360 {
361         struct inode *old_inode = d_inode(old_dentry);
362         struct inode *new_inode = d_inode(new_dentry);
363         struct page *dir_page = NULL;
364         struct nilfs_dir_entry *dir_de = NULL;
365         struct page *old_page;
366         struct nilfs_dir_entry *old_de;
367         struct nilfs_transaction_info ti;
368         int err;
369
370         err = nilfs_transaction_begin(old_dir->i_sb, &ti, 1);
371         if (unlikely(err))
372                 return err;
373
374         err = -ENOENT;
375         old_de = nilfs_find_entry(old_dir, &old_dentry->d_name, &old_page);
376         if (!old_de)
377                 goto out;
378
379         if (S_ISDIR(old_inode->i_mode)) {
380                 err = -EIO;
381                 dir_de = nilfs_dotdot(old_inode, &dir_page);
382                 if (!dir_de)
383                         goto out_old;
384         }
385
386         if (new_inode) {
387                 struct page *new_page;
388                 struct nilfs_dir_entry *new_de;
389
390                 err = -ENOTEMPTY;
391                 if (dir_de && !nilfs_empty_dir(new_inode))
392                         goto out_dir;
393
394                 err = -ENOENT;
395                 new_de = nilfs_find_entry(new_dir, &new_dentry->d_name, &new_page);
396                 if (!new_de)
397                         goto out_dir;
398                 nilfs_set_link(new_dir, new_de, new_page, old_inode);
399                 nilfs_mark_inode_dirty(new_dir);
400                 new_inode->i_ctime = CURRENT_TIME;
401                 if (dir_de)
402                         drop_nlink(new_inode);
403                 drop_nlink(new_inode);
404                 nilfs_mark_inode_dirty(new_inode);
405         } else {
406                 err = nilfs_add_link(new_dentry, old_inode);
407                 if (err)
408                         goto out_dir;
409                 if (dir_de) {
410                         inc_nlink(new_dir);
411                         nilfs_mark_inode_dirty(new_dir);
412                 }
413         }
414
415         /*
416          * Like most other Unix systems, set the ctime for inodes on a
417          * rename.
418          */
419         old_inode->i_ctime = CURRENT_TIME;
420
421         nilfs_delete_entry(old_de, old_page);
422
423         if (dir_de) {
424                 nilfs_set_link(old_inode, dir_de, dir_page, new_dir);
425                 drop_nlink(old_dir);
426         }
427         nilfs_mark_inode_dirty(old_dir);
428         nilfs_mark_inode_dirty(old_inode);
429
430         err = nilfs_transaction_commit(old_dir->i_sb);
431         return err;
432
433 out_dir:
434         if (dir_de) {
435                 kunmap(dir_page);
436                 page_cache_release(dir_page);
437         }
438 out_old:
439         kunmap(old_page);
440         page_cache_release(old_page);
441 out:
442         nilfs_transaction_abort(old_dir->i_sb);
443         return err;
444 }
445
446 /*
447  * Export operations
448  */
449 static struct dentry *nilfs_get_parent(struct dentry *child)
450 {
451         unsigned long ino;
452         struct inode *inode;
453         struct qstr dotdot = QSTR_INIT("..", 2);
454         struct nilfs_root *root;
455
456         ino = nilfs_inode_by_name(d_inode(child), &dotdot);
457         if (!ino)
458                 return ERR_PTR(-ENOENT);
459
460         root = NILFS_I(d_inode(child))->i_root;
461
462         inode = nilfs_iget(d_inode(child)->i_sb, root, ino);
463         if (IS_ERR(inode))
464                 return ERR_CAST(inode);
465
466         return d_obtain_alias(inode);
467 }
468
469 static struct dentry *nilfs_get_dentry(struct super_block *sb, u64 cno,
470                                        u64 ino, u32 gen)
471 {
472         struct nilfs_root *root;
473         struct inode *inode;
474
475         if (ino < NILFS_FIRST_INO(sb) && ino != NILFS_ROOT_INO)
476                 return ERR_PTR(-ESTALE);
477
478         root = nilfs_lookup_root(sb->s_fs_info, cno);
479         if (!root)
480                 return ERR_PTR(-ESTALE);
481
482         inode = nilfs_iget(sb, root, ino);
483         nilfs_put_root(root);
484
485         if (IS_ERR(inode))
486                 return ERR_CAST(inode);
487         if (gen && inode->i_generation != gen) {
488                 iput(inode);
489                 return ERR_PTR(-ESTALE);
490         }
491         return d_obtain_alias(inode);
492 }
493
494 static struct dentry *nilfs_fh_to_dentry(struct super_block *sb, struct fid *fh,
495                                          int fh_len, int fh_type)
496 {
497         struct nilfs_fid *fid = (struct nilfs_fid *)fh;
498
499         if (fh_len < NILFS_FID_SIZE_NON_CONNECTABLE ||
500             (fh_type != FILEID_NILFS_WITH_PARENT &&
501              fh_type != FILEID_NILFS_WITHOUT_PARENT))
502                 return NULL;
503
504         return nilfs_get_dentry(sb, fid->cno, fid->ino, fid->gen);
505 }
506
507 static struct dentry *nilfs_fh_to_parent(struct super_block *sb, struct fid *fh,
508                                          int fh_len, int fh_type)
509 {
510         struct nilfs_fid *fid = (struct nilfs_fid *)fh;
511
512         if (fh_len < NILFS_FID_SIZE_CONNECTABLE ||
513             fh_type != FILEID_NILFS_WITH_PARENT)
514                 return NULL;
515
516         return nilfs_get_dentry(sb, fid->cno, fid->parent_ino, fid->parent_gen);
517 }
518
519 static int nilfs_encode_fh(struct inode *inode, __u32 *fh, int *lenp,
520                            struct inode *parent)
521 {
522         struct nilfs_fid *fid = (struct nilfs_fid *)fh;
523         struct nilfs_root *root = NILFS_I(inode)->i_root;
524         int type;
525
526         if (parent && *lenp < NILFS_FID_SIZE_CONNECTABLE) {
527                 *lenp = NILFS_FID_SIZE_CONNECTABLE;
528                 return FILEID_INVALID;
529         }
530         if (*lenp < NILFS_FID_SIZE_NON_CONNECTABLE) {
531                 *lenp = NILFS_FID_SIZE_NON_CONNECTABLE;
532                 return FILEID_INVALID;
533         }
534
535         fid->cno = root->cno;
536         fid->ino = inode->i_ino;
537         fid->gen = inode->i_generation;
538
539         if (parent) {
540                 fid->parent_ino = parent->i_ino;
541                 fid->parent_gen = parent->i_generation;
542                 type = FILEID_NILFS_WITH_PARENT;
543                 *lenp = NILFS_FID_SIZE_CONNECTABLE;
544         } else {
545                 type = FILEID_NILFS_WITHOUT_PARENT;
546                 *lenp = NILFS_FID_SIZE_NON_CONNECTABLE;
547         }
548
549         return type;
550 }
551
552 const struct inode_operations nilfs_dir_inode_operations = {
553         .create         = nilfs_create,
554         .lookup         = nilfs_lookup,
555         .link           = nilfs_link,
556         .unlink         = nilfs_unlink,
557         .symlink        = nilfs_symlink,
558         .mkdir          = nilfs_mkdir,
559         .rmdir          = nilfs_rmdir,
560         .mknod          = nilfs_mknod,
561         .rename         = nilfs_rename,
562         .setattr        = nilfs_setattr,
563         .permission     = nilfs_permission,
564         .fiemap         = nilfs_fiemap,
565 };
566
567 const struct inode_operations nilfs_special_inode_operations = {
568         .setattr        = nilfs_setattr,
569         .permission     = nilfs_permission,
570 };
571
572 const struct inode_operations nilfs_symlink_inode_operations = {
573         .readlink       = generic_readlink,
574         .follow_link    = page_follow_link_light,
575         .put_link       = page_put_link,
576         .permission     = nilfs_permission,
577 };
578
579 const struct export_operations nilfs_export_ops = {
580         .encode_fh = nilfs_encode_fh,
581         .fh_to_dentry = nilfs_fh_to_dentry,
582         .fh_to_parent = nilfs_fh_to_parent,
583         .get_parent = nilfs_get_parent,
584 };