CIFS: Fix too big maxBuf size for SMB3 mounts
[linux-3.10.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                 return 0;
55         }
56         inode_dec_link_count(inode);
57         iput(inode);
58         return err;
59 }
60
61 /*
62  * Methods themselves.
63  */
64
65 static struct dentry *
66 nilfs_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
67 {
68         struct inode *inode;
69         ino_t ino;
70
71         if (dentry->d_name.len > NILFS_NAME_LEN)
72                 return ERR_PTR(-ENAMETOOLONG);
73
74         ino = nilfs_inode_by_name(dir, &dentry->d_name);
75         inode = ino ? nilfs_iget(dir->i_sb, NILFS_I(dir)->i_root, ino) : NULL;
76         return d_splice_alias(inode, dentry);
77 }
78
79 /*
80  * By the time this is called, we already have created
81  * the directory cache entry for the new file, but it
82  * is so far negative - it has no inode.
83  *
84  * If the create succeeds, we fill in the inode information
85  * with d_instantiate().
86  */
87 static int nilfs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
88                         bool excl)
89 {
90         struct inode *inode;
91         struct nilfs_transaction_info ti;
92         int err;
93
94         err = nilfs_transaction_begin(dir->i_sb, &ti, 1);
95         if (err)
96                 return err;
97         inode = nilfs_new_inode(dir, mode);
98         err = PTR_ERR(inode);
99         if (!IS_ERR(inode)) {
100                 inode->i_op = &nilfs_file_inode_operations;
101                 inode->i_fop = &nilfs_file_operations;
102                 inode->i_mapping->a_ops = &nilfs_aops;
103                 nilfs_mark_inode_dirty(inode);
104                 err = nilfs_add_nondir(dentry, inode);
105         }
106         if (!err)
107                 err = nilfs_transaction_commit(dir->i_sb);
108         else
109                 nilfs_transaction_abort(dir->i_sb);
110
111         return err;
112 }
113
114 static int
115 nilfs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode, dev_t rdev)
116 {
117         struct inode *inode;
118         struct nilfs_transaction_info ti;
119         int err;
120
121         if (!new_valid_dev(rdev))
122                 return -EINVAL;
123
124         err = nilfs_transaction_begin(dir->i_sb, &ti, 1);
125         if (err)
126                 return err;
127         inode = nilfs_new_inode(dir, mode);
128         err = PTR_ERR(inode);
129         if (!IS_ERR(inode)) {
130                 init_special_inode(inode, inode->i_mode, rdev);
131                 nilfs_mark_inode_dirty(inode);
132                 err = nilfs_add_nondir(dentry, inode);
133         }
134         if (!err)
135                 err = nilfs_transaction_commit(dir->i_sb);
136         else
137                 nilfs_transaction_abort(dir->i_sb);
138
139         return err;
140 }
141
142 static int nilfs_symlink(struct inode *dir, struct dentry *dentry,
143                          const char *symname)
144 {
145         struct nilfs_transaction_info ti;
146         struct super_block *sb = dir->i_sb;
147         unsigned l = strlen(symname)+1;
148         struct inode *inode;
149         int err;
150
151         if (l > sb->s_blocksize)
152                 return -ENAMETOOLONG;
153
154         err = nilfs_transaction_begin(dir->i_sb, &ti, 1);
155         if (err)
156                 return err;
157
158         inode = nilfs_new_inode(dir, S_IFLNK | S_IRWXUGO);
159         err = PTR_ERR(inode);
160         if (IS_ERR(inode))
161                 goto out;
162
163         /* slow symlink */
164         inode->i_op = &nilfs_symlink_inode_operations;
165         inode->i_mapping->a_ops = &nilfs_aops;
166         err = page_symlink(inode, symname, l);
167         if (err)
168                 goto out_fail;
169
170         /* mark_inode_dirty(inode); */
171         /* page_symlink() do this */
172
173         err = nilfs_add_nondir(dentry, inode);
174 out:
175         if (!err)
176                 err = nilfs_transaction_commit(dir->i_sb);
177         else
178                 nilfs_transaction_abort(dir->i_sb);
179
180         return err;
181
182 out_fail:
183         drop_nlink(inode);
184         nilfs_mark_inode_dirty(inode);
185         iput(inode);
186         goto out;
187 }
188
189 static int nilfs_link(struct dentry *old_dentry, struct inode *dir,
190                       struct dentry *dentry)
191 {
192         struct inode *inode = old_dentry->d_inode;
193         struct nilfs_transaction_info ti;
194         int err;
195
196         err = nilfs_transaction_begin(dir->i_sb, &ti, 1);
197         if (err)
198                 return err;
199
200         inode->i_ctime = CURRENT_TIME;
201         inode_inc_link_count(inode);
202         ihold(inode);
203
204         err = nilfs_add_nondir(dentry, inode);
205         if (!err)
206                 err = nilfs_transaction_commit(dir->i_sb);
207         else
208                 nilfs_transaction_abort(dir->i_sb);
209
210         return err;
211 }
212
213 static int nilfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
214 {
215         struct inode *inode;
216         struct nilfs_transaction_info ti;
217         int err;
218
219         err = nilfs_transaction_begin(dir->i_sb, &ti, 1);
220         if (err)
221                 return err;
222
223         inc_nlink(dir);
224
225         inode = nilfs_new_inode(dir, S_IFDIR | mode);
226         err = PTR_ERR(inode);
227         if (IS_ERR(inode))
228                 goto out_dir;
229
230         inode->i_op = &nilfs_dir_inode_operations;
231         inode->i_fop = &nilfs_dir_operations;
232         inode->i_mapping->a_ops = &nilfs_aops;
233
234         inc_nlink(inode);
235
236         err = nilfs_make_empty(inode, dir);
237         if (err)
238                 goto out_fail;
239
240         err = nilfs_add_link(dentry, inode);
241         if (err)
242                 goto out_fail;
243
244         nilfs_mark_inode_dirty(inode);
245         d_instantiate(dentry, inode);
246 out:
247         if (!err)
248                 err = nilfs_transaction_commit(dir->i_sb);
249         else
250                 nilfs_transaction_abort(dir->i_sb);
251
252         return err;
253
254 out_fail:
255         drop_nlink(inode);
256         drop_nlink(inode);
257         nilfs_mark_inode_dirty(inode);
258         iput(inode);
259 out_dir:
260         drop_nlink(dir);
261         nilfs_mark_inode_dirty(dir);
262         goto out;
263 }
264
265 static int nilfs_do_unlink(struct inode *dir, struct dentry *dentry)
266 {
267         struct inode *inode;
268         struct nilfs_dir_entry *de;
269         struct page *page;
270         int err;
271
272         err = -ENOENT;
273         de = nilfs_find_entry(dir, &dentry->d_name, &page);
274         if (!de)
275                 goto out;
276
277         inode = dentry->d_inode;
278         err = -EIO;
279         if (le64_to_cpu(de->inode) != inode->i_ino)
280                 goto out;
281
282         if (!inode->i_nlink) {
283                 nilfs_warning(inode->i_sb, __func__,
284                               "deleting nonexistent file (%lu), %d\n",
285                               inode->i_ino, inode->i_nlink);
286                 set_nlink(inode, 1);
287         }
288         err = nilfs_delete_entry(de, page);
289         if (err)
290                 goto out;
291
292         inode->i_ctime = dir->i_ctime;
293         drop_nlink(inode);
294         err = 0;
295 out:
296         return err;
297 }
298
299 static int nilfs_unlink(struct inode *dir, struct dentry *dentry)
300 {
301         struct nilfs_transaction_info ti;
302         int err;
303
304         err = nilfs_transaction_begin(dir->i_sb, &ti, 0);
305         if (err)
306                 return err;
307
308         err = nilfs_do_unlink(dir, dentry);
309
310         if (!err) {
311                 nilfs_mark_inode_dirty(dir);
312                 nilfs_mark_inode_dirty(dentry->d_inode);
313                 err = nilfs_transaction_commit(dir->i_sb);
314         } else
315                 nilfs_transaction_abort(dir->i_sb);
316
317         return err;
318 }
319
320 static int nilfs_rmdir(struct inode *dir, struct dentry *dentry)
321 {
322         struct inode *inode = dentry->d_inode;
323         struct nilfs_transaction_info ti;
324         int err;
325
326         err = nilfs_transaction_begin(dir->i_sb, &ti, 0);
327         if (err)
328                 return err;
329
330         err = -ENOTEMPTY;
331         if (nilfs_empty_dir(inode)) {
332                 err = nilfs_do_unlink(dir, dentry);
333                 if (!err) {
334                         inode->i_size = 0;
335                         drop_nlink(inode);
336                         nilfs_mark_inode_dirty(inode);
337                         drop_nlink(dir);
338                         nilfs_mark_inode_dirty(dir);
339                 }
340         }
341         if (!err)
342                 err = nilfs_transaction_commit(dir->i_sb);
343         else
344                 nilfs_transaction_abort(dir->i_sb);
345
346         return err;
347 }
348
349 static int nilfs_rename(struct inode *old_dir, struct dentry *old_dentry,
350                         struct inode *new_dir,  struct dentry *new_dentry)
351 {
352         struct inode *old_inode = old_dentry->d_inode;
353         struct inode *new_inode = new_dentry->d_inode;
354         struct page *dir_page = NULL;
355         struct nilfs_dir_entry *dir_de = NULL;
356         struct page *old_page;
357         struct nilfs_dir_entry *old_de;
358         struct nilfs_transaction_info ti;
359         int err;
360
361         err = nilfs_transaction_begin(old_dir->i_sb, &ti, 1);
362         if (unlikely(err))
363                 return err;
364
365         err = -ENOENT;
366         old_de = nilfs_find_entry(old_dir, &old_dentry->d_name, &old_page);
367         if (!old_de)
368                 goto out;
369
370         if (S_ISDIR(old_inode->i_mode)) {
371                 err = -EIO;
372                 dir_de = nilfs_dotdot(old_inode, &dir_page);
373                 if (!dir_de)
374                         goto out_old;
375         }
376
377         if (new_inode) {
378                 struct page *new_page;
379                 struct nilfs_dir_entry *new_de;
380
381                 err = -ENOTEMPTY;
382                 if (dir_de && !nilfs_empty_dir(new_inode))
383                         goto out_dir;
384
385                 err = -ENOENT;
386                 new_de = nilfs_find_entry(new_dir, &new_dentry->d_name, &new_page);
387                 if (!new_de)
388                         goto out_dir;
389                 nilfs_set_link(new_dir, new_de, new_page, old_inode);
390                 nilfs_mark_inode_dirty(new_dir);
391                 new_inode->i_ctime = CURRENT_TIME;
392                 if (dir_de)
393                         drop_nlink(new_inode);
394                 drop_nlink(new_inode);
395                 nilfs_mark_inode_dirty(new_inode);
396         } else {
397                 err = nilfs_add_link(new_dentry, old_inode);
398                 if (err)
399                         goto out_dir;
400                 if (dir_de) {
401                         inc_nlink(new_dir);
402                         nilfs_mark_inode_dirty(new_dir);
403                 }
404         }
405
406         /*
407          * Like most other Unix systems, set the ctime for inodes on a
408          * rename.
409          */
410         old_inode->i_ctime = CURRENT_TIME;
411
412         nilfs_delete_entry(old_de, old_page);
413
414         if (dir_de) {
415                 nilfs_set_link(old_inode, dir_de, dir_page, new_dir);
416                 drop_nlink(old_dir);
417         }
418         nilfs_mark_inode_dirty(old_dir);
419         nilfs_mark_inode_dirty(old_inode);
420
421         err = nilfs_transaction_commit(old_dir->i_sb);
422         return err;
423
424 out_dir:
425         if (dir_de) {
426                 kunmap(dir_page);
427                 page_cache_release(dir_page);
428         }
429 out_old:
430         kunmap(old_page);
431         page_cache_release(old_page);
432 out:
433         nilfs_transaction_abort(old_dir->i_sb);
434         return err;
435 }
436
437 /*
438  * Export operations
439  */
440 static struct dentry *nilfs_get_parent(struct dentry *child)
441 {
442         unsigned long ino;
443         struct inode *inode;
444         struct qstr dotdot = QSTR_INIT("..", 2);
445         struct nilfs_root *root;
446
447         ino = nilfs_inode_by_name(child->d_inode, &dotdot);
448         if (!ino)
449                 return ERR_PTR(-ENOENT);
450
451         root = NILFS_I(child->d_inode)->i_root;
452
453         inode = nilfs_iget(child->d_inode->i_sb, root, ino);
454         if (IS_ERR(inode))
455                 return ERR_CAST(inode);
456
457         return d_obtain_alias(inode);
458 }
459
460 static struct dentry *nilfs_get_dentry(struct super_block *sb, u64 cno,
461                                        u64 ino, u32 gen)
462 {
463         struct nilfs_root *root;
464         struct inode *inode;
465
466         if (ino < NILFS_FIRST_INO(sb) && ino != NILFS_ROOT_INO)
467                 return ERR_PTR(-ESTALE);
468
469         root = nilfs_lookup_root(sb->s_fs_info, cno);
470         if (!root)
471                 return ERR_PTR(-ESTALE);
472
473         inode = nilfs_iget(sb, root, ino);
474         nilfs_put_root(root);
475
476         if (IS_ERR(inode))
477                 return ERR_CAST(inode);
478         if (gen && inode->i_generation != gen) {
479                 iput(inode);
480                 return ERR_PTR(-ESTALE);
481         }
482         return d_obtain_alias(inode);
483 }
484
485 static struct dentry *nilfs_fh_to_dentry(struct super_block *sb, struct fid *fh,
486                                          int fh_len, int fh_type)
487 {
488         struct nilfs_fid *fid = (struct nilfs_fid *)fh;
489
490         if ((fh_len != NILFS_FID_SIZE_NON_CONNECTABLE &&
491              fh_len != NILFS_FID_SIZE_CONNECTABLE) ||
492             (fh_type != FILEID_NILFS_WITH_PARENT &&
493              fh_type != FILEID_NILFS_WITHOUT_PARENT))
494                 return NULL;
495
496         return nilfs_get_dentry(sb, fid->cno, fid->ino, fid->gen);
497 }
498
499 static struct dentry *nilfs_fh_to_parent(struct super_block *sb, struct fid *fh,
500                                          int fh_len, int fh_type)
501 {
502         struct nilfs_fid *fid = (struct nilfs_fid *)fh;
503
504         if (fh_len != NILFS_FID_SIZE_CONNECTABLE ||
505             fh_type != FILEID_NILFS_WITH_PARENT)
506                 return NULL;
507
508         return nilfs_get_dentry(sb, fid->cno, fid->parent_ino, fid->parent_gen);
509 }
510
511 static int nilfs_encode_fh(struct inode *inode, __u32 *fh, int *lenp,
512                            struct inode *parent)
513 {
514         struct nilfs_fid *fid = (struct nilfs_fid *)fh;
515         struct nilfs_root *root = NILFS_I(inode)->i_root;
516         int type;
517
518         if (parent && *lenp < NILFS_FID_SIZE_CONNECTABLE) {
519                 *lenp = NILFS_FID_SIZE_CONNECTABLE;
520                 return FILEID_INVALID;
521         }
522         if (*lenp < NILFS_FID_SIZE_NON_CONNECTABLE) {
523                 *lenp = NILFS_FID_SIZE_NON_CONNECTABLE;
524                 return FILEID_INVALID;
525         }
526
527         fid->cno = root->cno;
528         fid->ino = inode->i_ino;
529         fid->gen = inode->i_generation;
530
531         if (parent) {
532                 fid->parent_ino = parent->i_ino;
533                 fid->parent_gen = parent->i_generation;
534                 type = FILEID_NILFS_WITH_PARENT;
535                 *lenp = NILFS_FID_SIZE_CONNECTABLE;
536         } else {
537                 type = FILEID_NILFS_WITHOUT_PARENT;
538                 *lenp = NILFS_FID_SIZE_NON_CONNECTABLE;
539         }
540
541         return type;
542 }
543
544 const struct inode_operations nilfs_dir_inode_operations = {
545         .create         = nilfs_create,
546         .lookup         = nilfs_lookup,
547         .link           = nilfs_link,
548         .unlink         = nilfs_unlink,
549         .symlink        = nilfs_symlink,
550         .mkdir          = nilfs_mkdir,
551         .rmdir          = nilfs_rmdir,
552         .mknod          = nilfs_mknod,
553         .rename         = nilfs_rename,
554         .setattr        = nilfs_setattr,
555         .permission     = nilfs_permission,
556         .fiemap         = nilfs_fiemap,
557 };
558
559 const struct inode_operations nilfs_special_inode_operations = {
560         .setattr        = nilfs_setattr,
561         .permission     = nilfs_permission,
562 };
563
564 const struct inode_operations nilfs_symlink_inode_operations = {
565         .readlink       = generic_readlink,
566         .follow_link    = page_follow_link_light,
567         .put_link       = page_put_link,
568         .permission     = nilfs_permission,
569 };
570
571 const struct export_operations nilfs_export_ops = {
572         .encode_fh = nilfs_encode_fh,
573         .fh_to_dentry = nilfs_fh_to_dentry,
574         .fh_to_parent = nilfs_fh_to_parent,
575         .get_parent = nilfs_get_parent,
576 };