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