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