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