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

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

Version: ~ [ linux-5.18-rc6 ] ~ [ linux-5.17.6 ] ~ [ linux-5.16.20 ] ~ [ linux-5.15.38 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.114 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.192 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.241 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.277 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.312 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.302 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ 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.9 ] ~ [ 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  * 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 = old_dentry->d_inode;
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 = dentry->d_inode;
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(dentry->d_inode);
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 = dentry->d_inode;
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 = old_dentry->d_inode;
362         struct inode *new_inode = new_dentry->d_inode;
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(child->d_inode, &dotdot);
457         if (!ino)
458                 return ERR_PTR(-ENOENT);
459 
460         root = NILFS_I(child->d_inode)->i_root;
461 
462         inode = nilfs_iget(child->d_inode->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_len != NILFS_FID_SIZE_CONNECTABLE) ||
501             (fh_type != FILEID_NILFS_WITH_PARENT &&
502              fh_type != FILEID_NILFS_WITHOUT_PARENT))
503                 return NULL;
504 
505         return nilfs_get_dentry(sb, fid->cno, fid->ino, fid->gen);
506 }
507 
508 static struct dentry *nilfs_fh_to_parent(struct super_block *sb, struct fid *fh,
509                                          int fh_len, int fh_type)
510 {
511         struct nilfs_fid *fid = (struct nilfs_fid *)fh;
512 
513         if (fh_len != NILFS_FID_SIZE_CONNECTABLE ||
514             fh_type != FILEID_NILFS_WITH_PARENT)
515                 return NULL;
516 
517         return nilfs_get_dentry(sb, fid->cno, fid->parent_ino, fid->parent_gen);
518 }
519 
520 static int nilfs_encode_fh(struct inode *inode, __u32 *fh, int *lenp,
521                            struct inode *parent)
522 {
523         struct nilfs_fid *fid = (struct nilfs_fid *)fh;
524         struct nilfs_root *root = NILFS_I(inode)->i_root;
525         int type;
526 
527         if (parent && *lenp < NILFS_FID_SIZE_CONNECTABLE) {
528                 *lenp = NILFS_FID_SIZE_CONNECTABLE;
529                 return FILEID_INVALID;
530         }
531         if (*lenp < NILFS_FID_SIZE_NON_CONNECTABLE) {
532                 *lenp = NILFS_FID_SIZE_NON_CONNECTABLE;
533                 return FILEID_INVALID;
534         }
535 
536         fid->cno = root->cno;
537         fid->ino = inode->i_ino;
538         fid->gen = inode->i_generation;
539 
540         if (parent) {
541                 fid->parent_ino = parent->i_ino;
542                 fid->parent_gen = parent->i_generation;
543                 type = FILEID_NILFS_WITH_PARENT;
544                 *lenp = NILFS_FID_SIZE_CONNECTABLE;
545         } else {
546                 type = FILEID_NILFS_WITHOUT_PARENT;
547                 *lenp = NILFS_FID_SIZE_NON_CONNECTABLE;
548         }
549 
550         return type;
551 }
552 
553 const struct inode_operations nilfs_dir_inode_operations = {
554         .create         = nilfs_create,
555         .lookup         = nilfs_lookup,
556         .link           = nilfs_link,
557         .unlink         = nilfs_unlink,
558         .symlink        = nilfs_symlink,
559         .mkdir          = nilfs_mkdir,
560         .rmdir          = nilfs_rmdir,
561         .mknod          = nilfs_mknod,
562         .rename         = nilfs_rename,
563         .setattr        = nilfs_setattr,
564         .permission     = nilfs_permission,
565         .fiemap         = nilfs_fiemap,
566 };
567 
568 const struct inode_operations nilfs_special_inode_operations = {
569         .setattr        = nilfs_setattr,
570         .permission     = nilfs_permission,
571 };
572 
573 const struct inode_operations nilfs_symlink_inode_operations = {
574         .readlink       = generic_readlink,
575         .follow_link    = page_follow_link_light,
576         .put_link       = page_put_link,
577         .permission     = nilfs_permission,
578 };
579 
580 const struct export_operations nilfs_export_ops = {
581         .encode_fh = nilfs_encode_fh,
582         .fh_to_dentry = nilfs_fh_to_dentry,
583         .fh_to_parent = nilfs_fh_to_parent,
584         .get_parent = nilfs_get_parent,
585 };
586 

~ [ 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