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