1 /* -*- mode: c; c-basic-offset: 8; -*- 2 * vim: noexpandtab sw=8 ts=8 sts=0: 3 * 4 * namei.c 5 * 6 * Create and rename file, directory, symlinks 7 * 8 * Copyright (C) 2002, 2004 Oracle. All rights reserved. 9 * 10 * Portions of this code from linux/fs/ext3/dir.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/dir.c 20 * 21 * Copyright (C) 1991, 1992 Linux Torvalds 22 * 23 * This program is free software; you can redistribute it and/or 24 * modify it under the terms of the GNU General Public 25 * License as published by the Free Software Foundation; either 26 * version 2 of the License, or (at your option) any later version. 27 * 28 * This program is distributed in the hope that it will be useful, 29 * but WITHOUT ANY WARRANTY; without even the implied warranty of 30 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 31 * General Public License for more details. 32 * 33 * You should have received a copy of the GNU General Public 34 * License along with this program; if not, write to the 35 * Free Software Foundation, Inc., 59 Temple Place - Suite 330, 36 * Boston, MA 021110-1307, USA. 37 */ 38 39 #include <linux/fs.h> 40 #include <linux/types.h> 41 #include <linux/slab.h> 42 #include <linux/highmem.h> 43 #include <linux/quotaops.h> 44 #include <linux/iversion.h> 45 46 #include <cluster/masklog.h> 47 48 #include "ocfs2.h" 49 50 #include "alloc.h" 51 #include "dcache.h" 52 #include "dir.h" 53 #include "dlmglue.h" 54 #include "extent_map.h" 55 #include "file.h" 56 #include "inode.h" 57 #include "journal.h" 58 #include "namei.h" 59 #include "suballoc.h" 60 #include "super.h" 61 #include "symlink.h" 62 #include "sysfile.h" 63 #include "uptodate.h" 64 #include "xattr.h" 65 #include "acl.h" 66 #include "ocfs2_trace.h" 67 68 #include "buffer_head_io.h" 69 70 static int ocfs2_mknod_locked(struct ocfs2_super *osb, 71 struct inode *dir, 72 struct inode *inode, 73 dev_t dev, 74 struct buffer_head **new_fe_bh, 75 struct buffer_head *parent_fe_bh, 76 handle_t *handle, 77 struct ocfs2_alloc_context *inode_ac); 78 79 static int ocfs2_prepare_orphan_dir(struct ocfs2_super *osb, 80 struct inode **ret_orphan_dir, 81 u64 blkno, 82 char *name, 83 struct ocfs2_dir_lookup_result *lookup, 84 bool dio); 85 86 static int ocfs2_orphan_add(struct ocfs2_super *osb, 87 handle_t *handle, 88 struct inode *inode, 89 struct buffer_head *fe_bh, 90 char *name, 91 struct ocfs2_dir_lookup_result *lookup, 92 struct inode *orphan_dir_inode, 93 bool dio); 94 95 static int ocfs2_create_symlink_data(struct ocfs2_super *osb, 96 handle_t *handle, 97 struct inode *inode, 98 const char *symname); 99 100 static int ocfs2_double_lock(struct ocfs2_super *osb, 101 struct buffer_head **bh1, 102 struct inode *inode1, 103 struct buffer_head **bh2, 104 struct inode *inode2, 105 int rename); 106 107 static void ocfs2_double_unlock(struct inode *inode1, struct inode *inode2); 108 /* An orphan dir name is an 8 byte value, printed as a hex string */ 109 #define OCFS2_ORPHAN_NAMELEN ((int)(2 * sizeof(u64))) 110 111 static struct dentry *ocfs2_lookup(struct inode *dir, struct dentry *dentry, 112 unsigned int flags) 113 { 114 int status; 115 u64 blkno; 116 struct inode *inode = NULL; 117 struct dentry *ret; 118 struct ocfs2_inode_info *oi; 119 120 trace_ocfs2_lookup(dir, dentry, dentry->d_name.len, 121 dentry->d_name.name, 122 (unsigned long long)OCFS2_I(dir)->ip_blkno, 0); 123 124 if (dentry->d_name.len > OCFS2_MAX_FILENAME_LEN) { 125 ret = ERR_PTR(-ENAMETOOLONG); 126 goto bail; 127 } 128 129 status = ocfs2_inode_lock_nested(dir, NULL, 0, OI_LS_PARENT); 130 if (status < 0) { 131 if (status != -ENOENT) 132 mlog_errno(status); 133 ret = ERR_PTR(status); 134 goto bail; 135 } 136 137 status = ocfs2_lookup_ino_from_name(dir, dentry->d_name.name, 138 dentry->d_name.len, &blkno); 139 if (status < 0) 140 goto bail_add; 141 142 inode = ocfs2_iget(OCFS2_SB(dir->i_sb), blkno, 0, 0); 143 if (IS_ERR(inode)) { 144 ret = ERR_PTR(-EACCES); 145 goto bail_unlock; 146 } 147 148 oi = OCFS2_I(inode); 149 /* Clear any orphaned state... If we were able to look up the 150 * inode from a directory, it certainly can't be orphaned. We 151 * might have the bad state from a node which intended to 152 * orphan this inode but crashed before it could commit the 153 * unlink. */ 154 spin_lock(&oi->ip_lock); 155 oi->ip_flags &= ~OCFS2_INODE_MAYBE_ORPHANED; 156 spin_unlock(&oi->ip_lock); 157 158 bail_add: 159 ret = d_splice_alias(inode, dentry); 160 161 if (inode) { 162 /* 163 * If d_splice_alias() finds a DCACHE_DISCONNECTED 164 * dentry, it will d_move() it on top of ourse. The 165 * return value will indicate this however, so in 166 * those cases, we switch them around for the locking 167 * code. 168 * 169 * NOTE: This dentry already has ->d_op set from 170 * ocfs2_get_parent() and ocfs2_get_dentry() 171 */ 172 if (!IS_ERR_OR_NULL(ret)) 173 dentry = ret; 174 175 status = ocfs2_dentry_attach_lock(dentry, inode, 176 OCFS2_I(dir)->ip_blkno); 177 if (status) { 178 mlog_errno(status); 179 ret = ERR_PTR(status); 180 goto bail_unlock; 181 } 182 } else 183 ocfs2_dentry_attach_gen(dentry); 184 185 bail_unlock: 186 /* Don't drop the cluster lock until *after* the d_add -- 187 * unlink on another node will message us to remove that 188 * dentry under this lock so otherwise we can race this with 189 * the downconvert thread and have a stale dentry. */ 190 ocfs2_inode_unlock(dir, 0); 191 192 bail: 193 194 trace_ocfs2_lookup_ret(ret); 195 196 return ret; 197 } 198 199 static struct inode *ocfs2_get_init_inode(struct inode *dir, umode_t mode) 200 { 201 struct inode *inode; 202 int status; 203 204 inode = new_inode(dir->i_sb); 205 if (!inode) { 206 mlog(ML_ERROR, "new_inode failed!\n"); 207 return ERR_PTR(-ENOMEM); 208 } 209 210 /* populate as many fields early on as possible - many of 211 * these are used by the support functions here and in 212 * callers. */ 213 if (S_ISDIR(mode)) 214 set_nlink(inode, 2); 215 inode_init_owner(inode, dir, mode); 216 status = dquot_initialize(inode); 217 if (status) 218 return ERR_PTR(status); 219 220 return inode; 221 } 222 223 static void ocfs2_cleanup_add_entry_failure(struct ocfs2_super *osb, 224 struct dentry *dentry, struct inode *inode) 225 { 226 struct ocfs2_dentry_lock *dl = dentry->d_fsdata; 227 228 ocfs2_simple_drop_lockres(osb, &dl->dl_lockres); 229 ocfs2_lock_res_free(&dl->dl_lockres); 230 BUG_ON(dl->dl_count != 1); 231 spin_lock(&dentry_attach_lock); 232 dentry->d_fsdata = NULL; 233 spin_unlock(&dentry_attach_lock); 234 kfree(dl); 235 iput(inode); 236 } 237 238 static int ocfs2_mknod(struct inode *dir, 239 struct dentry *dentry, 240 umode_t mode, 241 dev_t dev) 242 { 243 int status = 0; 244 struct buffer_head *parent_fe_bh = NULL; 245 handle_t *handle = NULL; 246 struct ocfs2_super *osb; 247 struct ocfs2_dinode *dirfe; 248 struct buffer_head *new_fe_bh = NULL; 249 struct inode *inode = NULL; 250 struct ocfs2_alloc_context *inode_ac = NULL; 251 struct ocfs2_alloc_context *data_ac = NULL; 252 struct ocfs2_alloc_context *meta_ac = NULL; 253 int want_clusters = 0; 254 int want_meta = 0; 255 int xattr_credits = 0; 256 struct ocfs2_security_xattr_info si = { 257 .enable = 1, 258 }; 259 int did_quota_inode = 0; 260 struct ocfs2_dir_lookup_result lookup = { NULL, }; 261 sigset_t oldset; 262 int did_block_signals = 0; 263 struct ocfs2_dentry_lock *dl = NULL; 264 265 trace_ocfs2_mknod(dir, dentry, dentry->d_name.len, dentry->d_name.name, 266 (unsigned long long)OCFS2_I(dir)->ip_blkno, 267 (unsigned long)dev, mode); 268 269 status = dquot_initialize(dir); 270 if (status) { 271 mlog_errno(status); 272 return status; 273 } 274 275 /* get our super block */ 276 osb = OCFS2_SB(dir->i_sb); 277 278 status = ocfs2_inode_lock(dir, &parent_fe_bh, 1); 279 if (status < 0) { 280 if (status != -ENOENT) 281 mlog_errno(status); 282 return status; 283 } 284 285 if (S_ISDIR(mode) && (dir->i_nlink >= ocfs2_link_max(osb))) { 286 status = -EMLINK; 287 goto leave; 288 } 289 290 dirfe = (struct ocfs2_dinode *) parent_fe_bh->b_data; 291 if (!ocfs2_read_links_count(dirfe)) { 292 /* can't make a file in a deleted directory. */ 293 status = -ENOENT; 294 goto leave; 295 } 296 297 status = ocfs2_check_dir_for_entry(dir, dentry->d_name.name, 298 dentry->d_name.len); 299 if (status) 300 goto leave; 301 302 /* get a spot inside the dir. */ 303 status = ocfs2_prepare_dir_for_insert(osb, dir, parent_fe_bh, 304 dentry->d_name.name, 305 dentry->d_name.len, &lookup); 306 if (status < 0) { 307 mlog_errno(status); 308 goto leave; 309 } 310 311 /* reserve an inode spot */ 312 status = ocfs2_reserve_new_inode(osb, &inode_ac); 313 if (status < 0) { 314 if (status != -ENOSPC) 315 mlog_errno(status); 316 goto leave; 317 } 318 319 inode = ocfs2_get_init_inode(dir, mode); 320 if (IS_ERR(inode)) { 321 status = PTR_ERR(inode); 322 inode = NULL; 323 mlog_errno(status); 324 goto leave; 325 } 326 327 /* get security xattr */ 328 status = ocfs2_init_security_get(inode, dir, &dentry->d_name, &si); 329 if (status) { 330 if (status == -EOPNOTSUPP) 331 si.enable = 0; 332 else { 333 mlog_errno(status); 334 goto leave; 335 } 336 } 337 338 /* calculate meta data/clusters for setting security and acl xattr */ 339 status = ocfs2_calc_xattr_init(dir, parent_fe_bh, mode, 340 &si, &want_clusters, 341 &xattr_credits, &want_meta); 342 if (status < 0) { 343 mlog_errno(status); 344 goto leave; 345 } 346 347 /* Reserve a cluster if creating an extent based directory. */ 348 if (S_ISDIR(mode) && !ocfs2_supports_inline_data(osb)) { 349 want_clusters += 1; 350 351 /* Dir indexing requires extra space as well */ 352 if (ocfs2_supports_indexed_dirs(osb)) 353 want_meta++; 354 } 355 356 status = ocfs2_reserve_new_metadata_blocks(osb, want_meta, &meta_ac); 357 if (status < 0) { 358 if (status != -ENOSPC) 359 mlog_errno(status); 360 goto leave; 361 } 362 363 status = ocfs2_reserve_clusters(osb, want_clusters, &data_ac); 364 if (status < 0) { 365 if (status != -ENOSPC) 366 mlog_errno(status); 367 goto leave; 368 } 369 370 handle = ocfs2_start_trans(osb, ocfs2_mknod_credits(osb->sb, 371 S_ISDIR(mode), 372 xattr_credits)); 373 if (IS_ERR(handle)) { 374 status = PTR_ERR(handle); 375 handle = NULL; 376 mlog_errno(status); 377 goto leave; 378 } 379 380 /* Starting to change things, restart is no longer possible. */ 381 ocfs2_block_signals(&oldset); 382 did_block_signals = 1; 383 384 status = dquot_alloc_inode(inode); 385 if (status) 386 goto leave; 387 did_quota_inode = 1; 388 389 /* do the real work now. */ 390 status = ocfs2_mknod_locked(osb, dir, inode, dev, 391 &new_fe_bh, parent_fe_bh, handle, 392 inode_ac); 393 if (status < 0) { 394 mlog_errno(status); 395 goto leave; 396 } 397 398 if (S_ISDIR(mode)) { 399 status = ocfs2_fill_new_dir(osb, handle, dir, inode, 400 new_fe_bh, data_ac, meta_ac); 401 if (status < 0) { 402 mlog_errno(status); 403 goto leave; 404 } 405 406 status = ocfs2_journal_access_di(handle, INODE_CACHE(dir), 407 parent_fe_bh, 408 OCFS2_JOURNAL_ACCESS_WRITE); 409 if (status < 0) { 410 mlog_errno(status); 411 goto leave; 412 } 413 ocfs2_add_links_count(dirfe, 1); 414 ocfs2_journal_dirty(handle, parent_fe_bh); 415 inc_nlink(dir); 416 } 417 418 status = ocfs2_init_acl(handle, inode, dir, new_fe_bh, parent_fe_bh, 419 meta_ac, data_ac); 420 421 if (status < 0) { 422 mlog_errno(status); 423 goto leave; 424 } 425 426 if (si.enable) { 427 status = ocfs2_init_security_set(handle, inode, new_fe_bh, &si, 428 meta_ac, data_ac); 429 if (status < 0) { 430 mlog_errno(status); 431 goto leave; 432 } 433 } 434 435 /* 436 * Do this before adding the entry to the directory. We add 437 * also set d_op after success so that ->d_iput() will cleanup 438 * the dentry lock even if ocfs2_add_entry() fails below. 439 */ 440 status = ocfs2_dentry_attach_lock(dentry, inode, 441 OCFS2_I(dir)->ip_blkno); 442 if (status) { 443 mlog_errno(status); 444 goto leave; 445 } 446 447 dl = dentry->d_fsdata; 448 449 status = ocfs2_add_entry(handle, dentry, inode, 450 OCFS2_I(inode)->ip_blkno, parent_fe_bh, 451 &lookup); 452 if (status < 0) { 453 mlog_errno(status); 454 goto leave; 455 } 456 457 insert_inode_hash(inode); 458 d_instantiate(dentry, inode); 459 status = 0; 460 leave: 461 if (status < 0 && did_quota_inode) 462 dquot_free_inode(inode); 463 if (handle) 464 ocfs2_commit_trans(osb, handle); 465 466 ocfs2_inode_unlock(dir, 1); 467 if (did_block_signals) 468 ocfs2_unblock_signals(&oldset); 469 470 brelse(new_fe_bh); 471 brelse(parent_fe_bh); 472 kfree(si.value); 473 474 ocfs2_free_dir_lookup_result(&lookup); 475 476 if (inode_ac) 477 ocfs2_free_alloc_context(inode_ac); 478 479 if (data_ac) 480 ocfs2_free_alloc_context(data_ac); 481 482 if (meta_ac) 483 ocfs2_free_alloc_context(meta_ac); 484 485 /* 486 * We should call iput after the i_mutex of the bitmap been 487 * unlocked in ocfs2_free_alloc_context, or the 488 * ocfs2_delete_inode will mutex_lock again. 489 */ 490 if ((status < 0) && inode) { 491 if (dl) 492 ocfs2_cleanup_add_entry_failure(osb, dentry, inode); 493 494 OCFS2_I(inode)->ip_flags |= OCFS2_INODE_SKIP_ORPHAN_DIR; 495 clear_nlink(inode); 496 iput(inode); 497 } 498 499 if (status) 500 mlog_errno(status); 501 502 return status; 503 } 504 505 static int __ocfs2_mknod_locked(struct inode *dir, 506 struct inode *inode, 507 dev_t dev, 508 struct buffer_head **new_fe_bh, 509 struct buffer_head *parent_fe_bh, 510 handle_t *handle, 511 struct ocfs2_alloc_context *inode_ac, 512 u64 fe_blkno, u64 suballoc_loc, u16 suballoc_bit) 513 { 514 int status = 0; 515 struct ocfs2_super *osb = OCFS2_SB(dir->i_sb); 516 struct ocfs2_dinode *fe = NULL; 517 struct ocfs2_extent_list *fel; 518 u16 feat; 519 struct ocfs2_inode_info *oi = OCFS2_I(inode); 520 struct timespec64 ts; 521 522 *new_fe_bh = NULL; 523 524 /* populate as many fields early on as possible - many of 525 * these are used by the support functions here and in 526 * callers. */ 527 inode->i_ino = ino_from_blkno(osb->sb, fe_blkno); 528 OCFS2_I(inode)->ip_blkno = fe_blkno; 529 spin_lock(&osb->osb_lock); 530 inode->i_generation = osb->s_next_generation++; 531 spin_unlock(&osb->osb_lock); 532 533 *new_fe_bh = sb_getblk(osb->sb, fe_blkno); 534 if (!*new_fe_bh) { 535 status = -ENOMEM; 536 mlog_errno(status); 537 goto leave; 538 } 539 ocfs2_set_new_buffer_uptodate(INODE_CACHE(inode), *new_fe_bh); 540 541 status = ocfs2_journal_access_di(handle, INODE_CACHE(inode), 542 *new_fe_bh, 543 OCFS2_JOURNAL_ACCESS_CREATE); 544 if (status < 0) { 545 mlog_errno(status); 546 goto leave; 547 } 548 549 fe = (struct ocfs2_dinode *) (*new_fe_bh)->b_data; 550 memset(fe, 0, osb->sb->s_blocksize); 551 552 fe->i_generation = cpu_to_le32(inode->i_generation); 553 fe->i_fs_generation = cpu_to_le32(osb->fs_generation); 554 fe->i_blkno = cpu_to_le64(fe_blkno); 555 fe->i_suballoc_loc = cpu_to_le64(suballoc_loc); 556 fe->i_suballoc_bit = cpu_to_le16(suballoc_bit); 557 fe->i_suballoc_slot = cpu_to_le16(inode_ac->ac_alloc_slot); 558 fe->i_uid = cpu_to_le32(i_uid_read(inode)); 559 fe->i_gid = cpu_to_le32(i_gid_read(inode)); 560 fe->i_mode = cpu_to_le16(inode->i_mode); 561 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) 562 fe->id1.dev1.i_rdev = cpu_to_le64(huge_encode_dev(dev)); 563 564 ocfs2_set_links_count(fe, inode->i_nlink); 565 566 fe->i_last_eb_blk = 0; 567 strcpy(fe->i_signature, OCFS2_INODE_SIGNATURE); 568 fe->i_flags |= cpu_to_le32(OCFS2_VALID_FL); 569 ktime_get_real_ts64(&ts); 570 fe->i_atime = fe->i_ctime = fe->i_mtime = 571 cpu_to_le64(ts.tv_sec); 572 fe->i_mtime_nsec = fe->i_ctime_nsec = fe->i_atime_nsec = 573 cpu_to_le32(ts.tv_nsec); 574 fe->i_dtime = 0; 575 576 /* 577 * If supported, directories start with inline data. If inline 578 * isn't supported, but indexing is, we start them as indexed. 579 */ 580 feat = le16_to_cpu(fe->i_dyn_features); 581 if (S_ISDIR(inode->i_mode) && ocfs2_supports_inline_data(osb)) { 582 fe->i_dyn_features = cpu_to_le16(feat | OCFS2_INLINE_DATA_FL); 583 584 fe->id2.i_data.id_count = cpu_to_le16( 585 ocfs2_max_inline_data_with_xattr(osb->sb, fe)); 586 } else { 587 fel = &fe->id2.i_list; 588 fel->l_tree_depth = 0; 589 fel->l_next_free_rec = 0; 590 fel->l_count = cpu_to_le16(ocfs2_extent_recs_per_inode(osb->sb)); 591 } 592 593 ocfs2_journal_dirty(handle, *new_fe_bh); 594 595 ocfs2_populate_inode(inode, fe, 1); 596 ocfs2_ci_set_new(osb, INODE_CACHE(inode)); 597 if (!ocfs2_mount_local(osb)) { 598 status = ocfs2_create_new_inode_locks(inode); 599 if (status < 0) 600 mlog_errno(status); 601 } 602 603 oi->i_sync_tid = handle->h_transaction->t_tid; 604 oi->i_datasync_tid = handle->h_transaction->t_tid; 605 606 leave: 607 if (status < 0) { 608 if (*new_fe_bh) { 609 brelse(*new_fe_bh); 610 *new_fe_bh = NULL; 611 } 612 } 613 614 if (status) 615 mlog_errno(status); 616 return status; 617 } 618 619 static int ocfs2_mknod_locked(struct ocfs2_super *osb, 620 struct inode *dir, 621 struct inode *inode, 622 dev_t dev, 623 struct buffer_head **new_fe_bh, 624 struct buffer_head *parent_fe_bh, 625 handle_t *handle, 626 struct ocfs2_alloc_context *inode_ac) 627 { 628 int status = 0; 629 u64 suballoc_loc, fe_blkno = 0; 630 u16 suballoc_bit; 631 632 *new_fe_bh = NULL; 633 634 status = ocfs2_claim_new_inode(handle, dir, parent_fe_bh, 635 inode_ac, &suballoc_loc, 636 &suballoc_bit, &fe_blkno); 637 if (status < 0) { 638 mlog_errno(status); 639 return status; 640 } 641 642 status = __ocfs2_mknod_locked(dir, inode, dev, new_fe_bh, 643 parent_fe_bh, handle, inode_ac, 644 fe_blkno, suballoc_loc, suballoc_bit); 645 if (status < 0) { 646 u64 bg_blkno = ocfs2_which_suballoc_group(fe_blkno, suballoc_bit); 647 int tmp = ocfs2_free_suballoc_bits(handle, inode_ac->ac_inode, 648 inode_ac->ac_bh, suballoc_bit, bg_blkno, 1); 649 if (tmp) 650 mlog_errno(tmp); 651 } 652 653 return status; 654 } 655 656 static int ocfs2_mkdir(struct inode *dir, 657 struct dentry *dentry, 658 umode_t mode) 659 { 660 int ret; 661 662 trace_ocfs2_mkdir(dir, dentry, dentry->d_name.len, dentry->d_name.name, 663 OCFS2_I(dir)->ip_blkno, mode); 664 ret = ocfs2_mknod(dir, dentry, mode | S_IFDIR, 0); 665 if (ret) 666 mlog_errno(ret); 667 668 return ret; 669 } 670 671 static int ocfs2_create(struct inode *dir, 672 struct dentry *dentry, 673 umode_t mode, 674 bool excl) 675 { 676 int ret; 677 678 trace_ocfs2_create(dir, dentry, dentry->d_name.len, dentry->d_name.name, 679 (unsigned long long)OCFS2_I(dir)->ip_blkno, mode); 680 ret = ocfs2_mknod(dir, dentry, mode | S_IFREG, 0); 681 if (ret) 682 mlog_errno(ret); 683 684 return ret; 685 } 686 687 static int ocfs2_link(struct dentry *old_dentry, 688 struct inode *dir, 689 struct dentry *dentry) 690 { 691 handle_t *handle; 692 struct inode *inode = d_inode(old_dentry); 693 struct inode *old_dir = d_inode(old_dentry->d_parent); 694 int err; 695 struct buffer_head *fe_bh = NULL; 696 struct buffer_head *old_dir_bh = NULL; 697 struct buffer_head *parent_fe_bh = NULL; 698 struct ocfs2_dinode *fe = NULL; 699 struct ocfs2_super *osb = OCFS2_SB(dir->i_sb); 700 struct ocfs2_dir_lookup_result lookup = { NULL, }; 701 sigset_t oldset; 702 u64 old_de_ino; 703 704 trace_ocfs2_link((unsigned long long)OCFS2_I(inode)->ip_blkno, 705 old_dentry->d_name.len, old_dentry->d_name.name, 706 dentry->d_name.len, dentry->d_name.name); 707 708 if (S_ISDIR(inode->i_mode)) 709 return -EPERM; 710 711 err = dquot_initialize(dir); 712 if (err) { 713 mlog_errno(err); 714 return err; 715 } 716 717 err = ocfs2_double_lock(osb, &old_dir_bh, old_dir, 718 &parent_fe_bh, dir, 0); 719 if (err < 0) { 720 if (err != -ENOENT) 721 mlog_errno(err); 722 return err; 723 } 724 725 /* make sure both dirs have bhs 726 * get an extra ref on old_dir_bh if old==new */ 727 if (!parent_fe_bh) { 728 if (old_dir_bh) { 729 parent_fe_bh = old_dir_bh; 730 get_bh(parent_fe_bh); 731 } else { 732 mlog(ML_ERROR, "%s: no old_dir_bh!\n", osb->uuid_str); 733 err = -EIO; 734 goto out; 735 } 736 } 737 738 if (!dir->i_nlink) { 739 err = -ENOENT; 740 goto out; 741 } 742 743 err = ocfs2_lookup_ino_from_name(old_dir, old_dentry->d_name.name, 744 old_dentry->d_name.len, &old_de_ino); 745 if (err) { 746 err = -ENOENT; 747 goto out; 748 } 749 750 /* 751 * Check whether another node removed the source inode while we 752 * were in the vfs. 753 */ 754 if (old_de_ino != OCFS2_I(inode)->ip_blkno) { 755 err = -ENOENT; 756 goto out; 757 } 758 759 err = ocfs2_check_dir_for_entry(dir, dentry->d_name.name, 760 dentry->d_name.len); 761 if (err) 762 goto out; 763 764 err = ocfs2_prepare_dir_for_insert(osb, dir, parent_fe_bh, 765 dentry->d_name.name, 766 dentry->d_name.len, &lookup); 767 if (err < 0) { 768 mlog_errno(err); 769 goto out; 770 } 771 772 err = ocfs2_inode_lock(inode, &fe_bh, 1); 773 if (err < 0) { 774 if (err != -ENOENT) 775 mlog_errno(err); 776 goto out; 777 } 778 779 fe = (struct ocfs2_dinode *) fe_bh->b_data; 780 if (ocfs2_read_links_count(fe) >= ocfs2_link_max(osb)) { 781 err = -EMLINK; 782 goto out_unlock_inode; 783 } 784 785 handle = ocfs2_start_trans(osb, ocfs2_link_credits(osb->sb)); 786 if (IS_ERR(handle)) { 787 err = PTR_ERR(handle); 788 handle = NULL; 789 mlog_errno(err); 790 goto out_unlock_inode; 791 } 792 793 /* Starting to change things, restart is no longer possible. */ 794 ocfs2_block_signals(&oldset); 795 796 err = ocfs2_journal_access_di(handle, INODE_CACHE(inode), fe_bh, 797 OCFS2_JOURNAL_ACCESS_WRITE); 798 if (err < 0) { 799 mlog_errno(err); 800 goto out_commit; 801 } 802 803 inc_nlink(inode); 804 inode->i_ctime = current_time(inode); 805 ocfs2_set_links_count(fe, inode->i_nlink); 806 fe->i_ctime = cpu_to_le64(inode->i_ctime.tv_sec); 807 fe->i_ctime_nsec = cpu_to_le32(inode->i_ctime.tv_nsec); 808 ocfs2_journal_dirty(handle, fe_bh); 809 810 err = ocfs2_add_entry(handle, dentry, inode, 811 OCFS2_I(inode)->ip_blkno, 812 parent_fe_bh, &lookup); 813 if (err) { 814 ocfs2_add_links_count(fe, -1); 815 drop_nlink(inode); 816 mlog_errno(err); 817 goto out_commit; 818 } 819 820 err = ocfs2_dentry_attach_lock(dentry, inode, OCFS2_I(dir)->ip_blkno); 821 if (err) { 822 mlog_errno(err); 823 goto out_commit; 824 } 825 826 ihold(inode); 827 d_instantiate(dentry, inode); 828 829 out_commit: 830 ocfs2_commit_trans(osb, handle); 831 ocfs2_unblock_signals(&oldset); 832 out_unlock_inode: 833 ocfs2_inode_unlock(inode, 1); 834 835 out: 836 ocfs2_double_unlock(old_dir, dir); 837 838 brelse(fe_bh); 839 brelse(parent_fe_bh); 840 brelse(old_dir_bh); 841 842 ocfs2_free_dir_lookup_result(&lookup); 843 844 if (err) 845 mlog_errno(err); 846 847 return err; 848 } 849 850 /* 851 * Takes and drops an exclusive lock on the given dentry. This will 852 * force other nodes to drop it. 853 */ 854 static int ocfs2_remote_dentry_delete(struct dentry *dentry) 855 { 856 int ret; 857 858 ret = ocfs2_dentry_lock(dentry, 1); 859 if (ret) 860 mlog_errno(ret); 861 else 862 ocfs2_dentry_unlock(dentry, 1); 863 864 return ret; 865 } 866 867 static inline int ocfs2_inode_is_unlinkable(struct inode *inode) 868 { 869 if (S_ISDIR(inode->i_mode)) { 870 if (inode->i_nlink == 2) 871 return 1; 872 return 0; 873 } 874 875 if (inode->i_nlink == 1) 876 return 1; 877 return 0; 878 } 879 880 static int ocfs2_unlink(struct inode *dir, 881 struct dentry *dentry) 882 { 883 int status; 884 int child_locked = 0; 885 bool is_unlinkable = false; 886 struct inode *inode = d_inode(dentry); 887 struct inode *orphan_dir = NULL; 888 struct ocfs2_super *osb = OCFS2_SB(dir->i_sb); 889 u64 blkno; 890 struct ocfs2_dinode *fe = NULL; 891 struct buffer_head *fe_bh = NULL; 892 struct buffer_head *parent_node_bh = NULL; 893 handle_t *handle = NULL; 894 char orphan_name[OCFS2_ORPHAN_NAMELEN + 1]; 895 struct ocfs2_dir_lookup_result lookup = { NULL, }; 896 struct ocfs2_dir_lookup_result orphan_insert = { NULL, }; 897 898 trace_ocfs2_unlink(dir, dentry, dentry->d_name.len, 899 dentry->d_name.name, 900 (unsigned long long)OCFS2_I(dir)->ip_blkno, 901 (unsigned long long)OCFS2_I(inode)->ip_blkno); 902 903 status = dquot_initialize(dir); 904 if (status) { 905 mlog_errno(status); 906 return status; 907 } 908 909 BUG_ON(d_inode(dentry->d_parent) != dir); 910 911 if (inode == osb->root_inode) 912 return -EPERM; 913 914 status = ocfs2_inode_lock_nested(dir, &parent_node_bh, 1, 915 OI_LS_PARENT); 916 if (status < 0) { 917 if (status != -ENOENT) 918 mlog_errno(status); 919 return status; 920 } 921 922 status = ocfs2_find_files_on_disk(dentry->d_name.name, 923 dentry->d_name.len, &blkno, dir, 924 &lookup); 925 if (status < 0) { 926 if (status != -ENOENT) 927 mlog_errno(status); 928 goto leave; 929 } 930 931 if (OCFS2_I(inode)->ip_blkno != blkno) { 932 status = -ENOENT; 933 934 trace_ocfs2_unlink_noent( 935 (unsigned long long)OCFS2_I(inode)->ip_blkno, 936 (unsigned long long)blkno, 937 OCFS2_I(inode)->ip_flags); 938 goto leave; 939 } 940 941 status = ocfs2_inode_lock(inode, &fe_bh, 1); 942 if (status < 0) { 943 if (status != -ENOENT) 944 mlog_errno(status); 945 goto leave; 946 } 947 child_locked = 1; 948 949 if (S_ISDIR(inode->i_mode)) { 950 if (inode->i_nlink != 2 || !ocfs2_empty_dir(inode)) { 951 status = -ENOTEMPTY; 952 goto leave; 953 } 954 } 955 956 status = ocfs2_remote_dentry_delete(dentry); 957 if (status < 0) { 958 /* This remote delete should succeed under all normal 959 * circumstances. */ 960 mlog_errno(status); 961 goto leave; 962 } 963 964 if (ocfs2_inode_is_unlinkable(inode)) { 965 status = ocfs2_prepare_orphan_dir(osb, &orphan_dir, 966 OCFS2_I(inode)->ip_blkno, 967 orphan_name, &orphan_insert, 968 false); 969 if (status < 0) { 970 mlog_errno(status); 971 goto leave; 972 } 973 is_unlinkable = true; 974 } 975 976 handle = ocfs2_start_trans(osb, ocfs2_unlink_credits(osb->sb)); 977 if (IS_ERR(handle)) { 978 status = PTR_ERR(handle); 979 handle = NULL; 980 mlog_errno(status); 981 goto leave; 982 } 983 984 status = ocfs2_journal_access_di(handle, INODE_CACHE(inode), fe_bh, 985 OCFS2_JOURNAL_ACCESS_WRITE); 986 if (status < 0) { 987 mlog_errno(status); 988 goto leave; 989 } 990 991 fe = (struct ocfs2_dinode *) fe_bh->b_data; 992 993 /* delete the name from the parent dir */ 994 status = ocfs2_delete_entry(handle, dir, &lookup); 995 if (status < 0) { 996 mlog_errno(status); 997 goto leave; 998 } 999 1000 if (S_ISDIR(inode->i_mode)) 1001 drop_nlink(inode); 1002 drop_nlink(inode); 1003 ocfs2_set_links_count(fe, inode->i_nlink); 1004 ocfs2_journal_dirty(handle, fe_bh); 1005 1006 dir->i_ctime = dir->i_mtime = current_time(dir); 1007 if (S_ISDIR(inode->i_mode)) 1008 drop_nlink(dir); 1009 1010 status = ocfs2_mark_inode_dirty(handle, dir, parent_node_bh); 1011 if (status < 0) { 1012 mlog_errno(status); 1013 if (S_ISDIR(inode->i_mode)) 1014 inc_nlink(dir); 1015 goto leave; 1016 } 1017 1018 if (is_unlinkable) { 1019 status = ocfs2_orphan_add(osb, handle, inode, fe_bh, 1020 orphan_name, &orphan_insert, orphan_dir, false); 1021 if (status < 0) 1022 mlog_errno(status); 1023 } 1024 1025 leave: 1026 if (handle) 1027 ocfs2_commit_trans(osb, handle); 1028 1029 if (orphan_dir) { 1030 /* This was locked for us in ocfs2_prepare_orphan_dir() */ 1031 ocfs2_inode_unlock(orphan_dir, 1); 1032 inode_unlock(orphan_dir); 1033 iput(orphan_dir); 1034 } 1035 1036 if (child_locked) 1037 ocfs2_inode_unlock(inode, 1); 1038 1039 ocfs2_inode_unlock(dir, 1); 1040 1041 brelse(fe_bh); 1042 brelse(parent_node_bh); 1043 1044 ocfs2_free_dir_lookup_result(&orphan_insert); 1045 ocfs2_free_dir_lookup_result(&lookup); 1046 1047 if (status && (status != -ENOTEMPTY) && (status != -ENOENT)) 1048 mlog_errno(status); 1049 1050 return status; 1051 } 1052 1053 static int ocfs2_check_if_ancestor(struct ocfs2_super *osb, 1054 u64 src_inode_no, u64 dest_inode_no) 1055 { 1056 int ret = 0, i = 0; 1057 u64 parent_inode_no = 0; 1058 u64 child_inode_no = src_inode_no; 1059 struct inode *child_inode; 1060 1061 #define MAX_LOOKUP_TIMES 32 1062 while (1) { 1063 child_inode = ocfs2_iget(osb, child_inode_no, 0, 0); 1064 if (IS_ERR(child_inode)) { 1065 ret = PTR_ERR(child_inode); 1066 break; 1067 } 1068 1069 ret = ocfs2_inode_lock(child_inode, NULL, 0); 1070 if (ret < 0) { 1071 iput(child_inode); 1072 if (ret != -ENOENT) 1073 mlog_errno(ret); 1074 break; 1075 } 1076 1077 ret = ocfs2_lookup_ino_from_name(child_inode, "..", 2, 1078 &parent_inode_no); 1079 ocfs2_inode_unlock(child_inode, 0); 1080 iput(child_inode); 1081 if (ret < 0) { 1082 ret = -ENOENT; 1083 break; 1084 } 1085 1086 if (parent_inode_no == dest_inode_no) { 1087 ret = 1; 1088 break; 1089 } 1090 1091 if (parent_inode_no == osb->root_inode->i_ino) { 1092 ret = 0; 1093 break; 1094 } 1095 1096 child_inode_no = parent_inode_no; 1097 1098 if (++i >= MAX_LOOKUP_TIMES) { 1099 mlog(ML_NOTICE, "max lookup times reached, filesystem " 1100 "may have nested directories, " 1101 "src inode: %llu, dest inode: %llu.\n", 1102 (unsigned long long)src_inode_no, 1103 (unsigned long long)dest_inode_no); 1104 ret = 0; 1105 break; 1106 } 1107 } 1108 1109 return ret; 1110 } 1111 1112 /* 1113 * The only place this should be used is rename and link! 1114 * if they have the same id, then the 1st one is the only one locked. 1115 */ 1116 static int ocfs2_double_lock(struct ocfs2_super *osb, 1117 struct buffer_head **bh1, 1118 struct inode *inode1, 1119 struct buffer_head **bh2, 1120 struct inode *inode2, 1121 int rename) 1122 { 1123 int status; 1124 int inode1_is_ancestor, inode2_is_ancestor; 1125 struct ocfs2_inode_info *oi1 = OCFS2_I(inode1); 1126 struct ocfs2_inode_info *oi2 = OCFS2_I(inode2); 1127 1128 trace_ocfs2_double_lock((unsigned long long)oi1->ip_blkno, 1129 (unsigned long long)oi2->ip_blkno); 1130 1131 if (*bh1) 1132 *bh1 = NULL; 1133 if (*bh2) 1134 *bh2 = NULL; 1135 1136 /* we always want to lock the one with the lower lockid first. 1137 * and if they are nested, we lock ancestor first */ 1138 if (oi1->ip_blkno != oi2->ip_blkno) { 1139 inode1_is_ancestor = ocfs2_check_if_ancestor(osb, oi2->ip_blkno, 1140 oi1->ip_blkno); 1141 if (inode1_is_ancestor < 0) { 1142 status = inode1_is_ancestor; 1143 goto bail; 1144 } 1145 1146 inode2_is_ancestor = ocfs2_check_if_ancestor(osb, oi1->ip_blkno, 1147 oi2->ip_blkno); 1148 if (inode2_is_ancestor < 0) { 1149 status = inode2_is_ancestor; 1150 goto bail; 1151 } 1152 1153 if ((inode1_is_ancestor == 1) || 1154 (oi1->ip_blkno < oi2->ip_blkno && 1155 inode2_is_ancestor == 0)) { 1156 /* switch id1 and id2 around */ 1157 swap(bh2, bh1); 1158 swap(inode2, inode1); 1159 } 1160 /* lock id2 */ 1161 status = ocfs2_inode_lock_nested(inode2, bh2, 1, 1162 rename == 1 ? OI_LS_RENAME1 : OI_LS_PARENT); 1163 if (status < 0) { 1164 if (status != -ENOENT) 1165 mlog_errno(status); 1166 goto bail; 1167 } 1168 } 1169 1170 /* lock id1 */ 1171 status = ocfs2_inode_lock_nested(inode1, bh1, 1, 1172 rename == 1 ? OI_LS_RENAME2 : OI_LS_PARENT); 1173 if (status < 0) { 1174 /* 1175 * An error return must mean that no cluster locks 1176 * were held on function exit. 1177 */ 1178 if (oi1->ip_blkno != oi2->ip_blkno) { 1179 ocfs2_inode_unlock(inode2, 1); 1180 brelse(*bh2); 1181 *bh2 = NULL; 1182 } 1183 1184 if (status != -ENOENT) 1185 mlog_errno(status); 1186 } 1187 1188 trace_ocfs2_double_lock_end( 1189 (unsigned long long)OCFS2_I(inode1)->ip_blkno, 1190 (unsigned long long)OCFS2_I(inode2)->ip_blkno); 1191 1192 bail: 1193 if (status) 1194 mlog_errno(status); 1195 return status; 1196 } 1197 1198 static void ocfs2_double_unlock(struct inode *inode1, struct inode *inode2) 1199 { 1200 ocfs2_inode_unlock(inode1, 1); 1201 1202 if (inode1 != inode2) 1203 ocfs2_inode_unlock(inode2, 1); 1204 } 1205 1206 static int ocfs2_rename(struct inode *old_dir, 1207 struct dentry *old_dentry, 1208 struct inode *new_dir, 1209 struct dentry *new_dentry, 1210 unsigned int flags) 1211 { 1212 int status = 0, rename_lock = 0, parents_locked = 0, target_exists = 0; 1213 int old_child_locked = 0, new_child_locked = 0, update_dot_dot = 0; 1214 struct inode *old_inode = d_inode(old_dentry); 1215 struct inode *new_inode = d_inode(new_dentry); 1216 struct inode *orphan_dir = NULL; 1217 struct ocfs2_dinode *newfe = NULL; 1218 char orphan_name[OCFS2_ORPHAN_NAMELEN + 1]; 1219 struct buffer_head *newfe_bh = NULL; 1220 struct buffer_head *old_inode_bh = NULL; 1221 struct ocfs2_super *osb = NULL; 1222 u64 newfe_blkno, old_de_ino; 1223 handle_t *handle = NULL; 1224 struct buffer_head *old_dir_bh = NULL; 1225 struct buffer_head *new_dir_bh = NULL; 1226 u32 old_dir_nlink = old_dir->i_nlink; 1227 struct ocfs2_dinode *old_di; 1228 struct ocfs2_dir_lookup_result old_inode_dot_dot_res = { NULL, }; 1229 struct ocfs2_dir_lookup_result target_lookup_res = { NULL, }; 1230 struct ocfs2_dir_lookup_result old_entry_lookup = { NULL, }; 1231 struct ocfs2_dir_lookup_result orphan_insert = { NULL, }; 1232 struct ocfs2_dir_lookup_result target_insert = { NULL, }; 1233 bool should_add_orphan = false; 1234 1235 if (flags) 1236 return -EINVAL; 1237 1238 /* At some point it might be nice to break this function up a 1239 * bit. */ 1240 1241 trace_ocfs2_rename(old_dir, old_dentry, new_dir, new_dentry, 1242 old_dentry->d_name.len, old_dentry->d_name.name, 1243 new_dentry->d_name.len, new_dentry->d_name.name); 1244 1245 status = dquot_initialize(old_dir); 1246 if (status) { 1247 mlog_errno(status); 1248 goto bail; 1249 } 1250 status = dquot_initialize(new_dir); 1251 if (status) { 1252 mlog_errno(status); 1253 goto bail; 1254 } 1255 1256 osb = OCFS2_SB(old_dir->i_sb); 1257 1258 if (new_inode) { 1259 if (!igrab(new_inode)) 1260 BUG(); 1261 } 1262 1263 /* Assume a directory hierarchy thusly: 1264 * a/b/c 1265 * a/d 1266 * a,b,c, and d are all directories. 1267 * 1268 * from cwd of 'a' on both nodes: 1269 * node1: mv b/c d 1270 * node2: mv d b/c 1271 * 1272 * And that's why, just like the VFS, we need a file system 1273 * rename lock. */ 1274 if (old_dir != new_dir && S_ISDIR(old_inode->i_mode)) { 1275 status = ocfs2_rename_lock(osb); 1276 if (status < 0) { 1277 mlog_errno(status); 1278 goto bail; 1279 } 1280 rename_lock = 1; 1281 1282 /* here we cannot guarantee the inodes haven't just been 1283 * changed, so check if they are nested again */ 1284 status = ocfs2_check_if_ancestor(osb, new_dir->i_ino, 1285 old_inode->i_ino); 1286 if (status < 0) { 1287 mlog_errno(status); 1288 goto bail; 1289 } else if (status == 1) { 1290 status = -EPERM; 1291 trace_ocfs2_rename_not_permitted( 1292 (unsigned long long)old_inode->i_ino, 1293 (unsigned long long)new_dir->i_ino); 1294 goto bail; 1295 } 1296 } 1297 1298 /* if old and new are the same, this'll just do one lock. */ 1299 status = ocfs2_double_lock(osb, &old_dir_bh, old_dir, 1300 &new_dir_bh, new_dir, 1); 1301 if (status < 0) { 1302 mlog_errno(status); 1303 goto bail; 1304 } 1305 parents_locked = 1; 1306 1307 if (!new_dir->i_nlink) { 1308 status = -EACCES; 1309 goto bail; 1310 } 1311 1312 /* make sure both dirs have bhs 1313 * get an extra ref on old_dir_bh if old==new */ 1314 if (!new_dir_bh) { 1315 if (old_dir_bh) { 1316 new_dir_bh = old_dir_bh; 1317 get_bh(new_dir_bh); 1318 } else { 1319 mlog(ML_ERROR, "no old_dir_bh!\n"); 1320 status = -EIO; 1321 goto bail; 1322 } 1323 } 1324 1325 /* 1326 * Aside from allowing a meta data update, the locking here 1327 * also ensures that the downconvert thread on other nodes 1328 * won't have to concurrently downconvert the inode and the 1329 * dentry locks. 1330 */ 1331 status = ocfs2_inode_lock_nested(old_inode, &old_inode_bh, 1, 1332 OI_LS_PARENT); 1333 if (status < 0) { 1334 if (status != -ENOENT) 1335 mlog_errno(status); 1336 goto bail; 1337 } 1338 old_child_locked = 1; 1339 1340 status = ocfs2_remote_dentry_delete(old_dentry); 1341 if (status < 0) { 1342 mlog_errno(status); 1343 goto bail; 1344 } 1345 1346 if (S_ISDIR(old_inode->i_mode)) { 1347 u64 old_inode_parent; 1348 1349 update_dot_dot = 1; 1350 status = ocfs2_find_files_on_disk("..", 2, &old_inode_parent, 1351 old_inode, 1352 &old_inode_dot_dot_res); 1353 if (status) { 1354 status = -EIO; 1355 goto bail; 1356 } 1357 1358 if (old_inode_parent != OCFS2_I(old_dir)->ip_blkno) { 1359 status = -EIO; 1360 goto bail; 1361 } 1362 1363 if (!new_inode && new_dir != old_dir && 1364 new_dir->i_nlink >= ocfs2_link_max(osb)) { 1365 status = -EMLINK; 1366 goto bail; 1367 } 1368 } 1369 1370 status = ocfs2_lookup_ino_from_name(old_dir, old_dentry->d_name.name, 1371 old_dentry->d_name.len, 1372 &old_de_ino); 1373 if (status) { 1374 status = -ENOENT; 1375 goto bail; 1376 } 1377 1378 /* 1379 * Check for inode number is _not_ due to possible IO errors. 1380 * We might rmdir the source, keep it as pwd of some process 1381 * and merrily kill the link to whatever was created under the 1382 * same name. Goodbye sticky bit ;-< 1383 */ 1384 if (old_de_ino != OCFS2_I(old_inode)->ip_blkno) { 1385 status = -ENOENT; 1386 goto bail; 1387 } 1388 1389 /* check if the target already exists (in which case we need 1390 * to delete it */ 1391 status = ocfs2_find_files_on_disk(new_dentry->d_name.name, 1392 new_dentry->d_name.len, 1393 &newfe_blkno, new_dir, 1394 &target_lookup_res); 1395 /* The only error we allow here is -ENOENT because the new 1396 * file not existing is perfectly valid. */ 1397 if ((status < 0) && (status != -ENOENT)) { 1398 /* If we cannot find the file specified we should just */ 1399 /* return the error... */ 1400 mlog_errno(status); 1401 goto bail; 1402 } 1403 if (status == 0) 1404 target_exists = 1; 1405 1406 if (!target_exists && new_inode) { 1407 /* 1408 * Target was unlinked by another node while we were 1409 * waiting to get to ocfs2_rename(). There isn't 1410 * anything we can do here to help the situation, so 1411 * bubble up the appropriate error. 1412 */ 1413 status = -ENOENT; 1414 goto bail; 1415 } 1416 1417 /* In case we need to overwrite an existing file, we blow it 1418 * away first */ 1419 if (target_exists) { 1420 /* VFS didn't think there existed an inode here, but 1421 * someone else in the cluster must have raced our 1422 * rename to create one. Today we error cleanly, in 1423 * the future we should consider calling iget to build 1424 * a new struct inode for this entry. */ 1425 if (!new_inode) { 1426 status = -EACCES; 1427 1428 trace_ocfs2_rename_target_exists(new_dentry->d_name.len, 1429 new_dentry->d_name.name); 1430 goto bail; 1431 } 1432 1433 if (OCFS2_I(new_inode)->ip_blkno != newfe_blkno) { 1434 status = -EACCES; 1435 1436 trace_ocfs2_rename_disagree( 1437 (unsigned long long)OCFS2_I(new_inode)->ip_blkno, 1438 (unsigned long long)newfe_blkno, 1439 OCFS2_I(new_inode)->ip_flags); 1440 goto bail; 1441 } 1442 1443 status = ocfs2_inode_lock(new_inode, &newfe_bh, 1); 1444 if (status < 0) { 1445 if (status != -ENOENT) 1446 mlog_errno(status); 1447 goto bail; 1448 } 1449 new_child_locked = 1; 1450 1451 status = ocfs2_remote_dentry_delete(new_dentry); 1452 if (status < 0) { 1453 mlog_errno(status); 1454 goto bail; 1455 } 1456 1457 newfe = (struct ocfs2_dinode *) newfe_bh->b_data; 1458 1459 trace_ocfs2_rename_over_existing( 1460 (unsigned long long)newfe_blkno, newfe_bh, newfe_bh ? 1461 (unsigned long long)newfe_bh->b_blocknr : 0ULL); 1462 1463 if (S_ISDIR(new_inode->i_mode) || (new_inode->i_nlink == 1)) { 1464 status = ocfs2_prepare_orphan_dir(osb, &orphan_dir, 1465 OCFS2_I(new_inode)->ip_blkno, 1466 orphan_name, &orphan_insert, 1467 false); 1468 if (status < 0) { 1469 mlog_errno(status); 1470 goto bail; 1471 } 1472 should_add_orphan = true; 1473 } 1474 } else { 1475 BUG_ON(d_inode(new_dentry->d_parent) != new_dir); 1476 1477 status = ocfs2_check_dir_for_entry(new_dir, 1478 new_dentry->d_name.name, 1479 new_dentry->d_name.len); 1480 if (status) 1481 goto bail; 1482 1483 status = ocfs2_prepare_dir_for_insert(osb, new_dir, new_dir_bh, 1484 new_dentry->d_name.name, 1485 new_dentry->d_name.len, 1486 &target_insert); 1487 if (status < 0) { 1488 mlog_errno(status); 1489 goto bail; 1490 } 1491 } 1492 1493 handle = ocfs2_start_trans(osb, ocfs2_rename_credits(osb->sb)); 1494 if (IS_ERR(handle)) { 1495 status = PTR_ERR(handle); 1496 handle = NULL; 1497 mlog_errno(status); 1498 goto bail; 1499 } 1500 1501 if (target_exists) { 1502 if (S_ISDIR(new_inode->i_mode)) { 1503 if (new_inode->i_nlink != 2 || 1504 !ocfs2_empty_dir(new_inode)) { 1505 status = -ENOTEMPTY; 1506 goto bail; 1507 } 1508 } 1509 status = ocfs2_journal_access_di(handle, INODE_CACHE(new_inode), 1510 newfe_bh, 1511 OCFS2_JOURNAL_ACCESS_WRITE); 1512 if (status < 0) { 1513 mlog_errno(status); 1514 goto bail; 1515 } 1516 1517 /* change the dirent to point to the correct inode */ 1518 status = ocfs2_update_entry(new_dir, handle, &target_lookup_res, 1519 old_inode); 1520 if (status < 0) { 1521 mlog_errno(status); 1522 goto bail; 1523 } 1524 inode_inc_iversion(new_dir); 1525 1526 if (S_ISDIR(new_inode->i_mode)) 1527 ocfs2_set_links_count(newfe, 0); 1528 else 1529 ocfs2_add_links_count(newfe, -1); 1530 ocfs2_journal_dirty(handle, newfe_bh); 1531 if (should_add_orphan) { 1532 status = ocfs2_orphan_add(osb, handle, new_inode, 1533 newfe_bh, orphan_name, 1534 &orphan_insert, orphan_dir, false); 1535 if (status < 0) { 1536 mlog_errno(status); 1537 goto bail; 1538 } 1539 } 1540 } else { 1541 /* if the name was not found in new_dir, add it now */ 1542 status = ocfs2_add_entry(handle, new_dentry, old_inode, 1543 OCFS2_I(old_inode)->ip_blkno, 1544 new_dir_bh, &target_insert); 1545 } 1546 1547 old_inode->i_ctime = current_time(old_inode); 1548 mark_inode_dirty(old_inode); 1549 1550 status = ocfs2_journal_access_di(handle, INODE_CACHE(old_inode), 1551 old_inode_bh, 1552 OCFS2_JOURNAL_ACCESS_WRITE); 1553 if (status >= 0) { 1554 old_di = (struct ocfs2_dinode *) old_inode_bh->b_data; 1555 1556 old_di->i_ctime = cpu_to_le64(old_inode->i_ctime.tv_sec); 1557 old_di->i_ctime_nsec = cpu_to_le32(old_inode->i_ctime.tv_nsec); 1558 ocfs2_journal_dirty(handle, old_inode_bh); 1559 } else 1560 mlog_errno(status); 1561 1562 /* 1563 * Now that the name has been added to new_dir, remove the old name. 1564 * 1565 * We don't keep any directory entry context around until now 1566 * because the insert might have changed the type of directory 1567 * we're dealing with. 1568 */ 1569 status = ocfs2_find_entry(old_dentry->d_name.name, 1570 old_dentry->d_name.len, old_dir, 1571 &old_entry_lookup); 1572 if (status) { 1573 if (!is_journal_aborted(osb->journal->j_journal)) { 1574 ocfs2_error(osb->sb, "new entry %.*s is added, but old entry %.*s " 1575 "is not deleted.", 1576 new_dentry->d_name.len, new_dentry->d_name.name, 1577 old_dentry->d_name.len, old_dentry->d_name.name); 1578 } 1579 goto bail; 1580 } 1581 1582 status = ocfs2_delete_entry(handle, old_dir, &old_entry_lookup); 1583 if (status < 0) { 1584 mlog_errno(status); 1585 if (!is_journal_aborted(osb->journal->j_journal)) { 1586 ocfs2_error(osb->sb, "new entry %.*s is added, but old entry %.*s " 1587 "is not deleted.", 1588 new_dentry->d_name.len, new_dentry->d_name.name, 1589 old_dentry->d_name.len, old_dentry->d_name.name); 1590 } 1591 goto bail; 1592 } 1593 1594 if (new_inode) { 1595 drop_nlink(new_inode); 1596 new_inode->i_ctime = current_time(new_inode); 1597 } 1598 old_dir->i_ctime = old_dir->i_mtime = current_time(old_dir); 1599 1600 if (update_dot_dot) { 1601 status = ocfs2_update_entry(old_inode, handle, 1602 &old_inode_dot_dot_res, new_dir); 1603 drop_nlink(old_dir); 1604 if (new_inode) { 1605 drop_nlink(new_inode); 1606 } else { 1607 inc_nlink(new_dir); 1608 mark_inode_dirty(new_dir); 1609 } 1610 } 1611 mark_inode_dirty(old_dir); 1612 ocfs2_mark_inode_dirty(handle, old_dir, old_dir_bh); 1613 if (new_inode) { 1614 mark_inode_dirty(new_inode); 1615 ocfs2_mark_inode_dirty(handle, new_inode, newfe_bh); 1616 } 1617 1618 if (old_dir != new_dir) { 1619 /* Keep the same times on both directories.*/ 1620 new_dir->i_ctime = new_dir->i_mtime = old_dir->i_ctime; 1621 1622 /* 1623 * This will also pick up the i_nlink change from the 1624 * block above. 1625 */ 1626 ocfs2_mark_inode_dirty(handle, new_dir, new_dir_bh); 1627 } 1628 1629 if (old_dir_nlink != old_dir->i_nlink) { 1630 if (!old_dir_bh) { 1631 mlog(ML_ERROR, "need to change nlink for old dir " 1632 "%llu from %d to %d but bh is NULL!\n", 1633 (unsigned long long)OCFS2_I(old_dir)->ip_blkno, 1634 (int)old_dir_nlink, old_dir->i_nlink); 1635 } else { 1636 struct ocfs2_dinode *fe; 1637 status = ocfs2_journal_access_di(handle, 1638 INODE_CACHE(old_dir), 1639 old_dir_bh, 1640 OCFS2_JOURNAL_ACCESS_WRITE); 1641 fe = (struct ocfs2_dinode *) old_dir_bh->b_data; 1642 ocfs2_set_links_count(fe, old_dir->i_nlink); 1643 ocfs2_journal_dirty(handle, old_dir_bh); 1644 } 1645 } 1646 ocfs2_dentry_move(old_dentry, new_dentry, old_dir, new_dir); 1647 status = 0; 1648 bail: 1649 if (handle) 1650 ocfs2_commit_trans(osb, handle); 1651 1652 if (orphan_dir) { 1653 /* This was locked for us in ocfs2_prepare_orphan_dir() */ 1654 ocfs2_inode_unlock(orphan_dir, 1); 1655 inode_unlock(orphan_dir); 1656 iput(orphan_dir); 1657 } 1658 1659 if (new_child_locked) 1660 ocfs2_inode_unlock(new_inode, 1); 1661 1662 if (old_child_locked) 1663 ocfs2_inode_unlock(old_inode, 1); 1664 1665 if (parents_locked) 1666 ocfs2_double_unlock(old_dir, new_dir); 1667 1668 if (rename_lock) 1669 ocfs2_rename_unlock(osb); 1670 1671 if (new_inode) 1672 sync_mapping_buffers(old_inode->i_mapping); 1673 1674 iput(new_inode); 1675 1676 ocfs2_free_dir_lookup_result(&target_lookup_res); 1677 ocfs2_free_dir_lookup_result(&old_entry_lookup); 1678 ocfs2_free_dir_lookup_result(&old_inode_dot_dot_res); 1679 ocfs2_free_dir_lookup_result(&orphan_insert); 1680 ocfs2_free_dir_lookup_result(&target_insert); 1681 1682 brelse(newfe_bh); 1683 brelse(old_inode_bh); 1684 brelse(old_dir_bh); 1685 brelse(new_dir_bh); 1686 1687 if (status) 1688 mlog_errno(status); 1689 1690 return status; 1691 } 1692 1693 /* 1694 * we expect i_size = strlen(symname). Copy symname into the file 1695 * data, including the null terminator. 1696 */ 1697 static int ocfs2_create_symlink_data(struct ocfs2_super *osb, 1698 handle_t *handle, 1699 struct inode *inode, 1700 const char *symname) 1701 { 1702 struct buffer_head **bhs = NULL; 1703 const char *c; 1704 struct super_block *sb = osb->sb; 1705 u64 p_blkno, p_blocks; 1706 int virtual, blocks, status, i, bytes_left; 1707 1708 bytes_left = i_size_read(inode) + 1; 1709 /* we can't trust i_blocks because we're actually going to 1710 * write i_size + 1 bytes. */ 1711 blocks = (bytes_left + sb->s_blocksize - 1) >> sb->s_blocksize_bits; 1712 1713 trace_ocfs2_create_symlink_data((unsigned long long)inode->i_blocks, 1714 i_size_read(inode), blocks); 1715 1716 /* Sanity check -- make sure we're going to fit. */ 1717 if (bytes_left > 1718 ocfs2_clusters_to_bytes(sb, OCFS2_I(inode)->ip_clusters)) { 1719 status = -EIO; 1720 mlog_errno(status); 1721 goto bail; 1722 } 1723 1724 bhs = kcalloc(blocks, sizeof(struct buffer_head *), GFP_KERNEL); 1725 if (!bhs) { 1726 status = -ENOMEM; 1727 mlog_errno(status); 1728 goto bail; 1729 } 1730 1731 status = ocfs2_extent_map_get_blocks(inode, 0, &p_blkno, &p_blocks, 1732 NULL); 1733 if (status < 0) { 1734 mlog_errno(status); 1735 goto bail; 1736 } 1737 1738 /* links can never be larger than one cluster so we know this 1739 * is all going to be contiguous, but do a sanity check 1740 * anyway. */ 1741 if ((p_blocks << sb->s_blocksize_bits) < bytes_left) { 1742 status = -EIO; 1743 mlog_errno(status); 1744 goto bail; 1745 } 1746 1747 virtual = 0; 1748 while(bytes_left > 0) { 1749 c = &symname[virtual * sb->s_blocksize]; 1750 1751 bhs[virtual] = sb_getblk(sb, p_blkno); 1752 if (!bhs[virtual]) { 1753 status = -ENOMEM; 1754 mlog_errno(status); 1755 goto bail; 1756 } 1757 ocfs2_set_new_buffer_uptodate(INODE_CACHE(inode), 1758 bhs[virtual]); 1759 1760 status = ocfs2_journal_access(handle, INODE_CACHE(inode), 1761 bhs[virtual], 1762 OCFS2_JOURNAL_ACCESS_CREATE); 1763 if (status < 0) { 1764 mlog_errno(status); 1765 goto bail; 1766 } 1767 1768 memset(bhs[virtual]->b_data, 0, sb->s_blocksize); 1769 1770 memcpy(bhs[virtual]->b_data, c, 1771 (bytes_left > sb->s_blocksize) ? sb->s_blocksize : 1772 bytes_left); 1773 1774 ocfs2_journal_dirty(handle, bhs[virtual]); 1775 1776 virtual++; 1777 p_blkno++; 1778 bytes_left -= sb->s_blocksize; 1779 } 1780 1781 status = 0; 1782 bail: 1783 1784 if (bhs) { 1785 for(i = 0; i < blocks; i++) 1786 brelse(bhs[i]); 1787 kfree(bhs); 1788 } 1789 1790 if (status) 1791 mlog_errno(status); 1792 return status; 1793 } 1794 1795 static int ocfs2_symlink(struct inode *dir, 1796 struct dentry *dentry, 1797 const char *symname) 1798 { 1799 int status, l, credits; 1800 u64 newsize; 1801 struct ocfs2_super *osb = NULL; 1802 struct inode *inode = NULL; 1803 struct super_block *sb; 1804 struct buffer_head *new_fe_bh = NULL; 1805 struct buffer_head *parent_fe_bh = NULL; 1806 struct ocfs2_dinode *fe = NULL; 1807 struct ocfs2_dinode *dirfe; 1808 handle_t *handle = NULL; 1809 struct ocfs2_alloc_context *inode_ac = NULL; 1810 struct ocfs2_alloc_context *data_ac = NULL; 1811 struct ocfs2_alloc_context *xattr_ac = NULL; 1812 int want_clusters = 0; 1813 int xattr_credits = 0; 1814 struct ocfs2_security_xattr_info si = { 1815 .enable = 1, 1816 }; 1817 int did_quota = 0, did_quota_inode = 0; 1818 struct ocfs2_dir_lookup_result lookup = { NULL, }; 1819 sigset_t oldset; 1820 int did_block_signals = 0; 1821 struct ocfs2_dentry_lock *dl = NULL; 1822 1823 trace_ocfs2_symlink_begin(dir, dentry, symname, 1824 dentry->d_name.len, dentry->d_name.name); 1825 1826 status = dquot_initialize(dir); 1827 if (status) { 1828 mlog_errno(status); 1829 goto bail; 1830 } 1831 1832 sb = dir->i_sb; 1833 osb = OCFS2_SB(sb); 1834 1835 l = strlen(symname) + 1; 1836 1837 credits = ocfs2_calc_symlink_credits(sb); 1838 1839 /* lock the parent directory */ 1840 status = ocfs2_inode_lock(dir, &parent_fe_bh, 1); 1841 if (status < 0) { 1842 if (status != -ENOENT) 1843 mlog_errno(status); 1844 return status; 1845 } 1846 1847 dirfe = (struct ocfs2_dinode *) parent_fe_bh->b_data; 1848 if (!ocfs2_read_links_count(dirfe)) { 1849 /* can't make a file in a deleted directory. */ 1850 status = -ENOENT; 1851 goto bail; 1852 } 1853 1854 status = ocfs2_check_dir_for_entry(dir, dentry->d_name.name, 1855 dentry->d_name.len); 1856 if (status) 1857 goto bail; 1858 1859 status = ocfs2_prepare_dir_for_insert(osb, dir, parent_fe_bh, 1860 dentry->d_name.name, 1861 dentry->d_name.len, &lookup); 1862 if (status < 0) { 1863 mlog_errno(status); 1864 goto bail; 1865 } 1866 1867 status = ocfs2_reserve_new_inode(osb, &inode_ac); 1868 if (status < 0) { 1869 if (status != -ENOSPC) 1870 mlog_errno(status); 1871 goto bail; 1872 } 1873 1874 inode = ocfs2_get_init_inode(dir, S_IFLNK | S_IRWXUGO); 1875 if (IS_ERR(inode)) { 1876 status = PTR_ERR(inode); 1877 inode = NULL; 1878 mlog_errno(status); 1879 goto bail; 1880 } 1881 1882 /* get security xattr */ 1883 status = ocfs2_init_security_get(inode, dir, &dentry->d_name, &si); 1884 if (status) { 1885 if (status == -EOPNOTSUPP) 1886 si.enable = 0; 1887 else { 1888 mlog_errno(status); 1889 goto bail; 1890 } 1891 } 1892 1893 /* calculate meta data/clusters for setting security xattr */ 1894 if (si.enable) { 1895 status = ocfs2_calc_security_init(dir, &si, &want_clusters, 1896 &xattr_credits, &xattr_ac); 1897 if (status < 0) { 1898 mlog_errno(status); 1899 goto bail; 1900 } 1901 } 1902 1903 /* don't reserve bitmap space for fast symlinks. */ 1904 if (l > ocfs2_fast_symlink_chars(sb)) 1905 want_clusters += 1; 1906 1907 status = ocfs2_reserve_clusters(osb, want_clusters, &data_ac); 1908 if (status < 0) { 1909 if (status != -ENOSPC) 1910 mlog_errno(status); 1911 goto bail; 1912 } 1913 1914 handle = ocfs2_start_trans(osb, credits + xattr_credits); 1915 if (IS_ERR(handle)) { 1916 status = PTR_ERR(handle); 1917 handle = NULL; 1918 mlog_errno(status); 1919 goto bail; 1920 } 1921 1922 /* Starting to change things, restart is no longer possible. */ 1923 ocfs2_block_signals(&oldset); 1924 did_block_signals = 1; 1925 1926 status = dquot_alloc_inode(inode); 1927 if (status) 1928 goto bail; 1929 did_quota_inode = 1; 1930 1931 trace_ocfs2_symlink_create(dir, dentry, dentry->d_name.len, 1932 dentry->d_name.name, 1933 (unsigned long long)OCFS2_I(dir)->ip_blkno, 1934 inode->i_mode); 1935 1936 status = ocfs2_mknod_locked(osb, dir, inode, 1937 0, &new_fe_bh, parent_fe_bh, handle, 1938 inode_ac); 1939 if (status < 0) { 1940 mlog_errno(status); 1941 goto bail; 1942 } 1943 1944 fe = (struct ocfs2_dinode *) new_fe_bh->b_data; 1945 inode->i_rdev = 0; 1946 newsize = l - 1; 1947 inode->i_op = &ocfs2_symlink_inode_operations; 1948 inode_nohighmem(inode); 1949 if (l > ocfs2_fast_symlink_chars(sb)) { 1950 u32 offset = 0; 1951 1952 status = dquot_alloc_space_nodirty(inode, 1953 ocfs2_clusters_to_bytes(osb->sb, 1)); 1954 if (status) 1955 goto bail; 1956 did_quota = 1; 1957 inode->i_mapping->a_ops = &ocfs2_aops; 1958 status = ocfs2_add_inode_data(osb, inode, &offset, 1, 0, 1959 new_fe_bh, 1960 handle, data_ac, NULL, 1961 NULL); 1962 if (status < 0) { 1963 if (status != -ENOSPC && status != -EINTR) { 1964 mlog(ML_ERROR, 1965 "Failed to extend file to %llu\n", 1966 (unsigned long long)newsize); 1967 mlog_errno(status); 1968 status = -ENOSPC; 1969 } 1970 goto bail; 1971 } 1972 i_size_write(inode, newsize); 1973 inode->i_blocks = ocfs2_inode_sector_count(inode); 1974 } else { 1975 inode->i_mapping->a_ops = &ocfs2_fast_symlink_aops; 1976 memcpy((char *) fe->id2.i_symlink, symname, l); 1977 i_size_write(inode, newsize); 1978 inode->i_blocks = 0; 1979 } 1980 1981 status = ocfs2_mark_inode_dirty(handle, inode, new_fe_bh); 1982 if (status < 0) { 1983 mlog_errno(status); 1984 goto bail; 1985 } 1986 1987 if (!ocfs2_inode_is_fast_symlink(inode)) { 1988 status = ocfs2_create_symlink_data(osb, handle, inode, 1989 symname); 1990 if (status < 0) { 1991 mlog_errno(status); 1992 goto bail; 1993 } 1994 } 1995 1996 if (si.enable) { 1997 status = ocfs2_init_security_set(handle, inode, new_fe_bh, &si, 1998 xattr_ac, data_ac); 1999 if (status < 0) { 2000 mlog_errno(status); 2001 goto bail; 2002 } 2003 } 2004 2005 /* 2006 * Do this before adding the entry to the directory. We add 2007 * also set d_op after success so that ->d_iput() will cleanup 2008 * the dentry lock even if ocfs2_add_entry() fails below. 2009 */ 2010 status = ocfs2_dentry_attach_lock(dentry, inode, OCFS2_I(dir)->ip_blkno); 2011 if (status) { 2012 mlog_errno(status); 2013 goto bail; 2014 } 2015 2016 dl = dentry->d_fsdata; 2017 2018 status = ocfs2_add_entry(handle, dentry, inode, 2019 le64_to_cpu(fe->i_blkno), parent_fe_bh, 2020 &lookup); 2021 if (status < 0) { 2022 mlog_errno(status); 2023 goto bail; 2024 } 2025 2026 insert_inode_hash(inode); 2027 d_instantiate(dentry, inode); 2028 bail: 2029 if (status < 0 && did_quota) 2030 dquot_free_space_nodirty(inode, 2031 ocfs2_clusters_to_bytes(osb->sb, 1)); 2032 if (status < 0 && did_quota_inode) 2033 dquot_free_inode(inode); 2034 if (handle) 2035 ocfs2_commit_trans(osb, handle); 2036 2037 ocfs2_inode_unlock(dir, 1); 2038 if (did_block_signals) 2039 ocfs2_unblock_signals(&oldset); 2040 2041 brelse(new_fe_bh); 2042 brelse(parent_fe_bh); 2043 kfree(si.value); 2044 ocfs2_free_dir_lookup_result(&lookup); 2045 if (inode_ac) 2046 ocfs2_free_alloc_context(inode_ac); 2047 if (data_ac) 2048 ocfs2_free_alloc_context(data_ac); 2049 if (xattr_ac) 2050 ocfs2_free_alloc_context(xattr_ac); 2051 if ((status < 0) && inode) { 2052 if (dl) 2053 ocfs2_cleanup_add_entry_failure(osb, dentry, inode); 2054 2055 OCFS2_I(inode)->ip_flags |= OCFS2_INODE_SKIP_ORPHAN_DIR; 2056 clear_nlink(inode); 2057 iput(inode); 2058 } 2059 2060 if (status) 2061 mlog_errno(status); 2062 2063 return status; 2064 } 2065 2066 static int ocfs2_blkno_stringify(u64 blkno, char *name) 2067 { 2068 int status, namelen; 2069 2070 namelen = snprintf(name, OCFS2_ORPHAN_NAMELEN + 1, "%016llx", 2071 (long long)blkno); 2072 if (namelen <= 0) { 2073 if (namelen) 2074 status = namelen; 2075 else 2076 status = -EINVAL; 2077 mlog_errno(status); 2078 goto bail; 2079 } 2080 if (namelen != OCFS2_ORPHAN_NAMELEN) { 2081 status = -EINVAL; 2082 mlog_errno(status); 2083 goto bail; 2084 } 2085 2086 trace_ocfs2_blkno_stringify(blkno, name, namelen); 2087 2088 status = 0; 2089 bail: 2090 if (status < 0) 2091 mlog_errno(status); 2092 return status; 2093 } 2094 2095 static int ocfs2_lookup_lock_orphan_dir(struct ocfs2_super *osb, 2096 struct inode **ret_orphan_dir, 2097 struct buffer_head **ret_orphan_dir_bh) 2098 { 2099 struct inode *orphan_dir_inode; 2100 struct buffer_head *orphan_dir_bh = NULL; 2101 int ret = 0; 2102 2103 orphan_dir_inode = ocfs2_get_system_file_inode(osb, 2104 ORPHAN_DIR_SYSTEM_INODE, 2105 osb->slot_num); 2106 if (!orphan_dir_inode) { 2107 ret = -ENOENT; 2108 mlog_errno(ret); 2109 return ret; 2110 } 2111 2112 inode_lock(orphan_dir_inode); 2113 2114 ret = ocfs2_inode_lock(orphan_dir_inode, &orphan_dir_bh, 1); 2115 if (ret < 0) { 2116 inode_unlock(orphan_dir_inode); 2117 iput(orphan_dir_inode); 2118 2119 mlog_errno(ret); 2120 return ret; 2121 } 2122 2123 *ret_orphan_dir = orphan_dir_inode; 2124 *ret_orphan_dir_bh = orphan_dir_bh; 2125 2126 return 0; 2127 } 2128 2129 static int __ocfs2_prepare_orphan_dir(struct inode *orphan_dir_inode, 2130 struct buffer_head *orphan_dir_bh, 2131 u64 blkno, 2132 char *name, 2133 struct ocfs2_dir_lookup_result *lookup, 2134 bool dio) 2135 { 2136 int ret; 2137 struct ocfs2_super *osb = OCFS2_SB(orphan_dir_inode->i_sb); 2138 int namelen = dio ? 2139 (OCFS2_DIO_ORPHAN_PREFIX_LEN + OCFS2_ORPHAN_NAMELEN) : 2140 OCFS2_ORPHAN_NAMELEN; 2141 2142 if (dio) { 2143 ret = snprintf(name, OCFS2_DIO_ORPHAN_PREFIX_LEN + 1, "%s", 2144 OCFS2_DIO_ORPHAN_PREFIX); 2145 if (ret != OCFS2_DIO_ORPHAN_PREFIX_LEN) { 2146 ret = -EINVAL; 2147 mlog_errno(ret); 2148 return ret; 2149 } 2150 2151 ret = ocfs2_blkno_stringify(blkno, 2152 name + OCFS2_DIO_ORPHAN_PREFIX_LEN); 2153 } else 2154 ret = ocfs2_blkno_stringify(blkno, name); 2155 if (ret < 0) { 2156 mlog_errno(ret); 2157 return ret; 2158 } 2159 2160 ret = ocfs2_prepare_dir_for_insert(osb, orphan_dir_inode, 2161 orphan_dir_bh, name, 2162 namelen, lookup); 2163 if (ret < 0) { 2164 mlog_errno(ret); 2165 return ret; 2166 } 2167 2168 return 0; 2169 } 2170 2171 /** 2172 * ocfs2_prepare_orphan_dir() - Prepare an orphan directory for 2173 * insertion of an orphan. 2174 * @osb: ocfs2 file system 2175 * @ret_orphan_dir: Orphan dir inode - returned locked! 2176 * @blkno: Actual block number of the inode to be inserted into orphan dir. 2177 * @lookup: dir lookup result, to be passed back into functions like 2178 * ocfs2_orphan_add 2179 * 2180 * Returns zero on success and the ret_orphan_dir, name and lookup 2181 * fields will be populated. 2182 * 2183 * Returns non-zero on failure. 2184 */ 2185 static int ocfs2_prepare_orphan_dir(struct ocfs2_super *osb, 2186 struct inode **ret_orphan_dir, 2187 u64 blkno, 2188 char *name, 2189 struct ocfs2_dir_lookup_result *lookup, 2190 bool dio) 2191 { 2192 struct inode *orphan_dir_inode = NULL; 2193 struct buffer_head *orphan_dir_bh = NULL; 2194 int ret = 0; 2195 2196 ret = ocfs2_lookup_lock_orphan_dir(osb, &orphan_dir_inode, 2197 &orphan_dir_bh); 2198 if (ret < 0) { 2199 mlog_errno(ret); 2200 return ret; 2201 } 2202 2203 ret = __ocfs2_prepare_orphan_dir(orphan_dir_inode, orphan_dir_bh, 2204 blkno, name, lookup, dio); 2205 if (ret < 0) { 2206 mlog_errno(ret); 2207 goto out; 2208 } 2209 2210 *ret_orphan_dir = orphan_dir_inode; 2211 2212 out: 2213 brelse(orphan_dir_bh); 2214 2215 if (ret) { 2216 ocfs2_inode_unlock(orphan_dir_inode, 1); 2217 inode_unlock(orphan_dir_inode); 2218 iput(orphan_dir_inode); 2219 } 2220 2221 if (ret) 2222 mlog_errno(ret); 2223 return ret; 2224 } 2225 2226 static int ocfs2_orphan_add(struct ocfs2_super *osb, 2227 handle_t *handle, 2228 struct inode *inode, 2229 struct buffer_head *fe_bh, 2230 char *name, 2231 struct ocfs2_dir_lookup_result *lookup, 2232 struct inode *orphan_dir_inode, 2233 bool dio) 2234 { 2235 struct buffer_head *orphan_dir_bh = NULL; 2236 int status = 0; 2237 struct ocfs2_dinode *orphan_fe; 2238 struct ocfs2_dinode *fe = (struct ocfs2_dinode *) fe_bh->b_data; 2239 int namelen = dio ? 2240 (OCFS2_DIO_ORPHAN_PREFIX_LEN + OCFS2_ORPHAN_NAMELEN) : 2241 OCFS2_ORPHAN_NAMELEN; 2242 2243 trace_ocfs2_orphan_add_begin( 2244 (unsigned long long)OCFS2_I(inode)->ip_blkno); 2245 2246 status = ocfs2_read_inode_block(orphan_dir_inode, &orphan_dir_bh); 2247 if (status < 0) { 2248 mlog_errno(status); 2249 goto leave; 2250 } 2251 2252 status = ocfs2_journal_access_di(handle, 2253 INODE_CACHE(orphan_dir_inode), 2254 orphan_dir_bh, 2255 OCFS2_JOURNAL_ACCESS_WRITE); 2256 if (status < 0) { 2257 mlog_errno(status); 2258 goto leave; 2259 } 2260 2261 /* 2262 * We're going to journal the change of i_flags and i_orphaned_slot. 2263 * It's safe anyway, though some callers may duplicate the journaling. 2264 * Journaling within the func just make the logic look more 2265 * straightforward. 2266 */ 2267 status = ocfs2_journal_access_di(handle, 2268 INODE_CACHE(inode), 2269 fe_bh, 2270 OCFS2_JOURNAL_ACCESS_WRITE); 2271 if (status < 0) { 2272 mlog_errno(status); 2273 goto leave; 2274 } 2275 2276 /* we're a cluster, and nlink can change on disk from 2277 * underneath us... */ 2278 orphan_fe = (struct ocfs2_dinode *) orphan_dir_bh->b_data; 2279 if (S_ISDIR(inode->i_mode)) 2280 ocfs2_add_links_count(orphan_fe, 1); 2281 set_nlink(orphan_dir_inode, ocfs2_read_links_count(orphan_fe)); 2282 ocfs2_journal_dirty(handle, orphan_dir_bh); 2283 2284 status = __ocfs2_add_entry(handle, orphan_dir_inode, name, 2285 namelen, inode, 2286 OCFS2_I(inode)->ip_blkno, 2287 orphan_dir_bh, lookup); 2288 if (status < 0) { 2289 mlog_errno(status); 2290 goto rollback; 2291 } 2292 2293 if (dio) { 2294 /* Update flag OCFS2_DIO_ORPHANED_FL and record the orphan 2295 * slot. 2296 */ 2297 fe->i_flags |= cpu_to_le32(OCFS2_DIO_ORPHANED_FL); 2298 fe->i_dio_orphaned_slot = cpu_to_le16(osb->slot_num); 2299 } else { 2300 fe->i_flags |= cpu_to_le32(OCFS2_ORPHANED_FL); 2301 OCFS2_I(inode)->ip_flags &= ~OCFS2_INODE_SKIP_ORPHAN_DIR; 2302 2303 /* Record which orphan dir our inode now resides 2304 * in. delete_inode will use this to determine which orphan 2305 * dir to lock. */ 2306 fe->i_orphaned_slot = cpu_to_le16(osb->slot_num); 2307 } 2308 2309 ocfs2_journal_dirty(handle, fe_bh); 2310 2311 trace_ocfs2_orphan_add_end((unsigned long long)OCFS2_I(inode)->ip_blkno, 2312 osb->slot_num); 2313 2314 rollback: 2315 if (status < 0) { 2316 if (S_ISDIR(inode->i_mode)) 2317 ocfs2_add_links_count(orphan_fe, -1); 2318 set_nlink(orphan_dir_inode, ocfs2_read_links_count(orphan_fe)); 2319 } 2320 2321 leave: 2322 brelse(orphan_dir_bh); 2323 2324 return status; 2325 } 2326 2327 /* unlike orphan_add, we expect the orphan dir to already be locked here. */ 2328 int ocfs2_orphan_del(struct ocfs2_super *osb, 2329 handle_t *handle, 2330 struct inode *orphan_dir_inode, 2331 struct inode *inode, 2332 struct buffer_head *orphan_dir_bh, 2333 bool dio) 2334 { 2335 const int namelen = OCFS2_DIO_ORPHAN_PREFIX_LEN + OCFS2_ORPHAN_NAMELEN; 2336 char name[namelen + 1]; 2337 struct ocfs2_dinode *orphan_fe; 2338 int status = 0; 2339 struct ocfs2_dir_lookup_result lookup = { NULL, }; 2340 2341 if (dio) { 2342 status = snprintf(name, OCFS2_DIO_ORPHAN_PREFIX_LEN + 1, "%s", 2343 OCFS2_DIO_ORPHAN_PREFIX); 2344 if (status != OCFS2_DIO_ORPHAN_PREFIX_LEN) { 2345 status = -EINVAL; 2346 mlog_errno(status); 2347 return status; 2348 } 2349 2350 status = ocfs2_blkno_stringify(OCFS2_I(inode)->ip_blkno, 2351 name + OCFS2_DIO_ORPHAN_PREFIX_LEN); 2352 } else 2353 status = ocfs2_blkno_stringify(OCFS2_I(inode)->ip_blkno, name); 2354 if (status < 0) { 2355 mlog_errno(status); 2356 goto leave; 2357 } 2358 2359 trace_ocfs2_orphan_del( 2360 (unsigned long long)OCFS2_I(orphan_dir_inode)->ip_blkno, 2361 name, strlen(name)); 2362 2363 status = ocfs2_journal_access_di(handle, 2364 INODE_CACHE(orphan_dir_inode), 2365 orphan_dir_bh, 2366 OCFS2_JOURNAL_ACCESS_WRITE); 2367 if (status < 0) { 2368 mlog_errno(status); 2369 goto leave; 2370 } 2371 2372 /* find it's spot in the orphan directory */ 2373 status = ocfs2_find_entry(name, strlen(name), orphan_dir_inode, 2374 &lookup); 2375 if (status) { 2376 mlog_errno(status); 2377 goto leave; 2378 } 2379 2380 /* remove it from the orphan directory */ 2381 status = ocfs2_delete_entry(handle, orphan_dir_inode, &lookup); 2382 if (status < 0) { 2383 mlog_errno(status); 2384 goto leave; 2385 } 2386 2387 /* do the i_nlink dance! :) */ 2388 orphan_fe = (struct ocfs2_dinode *) orphan_dir_bh->b_data; 2389 if (S_ISDIR(inode->i_mode)) 2390 ocfs2_add_links_count(orphan_fe, -1); 2391 set_nlink(orphan_dir_inode, ocfs2_read_links_count(orphan_fe)); 2392 ocfs2_journal_dirty(handle, orphan_dir_bh); 2393 2394 leave: 2395 ocfs2_free_dir_lookup_result(&lookup); 2396 2397 if (status) 2398 mlog_errno(status); 2399 return status; 2400 } 2401 2402 /** 2403 * ocfs2_prep_new_orphaned_file() - Prepare the orphan dir to receive a newly 2404 * allocated file. This is different from the typical 'add to orphan dir' 2405 * operation in that the inode does not yet exist. This is a problem because 2406 * the orphan dir stringifies the inode block number to come up with it's 2407 * dirent. Obviously if the inode does not yet exist we have a chicken and egg 2408 * problem. This function works around it by calling deeper into the orphan 2409 * and suballoc code than other callers. Use this only by necessity. 2410 * @dir: The directory which this inode will ultimately wind up under - not the 2411 * orphan dir! 2412 * @dir_bh: buffer_head the @dir inode block 2413 * @orphan_name: string of length (CFS2_ORPHAN_NAMELEN + 1). Will be filled 2414 * with the string to be used for orphan dirent. Pass back to the orphan dir 2415 * code. 2416 * @ret_orphan_dir: orphan dir inode returned to be passed back into orphan 2417 * dir code. 2418 * @ret_di_blkno: block number where the new inode will be allocated. 2419 * @orphan_insert: Dir insert context to be passed back into orphan dir code. 2420 * @ret_inode_ac: Inode alloc context to be passed back to the allocator. 2421 * 2422 * Returns zero on success and the ret_orphan_dir, name and lookup 2423 * fields will be populated. 2424 * 2425 * Returns non-zero on failure. 2426 */ 2427 static int ocfs2_prep_new_orphaned_file(struct inode *dir, 2428 struct buffer_head *dir_bh, 2429 char *orphan_name, 2430 struct inode **ret_orphan_dir, 2431 u64 *ret_di_blkno, 2432 struct ocfs2_dir_lookup_result *orphan_insert, 2433 struct ocfs2_alloc_context **ret_inode_ac) 2434 { 2435 int ret; 2436 u64 di_blkno; 2437 struct ocfs2_super *osb = OCFS2_SB(dir->i_sb); 2438 struct inode *orphan_dir = NULL; 2439 struct buffer_head *orphan_dir_bh = NULL; 2440 struct ocfs2_alloc_context *inode_ac = NULL; 2441 2442 ret = ocfs2_lookup_lock_orphan_dir(osb, &orphan_dir, &orphan_dir_bh); 2443 if (ret < 0) { 2444 mlog_errno(ret); 2445 return ret; 2446 } 2447 2448 /* reserve an inode spot */ 2449 ret = ocfs2_reserve_new_inode(osb, &inode_ac); 2450 if (ret < 0) { 2451 if (ret != -ENOSPC) 2452 mlog_errno(ret); 2453 goto out; 2454 } 2455 2456 ret = ocfs2_find_new_inode_loc(dir, dir_bh, inode_ac, 2457 &di_blkno); 2458 if (ret) { 2459 mlog_errno(ret); 2460 goto out; 2461 } 2462 2463 ret = __ocfs2_prepare_orphan_dir(orphan_dir, orphan_dir_bh, 2464 di_blkno, orphan_name, orphan_insert, 2465 false); 2466 if (ret < 0) { 2467 mlog_errno(ret); 2468 goto out; 2469 } 2470 2471 out: 2472 if (ret == 0) { 2473 *ret_orphan_dir = orphan_dir; 2474 *ret_di_blkno = di_blkno; 2475 *ret_inode_ac = inode_ac; 2476 /* 2477 * orphan_name and orphan_insert are already up to 2478 * date via prepare_orphan_dir 2479 */ 2480 } else { 2481 /* Unroll reserve_new_inode* */ 2482 if (inode_ac) 2483 ocfs2_free_alloc_context(inode_ac); 2484 2485 /* Unroll orphan dir locking */ 2486 inode_unlock(orphan_dir); 2487 ocfs2_inode_unlock(orphan_dir, 1); 2488 iput(orphan_dir); 2489 } 2490 2491 brelse(orphan_dir_bh); 2492 2493 return ret; 2494 } 2495 2496 int ocfs2_create_inode_in_orphan(struct inode *dir, 2497 int mode, 2498 struct inode **new_inode) 2499 { 2500 int status, did_quota_inode = 0; 2501 struct inode *inode = NULL; 2502 struct inode *orphan_dir = NULL; 2503 struct ocfs2_super *osb = OCFS2_SB(dir->i_sb); 2504 struct ocfs2_dinode *di = NULL; 2505 handle_t *handle = NULL; 2506 char orphan_name[OCFS2_ORPHAN_NAMELEN + 1]; 2507 struct buffer_head *parent_di_bh = NULL; 2508 struct buffer_head *new_di_bh = NULL; 2509 struct ocfs2_alloc_context *inode_ac = NULL; 2510 struct ocfs2_dir_lookup_result orphan_insert = { NULL, }; 2511 u64 uninitialized_var(di_blkno), suballoc_loc; 2512 u16 suballoc_bit; 2513 2514 status = ocfs2_inode_lock(dir, &parent_di_bh, 1); 2515 if (status < 0) { 2516 if (status != -ENOENT) 2517 mlog_errno(status); 2518 return status; 2519 } 2520 2521 status = ocfs2_prep_new_orphaned_file(dir, parent_di_bh, 2522 orphan_name, &orphan_dir, 2523 &di_blkno, &orphan_insert, &inode_ac); 2524 if (status < 0) { 2525 if (status != -ENOSPC) 2526 mlog_errno(status); 2527 goto leave; 2528 } 2529 2530 inode = ocfs2_get_init_inode(dir, mode); 2531 if (IS_ERR(inode)) { 2532 status = PTR_ERR(inode); 2533 inode = NULL; 2534 mlog_errno(status); 2535 goto leave; 2536 } 2537 2538 handle = ocfs2_start_trans(osb, ocfs2_mknod_credits(osb->sb, 0, 0)); 2539 if (IS_ERR(handle)) { 2540 status = PTR_ERR(handle); 2541 handle = NULL; 2542 mlog_errno(status); 2543 goto leave; 2544 } 2545 2546 status = dquot_alloc_inode(inode); 2547 if (status) 2548 goto leave; 2549 did_quota_inode = 1; 2550 2551 status = ocfs2_claim_new_inode_at_loc(handle, dir, inode_ac, 2552 &suballoc_loc, 2553 &suballoc_bit, di_blkno); 2554 if (status < 0) { 2555 mlog_errno(status); 2556 goto leave; 2557 } 2558 2559 clear_nlink(inode); 2560 /* do the real work now. */ 2561 status = __ocfs2_mknod_locked(dir, inode, 2562 0, &new_di_bh, parent_di_bh, handle, 2563 inode_ac, di_blkno, suballoc_loc, 2564 suballoc_bit); 2565 if (status < 0) { 2566 mlog_errno(status); 2567 goto leave; 2568 } 2569 2570 di = (struct ocfs2_dinode *)new_di_bh->b_data; 2571 status = ocfs2_orphan_add(osb, handle, inode, new_di_bh, orphan_name, 2572 &orphan_insert, orphan_dir, false); 2573 if (status < 0) { 2574 mlog_errno(status); 2575 goto leave; 2576 } 2577 2578 /* get open lock so that only nodes can't remove it from orphan dir. */ 2579 status = ocfs2_open_lock(inode); 2580 if (status < 0) 2581 mlog_errno(status); 2582 2583 insert_inode_hash(inode); 2584 leave: 2585 if (status < 0 && did_quota_inode) 2586 dquot_free_inode(inode); 2587 if (handle) 2588 ocfs2_commit_trans(osb, handle); 2589 2590 if (orphan_dir) { 2591 /* This was locked for us in ocfs2_prepare_orphan_dir() */ 2592 ocfs2_inode_unlock(orphan_dir, 1); 2593 inode_unlock(orphan_dir); 2594 iput(orphan_dir); 2595 } 2596 2597 if ((status < 0) && inode) { 2598 clear_nlink(inode); 2599 iput(inode); 2600 } 2601 2602 if (inode_ac) 2603 ocfs2_free_alloc_context(inode_ac); 2604 2605 brelse(new_di_bh); 2606 2607 if (!status) 2608 *new_inode = inode; 2609 2610 ocfs2_free_dir_lookup_result(&orphan_insert); 2611 2612 ocfs2_inode_unlock(dir, 1); 2613 brelse(parent_di_bh); 2614 return status; 2615 } 2616 2617 int ocfs2_add_inode_to_orphan(struct ocfs2_super *osb, 2618 struct inode *inode) 2619 { 2620 char orphan_name[OCFS2_DIO_ORPHAN_PREFIX_LEN + OCFS2_ORPHAN_NAMELEN + 1]; 2621 struct inode *orphan_dir_inode = NULL; 2622 struct ocfs2_dir_lookup_result orphan_insert = { NULL, }; 2623 struct buffer_head *di_bh = NULL; 2624 int status = 0; 2625 handle_t *handle = NULL; 2626 struct ocfs2_dinode *di = NULL; 2627 2628 status = ocfs2_inode_lock(inode, &di_bh, 1); 2629 if (status < 0) { 2630 mlog_errno(status); 2631 goto bail; 2632 } 2633 2634 di = (struct ocfs2_dinode *) di_bh->b_data; 2635 /* 2636 * Another append dio crashed? 2637 * If so, manually recover it first. 2638 */ 2639 if (unlikely(di->i_flags & cpu_to_le32(OCFS2_DIO_ORPHANED_FL))) { 2640 status = ocfs2_truncate_file(inode, di_bh, i_size_read(inode)); 2641 if (status < 0) { 2642 if (status != -ENOSPC) 2643 mlog_errno(status); 2644 goto bail_unlock_inode; 2645 } 2646 2647 status = ocfs2_del_inode_from_orphan(osb, inode, di_bh, 0, 0); 2648 if (status < 0) { 2649 mlog_errno(status); 2650 goto bail_unlock_inode; 2651 } 2652 } 2653 2654 status = ocfs2_prepare_orphan_dir(osb, &orphan_dir_inode, 2655 OCFS2_I(inode)->ip_blkno, 2656 orphan_name, 2657 &orphan_insert, 2658 true); 2659 if (status < 0) { 2660 mlog_errno(status); 2661 goto bail_unlock_inode; 2662 } 2663 2664 handle = ocfs2_start_trans(osb, 2665 OCFS2_INODE_ADD_TO_ORPHAN_CREDITS); 2666 if (IS_ERR(handle)) { 2667 status = PTR_ERR(handle); 2668 goto bail_unlock_orphan; 2669 } 2670 2671 status = ocfs2_orphan_add(osb, handle, inode, di_bh, orphan_name, 2672 &orphan_insert, orphan_dir_inode, true); 2673 if (status) 2674 mlog_errno(status); 2675 2676 ocfs2_commit_trans(osb, handle); 2677 2678 bail_unlock_orphan: 2679 ocfs2_inode_unlock(orphan_dir_inode, 1); 2680 inode_unlock(orphan_dir_inode); 2681 iput(orphan_dir_inode); 2682 2683 ocfs2_free_dir_lookup_result(&orphan_insert); 2684 2685 bail_unlock_inode: 2686 ocfs2_inode_unlock(inode, 1); 2687 brelse(di_bh); 2688 2689 bail: 2690 return status; 2691 } 2692 2693 int ocfs2_del_inode_from_orphan(struct ocfs2_super *osb, 2694 struct inode *inode, struct buffer_head *di_bh, 2695 int update_isize, loff_t end) 2696 { 2697 struct inode *orphan_dir_inode = NULL; 2698 struct buffer_head *orphan_dir_bh = NULL; 2699 struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data; 2700 handle_t *handle = NULL; 2701 int status = 0; 2702 2703 orphan_dir_inode = ocfs2_get_system_file_inode(osb, 2704 ORPHAN_DIR_SYSTEM_INODE, 2705 le16_to_cpu(di->i_dio_orphaned_slot)); 2706 if (!orphan_dir_inode) { 2707 status = -ENOENT; 2708 mlog_errno(status); 2709 goto bail; 2710 } 2711 2712 inode_lock(orphan_dir_inode); 2713 status = ocfs2_inode_lock(orphan_dir_inode, &orphan_dir_bh, 1); 2714 if (status < 0) { 2715 inode_unlock(orphan_dir_inode); 2716 iput(orphan_dir_inode); 2717 mlog_errno(status); 2718 goto bail; 2719 } 2720 2721 handle = ocfs2_start_trans(osb, 2722 OCFS2_INODE_DEL_FROM_ORPHAN_CREDITS); 2723 if (IS_ERR(handle)) { 2724 status = PTR_ERR(handle); 2725 goto bail_unlock_orphan; 2726 } 2727 2728 BUG_ON(!(di->i_flags & cpu_to_le32(OCFS2_DIO_ORPHANED_FL))); 2729 2730 status = ocfs2_orphan_del(osb, handle, orphan_dir_inode, 2731 inode, orphan_dir_bh, true); 2732 if (status < 0) { 2733 mlog_errno(status); 2734 goto bail_commit; 2735 } 2736 2737 status = ocfs2_journal_access_di(handle, 2738 INODE_CACHE(inode), 2739 di_bh, 2740 OCFS2_JOURNAL_ACCESS_WRITE); 2741 if (status < 0) { 2742 mlog_errno(status); 2743 goto bail_commit; 2744 } 2745 2746 di->i_flags &= ~cpu_to_le32(OCFS2_DIO_ORPHANED_FL); 2747 di->i_dio_orphaned_slot = 0; 2748 2749 if (update_isize) { 2750 status = ocfs2_set_inode_size(handle, inode, di_bh, end); 2751 if (status) 2752 mlog_errno(status); 2753 } else 2754 ocfs2_journal_dirty(handle, di_bh); 2755 2756 bail_commit: 2757 ocfs2_commit_trans(osb, handle); 2758 2759 bail_unlock_orphan: 2760 ocfs2_inode_unlock(orphan_dir_inode, 1); 2761 inode_unlock(orphan_dir_inode); 2762 brelse(orphan_dir_bh); 2763 iput(orphan_dir_inode); 2764 2765 bail: 2766 return status; 2767 } 2768 2769 int ocfs2_mv_orphaned_inode_to_new(struct inode *dir, 2770 struct inode *inode, 2771 struct dentry *dentry) 2772 { 2773 int status = 0; 2774 struct buffer_head *parent_di_bh = NULL; 2775 handle_t *handle = NULL; 2776 struct ocfs2_super *osb = OCFS2_SB(dir->i_sb); 2777 struct ocfs2_dinode *dir_di, *di; 2778 struct inode *orphan_dir_inode = NULL; 2779 struct buffer_head *orphan_dir_bh = NULL; 2780 struct buffer_head *di_bh = NULL; 2781 struct ocfs2_dir_lookup_result lookup = { NULL, }; 2782 2783 trace_ocfs2_mv_orphaned_inode_to_new(dir, dentry, 2784 dentry->d_name.len, dentry->d_name.name, 2785 (unsigned long long)OCFS2_I(dir)->ip_blkno, 2786 (unsigned long long)OCFS2_I(inode)->ip_blkno); 2787 2788 status = ocfs2_inode_lock(dir, &parent_di_bh, 1); 2789 if (status < 0) { 2790 if (status != -ENOENT) 2791 mlog_errno(status); 2792 return status; 2793 } 2794 2795 dir_di = (struct ocfs2_dinode *) parent_di_bh->b_data; 2796 if (!dir_di->i_links_count) { 2797 /* can't make a file in a deleted directory. */ 2798 status = -ENOENT; 2799 goto leave; 2800 } 2801 2802 status = ocfs2_check_dir_for_entry(dir, dentry->d_name.name, 2803 dentry->d_name.len); 2804 if (status) 2805 goto leave; 2806 2807 /* get a spot inside the dir. */ 2808 status = ocfs2_prepare_dir_for_insert(osb, dir, parent_di_bh, 2809 dentry->d_name.name, 2810 dentry->d_name.len, &lookup); 2811 if (status < 0) { 2812 mlog_errno(status); 2813 goto leave; 2814 } 2815 2816 orphan_dir_inode = ocfs2_get_system_file_inode(osb, 2817 ORPHAN_DIR_SYSTEM_INODE, 2818 osb->slot_num); 2819 if (!orphan_dir_inode) { 2820 status = -ENOENT; 2821 mlog_errno(status); 2822 goto leave; 2823 } 2824 2825 inode_lock(orphan_dir_inode); 2826 2827 status = ocfs2_inode_lock(orphan_dir_inode, &orphan_dir_bh, 1); 2828 if (status < 0) { 2829 mlog_errno(status); 2830 inode_unlock(orphan_dir_inode); 2831 iput(orphan_dir_inode); 2832 goto leave; 2833 } 2834 2835 status = ocfs2_read_inode_block(inode, &di_bh); 2836 if (status < 0) { 2837 mlog_errno(status); 2838 goto orphan_unlock; 2839 } 2840 2841 handle = ocfs2_start_trans(osb, ocfs2_rename_credits(osb->sb)); 2842 if (IS_ERR(handle)) { 2843 status = PTR_ERR(handle); 2844 handle = NULL; 2845 mlog_errno(status); 2846 goto orphan_unlock; 2847 } 2848 2849 status = ocfs2_journal_access_di(handle, INODE_CACHE(inode), 2850 di_bh, OCFS2_JOURNAL_ACCESS_WRITE); 2851 if (status < 0) { 2852 mlog_errno(status); 2853 goto out_commit; 2854 } 2855 2856 status = ocfs2_orphan_del(osb, handle, orphan_dir_inode, inode, 2857 orphan_dir_bh, false); 2858 if (status < 0) { 2859 mlog_errno(status); 2860 goto out_commit; 2861 } 2862 2863 di = (struct ocfs2_dinode *)di_bh->b_data; 2864 di->i_flags &= ~cpu_to_le32(OCFS2_ORPHANED_FL); 2865 di->i_orphaned_slot = 0; 2866 set_nlink(inode, 1); 2867 ocfs2_set_links_count(di, inode->i_nlink); 2868 ocfs2_update_inode_fsync_trans(handle, inode, 1); 2869 ocfs2_journal_dirty(handle, di_bh); 2870 2871 status = ocfs2_add_entry(handle, dentry, inode, 2872 OCFS2_I(inode)->ip_blkno, parent_di_bh, 2873 &lookup); 2874 if (status < 0) { 2875 mlog_errno(status); 2876 goto out_commit; 2877 } 2878 2879 status = ocfs2_dentry_attach_lock(dentry, inode, 2880 OCFS2_I(dir)->ip_blkno); 2881 if (status) { 2882 mlog_errno(status); 2883 goto out_commit; 2884 } 2885 2886 d_instantiate(dentry, inode); 2887 status = 0; 2888 out_commit: 2889 ocfs2_commit_trans(osb, handle); 2890 orphan_unlock: 2891 ocfs2_inode_unlock(orphan_dir_inode, 1); 2892 inode_unlock(orphan_dir_inode); 2893 iput(orphan_dir_inode); 2894 leave: 2895 2896 ocfs2_inode_unlock(dir, 1); 2897 2898 brelse(di_bh); 2899 brelse(parent_di_bh); 2900 brelse(orphan_dir_bh); 2901 2902 ocfs2_free_dir_lookup_result(&lookup); 2903 2904 if (status) 2905 mlog_errno(status); 2906 2907 return status; 2908 } 2909 2910 const struct inode_operations ocfs2_dir_iops = { 2911 .create = ocfs2_create, 2912 .lookup = ocfs2_lookup, 2913 .link = ocfs2_link, 2914 .unlink = ocfs2_unlink, 2915 .rmdir = ocfs2_unlink, 2916 .symlink = ocfs2_symlink, 2917 .mkdir = ocfs2_mkdir, 2918 .mknod = ocfs2_mknod, 2919 .rename = ocfs2_rename, 2920 .setattr = ocfs2_setattr, 2921 .getattr = ocfs2_getattr, 2922 .permission = ocfs2_permission, 2923 .listxattr = ocfs2_listxattr, 2924 .fiemap = ocfs2_fiemap, 2925 .get_acl = ocfs2_iop_get_acl, 2926 .set_acl = ocfs2_iop_set_acl, 2927 }; 2928