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