~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/nilfs2/namei.c

Version: ~ [ linux-5.17-rc1 ] ~ [ linux-5.16.2 ] ~ [ linux-5.15.16 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.93 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.173 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.225 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.262 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.297 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.299 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp