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