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