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