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 if (new_inode && S_ISDIR(new_inode->i_mode)) 375 dentry_unhash(new_dentry); 376 377 err = nilfs_transaction_begin(old_dir->i_sb, &ti, 1); 378 if (unlikely(err)) 379 return err; 380 381 err = -ENOENT; 382 old_de = nilfs_find_entry(old_dir, &old_dentry->d_name, &old_page); 383 if (!old_de) 384 goto out; 385 386 if (S_ISDIR(old_inode->i_mode)) { 387 err = -EIO; 388 dir_de = nilfs_dotdot(old_inode, &dir_page); 389 if (!dir_de) 390 goto out_old; 391 } 392 393 if (new_inode) { 394 struct page *new_page; 395 struct nilfs_dir_entry *new_de; 396 397 err = -ENOTEMPTY; 398 if (dir_de && !nilfs_empty_dir(new_inode)) 399 goto out_dir; 400 401 err = -ENOENT; 402 new_de = nilfs_find_entry(new_dir, &new_dentry->d_name, &new_page); 403 if (!new_de) 404 goto out_dir; 405 nilfs_set_link(new_dir, new_de, new_page, old_inode); 406 nilfs_mark_inode_dirty(new_dir); 407 new_inode->i_ctime = CURRENT_TIME; 408 if (dir_de) 409 drop_nlink(new_inode); 410 drop_nlink(new_inode); 411 nilfs_mark_inode_dirty(new_inode); 412 } else { 413 if (dir_de) { 414 err = -EMLINK; 415 if (new_dir->i_nlink >= NILFS_LINK_MAX) 416 goto out_dir; 417 } 418 err = nilfs_add_link(new_dentry, old_inode); 419 if (err) 420 goto out_dir; 421 if (dir_de) { 422 inc_nlink(new_dir); 423 nilfs_mark_inode_dirty(new_dir); 424 } 425 } 426 427 /* 428 * Like most other Unix systems, set the ctime for inodes on a 429 * rename. 430 */ 431 old_inode->i_ctime = CURRENT_TIME; 432 433 nilfs_delete_entry(old_de, old_page); 434 435 if (dir_de) { 436 nilfs_set_link(old_inode, dir_de, dir_page, new_dir); 437 drop_nlink(old_dir); 438 } 439 nilfs_mark_inode_dirty(old_dir); 440 nilfs_mark_inode_dirty(old_inode); 441 442 err = nilfs_transaction_commit(old_dir->i_sb); 443 return err; 444 445 out_dir: 446 if (dir_de) { 447 kunmap(dir_page); 448 page_cache_release(dir_page); 449 } 450 out_old: 451 kunmap(old_page); 452 page_cache_release(old_page); 453 out: 454 nilfs_transaction_abort(old_dir->i_sb); 455 return err; 456 } 457 458 /* 459 * Export operations 460 */ 461 static struct dentry *nilfs_get_parent(struct dentry *child) 462 { 463 unsigned long ino; 464 struct inode *inode; 465 struct qstr dotdot = {.name = "..", .len = 2}; 466 struct nilfs_root *root; 467 468 ino = nilfs_inode_by_name(child->d_inode, &dotdot); 469 if (!ino) 470 return ERR_PTR(-ENOENT); 471 472 root = NILFS_I(child->d_inode)->i_root; 473 474 inode = nilfs_iget(child->d_inode->i_sb, root, ino); 475 if (IS_ERR(inode)) 476 return ERR_CAST(inode); 477 478 return d_obtain_alias(inode); 479 } 480 481 static struct dentry *nilfs_get_dentry(struct super_block *sb, u64 cno, 482 u64 ino, u32 gen) 483 { 484 struct nilfs_root *root; 485 struct inode *inode; 486 487 if (ino < NILFS_FIRST_INO(sb) && ino != NILFS_ROOT_INO) 488 return ERR_PTR(-ESTALE); 489 490 root = nilfs_lookup_root(sb->s_fs_info, cno); 491 if (!root) 492 return ERR_PTR(-ESTALE); 493 494 inode = nilfs_iget(sb, root, ino); 495 nilfs_put_root(root); 496 497 if (IS_ERR(inode)) 498 return ERR_CAST(inode); 499 if (gen && inode->i_generation != gen) { 500 iput(inode); 501 return ERR_PTR(-ESTALE); 502 } 503 return d_obtain_alias(inode); 504 } 505 506 static struct dentry *nilfs_fh_to_dentry(struct super_block *sb, struct fid *fh, 507 int fh_len, int fh_type) 508 { 509 struct nilfs_fid *fid = (struct nilfs_fid *)fh; 510 511 if ((fh_len != NILFS_FID_SIZE_NON_CONNECTABLE && 512 fh_len != NILFS_FID_SIZE_CONNECTABLE) || 513 (fh_type != FILEID_NILFS_WITH_PARENT && 514 fh_type != FILEID_NILFS_WITHOUT_PARENT)) 515 return NULL; 516 517 return nilfs_get_dentry(sb, fid->cno, fid->ino, fid->gen); 518 } 519 520 static struct dentry *nilfs_fh_to_parent(struct super_block *sb, struct fid *fh, 521 int fh_len, int fh_type) 522 { 523 struct nilfs_fid *fid = (struct nilfs_fid *)fh; 524 525 if (fh_len != NILFS_FID_SIZE_CONNECTABLE || 526 fh_type != FILEID_NILFS_WITH_PARENT) 527 return NULL; 528 529 return nilfs_get_dentry(sb, fid->cno, fid->parent_ino, fid->parent_gen); 530 } 531 532 static int nilfs_encode_fh(struct dentry *dentry, __u32 *fh, int *lenp, 533 int connectable) 534 { 535 struct nilfs_fid *fid = (struct nilfs_fid *)fh; 536 struct inode *inode = dentry->d_inode; 537 struct nilfs_root *root = NILFS_I(inode)->i_root; 538 int type; 539 540 if (*lenp < NILFS_FID_SIZE_NON_CONNECTABLE || 541 (connectable && *lenp < NILFS_FID_SIZE_CONNECTABLE)) 542 return 255; 543 544 fid->cno = root->cno; 545 fid->ino = inode->i_ino; 546 fid->gen = inode->i_generation; 547 548 if (connectable && !S_ISDIR(inode->i_mode)) { 549 struct inode *parent; 550 551 spin_lock(&dentry->d_lock); 552 parent = dentry->d_parent->d_inode; 553 fid->parent_ino = parent->i_ino; 554 fid->parent_gen = parent->i_generation; 555 spin_unlock(&dentry->d_lock); 556 557 type = FILEID_NILFS_WITH_PARENT; 558 *lenp = NILFS_FID_SIZE_CONNECTABLE; 559 } else { 560 type = FILEID_NILFS_WITHOUT_PARENT; 561 *lenp = NILFS_FID_SIZE_NON_CONNECTABLE; 562 } 563 564 return type; 565 } 566 567 const struct inode_operations nilfs_dir_inode_operations = { 568 .create = nilfs_create, 569 .lookup = nilfs_lookup, 570 .link = nilfs_link, 571 .unlink = nilfs_unlink, 572 .symlink = nilfs_symlink, 573 .mkdir = nilfs_mkdir, 574 .rmdir = nilfs_rmdir, 575 .mknod = nilfs_mknod, 576 .rename = nilfs_rename, 577 .setattr = nilfs_setattr, 578 .permission = nilfs_permission, 579 .fiemap = nilfs_fiemap, 580 }; 581 582 const struct inode_operations nilfs_special_inode_operations = { 583 .setattr = nilfs_setattr, 584 .permission = nilfs_permission, 585 }; 586 587 const struct inode_operations nilfs_symlink_inode_operations = { 588 .readlink = generic_readlink, 589 .follow_link = page_follow_link_light, 590 .put_link = page_put_link, 591 .permission = nilfs_permission, 592 }; 593 594 const struct export_operations nilfs_export_ops = { 595 .encode_fh = nilfs_encode_fh, 596 .fh_to_dentry = nilfs_fh_to_dentry, 597 .fh_to_parent = nilfs_fh_to_parent, 598 .get_parent = nilfs_get_parent, 599 }; 600