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