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