Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
namei.c
Go to the documentation of this file.
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 <[email protected]>,
21  * Ryusuke Konishi <[email protected]>
22  */
23 /*
24  * linux/fs/ext2/namei.c
25  *
26  * Copyright (C) 1992, 1993, 1994, 1995
27  * Remy Card ([email protected])
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 ([email protected]), 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)) {
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
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
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 */
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
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
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 
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
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);
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) {
313  err = nilfs_transaction_commit(dir->i_sb);
314  } else
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);
339  }
340  }
341  if (!err)
342  err = nilfs_transaction_commit(dir->i_sb);
343  else
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) {
520  return 255;
521  }
522  if (*lenp < NILFS_FID_SIZE_NON_CONNECTABLE) {
524  return 255;
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;
536  } else {
539  }
540 
541  return type;
542 }
543 
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 
560  .setattr = nilfs_setattr,
561  .permission = nilfs_permission,
562 };
563 
565  .readlink = generic_readlink,
566  .follow_link = page_follow_link_light,
567  .put_link = page_put_link,
568  .permission = nilfs_permission,
569 };
570 
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 };