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
  44
  45 static inline int nilfs_add_nondir(struct dentry *dentry, struct inode *inode)
  46 {
  47         int err = nilfs_add_link(dentry, inode);
  48         if (!err) {
  49                 d_instantiate(dentry, inode);
  50                 return 0;
  51         }
  52         inode_dec_link_count(inode);
  53         iput(inode);
  54         return err;
  55 }
  56
  57 /*
  58  * Methods themselves.
  59  */
  60
  61 static struct dentry *
  62 nilfs_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
  63 {
  64         struct inode *inode;
  65         ino_t ino;
  66
  67         if (dentry->d_name.len > NILFS_NAME_LEN)
  68                 return ERR_PTR(-ENAMETOOLONG);
  69
  70         ino = nilfs_inode_by_name(dir, &dentry->d_name);
  71         inode = NULL;
  72         if (ino) {
  73                 inode = nilfs_iget(dir->i_sb, NILFS_I(dir)->i_root, ino);
  74                 if (IS_ERR(inode))
  75                         return ERR_CAST(inode);
  76         }
  77         return d_splice_alias(inode, dentry);
  78 }
  79
  80 struct dentry *nilfs_get_parent(struct dentry *child)
  81 {
  82         unsigned long ino;
  83         struct inode *inode;
  84         struct qstr dotdot = {.name = "..", .len = 2};
  85
  86         ino = nilfs_inode_by_name(child->d_inode, &dotdot);
  87         if (!ino)
  88                 return ERR_PTR(-ENOENT);
  89
  90         inode = nilfs_iget(child->d_inode->i_sb,
  91                            NILFS_I(child->d_inode)->i_root, ino);
  92         if (IS_ERR(inode))
  93                 return ERR_CAST(inode);
  94         return d_obtain_alias(inode);
  95 }
  96
  97 /*
  98  * By the time this is called, we already have created
  99  * the directory cache entry for the new file, but it
 100  * is so far negative - it has no inode.
 101  *
 102  * If the create succeeds, we fill in the inode information
 103  * with d_instantiate().
 104  */
 105 static int nilfs_create(struct inode *dir, struct dentry *dentry, int mode,
 106                         struct nameidata *nd)
 107 {
 108         struct inode *inode;
 109         struct nilfs_transaction_info ti;
 110         int err;
 111
 112         err = nilfs_transaction_begin(dir->i_sb, &ti, 1);
 113         if (err)
 114                 return err;
 115         inode = nilfs_new_inode(dir, mode);
 116         err = PTR_ERR(inode);
 117         if (!IS_ERR(inode)) {
 118                 inode->i_op = &nilfs_file_inode_operations;
 119                 inode->i_fop = &nilfs_file_operations;
 120                 inode->i_mapping->a_ops = &nilfs_aops;
 121                 nilfs_mark_inode_dirty(inode);
 122                 err = nilfs_add_nondir(dentry, inode);
 123         }
 124         if (!err)
 125                 err = nilfs_transaction_commit(dir->i_sb);
 126         else
 127                 nilfs_transaction_abort(dir->i_sb);
 128
 129         return err;
 130 }
 131
 132 static int
 133 nilfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t rdev)
 134 {
 135         struct inode *inode;
 136         struct nilfs_transaction_info ti;
 137         int err;
 138
 139         if (!new_valid_dev(rdev))
 140                 return -EINVAL;
 141
 142         err = nilfs_transaction_begin(dir->i_sb, &ti, 1);
 143         if (err)
 144                 return err;
 145         inode = nilfs_new_inode(dir, mode);
 146         err = PTR_ERR(inode);
 147         if (!IS_ERR(inode)) {
 148                 init_special_inode(inode, inode->i_mode, rdev);
 149                 nilfs_mark_inode_dirty(inode);
 150                 err = nilfs_add_nondir(dentry, inode);
 151         }
 152         if (!err)
 153                 err = nilfs_transaction_commit(dir->i_sb);
 154         else
 155                 nilfs_transaction_abort(dir->i_sb);
 156
 157         return err;
 158 }
 159
 160 static int nilfs_symlink(struct inode *dir, struct dentry *dentry,
 161                          const char *symname)
 162 {
 163         struct nilfs_transaction_info ti;
 164         struct super_block *sb = dir->i_sb;
 165         unsigned l = strlen(symname)+1;
 166         struct inode *inode;
 167         int err;
 168
 169         if (l > sb->s_blocksize)
 170                 return -ENAMETOOLONG;
 171
 172         err = nilfs_transaction_begin(dir->i_sb, &ti, 1);
 173         if (err)
 174                 return err;
 175
 176         inode = nilfs_new_inode(dir, S_IFLNK | S_IRWXUGO);
 177         err = PTR_ERR(inode);
 178         if (IS_ERR(inode))
 179                 goto out;
 180
 181         /* slow symlink */
 182         inode->i_op = &nilfs_symlink_inode_operations;
 183         inode->i_mapping->a_ops = &nilfs_aops;
 184         err = page_symlink(inode, symname, l);
 185         if (err)
 186                 goto out_fail;
 187
 188         /* mark_inode_dirty(inode); */
 189         /* page_symlink() do this */
 190
 191         err = nilfs_add_nondir(dentry, inode);
 192 out:
 193         if (!err)
 194                 err = nilfs_transaction_commit(dir->i_sb);
 195         else
 196                 nilfs_transaction_abort(dir->i_sb);
 197
 198         return err;
 199
 200 out_fail:
 201         drop_nlink(inode);
 202         nilfs_mark_inode_dirty(inode);
 203         iput(inode);
 204         goto out;
 205 }
 206
 207 static int nilfs_link(struct dentry *old_dentry, struct inode *dir,
 208                       struct dentry *dentry)
 209 {
 210         struct inode *inode = old_dentry->d_inode;
 211         struct nilfs_transaction_info ti;
 212         int err;
 213
 214         if (inode->i_nlink >= NILFS_LINK_MAX)
 215                 return -EMLINK;
 216
 217         err = nilfs_transaction_begin(dir->i_sb, &ti, 1);
 218         if (err)
 219                 return err;
 220
 221         inode->i_ctime = CURRENT_TIME;
 222         inode_inc_link_count(inode);
 223         atomic_inc(&inode->i_count);
 224
 225         err = nilfs_add_nondir(dentry, inode);
 226         if (!err)
 227                 err = nilfs_transaction_commit(dir->i_sb);
 228         else
 229                 nilfs_transaction_abort(dir->i_sb);
 230
 231         return err;
 232 }
 233
 234 static int nilfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
 235 {
 236         struct inode *inode;
 237         struct nilfs_transaction_info ti;
 238         int err;
 239
 240         if (dir->i_nlink >= NILFS_LINK_MAX)
 241                 return -EMLINK;
 242
 243         err = nilfs_transaction_begin(dir->i_sb, &ti, 1);
 244         if (err)
 245                 return err;
 246
 247         inc_nlink(dir);
 248
 249         inode = nilfs_new_inode(dir, S_IFDIR | mode);
 250         err = PTR_ERR(inode);
 251         if (IS_ERR(inode))
 252                 goto out_dir;
 253
 254         inode->i_op = &nilfs_dir_inode_operations;
 255         inode->i_fop = &nilfs_dir_operations;
 256         inode->i_mapping->a_ops = &nilfs_aops;
 257
 258         inc_nlink(inode);
 259
 260         err = nilfs_make_empty(inode, dir);
 261         if (err)
 262                 goto out_fail;
 263
 264         err = nilfs_add_link(dentry, inode);
 265         if (err)
 266                 goto out_fail;
 267
 268         nilfs_mark_inode_dirty(inode);
 269         d_instantiate(dentry, inode);
 270 out:
 271         if (!err)
 272                 err = nilfs_transaction_commit(dir->i_sb);
 273         else
 274                 nilfs_transaction_abort(dir->i_sb);
 275
 276         return err;
 277
 278 out_fail:
 279         drop_nlink(inode);
 280         drop_nlink(inode);
 281         nilfs_mark_inode_dirty(inode);
 282         iput(inode);
 283 out_dir:
 284         drop_nlink(dir);
 285         nilfs_mark_inode_dirty(dir);
 286         goto out;
 287 }
 288
 289 static int nilfs_do_unlink(struct inode *dir, struct dentry *dentry)
 290 {
 291         struct inode *inode;
 292         struct nilfs_dir_entry *de;
 293         struct page *page;
 294         int err;
 295
 296         err = -ENOENT;
 297         de = nilfs_find_entry(dir, &dentry->d_name, &page);
 298         if (!de)
 299                 goto out;
 300
 301         inode = dentry->d_inode;
 302         err = -EIO;
 303         if (le64_to_cpu(de->inode) != inode->i_ino)
 304                 goto out;
 305
 306         if (!inode->i_nlink) {
 307                 nilfs_warning(inode->i_sb, __func__,
 308                               "deleting nonexistent file (%lu), %d\n",
 309                               inode->i_ino, inode->i_nlink);
 310                 inode->i_nlink = 1;
 311         }
 312         err = nilfs_delete_entry(de, page);
 313         if (err)
 314                 goto out;
 315
 316         inode->i_ctime = dir->i_ctime;
 317         drop_nlink(inode);
 318         err = 0;
 319 out:
 320         return err;
 321 }
 322
 323 static int nilfs_unlink(struct inode *dir, struct dentry *dentry)
 324 {
 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 = nilfs_do_unlink(dir, dentry);
 333
 334         if (!err) {
 335                 nilfs_mark_inode_dirty(dir);
 336                 nilfs_mark_inode_dirty(dentry->d_inode);
 337                 err = nilfs_transaction_commit(dir->i_sb);
 338         } else
 339                 nilfs_transaction_abort(dir->i_sb);
 340
 341         return err;
 342 }
 343
 344 static int nilfs_rmdir(struct inode *dir, struct dentry *dentry)
 345 {
 346         struct inode *inode = dentry->d_inode;
 347         struct nilfs_transaction_info ti;
 348         int err;
 349
 350         err = nilfs_transaction_begin(dir->i_sb, &ti, 0);
 351         if (err)
 352                 return err;
 353
 354         err = -ENOTEMPTY;
 355         if (nilfs_empty_dir(inode)) {
 356                 err = nilfs_do_unlink(dir, dentry);
 357                 if (!err) {
 358                         inode->i_size = 0;
 359                         drop_nlink(inode);
 360                         nilfs_mark_inode_dirty(inode);
 361                         drop_nlink(dir);
 362                         nilfs_mark_inode_dirty(dir);
 363                 }
 364         }
 365         if (!err)
 366                 err = nilfs_transaction_commit(dir->i_sb);
 367         else
 368                 nilfs_transaction_abort(dir->i_sb);
 369
 370         return err;
 371 }
 372
 373 static int nilfs_rename(struct inode *old_dir, struct dentry *old_dentry,
 374                         struct inode *new_dir,  struct dentry *new_dentry)
 375 {
 376         struct inode *old_inode = old_dentry->d_inode;
 377         struct inode *new_inode = new_dentry->d_inode;
 378         struct page *dir_page = NULL;
 379         struct nilfs_dir_entry *dir_de = NULL;
 380         struct page *old_page;
 381         struct nilfs_dir_entry *old_de;
 382         struct nilfs_transaction_info ti;
 383         int err;
 384
 385         err = nilfs_transaction_begin(old_dir->i_sb, &ti, 1);
 386         if (unlikely(err))
 387                 return err;
 388
 389         err = -ENOENT;
 390         old_de = nilfs_find_entry(old_dir, &old_dentry->d_name, &old_page);
 391         if (!old_de)
 392                 goto out;
 393
 394         if (S_ISDIR(old_inode->i_mode)) {
 395                 err = -EIO;
 396                 dir_de = nilfs_dotdot(old_inode, &dir_page);
 397                 if (!dir_de)
 398                         goto out_old;
 399         }
 400
 401         if (new_inode) {
 402                 struct page *new_page;
 403                 struct nilfs_dir_entry *new_de;
 404
 405                 err = -ENOTEMPTY;
 406                 if (dir_de && !nilfs_empty_dir(new_inode))
 407                         goto out_dir;
 408
 409                 err = -ENOENT;
 410                 new_de = nilfs_find_entry(new_dir, &new_dentry->d_name, &new_page);
 411                 if (!new_de)
 412                         goto out_dir;
 413                 inc_nlink(old_inode);
 414                 nilfs_set_link(new_dir, new_de, new_page, old_inode);
 415                 nilfs_mark_inode_dirty(new_dir);
 416                 new_inode->i_ctime = CURRENT_TIME;
 417                 if (dir_de)
 418                         drop_nlink(new_inode);
 419                 drop_nlink(new_inode);
 420                 nilfs_mark_inode_dirty(new_inode);
 421         } else {
 422                 if (dir_de) {
 423                         err = -EMLINK;
 424                         if (new_dir->i_nlink >= NILFS_LINK_MAX)
 425                                 goto out_dir;
 426                 }
 427                 inc_nlink(old_inode);
 428                 err = nilfs_add_link(new_dentry, old_inode);
 429                 if (err) {
 430                         drop_nlink(old_inode);
 431                         nilfs_mark_inode_dirty(old_inode);
 432                         goto out_dir;
 433                 }
 434                 if (dir_de) {
 435                         inc_nlink(new_dir);
 436                         nilfs_mark_inode_dirty(new_dir);
 437                 }
 438         }
 439
 440         /*
 441          * Like most other Unix systems, set the ctime for inodes on a
 442          * rename.
 443          */
 444         old_inode->i_ctime = CURRENT_TIME;
 445
 446         nilfs_delete_entry(old_de, old_page);
 447         drop_nlink(old_inode);
 448
 449         if (dir_de) {
 450                 nilfs_set_link(old_inode, dir_de, dir_page, new_dir);
 451                 drop_nlink(old_dir);
 452         }
 453         nilfs_mark_inode_dirty(old_dir);
 454         nilfs_mark_inode_dirty(old_inode);
 455
 456         err = nilfs_transaction_commit(old_dir->i_sb);
 457         return err;
 458
 459 out_dir:
 460         if (dir_de) {
 461                 kunmap(dir_page);
 462                 page_cache_release(dir_page);
 463         }
 464 out_old:
 465         kunmap(old_page);
 466         page_cache_release(old_page);
 467 out:
 468         nilfs_transaction_abort(old_dir->i_sb);
 469         return err;
 470 }
 471
 472 const struct inode_operations nilfs_dir_inode_operations = {
 473         .create         = nilfs_create,
 474         .lookup         = nilfs_lookup,
 475         .link           = nilfs_link,
 476         .unlink         = nilfs_unlink,
 477         .symlink        = nilfs_symlink,
 478         .mkdir          = nilfs_mkdir,
 479         .rmdir          = nilfs_rmdir,
 480         .mknod          = nilfs_mknod,
 481         .rename         = nilfs_rename,
 482         .setattr        = nilfs_setattr,
 483         .permission     = nilfs_permission,
 484 };
 485
 486 const struct inode_operations nilfs_special_inode_operations = {
 487         .setattr        = nilfs_setattr,
 488         .permission     = nilfs_permission,
 489 };
 490
 491 const struct inode_operations nilfs_symlink_inode_operations = {
 492         .readlink       = generic_readlink,
 493         .follow_link    = page_follow_link_light,
 494         .put_link       = page_put_link,
 495 };