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