namei.c 55.8 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42
/* -*- mode: c; c-basic-offset: 8; -*-
 * vim: noexpandtab sw=8 ts=8 sts=0:
 *
 * namei.c
 *
 * Create and rename file, directory, symlinks
 *
 * Copyright (C) 2002, 2004 Oracle.  All rights reserved.
 *
 *  Portions of this code from linux/fs/ext3/dir.c
 *
 *  Copyright (C) 1992, 1993, 1994, 1995
 *  Remy Card (card@masi.ibp.fr)
 *  Laboratoire MASI - Institut Blaise pascal
 *  Universite Pierre et Marie Curie (Paris VI)
 *
 *   from
 *
 *   linux/fs/minix/dir.c
 *
 *   Copyright (C) 1991, 1992 Linux Torvalds
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public
 * License along with this program; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 021110-1307, USA.
 */

#include <linux/fs.h>
#include <linux/types.h>
#include <linux/slab.h>
#include <linux/highmem.h>
43
#include <linux/quotaops.h>
44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59

#define MLOG_MASK_PREFIX ML_NAMEI
#include <cluster/masklog.h>

#include "ocfs2.h"

#include "alloc.h"
#include "dcache.h"
#include "dir.h"
#include "dlmglue.h"
#include "extent_map.h"
#include "file.h"
#include "inode.h"
#include "journal.h"
#include "namei.h"
#include "suballoc.h"
60
#include "super.h"
61 62 63
#include "symlink.h"
#include "sysfile.h"
#include "uptodate.h"
T
Tiger Yang 已提交
64
#include "xattr.h"
T
Tiger Yang 已提交
65
#include "acl.h"
66 67 68 69 70

#include "buffer_head_io.h"

static int ocfs2_mknod_locked(struct ocfs2_super *osb,
			      struct inode *dir,
71
			      struct inode *inode,
72 73 74
			      dev_t dev,
			      struct buffer_head **new_fe_bh,
			      struct buffer_head *parent_fe_bh,
75
			      handle_t *handle,
76 77 78
			      struct ocfs2_alloc_context *inode_ac);

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 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116
				     struct inode *inode,
				     const char *symname);

/* An orphan dir name is an 8 byte value, printed as a hex string */
#define OCFS2_ORPHAN_NAMELEN ((int)(2 * sizeof(u64)))

static struct dentry *ocfs2_lookup(struct inode *dir, struct dentry *dentry,
				   struct nameidata *nd)
{
	int status;
	u64 blkno;
	struct inode *inode = NULL;
	struct dentry *ret;
	struct ocfs2_inode_info *oi;

	mlog_entry("(0x%p, 0x%p, '%.*s')\n", dir, dentry,
		   dentry->d_name.len, dentry->d_name.name);

	if (dentry->d_name.len > OCFS2_MAX_FILENAME_LEN) {
		ret = ERR_PTR(-ENAMETOOLONG);
		goto bail;
	}

117 118
	mlog(0, "find name %.*s in directory %llu\n", dentry->d_name.len,
	     dentry->d_name.name, (unsigned long long)OCFS2_I(dir)->ip_blkno);
119

J
Jan Kara 已提交
120
	status = ocfs2_inode_lock_nested(dir, NULL, 0, OI_LS_PARENT);
121 122 123 124 125 126 127
	if (status < 0) {
		if (status != -ENOENT)
			mlog_errno(status);
		ret = ERR_PTR(status);
		goto bail;
	}

128 129
	status = ocfs2_lookup_ino_from_name(dir, dentry->d_name.name,
					    dentry->d_name.len, &blkno);
130 131 132
	if (status < 0)
		goto bail_add;

J
Jan Kara 已提交
133
	inode = ocfs2_iget(OCFS2_SB(dir->i_sb), blkno, 0, 0);
134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152
	if (IS_ERR(inode)) {
		ret = ERR_PTR(-EACCES);
		goto bail_unlock;
	}

	oi = OCFS2_I(inode);
	/* Clear any orphaned state... If we were able to look up the
	 * inode from a directory, it certainly can't be orphaned. We
	 * might have the bad state from a node which intended to
	 * orphan this inode but crashed before it could commit the
	 * unlink. */
	spin_lock(&oi->ip_lock);
	oi->ip_flags &= ~OCFS2_INODE_MAYBE_ORPHANED;
	spin_unlock(&oi->ip_lock);

bail_add:
	dentry->d_op = &ocfs2_dentry_ops;
	ret = d_splice_alias(inode, dentry);

153 154 155 156 157 158 159 160 161 162 163 164 165 166 167
	if (inode) {
		/*
		 * If d_splice_alias() finds a DCACHE_DISCONNECTED
		 * dentry, it will d_move() it on top of ourse. The
		 * return value will indicate this however, so in
		 * those cases, we switch them around for the locking
		 * code.
		 *
		 * NOTE: This dentry already has ->d_op set from
		 * ocfs2_get_parent() and ocfs2_get_dentry()
		 */
		if (ret)
			dentry = ret;

		status = ocfs2_dentry_attach_lock(dentry, inode,
168
						  OCFS2_I(dir)->ip_blkno);
169 170 171 172 173 174 175
		if (status) {
			mlog_errno(status);
			ret = ERR_PTR(status);
			goto bail_unlock;
		}
	}

176 177 178 179
bail_unlock:
	/* Don't drop the cluster lock until *after* the d_add --
	 * unlink on another node will message us to remove that
	 * dentry under this lock so otherwise we can race this with
M
Mark Fasheh 已提交
180
	 * the downconvert thread and have a stale dentry. */
M
Mark Fasheh 已提交
181
	ocfs2_inode_unlock(dir, 0);
182 183 184 185 186 187 188 189

bail:

	mlog_exit_ptr(ret);

	return ret;
}

190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214
static struct inode *ocfs2_get_init_inode(struct inode *dir, int mode)
{
	struct inode *inode;

	inode = new_inode(dir->i_sb);
	if (!inode) {
		mlog(ML_ERROR, "new_inode failed!\n");
		return NULL;
	}

	/* populate as many fields early on as possible - many of
	 * these are used by the support functions here and in
	 * callers. */
	if (S_ISDIR(mode))
		inode->i_nlink = 2;
	else
		inode->i_nlink = 1;
	inode->i_uid = current_fsuid();
	if (dir->i_mode & S_ISGID) {
		inode->i_gid = dir->i_gid;
		if (S_ISDIR(mode))
			mode |= S_ISGID;
	} else
		inode->i_gid = current_fsgid();
	inode->i_mode = mode;
215
	dquot_initialize(inode);
216 217 218
	return inode;
}

219 220 221 222 223 224 225
static int ocfs2_mknod(struct inode *dir,
		       struct dentry *dentry,
		       int mode,
		       dev_t dev)
{
	int status = 0;
	struct buffer_head *parent_fe_bh = NULL;
226
	handle_t *handle = NULL;
227 228 229 230 231 232
	struct ocfs2_super *osb;
	struct ocfs2_dinode *dirfe;
	struct buffer_head *new_fe_bh = NULL;
	struct inode *inode = NULL;
	struct ocfs2_alloc_context *inode_ac = NULL;
	struct ocfs2_alloc_context *data_ac = NULL;
233
	struct ocfs2_alloc_context *meta_ac = NULL;
234
	int want_clusters = 0;
235
	int want_meta = 0;
236 237 238 239
	int xattr_credits = 0;
	struct ocfs2_security_xattr_info si = {
		.enable = 1,
	};
240
	int did_quota_inode = 0;
241
	struct ocfs2_dir_lookup_result lookup = { NULL, };
242 243
	sigset_t oldset;
	int did_block_signals = 0;
244 245 246 247 248

	mlog_entry("(0x%p, 0x%p, %d, %lu, '%.*s')\n", dir, dentry, mode,
		   (unsigned long)dev, dentry->d_name.len,
		   dentry->d_name.name);

249
	dquot_initialize(dir);
250

251 252 253
	/* get our super block */
	osb = OCFS2_SB(dir->i_sb);

M
Mark Fasheh 已提交
254
	status = ocfs2_inode_lock(dir, &parent_fe_bh, 1);
255 256 257 258 259 260
	if (status < 0) {
		if (status != -ENOENT)
			mlog_errno(status);
		return status;
	}

M
Mark Fasheh 已提交
261
	if (S_ISDIR(mode) && (dir->i_nlink >= ocfs2_link_max(osb))) {
262 263 264 265
		status = -EMLINK;
		goto leave;
	}

266
	dirfe = (struct ocfs2_dinode *) parent_fe_bh->b_data;
M
Mark Fasheh 已提交
267
	if (!ocfs2_read_links_count(dirfe)) {
268 269 270 271 272 273 274 275 276 277 278 279 280
		/* can't make a file in a deleted directory. */
		status = -ENOENT;
		goto leave;
	}

	status = ocfs2_check_dir_for_entry(dir, dentry->d_name.name,
					   dentry->d_name.len);
	if (status)
		goto leave;

	/* get a spot inside the dir. */
	status = ocfs2_prepare_dir_for_insert(osb, dir, parent_fe_bh,
					      dentry->d_name.name,
281
					      dentry->d_name.len, &lookup);
282 283 284 285 286 287
	if (status < 0) {
		mlog_errno(status);
		goto leave;
	}

	/* reserve an inode spot */
288
	status = ocfs2_reserve_new_inode(osb, &inode_ac);
289 290 291 292 293 294
	if (status < 0) {
		if (status != -ENOSPC)
			mlog_errno(status);
		goto leave;
	}

295 296 297 298 299 300 301
	inode = ocfs2_get_init_inode(dir, mode);
	if (!inode) {
		status = -ENOMEM;
		mlog_errno(status);
		goto leave;
	}

302 303 304 305 306 307 308 309 310 311 312
	/* get security xattr */
	status = ocfs2_init_security_get(inode, dir, &si);
	if (status) {
		if (status == -EOPNOTSUPP)
			si.enable = 0;
		else {
			mlog_errno(status);
			goto leave;
		}
	}

T
Tiger Yang 已提交
313 314
	/* calculate meta data/clusters for setting security and acl xattr */
	status = ocfs2_calc_xattr_init(dir, parent_fe_bh, mode,
315 316
				       &si, &want_clusters,
				       &xattr_credits, &want_meta);
T
Tiger Yang 已提交
317 318 319
	if (status < 0) {
		mlog_errno(status);
		goto leave;
320 321
	}

322
	/* Reserve a cluster if creating an extent based directory. */
323
	if (S_ISDIR(mode) && !ocfs2_supports_inline_data(osb)) {
324 325
		want_clusters += 1;

326
		/* Dir indexing requires extra space as well */
327
		if (ocfs2_supports_indexed_dirs(osb))
328 329 330 331 332 333 334 335 336 337
			want_meta++;
	}

	status = ocfs2_reserve_new_metadata_blocks(osb, want_meta, &meta_ac);
	if (status < 0) {
		if (status != -ENOSPC)
			mlog_errno(status);
		goto leave;
	}

338 339 340 341 342 343 344
	status = ocfs2_reserve_clusters(osb, want_clusters, &data_ac);
	if (status < 0) {
		if (status != -ENOSPC)
			mlog_errno(status);
		goto leave;
	}

345 346 347
	handle = ocfs2_start_trans(osb, ocfs2_mknod_credits(osb->sb,
							    S_ISDIR(mode),
							    xattr_credits));
348 349 350 351 352 353 354
	if (IS_ERR(handle)) {
		status = PTR_ERR(handle);
		handle = NULL;
		mlog_errno(status);
		goto leave;
	}

355 356 357 358
	/* Starting to change things, restart is no longer possible. */
	ocfs2_block_signals(&oldset);
	did_block_signals = 1;

359 360
	status = dquot_alloc_inode(inode);
	if (status)
361 362 363
		goto leave;
	did_quota_inode = 1;

364 365 366 367
	mlog_entry("(0x%p, 0x%p, %d, %lu, '%.*s')\n", dir, dentry,
		   inode->i_mode, (unsigned long)dev, dentry->d_name.len,
		   dentry->d_name.name);

368
	/* do the real work now. */
369
	status = ocfs2_mknod_locked(osb, dir, inode, dev,
370
				    &new_fe_bh, parent_fe_bh, handle,
371
				    inode_ac);
372 373 374 375 376 377 378
	if (status < 0) {
		mlog_errno(status);
		goto leave;
	}

	if (S_ISDIR(mode)) {
		status = ocfs2_fill_new_dir(osb, handle, dir, inode,
379
					    new_fe_bh, data_ac, meta_ac);
380 381 382 383 384
		if (status < 0) {
			mlog_errno(status);
			goto leave;
		}

385 386
		status = ocfs2_journal_access_di(handle, INODE_CACHE(dir),
						 parent_fe_bh,
387
						 OCFS2_JOURNAL_ACCESS_WRITE);
388 389 390 391
		if (status < 0) {
			mlog_errno(status);
			goto leave;
		}
M
Mark Fasheh 已提交
392
		ocfs2_add_links_count(dirfe, 1);
393
		ocfs2_journal_dirty(handle, parent_fe_bh);
394
		inc_nlink(dir);
395 396
	}

T
Tiger Yang 已提交
397
	status = ocfs2_init_acl(handle, inode, dir, new_fe_bh, parent_fe_bh,
398
				meta_ac, data_ac);
T
Tiger Yang 已提交
399 400 401 402 403
	if (status < 0) {
		mlog_errno(status);
		goto leave;
	}

404 405
	if (si.enable) {
		status = ocfs2_init_security_set(handle, inode, new_fe_bh, &si,
406
						 meta_ac, data_ac);
407 408 409 410 411 412
		if (status < 0) {
			mlog_errno(status);
			goto leave;
		}
	}

413 414 415 416 417 418 419 420
	/*
	 * Do this before adding the entry to the directory. We add
	 * also set d_op after success so that ->d_iput() will cleanup
	 * the dentry lock even if ocfs2_add_entry() fails below.
	 */
	status = ocfs2_dentry_attach_lock(dentry, inode,
					  OCFS2_I(dir)->ip_blkno);
	if (status) {
421 422 423
		mlog_errno(status);
		goto leave;
	}
424
	dentry->d_op = &ocfs2_dentry_ops;
425

426 427 428 429
	status = ocfs2_add_entry(handle, dentry, inode,
				 OCFS2_I(inode)->ip_blkno, parent_fe_bh,
				 &lookup);
	if (status < 0) {
430 431 432 433
		mlog_errno(status);
		goto leave;
	}

434 435 436 437
	insert_inode_hash(inode);
	d_instantiate(dentry, inode);
	status = 0;
leave:
438
	if (status < 0 && did_quota_inode)
439
		dquot_free_inode(inode);
440
	if (handle)
441
		ocfs2_commit_trans(osb, handle);
442

M
Mark Fasheh 已提交
443
	ocfs2_inode_unlock(dir, 1);
444 445
	if (did_block_signals)
		ocfs2_unblock_signals(&oldset);
446

447 448 449
	if (status == -ENOSPC)
		mlog(0, "Disk is full\n");

450 451
	brelse(new_fe_bh);
	brelse(parent_fe_bh);
452 453
	kfree(si.name);
	kfree(si.value);
454

455 456
	ocfs2_free_dir_lookup_result(&lookup);

457 458 459 460 461 462
	if (inode_ac)
		ocfs2_free_alloc_context(inode_ac);

	if (data_ac)
		ocfs2_free_alloc_context(data_ac);

463 464
	if (meta_ac)
		ocfs2_free_alloc_context(meta_ac);
465

466 467 468 469 470 471 472 473 474 475 476
	/*
	 * We should call iput after the i_mutex of the bitmap been
	 * unlocked in ocfs2_free_alloc_context, or the
	 * ocfs2_delete_inode will mutex_lock again.
	 */
	if ((status < 0) && inode) {
		OCFS2_I(inode)->ip_flags |= OCFS2_INODE_SKIP_ORPHAN_DIR;
		clear_nlink(inode);
		iput(inode);
	}

477 478 479 480 481 482 483
	mlog_exit(status);

	return status;
}

static int ocfs2_mknod_locked(struct ocfs2_super *osb,
			      struct inode *dir,
484
			      struct inode *inode,
485 486 487
			      dev_t dev,
			      struct buffer_head **new_fe_bh,
			      struct buffer_head *parent_fe_bh,
488
			      handle_t *handle,
489 490 491 492 493
			      struct ocfs2_alloc_context *inode_ac)
{
	int status = 0;
	struct ocfs2_dinode *fe = NULL;
	struct ocfs2_extent_list *fel;
494
	u64 suballoc_loc, fe_blkno = 0;
495
	u16 suballoc_bit;
496
	u16 feat;
497 498 499

	*new_fe_bh = NULL;

500
	status = ocfs2_claim_new_inode(handle, dir, parent_fe_bh,
501 502
				       inode_ac, &suballoc_loc,
				       &suballoc_bit, &fe_blkno);
503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522
	if (status < 0) {
		mlog_errno(status);
		goto leave;
	}

	/* populate as many fields early on as possible - many of
	 * these are used by the support functions here and in
	 * callers. */
	inode->i_ino = ino_from_blkno(osb->sb, fe_blkno);
	OCFS2_I(inode)->ip_blkno = fe_blkno;
	spin_lock(&osb->osb_lock);
	inode->i_generation = osb->s_next_generation++;
	spin_unlock(&osb->osb_lock);

	*new_fe_bh = sb_getblk(osb->sb, fe_blkno);
	if (!*new_fe_bh) {
		status = -EIO;
		mlog_errno(status);
		goto leave;
	}
523
	ocfs2_set_new_buffer_uptodate(INODE_CACHE(inode), *new_fe_bh);
524

525 526
	status = ocfs2_journal_access_di(handle, INODE_CACHE(inode),
					 *new_fe_bh,
527
					 OCFS2_JOURNAL_ACCESS_CREATE);
528 529 530 531 532 533 534 535 536 537 538
	if (status < 0) {
		mlog_errno(status);
		goto leave;
	}

	fe = (struct ocfs2_dinode *) (*new_fe_bh)->b_data;
	memset(fe, 0, osb->sb->s_blocksize);

	fe->i_generation = cpu_to_le32(inode->i_generation);
	fe->i_fs_generation = cpu_to_le32(osb->fs_generation);
	fe->i_blkno = cpu_to_le64(fe_blkno);
539
	fe->i_suballoc_loc = cpu_to_le64(suballoc_loc);
540
	fe->i_suballoc_bit = cpu_to_le16(suballoc_bit);
541
	fe->i_suballoc_slot = cpu_to_le16(inode_ac->ac_alloc_slot);
542 543 544 545
	fe->i_uid = cpu_to_le32(inode->i_uid);
	fe->i_gid = cpu_to_le32(inode->i_gid);
	fe->i_mode = cpu_to_le16(inode->i_mode);
	if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
546
		fe->id1.dev1.i_rdev = cpu_to_le64(huge_encode_dev(dev));
M
Mark Fasheh 已提交
547 548

	ocfs2_set_links_count(fe, inode->i_nlink);
549 550 551 552 553 554 555 556 557 558

	fe->i_last_eb_blk = 0;
	strcpy(fe->i_signature, OCFS2_INODE_SIGNATURE);
	le32_add_cpu(&fe->i_flags, OCFS2_VALID_FL);
	fe->i_atime = fe->i_ctime = fe->i_mtime =
		cpu_to_le64(CURRENT_TIME.tv_sec);
	fe->i_mtime_nsec = fe->i_ctime_nsec = fe->i_atime_nsec =
		cpu_to_le32(CURRENT_TIME.tv_nsec);
	fe->i_dtime = 0;

559
	/*
560 561
	 * If supported, directories start with inline data. If inline
	 * isn't supported, but indexing is, we start them as indexed.
562
	 */
563
	feat = le16_to_cpu(fe->i_dyn_features);
564
	if (S_ISDIR(inode->i_mode) && ocfs2_supports_inline_data(osb)) {
565 566
		fe->i_dyn_features = cpu_to_le16(feat | OCFS2_INLINE_DATA_FL);

567 568
		fe->id2.i_data.id_count = cpu_to_le16(
				ocfs2_max_inline_data_with_xattr(osb->sb, fe));
569 570 571 572 573 574
	} else {
		fel = &fe->id2.i_list;
		fel->l_tree_depth = 0;
		fel->l_next_free_rec = 0;
		fel->l_count = cpu_to_le16(ocfs2_extent_recs_per_inode(osb->sb));
	}
575

576
	ocfs2_journal_dirty(handle, *new_fe_bh);
577

578
	ocfs2_populate_inode(inode, fe, 1);
579
	ocfs2_ci_set_new(osb, INODE_CACHE(inode));
S
Sunil Mushran 已提交
580 581 582 583 584
	if (!ocfs2_mount_local(osb)) {
		status = ocfs2_create_new_inode_locks(inode);
		if (status < 0)
			mlog_errno(status);
	}
585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633

	status = 0; /* error in ocfs2_create_new_inode_locks is not
		     * critical */

leave:
	if (status < 0) {
		if (*new_fe_bh) {
			brelse(*new_fe_bh);
			*new_fe_bh = NULL;
		}
	}

	mlog_exit(status);
	return status;
}

static int ocfs2_mkdir(struct inode *dir,
		       struct dentry *dentry,
		       int mode)
{
	int ret;

	mlog_entry("(0x%p, 0x%p, %d, '%.*s')\n", dir, dentry, mode,
		   dentry->d_name.len, dentry->d_name.name);
	ret = ocfs2_mknod(dir, dentry, mode | S_IFDIR, 0);
	mlog_exit(ret);

	return ret;
}

static int ocfs2_create(struct inode *dir,
			struct dentry *dentry,
			int mode,
			struct nameidata *nd)
{
	int ret;

	mlog_entry("(0x%p, 0x%p, %d, '%.*s')\n", dir, dentry, mode,
		   dentry->d_name.len, dentry->d_name.name);
	ret = ocfs2_mknod(dir, dentry, mode | S_IFREG, 0);
	mlog_exit(ret);

	return ret;
}

static int ocfs2_link(struct dentry *old_dentry,
		      struct inode *dir,
		      struct dentry *dentry)
{
634
	handle_t *handle;
635 636 637 638 639 640
	struct inode *inode = old_dentry->d_inode;
	int err;
	struct buffer_head *fe_bh = NULL;
	struct buffer_head *parent_fe_bh = NULL;
	struct ocfs2_dinode *fe = NULL;
	struct ocfs2_super *osb = OCFS2_SB(dir->i_sb);
641
	struct ocfs2_dir_lookup_result lookup = { NULL, };
642
	sigset_t oldset;
643 644 645 646 647

	mlog_entry("(inode=%lu, old='%.*s' new='%.*s')\n", inode->i_ino,
		   old_dentry->d_name.len, old_dentry->d_name.name,
		   dentry->d_name.len, dentry->d_name.name);

648 649
	if (S_ISDIR(inode->i_mode))
		return -EPERM;
650

651
	dquot_initialize(dir);
652

J
Jan Kara 已提交
653
	err = ocfs2_inode_lock_nested(dir, &parent_fe_bh, 1, OI_LS_PARENT);
654 655 656
	if (err < 0) {
		if (err != -ENOENT)
			mlog_errno(err);
657
		return err;
658 659
	}

660 661
	if (!dir->i_nlink) {
		err = -ENOENT;
662
		goto out;
663 664
	}

665 666 667
	err = ocfs2_check_dir_for_entry(dir, dentry->d_name.name,
					dentry->d_name.len);
	if (err)
668
		goto out;
669 670 671

	err = ocfs2_prepare_dir_for_insert(osb, dir, parent_fe_bh,
					   dentry->d_name.name,
672
					   dentry->d_name.len, &lookup);
673 674
	if (err < 0) {
		mlog_errno(err);
675
		goto out;
676 677
	}

M
Mark Fasheh 已提交
678
	err = ocfs2_inode_lock(inode, &fe_bh, 1);
679 680 681
	if (err < 0) {
		if (err != -ENOENT)
			mlog_errno(err);
682
		goto out;
683 684 685
	}

	fe = (struct ocfs2_dinode *) fe_bh->b_data;
M
Mark Fasheh 已提交
686
	if (ocfs2_read_links_count(fe) >= ocfs2_link_max(osb)) {
687
		err = -EMLINK;
688
		goto out_unlock_inode;
689 690
	}

691
	handle = ocfs2_start_trans(osb, ocfs2_link_credits(osb->sb));
692 693 694 695
	if (IS_ERR(handle)) {
		err = PTR_ERR(handle);
		handle = NULL;
		mlog_errno(err);
696
		goto out_unlock_inode;
697 698
	}

699 700 701
	/* Starting to change things, restart is no longer possible. */
	ocfs2_block_signals(&oldset);

702
	err = ocfs2_journal_access_di(handle, INODE_CACHE(inode), fe_bh,
703
				      OCFS2_JOURNAL_ACCESS_WRITE);
704 705
	if (err < 0) {
		mlog_errno(err);
706
		goto out_commit;
707 708
	}

709
	inc_nlink(inode);
710
	inode->i_ctime = CURRENT_TIME;
M
Mark Fasheh 已提交
711
	ocfs2_set_links_count(fe, inode->i_nlink);
712 713
	fe->i_ctime = cpu_to_le64(inode->i_ctime.tv_sec);
	fe->i_ctime_nsec = cpu_to_le32(inode->i_ctime.tv_nsec);
714
	ocfs2_journal_dirty(handle, fe_bh);
715 716 717

	err = ocfs2_add_entry(handle, dentry, inode,
			      OCFS2_I(inode)->ip_blkno,
718
			      parent_fe_bh, &lookup);
719
	if (err) {
M
Mark Fasheh 已提交
720
		ocfs2_add_links_count(fe, -1);
721
		drop_nlink(inode);
722
		mlog_errno(err);
723
		goto out_commit;
724 725
	}

726
	err = ocfs2_dentry_attach_lock(dentry, inode, OCFS2_I(dir)->ip_blkno);
727 728
	if (err) {
		mlog_errno(err);
729
		goto out_commit;
730 731
	}

732 733 734
	atomic_inc(&inode->i_count);
	dentry->d_op = &ocfs2_dentry_ops;
	d_instantiate(dentry, inode);
735 736

out_commit:
737
	ocfs2_commit_trans(osb, handle);
738
	ocfs2_unblock_signals(&oldset);
739
out_unlock_inode:
M
Mark Fasheh 已提交
740
	ocfs2_inode_unlock(inode, 1);
741 742

out:
M
Mark Fasheh 已提交
743
	ocfs2_inode_unlock(dir, 1);
744

745 746
	brelse(fe_bh);
	brelse(parent_fe_bh);
747

748 749
	ocfs2_free_dir_lookup_result(&lookup);

750 751 752 753 754
	mlog_exit(err);

	return err;
}

755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771
/*
 * Takes and drops an exclusive lock on the given dentry. This will
 * force other nodes to drop it.
 */
static int ocfs2_remote_dentry_delete(struct dentry *dentry)
{
	int ret;

	ret = ocfs2_dentry_lock(dentry, 1);
	if (ret)
		mlog_errno(ret);
	else
		ocfs2_dentry_unlock(dentry, 1);

	return ret;
}

772 773 774 775 776 777 778 779 780 781 782 783 784
static inline int inode_is_unlinkable(struct inode *inode)
{
	if (S_ISDIR(inode->i_mode)) {
		if (inode->i_nlink == 2)
			return 1;
		return 0;
	}

	if (inode->i_nlink == 1)
		return 1;
	return 0;
}

785 786 787 788
static int ocfs2_unlink(struct inode *dir,
			struct dentry *dentry)
{
	int status;
789
	int child_locked = 0;
790
	struct inode *inode = dentry->d_inode;
791
	struct inode *orphan_dir = NULL;
792 793 794 795 796
	struct ocfs2_super *osb = OCFS2_SB(dir->i_sb);
	u64 blkno;
	struct ocfs2_dinode *fe = NULL;
	struct buffer_head *fe_bh = NULL;
	struct buffer_head *parent_node_bh = NULL;
797
	handle_t *handle = NULL;
798
	char orphan_name[OCFS2_ORPHAN_NAMELEN + 1];
799 800
	struct ocfs2_dir_lookup_result lookup = { NULL, };
	struct ocfs2_dir_lookup_result orphan_insert = { NULL, };
801 802 803 804

	mlog_entry("(0x%p, 0x%p, '%.*s')\n", dir, dentry,
		   dentry->d_name.len, dentry->d_name.name);

805
	dquot_initialize(dir);
806

807 808
	BUG_ON(dentry->d_parent->d_inode != dir);

809
	mlog(0, "ino = %llu\n", (unsigned long long)OCFS2_I(inode)->ip_blkno);
810 811 812

	if (inode == osb->root_inode) {
		mlog(0, "Cannot delete the root directory\n");
813
		return -EPERM;
814 815
	}

J
Jan Kara 已提交
816 817
	status = ocfs2_inode_lock_nested(dir, &parent_node_bh, 1,
					 OI_LS_PARENT);
818 819 820
	if (status < 0) {
		if (status != -ENOENT)
			mlog_errno(status);
821
		return status;
822 823 824
	}

	status = ocfs2_find_files_on_disk(dentry->d_name.name,
825 826
					  dentry->d_name.len, &blkno, dir,
					  &lookup);
827 828 829 830 831 832 833 834 835
	if (status < 0) {
		if (status != -ENOENT)
			mlog_errno(status);
		goto leave;
	}

	if (OCFS2_I(inode)->ip_blkno != blkno) {
		status = -ENOENT;

836 837 838
		mlog(0, "ip_blkno %llu != dirent blkno %llu ip_flags = %x\n",
		     (unsigned long long)OCFS2_I(inode)->ip_blkno,
		     (unsigned long long)blkno, OCFS2_I(inode)->ip_flags);
839 840 841
		goto leave;
	}

M
Mark Fasheh 已提交
842
	status = ocfs2_inode_lock(inode, &fe_bh, 1);
843 844 845 846 847
	if (status < 0) {
		if (status != -ENOENT)
			mlog_errno(status);
		goto leave;
	}
848
	child_locked = 1;
849 850

	if (S_ISDIR(inode->i_mode)) {
851
		if (inode->i_nlink != 2 || !ocfs2_empty_dir(inode)) {
852 853 854 855 856
			status = -ENOTEMPTY;
			goto leave;
		}
	}

857
	status = ocfs2_remote_dentry_delete(dentry);
858
	if (status < 0) {
M
Mark Fasheh 已提交
859
		/* This remote delete should succeed under all normal
860 861 862 863 864
		 * circumstances. */
		mlog_errno(status);
		goto leave;
	}

865
	if (inode_is_unlinkable(inode)) {
866 867
		status = ocfs2_prepare_orphan_dir(osb, &orphan_dir,
						  OCFS2_I(inode)->ip_blkno,
868
						  orphan_name, &orphan_insert);
869 870 871 872 873 874
		if (status < 0) {
			mlog_errno(status);
			goto leave;
		}
	}

875
	handle = ocfs2_start_trans(osb, ocfs2_unlink_credits(osb->sb));
876 877 878 879 880 881 882
	if (IS_ERR(handle)) {
		status = PTR_ERR(handle);
		handle = NULL;
		mlog_errno(status);
		goto leave;
	}

883
	status = ocfs2_journal_access_di(handle, INODE_CACHE(inode), fe_bh,
884
					 OCFS2_JOURNAL_ACCESS_WRITE);
885 886 887 888 889 890 891
	if (status < 0) {
		mlog_errno(status);
		goto leave;
	}

	fe = (struct ocfs2_dinode *) fe_bh->b_data;

892
	if (inode_is_unlinkable(inode)) {
893
		status = ocfs2_orphan_add(osb, handle, inode, fe_bh, orphan_name,
894
					  &orphan_insert, orphan_dir);
895 896 897 898 899 900 901
		if (status < 0) {
			mlog_errno(status);
			goto leave;
		}
	}

	/* delete the name from the parent dir */
902
	status = ocfs2_delete_entry(handle, dir, &lookup);
903 904 905 906 907
	if (status < 0) {
		mlog_errno(status);
		goto leave;
	}

908 909 910
	if (S_ISDIR(inode->i_mode))
		drop_nlink(inode);
	drop_nlink(inode);
M
Mark Fasheh 已提交
911
	ocfs2_set_links_count(fe, inode->i_nlink);
912
	ocfs2_journal_dirty(handle, fe_bh);
913

914 915
	dir->i_ctime = dir->i_mtime = CURRENT_TIME;
	if (S_ISDIR(inode->i_mode))
916
		drop_nlink(dir);
917 918 919 920 921

	status = ocfs2_mark_inode_dirty(handle, dir, parent_node_bh);
	if (status < 0) {
		mlog_errno(status);
		if (S_ISDIR(inode->i_mode))
922
			inc_nlink(dir);
923 924 925 926
	}

leave:
	if (handle)
927
		ocfs2_commit_trans(osb, handle);
928

929
	if (child_locked)
M
Mark Fasheh 已提交
930
		ocfs2_inode_unlock(inode, 1);
931

M
Mark Fasheh 已提交
932
	ocfs2_inode_unlock(dir, 1);
933

934 935
	if (orphan_dir) {
		/* This was locked for us in ocfs2_prepare_orphan_dir() */
M
Mark Fasheh 已提交
936
		ocfs2_inode_unlock(orphan_dir, 1);
937 938 939 940
		mutex_unlock(&orphan_dir->i_mutex);
		iput(orphan_dir);
	}

941 942
	brelse(fe_bh);
	brelse(parent_node_bh);
943 944 945

	ocfs2_free_dir_lookup_result(&orphan_insert);
	ocfs2_free_dir_lookup_result(&lookup);
946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967

	mlog_exit(status);

	return status;
}

/*
 * The only place this should be used is rename!
 * if they have the same id, then the 1st one is the only one locked.
 */
static int ocfs2_double_lock(struct ocfs2_super *osb,
			     struct buffer_head **bh1,
			     struct inode *inode1,
			     struct buffer_head **bh2,
			     struct inode *inode2)
{
	int status;
	struct ocfs2_inode_info *oi1 = OCFS2_I(inode1);
	struct ocfs2_inode_info *oi2 = OCFS2_I(inode2);
	struct buffer_head **tmpbh;
	struct inode *tmpinode;

968 969 970
	mlog_entry("(inode1 = %llu, inode2 = %llu)\n",
		   (unsigned long long)oi1->ip_blkno,
		   (unsigned long long)oi2->ip_blkno);
971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990

	if (*bh1)
		*bh1 = NULL;
	if (*bh2)
		*bh2 = NULL;

	/* we always want to lock the one with the lower lockid first. */
	if (oi1->ip_blkno != oi2->ip_blkno) {
		if (oi1->ip_blkno < oi2->ip_blkno) {
			/* switch id1 and id2 around */
			mlog(0, "switching them around...\n");
			tmpbh = bh2;
			bh2 = bh1;
			bh1 = tmpbh;

			tmpinode = inode2;
			inode2 = inode1;
			inode1 = tmpinode;
		}
		/* lock id2 */
J
Jan Kara 已提交
991 992
		status = ocfs2_inode_lock_nested(inode2, bh2, 1,
						 OI_LS_RENAME1);
993 994 995 996 997 998
		if (status < 0) {
			if (status != -ENOENT)
				mlog_errno(status);
			goto bail;
		}
	}
999

1000
	/* lock id1 */
J
Jan Kara 已提交
1001
	status = ocfs2_inode_lock_nested(inode1, bh1, 1, OI_LS_RENAME2);
1002
	if (status < 0) {
1003 1004 1005 1006 1007
		/*
		 * An error return must mean that no cluster locks
		 * were held on function exit.
		 */
		if (oi1->ip_blkno != oi2->ip_blkno)
M
Mark Fasheh 已提交
1008
			ocfs2_inode_unlock(inode2, 1);
1009

1010 1011 1012
		if (status != -ENOENT)
			mlog_errno(status);
	}
1013

1014 1015 1016 1017 1018
bail:
	mlog_exit(status);
	return status;
}

1019 1020
static void ocfs2_double_unlock(struct inode *inode1, struct inode *inode2)
{
M
Mark Fasheh 已提交
1021
	ocfs2_inode_unlock(inode1, 1);
1022 1023

	if (inode1 != inode2)
M
Mark Fasheh 已提交
1024
		ocfs2_inode_unlock(inode2, 1);
1025 1026
}

1027 1028 1029 1030 1031
static int ocfs2_rename(struct inode *old_dir,
			struct dentry *old_dentry,
			struct inode *new_dir,
			struct dentry *new_dentry)
{
1032 1033
	int status = 0, rename_lock = 0, parents_locked = 0, target_exists = 0;
	int old_child_locked = 0, new_child_locked = 0, update_dot_dot = 0;
1034 1035
	struct inode *old_inode = old_dentry->d_inode;
	struct inode *new_inode = new_dentry->d_inode;
1036
	struct inode *orphan_dir = NULL;
1037 1038 1039
	struct ocfs2_dinode *newfe = NULL;
	char orphan_name[OCFS2_ORPHAN_NAMELEN + 1];
	struct buffer_head *newfe_bh = NULL;
1040
	struct buffer_head *old_inode_bh = NULL;
1041
	struct ocfs2_super *osb = NULL;
1042
	u64 newfe_blkno, old_de_ino;
1043
	handle_t *handle = NULL;
1044 1045
	struct buffer_head *old_dir_bh = NULL;
	struct buffer_head *new_dir_bh = NULL;
1046
	nlink_t old_dir_nlink = old_dir->i_nlink;
S
Sunil Mushran 已提交
1047
	struct ocfs2_dinode *old_di;
1048 1049 1050 1051 1052
	struct ocfs2_dir_lookup_result old_inode_dot_dot_res = { NULL, };
	struct ocfs2_dir_lookup_result target_lookup_res = { NULL, };
	struct ocfs2_dir_lookup_result old_entry_lookup = { NULL, };
	struct ocfs2_dir_lookup_result orphan_insert = { NULL, };
	struct ocfs2_dir_lookup_result target_insert = { NULL, };
1053 1054 1055 1056 1057 1058 1059 1060 1061

	/* At some point it might be nice to break this function up a
	 * bit. */

	mlog_entry("(0x%p, 0x%p, 0x%p, 0x%p, from='%.*s' to='%.*s')\n",
		   old_dir, old_dentry, new_dir, new_dentry,
		   old_dentry->d_name.len, old_dentry->d_name.name,
		   new_dentry->d_name.len, new_dentry->d_name.name);

1062 1063
	dquot_initialize(old_dir);
	dquot_initialize(new_dir);
1064

1065 1066 1067 1068 1069 1070 1071
	osb = OCFS2_SB(old_dir->i_sb);

	if (new_inode) {
		if (!igrab(new_inode))
			BUG();
	}

1072
	/* Assume a directory hierarchy thusly:
1073 1074 1075 1076 1077 1078 1079 1080 1081 1082
	 * a/b/c
	 * a/d
	 * a,b,c, and d are all directories.
	 *
	 * from cwd of 'a' on both nodes:
	 * node1: mv b/c d
	 * node2: mv d   b/c
	 *
	 * And that's why, just like the VFS, we need a file system
	 * rename lock. */
J
Jan Kara 已提交
1083
	if (old_dir != new_dir && S_ISDIR(old_inode->i_mode)) {
1084 1085 1086 1087 1088 1089 1090 1091 1092
		status = ocfs2_rename_lock(osb);
		if (status < 0) {
			mlog_errno(status);
			goto bail;
		}
		rename_lock = 1;
	}

	/* if old and new are the same, this'll just do one lock. */
1093 1094
	status = ocfs2_double_lock(osb, &old_dir_bh, old_dir,
				   &new_dir_bh, new_dir);
1095 1096 1097 1098
	if (status < 0) {
		mlog_errno(status);
		goto bail;
	}
1099
	parents_locked = 1;
1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113

	/* make sure both dirs have bhs
	 * get an extra ref on old_dir_bh if old==new */
	if (!new_dir_bh) {
		if (old_dir_bh) {
			new_dir_bh = old_dir_bh;
			get_bh(new_dir_bh);
		} else {
			mlog(ML_ERROR, "no old_dir_bh!\n");
			status = -EIO;
			goto bail;
		}
	}

1114
	/*
1115
	 * Aside from allowing a meta data update, the locking here
M
Mark Fasheh 已提交
1116 1117 1118
	 * also ensures that the downconvert thread on other nodes
	 * won't have to concurrently downconvert the inode and the
	 * dentry locks.
1119
	 */
J
Jan Kara 已提交
1120 1121
	status = ocfs2_inode_lock_nested(old_inode, &old_inode_bh, 1,
					 OI_LS_PARENT);
1122 1123
	if (status < 0) {
		if (status != -ENOENT)
1124
			mlog_errno(status);
1125 1126
		goto bail;
	}
1127
	old_child_locked = 1;
1128

1129 1130 1131 1132 1133 1134 1135
	status = ocfs2_remote_dentry_delete(old_dentry);
	if (status < 0) {
		mlog_errno(status);
		goto bail;
	}

	if (S_ISDIR(old_inode->i_mode)) {
M
Mark Fasheh 已提交
1136 1137
		u64 old_inode_parent;

1138
		update_dot_dot = 1;
M
Mark Fasheh 已提交
1139
		status = ocfs2_find_files_on_disk("..", 2, &old_inode_parent,
1140 1141
						  old_inode,
						  &old_inode_dot_dot_res);
M
Mark Fasheh 已提交
1142 1143
		if (status) {
			status = -EIO;
1144
			goto bail;
M
Mark Fasheh 已提交
1145
		}
1146

M
Mark Fasheh 已提交
1147 1148
		if (old_inode_parent != OCFS2_I(old_dir)->ip_blkno) {
			status = -EIO;
1149
			goto bail;
M
Mark Fasheh 已提交
1150 1151 1152
		}

		if (!new_inode && new_dir != old_dir &&
M
Mark Fasheh 已提交
1153
		    new_dir->i_nlink >= ocfs2_link_max(osb)) {
M
Mark Fasheh 已提交
1154
			status = -EMLINK;
1155
			goto bail;
M
Mark Fasheh 已提交
1156
		}
1157 1158
	}

1159 1160 1161 1162 1163
	status = ocfs2_lookup_ino_from_name(old_dir, old_dentry->d_name.name,
					    old_dentry->d_name.len,
					    &old_de_ino);
	if (status) {
		status = -ENOENT;
1164
		goto bail;
1165
	}
1166 1167 1168 1169 1170 1171 1172

	/*
	 *  Check for inode number is _not_ due to possible IO errors.
	 *  We might rmdir the source, keep it as pwd of some process
	 *  and merrily kill the link to whatever was created under the
	 *  same name. Goodbye sticky bit ;-<
	 */
1173 1174
	if (old_de_ino != OCFS2_I(old_inode)->ip_blkno) {
		status = -ENOENT;
1175
		goto bail;
1176
	}
1177 1178 1179 1180 1181

	/* check if the target already exists (in which case we need
	 * to delete it */
	status = ocfs2_find_files_on_disk(new_dentry->d_name.name,
					  new_dentry->d_name.len,
1182 1183
					  &newfe_blkno, new_dir,
					  &target_lookup_res);
1184 1185 1186 1187 1188 1189 1190 1191
	/* The only error we allow here is -ENOENT because the new
	 * file not existing is perfectly valid. */
	if ((status < 0) && (status != -ENOENT)) {
		/* If we cannot find the file specified we should just */
		/* return the error... */
		mlog_errno(status);
		goto bail;
	}
1192 1193
	if (status == 0)
		target_exists = 1;
1194

1195
	if (!target_exists && new_inode) {
S
Srinivas Eeda 已提交
1196 1197 1198 1199 1200 1201 1202 1203 1204
		/*
		 * Target was unlinked by another node while we were
		 * waiting to get to ocfs2_rename(). There isn't
		 * anything we can do here to help the situation, so
		 * bubble up the appropriate error.
		 */
		status = -ENOENT;
		goto bail;
	}
1205 1206 1207

	/* In case we need to overwrite an existing file, we blow it
	 * away first */
1208
	if (target_exists) {
1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225
		/* VFS didn't think there existed an inode here, but
		 * someone else in the cluster must have raced our
		 * rename to create one. Today we error cleanly, in
		 * the future we should consider calling iget to build
		 * a new struct inode for this entry. */
		if (!new_inode) {
			status = -EACCES;

			mlog(0, "We found an inode for name %.*s but VFS "
			     "didn't give us one.\n", new_dentry->d_name.len,
			     new_dentry->d_name.name);
			goto bail;
		}

		if (OCFS2_I(new_inode)->ip_blkno != newfe_blkno) {
			status = -EACCES;

1226 1227 1228
			mlog(0, "Inode %llu and dir %llu disagree. flags = %x\n",
			     (unsigned long long)OCFS2_I(new_inode)->ip_blkno,
			     (unsigned long long)newfe_blkno,
1229 1230 1231 1232
			     OCFS2_I(new_inode)->ip_flags);
			goto bail;
		}

M
Mark Fasheh 已提交
1233
		status = ocfs2_inode_lock(new_inode, &newfe_bh, 1);
1234 1235 1236 1237 1238
		if (status < 0) {
			if (status != -ENOENT)
				mlog_errno(status);
			goto bail;
		}
1239
		new_child_locked = 1;
1240

1241
		status = ocfs2_remote_dentry_delete(new_dentry);
1242 1243 1244 1245 1246 1247 1248
		if (status < 0) {
			mlog_errno(status);
			goto bail;
		}

		newfe = (struct ocfs2_dinode *) newfe_bh->b_data;

1249 1250
		mlog(0, "aha rename over existing... new_blkno=%llu "
		     "newfebh=%p bhblocknr=%llu\n",
1251
		     (unsigned long long)newfe_blkno, newfe_bh, newfe_bh ?
1252 1253 1254
		     (unsigned long long)newfe_bh->b_blocknr : 0ULL);

		if (S_ISDIR(new_inode->i_mode) || (new_inode->i_nlink == 1)) {
1255
			status = ocfs2_prepare_orphan_dir(osb, &orphan_dir,
1256 1257
						OCFS2_I(new_inode)->ip_blkno,
						orphan_name, &orphan_insert);
1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274
			if (status < 0) {
				mlog_errno(status);
				goto bail;
			}
		}
	} else {
		BUG_ON(new_dentry->d_parent->d_inode != new_dir);

		status = ocfs2_check_dir_for_entry(new_dir,
						   new_dentry->d_name.name,
						   new_dentry->d_name.len);
		if (status)
			goto bail;

		status = ocfs2_prepare_dir_for_insert(osb, new_dir, new_dir_bh,
						      new_dentry->d_name.name,
						      new_dentry->d_name.len,
1275
						      &target_insert);
1276 1277 1278 1279 1280 1281
		if (status < 0) {
			mlog_errno(status);
			goto bail;
		}
	}

1282
	handle = ocfs2_start_trans(osb, ocfs2_rename_credits(osb->sb));
1283 1284 1285 1286 1287 1288 1289
	if (IS_ERR(handle)) {
		status = PTR_ERR(handle);
		handle = NULL;
		mlog_errno(status);
		goto bail;
	}

1290
	if (target_exists) {
1291
		if (S_ISDIR(new_inode->i_mode)) {
1292 1293
			if (new_inode->i_nlink != 2 ||
			    !ocfs2_empty_dir(new_inode)) {
1294 1295 1296 1297
				status = -ENOTEMPTY;
				goto bail;
			}
		}
1298 1299
		status = ocfs2_journal_access_di(handle, INODE_CACHE(new_inode),
						 newfe_bh,
1300
						 OCFS2_JOURNAL_ACCESS_WRITE);
1301 1302 1303 1304 1305 1306
		if (status < 0) {
			mlog_errno(status);
			goto bail;
		}

		if (S_ISDIR(new_inode->i_mode) ||
M
Mark Fasheh 已提交
1307
		    (ocfs2_read_links_count(newfe) == 1)) {
1308
			status = ocfs2_orphan_add(osb, handle, new_inode,
1309
						  newfe_bh, orphan_name,
1310
						  &orphan_insert, orphan_dir);
1311 1312 1313 1314 1315 1316 1317
			if (status < 0) {
				mlog_errno(status);
				goto bail;
			}
		}

		/* change the dirent to point to the correct inode */
1318 1319
		status = ocfs2_update_entry(new_dir, handle, &target_lookup_res,
					    old_inode);
1320 1321 1322 1323 1324 1325 1326
		if (status < 0) {
			mlog_errno(status);
			goto bail;
		}
		new_dir->i_version++;

		if (S_ISDIR(new_inode->i_mode))
M
Mark Fasheh 已提交
1327
			ocfs2_set_links_count(newfe, 0);
1328
		else
M
Mark Fasheh 已提交
1329
			ocfs2_add_links_count(newfe, -1);
1330
		ocfs2_journal_dirty(handle, newfe_bh);
1331 1332 1333 1334
	} else {
		/* if the name was not found in new_dir, add it now */
		status = ocfs2_add_entry(handle, new_dentry, old_inode,
					 OCFS2_I(old_inode)->ip_blkno,
1335
					 new_dir_bh, &target_insert);
1336 1337 1338 1339
	}

	old_inode->i_ctime = CURRENT_TIME;
	mark_inode_dirty(old_inode);
S
Sunil Mushran 已提交
1340

1341 1342
	status = ocfs2_journal_access_di(handle, INODE_CACHE(old_inode),
					 old_inode_bh,
1343
					 OCFS2_JOURNAL_ACCESS_WRITE);
S
Sunil Mushran 已提交
1344 1345 1346 1347 1348
	if (status >= 0) {
		old_di = (struct ocfs2_dinode *) old_inode_bh->b_data;

		old_di->i_ctime = cpu_to_le64(old_inode->i_ctime.tv_sec);
		old_di->i_ctime_nsec = cpu_to_le32(old_inode->i_ctime.tv_nsec);
1349
		ocfs2_journal_dirty(handle, old_inode_bh);
S
Sunil Mushran 已提交
1350 1351
	} else
		mlog_errno(status);
1352

1353 1354 1355 1356 1357 1358 1359
	/*
	 * Now that the name has been added to new_dir, remove the old name.
	 *
	 * We don't keep any directory entry context around until now
	 * because the insert might have changed the type of directory
	 * we're dealing with.
	 */
1360 1361 1362 1363
	status = ocfs2_find_entry(old_dentry->d_name.name,
				  old_dentry->d_name.len, old_dir,
				  &old_entry_lookup);
	if (status)
1364 1365
		goto bail;

1366
	status = ocfs2_delete_entry(handle, old_dir, &old_entry_lookup);
1367 1368 1369 1370 1371 1372 1373 1374 1375 1376
	if (status < 0) {
		mlog_errno(status);
		goto bail;
	}

	if (new_inode) {
		new_inode->i_nlink--;
		new_inode->i_ctime = CURRENT_TIME;
	}
	old_dir->i_ctime = old_dir->i_mtime = CURRENT_TIME;
1377 1378 1379 1380

	if (update_dot_dot) {
		status = ocfs2_update_entry(old_inode, handle,
					    &old_inode_dot_dot_res, new_dir);
1381 1382 1383 1384
		old_dir->i_nlink--;
		if (new_inode) {
			new_inode->i_nlink--;
		} else {
1385
			inc_nlink(new_dir);
1386 1387 1388 1389
			mark_inode_dirty(new_dir);
		}
	}
	mark_inode_dirty(old_dir);
1390 1391
	ocfs2_mark_inode_dirty(handle, old_dir, old_dir_bh);
	if (new_inode) {
1392
		mark_inode_dirty(new_inode);
1393 1394
		ocfs2_mark_inode_dirty(handle, new_inode, newfe_bh);
	}
1395

1396 1397 1398 1399 1400 1401 1402 1403 1404 1405
	if (old_dir != new_dir) {
		/* Keep the same times on both directories.*/
		new_dir->i_ctime = new_dir->i_mtime = old_dir->i_ctime;

		/*
		 * This will also pick up the i_nlink change from the
		 * block above.
		 */
		ocfs2_mark_inode_dirty(handle, new_dir, new_dir_bh);
	}
1406 1407 1408 1409

	if (old_dir_nlink != old_dir->i_nlink) {
		if (!old_dir_bh) {
			mlog(ML_ERROR, "need to change nlink for old dir "
1410 1411 1412
			     "%llu from %d to %d but bh is NULL!\n",
			     (unsigned long long)OCFS2_I(old_dir)->ip_blkno,
			     (int)old_dir_nlink, old_dir->i_nlink);
1413 1414
		} else {
			struct ocfs2_dinode *fe;
1415 1416 1417 1418
			status = ocfs2_journal_access_di(handle,
							 INODE_CACHE(old_dir),
							 old_dir_bh,
							 OCFS2_JOURNAL_ACCESS_WRITE);
1419
			fe = (struct ocfs2_dinode *) old_dir_bh->b_data;
M
Mark Fasheh 已提交
1420
			ocfs2_set_links_count(fe, old_dir->i_nlink);
1421
			ocfs2_journal_dirty(handle, old_dir_bh);
1422 1423
		}
	}
1424
	ocfs2_dentry_move(old_dentry, new_dentry, old_dir, new_dir);
1425 1426 1427 1428 1429 1430
	status = 0;
bail:
	if (rename_lock)
		ocfs2_rename_unlock(osb);

	if (handle)
1431
		ocfs2_commit_trans(osb, handle);
1432

1433 1434 1435 1436
	if (parents_locked)
		ocfs2_double_unlock(old_dir, new_dir);

	if (old_child_locked)
M
Mark Fasheh 已提交
1437
		ocfs2_inode_unlock(old_inode, 1);
1438 1439

	if (new_child_locked)
M
Mark Fasheh 已提交
1440
		ocfs2_inode_unlock(new_inode, 1);
1441

1442 1443
	if (orphan_dir) {
		/* This was locked for us in ocfs2_prepare_orphan_dir() */
M
Mark Fasheh 已提交
1444
		ocfs2_inode_unlock(orphan_dir, 1);
1445 1446 1447 1448
		mutex_unlock(&orphan_dir->i_mutex);
		iput(orphan_dir);
	}

1449 1450 1451 1452 1453
	if (new_inode)
		sync_mapping_buffers(old_inode->i_mapping);

	if (new_inode)
		iput(new_inode);
1454 1455 1456 1457 1458 1459 1460

	ocfs2_free_dir_lookup_result(&target_lookup_res);
	ocfs2_free_dir_lookup_result(&old_entry_lookup);
	ocfs2_free_dir_lookup_result(&old_inode_dot_dot_res);
	ocfs2_free_dir_lookup_result(&orphan_insert);
	ocfs2_free_dir_lookup_result(&target_insert);

1461 1462 1463 1464
	brelse(newfe_bh);
	brelse(old_inode_bh);
	brelse(old_dir_bh);
	brelse(new_dir_bh);
1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475

	mlog_exit(status);

	return status;
}

/*
 * we expect i_size = strlen(symname). Copy symname into the file
 * data, including the null terminator.
 */
static int ocfs2_create_symlink_data(struct ocfs2_super *osb,
1476
				     handle_t *handle,
1477 1478 1479 1480 1481 1482
				     struct inode *inode,
				     const char *symname)
{
	struct buffer_head **bhs = NULL;
	const char *c;
	struct super_block *sb = osb->sb;
1483
	u64 p_blkno, p_blocks;
1484 1485 1486 1487 1488 1489 1490
	int virtual, blocks, status, i, bytes_left;

	bytes_left = i_size_read(inode) + 1;
	/* we can't trust i_blocks because we're actually going to
	 * write i_size + 1 bytes. */
	blocks = (bytes_left + sb->s_blocksize - 1) >> sb->s_blocksize_bits;

1491 1492 1493
	mlog_entry("i_blocks = %llu, i_size = %llu, blocks = %d\n",
			(unsigned long long)inode->i_blocks,
			i_size_read(inode), blocks);
1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509

	/* Sanity check -- make sure we're going to fit. */
	if (bytes_left >
	    ocfs2_clusters_to_bytes(sb, OCFS2_I(inode)->ip_clusters)) {
		status = -EIO;
		mlog_errno(status);
		goto bail;
	}

	bhs = kcalloc(blocks, sizeof(struct buffer_head *), GFP_KERNEL);
	if (!bhs) {
		status = -ENOMEM;
		mlog_errno(status);
		goto bail;
	}

1510 1511
	status = ocfs2_extent_map_get_blocks(inode, 0, &p_blkno, &p_blocks,
					     NULL);
1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535
	if (status < 0) {
		mlog_errno(status);
		goto bail;
	}

	/* links can never be larger than one cluster so we know this
	 * is all going to be contiguous, but do a sanity check
	 * anyway. */
	if ((p_blocks << sb->s_blocksize_bits) < bytes_left) {
		status = -EIO;
		mlog_errno(status);
		goto bail;
	}

	virtual = 0;
	while(bytes_left > 0) {
		c = &symname[virtual * sb->s_blocksize];

		bhs[virtual] = sb_getblk(sb, p_blkno);
		if (!bhs[virtual]) {
			status = -ENOMEM;
			mlog_errno(status);
			goto bail;
		}
1536 1537
		ocfs2_set_new_buffer_uptodate(INODE_CACHE(inode),
					      bhs[virtual]);
1538

1539 1540
		status = ocfs2_journal_access(handle, INODE_CACHE(inode),
					      bhs[virtual],
1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552
					      OCFS2_JOURNAL_ACCESS_CREATE);
		if (status < 0) {
			mlog_errno(status);
			goto bail;
		}

		memset(bhs[virtual]->b_data, 0, sb->s_blocksize);

		memcpy(bhs[virtual]->b_data, c,
		       (bytes_left > sb->s_blocksize) ? sb->s_blocksize :
		       bytes_left);

1553
		ocfs2_journal_dirty(handle, bhs[virtual]);
1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564

		virtual++;
		p_blkno++;
		bytes_left -= sb->s_blocksize;
	}

	status = 0;
bail:

	if (bhs) {
		for(i = 0; i < blocks; i++)
1565
			brelse(bhs[i]);
1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585
		kfree(bhs);
	}

	mlog_exit(status);
	return status;
}

static int ocfs2_symlink(struct inode *dir,
			 struct dentry *dentry,
			 const char *symname)
{
	int status, l, credits;
	u64 newsize;
	struct ocfs2_super *osb = NULL;
	struct inode *inode = NULL;
	struct super_block *sb;
	struct buffer_head *new_fe_bh = NULL;
	struct buffer_head *parent_fe_bh = NULL;
	struct ocfs2_dinode *fe = NULL;
	struct ocfs2_dinode *dirfe;
1586
	handle_t *handle = NULL;
1587 1588
	struct ocfs2_alloc_context *inode_ac = NULL;
	struct ocfs2_alloc_context *data_ac = NULL;
1589 1590 1591 1592 1593 1594
	struct ocfs2_alloc_context *xattr_ac = NULL;
	int want_clusters = 0;
	int xattr_credits = 0;
	struct ocfs2_security_xattr_info si = {
		.enable = 1,
	};
1595
	int did_quota = 0, did_quota_inode = 0;
1596
	struct ocfs2_dir_lookup_result lookup = { NULL, };
1597 1598
	sigset_t oldset;
	int did_block_signals = 0;
1599 1600 1601 1602

	mlog_entry("(0x%p, 0x%p, symname='%s' actual='%.*s')\n", dir,
		   dentry, symname, dentry->d_name.len, dentry->d_name.name);

1603
	dquot_initialize(dir);
1604

1605 1606 1607 1608 1609 1610 1611 1612
	sb = dir->i_sb;
	osb = OCFS2_SB(sb);

	l = strlen(symname) + 1;

	credits = ocfs2_calc_symlink_credits(sb);

	/* lock the parent directory */
M
Mark Fasheh 已提交
1613
	status = ocfs2_inode_lock(dir, &parent_fe_bh, 1);
1614 1615 1616
	if (status < 0) {
		if (status != -ENOENT)
			mlog_errno(status);
1617
		return status;
1618 1619 1620
	}

	dirfe = (struct ocfs2_dinode *) parent_fe_bh->b_data;
M
Mark Fasheh 已提交
1621
	if (!ocfs2_read_links_count(dirfe)) {
1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633
		/* can't make a file in a deleted directory. */
		status = -ENOENT;
		goto bail;
	}

	status = ocfs2_check_dir_for_entry(dir, dentry->d_name.name,
					   dentry->d_name.len);
	if (status)
		goto bail;

	status = ocfs2_prepare_dir_for_insert(osb, dir, parent_fe_bh,
					      dentry->d_name.name,
1634
					      dentry->d_name.len, &lookup);
1635 1636 1637 1638 1639
	if (status < 0) {
		mlog_errno(status);
		goto bail;
	}

1640
	status = ocfs2_reserve_new_inode(osb, &inode_ac);
1641 1642 1643 1644 1645 1646
	if (status < 0) {
		if (status != -ENOSPC)
			mlog_errno(status);
		goto bail;
	}

1647 1648 1649 1650 1651 1652 1653
	inode = ocfs2_get_init_inode(dir, S_IFLNK | S_IRWXUGO);
	if (!inode) {
		status = -ENOMEM;
		mlog_errno(status);
		goto bail;
	}

1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668
	/* get security xattr */
	status = ocfs2_init_security_get(inode, dir, &si);
	if (status) {
		if (status == -EOPNOTSUPP)
			si.enable = 0;
		else {
			mlog_errno(status);
			goto bail;
		}
	}

	/* calculate meta data/clusters for setting security xattr */
	if (si.enable) {
		status = ocfs2_calc_security_init(dir, &si, &want_clusters,
						  &xattr_credits, &xattr_ac);
1669
		if (status < 0) {
1670
			mlog_errno(status);
1671 1672 1673 1674
			goto bail;
		}
	}

1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686
	/* don't reserve bitmap space for fast symlinks. */
	if (l > ocfs2_fast_symlink_chars(sb))
		want_clusters += 1;

	status = ocfs2_reserve_clusters(osb, want_clusters, &data_ac);
	if (status < 0) {
		if (status != -ENOSPC)
			mlog_errno(status);
		goto bail;
	}

	handle = ocfs2_start_trans(osb, credits + xattr_credits);
1687 1688 1689 1690 1691 1692 1693
	if (IS_ERR(handle)) {
		status = PTR_ERR(handle);
		handle = NULL;
		mlog_errno(status);
		goto bail;
	}

1694 1695 1696 1697
	/* Starting to change things, restart is no longer possible. */
	ocfs2_block_signals(&oldset);
	did_block_signals = 1;

1698 1699
	status = dquot_alloc_inode(inode);
	if (status)
1700 1701 1702
		goto bail;
	did_quota_inode = 1;

1703 1704 1705 1706 1707
	mlog_entry("(0x%p, 0x%p, %d, '%.*s')\n", dir, dentry,
		   inode->i_mode, dentry->d_name.len,
		   dentry->d_name.name);

	status = ocfs2_mknod_locked(osb, dir, inode,
1708 1709
				    0, &new_fe_bh, parent_fe_bh, handle,
				    inode_ac);
1710 1711 1712 1713 1714 1715 1716 1717 1718
	if (status < 0) {
		mlog_errno(status);
		goto bail;
	}

	fe = (struct ocfs2_dinode *) new_fe_bh->b_data;
	inode->i_rdev = 0;
	newsize = l - 1;
	if (l > ocfs2_fast_symlink_chars(sb)) {
M
Mark Fasheh 已提交
1719 1720
		u32 offset = 0;

1721
		inode->i_op = &ocfs2_symlink_inode_operations;
1722 1723 1724
		status = dquot_alloc_space_nodirty(inode,
		    ocfs2_clusters_to_bytes(osb->sb, 1));
		if (status)
1725 1726
			goto bail;
		did_quota = 1;
1727 1728 1729 1730
		status = ocfs2_add_inode_data(osb, inode, &offset, 1, 0,
					      new_fe_bh,
					      handle, data_ac, NULL,
					      NULL);
1731 1732
		if (status < 0) {
			if (status != -ENOSPC && status != -EINTR) {
1733 1734 1735
				mlog(ML_ERROR,
				     "Failed to extend file to %llu\n",
				     (unsigned long long)newsize);
1736 1737 1738 1739 1740 1741
				mlog_errno(status);
				status = -ENOSPC;
			}
			goto bail;
		}
		i_size_write(inode, newsize);
1742
		inode->i_blocks = ocfs2_inode_sector_count(inode);
1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764
	} else {
		inode->i_op = &ocfs2_fast_symlink_inode_operations;
		memcpy((char *) fe->id2.i_symlink, symname, l);
		i_size_write(inode, newsize);
		inode->i_blocks = 0;
	}

	status = ocfs2_mark_inode_dirty(handle, inode, new_fe_bh);
	if (status < 0) {
		mlog_errno(status);
		goto bail;
	}

	if (!ocfs2_inode_is_fast_symlink(inode)) {
		status = ocfs2_create_symlink_data(osb, handle, inode,
						   symname);
		if (status < 0) {
			mlog_errno(status);
			goto bail;
		}
	}

1765 1766 1767 1768 1769 1770 1771 1772 1773
	if (si.enable) {
		status = ocfs2_init_security_set(handle, inode, new_fe_bh, &si,
						 xattr_ac, data_ac);
		if (status < 0) {
			mlog_errno(status);
			goto bail;
		}
	}

1774 1775 1776 1777 1778 1779 1780
	/*
	 * Do this before adding the entry to the directory. We add
	 * also set d_op after success so that ->d_iput() will cleanup
	 * the dentry lock even if ocfs2_add_entry() fails below.
	 */
	status = ocfs2_dentry_attach_lock(dentry, inode, OCFS2_I(dir)->ip_blkno);
	if (status) {
1781 1782 1783
		mlog_errno(status);
		goto bail;
	}
1784
	dentry->d_op = &ocfs2_dentry_ops;
1785

1786 1787 1788 1789
	status = ocfs2_add_entry(handle, dentry, inode,
				 le64_to_cpu(fe->i_blkno), parent_fe_bh,
				 &lookup);
	if (status < 0) {
1790 1791 1792 1793
		mlog_errno(status);
		goto bail;
	}

1794 1795 1796
	insert_inode_hash(inode);
	d_instantiate(dentry, inode);
bail:
1797
	if (status < 0 && did_quota)
1798
		dquot_free_space_nodirty(inode,
1799 1800
					ocfs2_clusters_to_bytes(osb->sb, 1));
	if (status < 0 && did_quota_inode)
1801
		dquot_free_inode(inode);
1802
	if (handle)
1803
		ocfs2_commit_trans(osb, handle);
1804

M
Mark Fasheh 已提交
1805
	ocfs2_inode_unlock(dir, 1);
1806 1807
	if (did_block_signals)
		ocfs2_unblock_signals(&oldset);
1808

1809 1810
	brelse(new_fe_bh);
	brelse(parent_fe_bh);
1811 1812
	kfree(si.name);
	kfree(si.value);
1813
	ocfs2_free_dir_lookup_result(&lookup);
1814 1815 1816 1817
	if (inode_ac)
		ocfs2_free_alloc_context(inode_ac);
	if (data_ac)
		ocfs2_free_alloc_context(data_ac);
1818 1819
	if (xattr_ac)
		ocfs2_free_alloc_context(xattr_ac);
1820
	if ((status < 0) && inode) {
1821
		OCFS2_I(inode)->ip_flags |= OCFS2_INODE_SKIP_ORPHAN_DIR;
1822
		clear_nlink(inode);
1823
		iput(inode);
1824
	}
1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836

	mlog_exit(status);

	return status;
}

static int ocfs2_blkno_stringify(u64 blkno, char *name)
{
	int status, namelen;

	mlog_entry_void();

1837 1838
	namelen = snprintf(name, OCFS2_ORPHAN_NAMELEN + 1, "%016llx",
			   (long long)blkno);
1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862
	if (namelen <= 0) {
		if (namelen)
			status = namelen;
		else
			status = -EINVAL;
		mlog_errno(status);
		goto bail;
	}
	if (namelen != OCFS2_ORPHAN_NAMELEN) {
		status = -EINVAL;
		mlog_errno(status);
		goto bail;
	}

	mlog(0, "built filename '%s' for orphan dir (len=%d)\n", name,
	     namelen);

	status = 0;
bail:
	mlog_exit(status);
	return status;
}

static int ocfs2_prepare_orphan_dir(struct ocfs2_super *osb,
1863
				    struct inode **ret_orphan_dir,
1864
				    u64 blkno,
1865
				    char *name,
1866
				    struct ocfs2_dir_lookup_result *lookup)
1867
{
1868
	struct inode *orphan_dir_inode;
1869 1870 1871
	struct buffer_head *orphan_dir_bh = NULL;
	int status = 0;

1872
	status = ocfs2_blkno_stringify(blkno, name);
1873 1874
	if (status < 0) {
		mlog_errno(status);
1875
		return status;
1876 1877 1878 1879 1880 1881 1882 1883
	}

	orphan_dir_inode = ocfs2_get_system_file_inode(osb,
						       ORPHAN_DIR_SYSTEM_INODE,
						       osb->slot_num);
	if (!orphan_dir_inode) {
		status = -ENOENT;
		mlog_errno(status);
1884
		return status;
1885 1886
	}

1887 1888
	mutex_lock(&orphan_dir_inode->i_mutex);

M
Mark Fasheh 已提交
1889
	status = ocfs2_inode_lock(orphan_dir_inode, &orphan_dir_bh, 1);
1890 1891 1892 1893 1894 1895 1896
	if (status < 0) {
		mlog_errno(status);
		goto leave;
	}

	status = ocfs2_prepare_dir_for_insert(osb, orphan_dir_inode,
					      orphan_dir_bh, name,
1897
					      OCFS2_ORPHAN_NAMELEN, lookup);
1898
	if (status < 0) {
M
Mark Fasheh 已提交
1899
		ocfs2_inode_unlock(orphan_dir_inode, 1);
1900

1901 1902 1903 1904
		mlog_errno(status);
		goto leave;
	}

1905 1906
	*ret_orphan_dir = orphan_dir_inode;

1907
leave:
1908 1909
	if (status) {
		mutex_unlock(&orphan_dir_inode->i_mutex);
1910
		iput(orphan_dir_inode);
1911
	}
1912

1913
	brelse(orphan_dir_bh);
1914 1915 1916 1917 1918 1919

	mlog_exit(status);
	return status;
}

static int ocfs2_orphan_add(struct ocfs2_super *osb,
1920
			    handle_t *handle,
1921
			    struct inode *inode,
1922
			    struct buffer_head *fe_bh,
1923
			    char *name,
1924
			    struct ocfs2_dir_lookup_result *lookup,
1925
			    struct inode *orphan_dir_inode)
1926 1927 1928 1929
{
	struct buffer_head *orphan_dir_bh = NULL;
	int status = 0;
	struct ocfs2_dinode *orphan_fe;
1930
	struct ocfs2_dinode *fe = (struct ocfs2_dinode *) fe_bh->b_data;
1931 1932 1933

	mlog_entry("(inode->i_ino = %lu)\n", inode->i_ino);

1934
	status = ocfs2_read_inode_block(orphan_dir_inode, &orphan_dir_bh);
1935 1936 1937 1938 1939
	if (status < 0) {
		mlog_errno(status);
		goto leave;
	}

1940 1941 1942
	status = ocfs2_journal_access_di(handle,
					 INODE_CACHE(orphan_dir_inode),
					 orphan_dir_bh,
1943
					 OCFS2_JOURNAL_ACCESS_WRITE);
1944 1945 1946 1947 1948 1949 1950 1951 1952
	if (status < 0) {
		mlog_errno(status);
		goto leave;
	}

	/* we're a cluster, and nlink can change on disk from
	 * underneath us... */
	orphan_fe = (struct ocfs2_dinode *) orphan_dir_bh->b_data;
	if (S_ISDIR(inode->i_mode))
M
Mark Fasheh 已提交
1953 1954
		ocfs2_add_links_count(orphan_fe, 1);
	orphan_dir_inode->i_nlink = ocfs2_read_links_count(orphan_fe);
1955
	ocfs2_journal_dirty(handle, orphan_dir_bh);
1956 1957 1958 1959

	status = __ocfs2_add_entry(handle, orphan_dir_inode, name,
				   OCFS2_ORPHAN_NAMELEN, inode,
				   OCFS2_I(inode)->ip_blkno,
1960
				   orphan_dir_bh, lookup);
1961 1962 1963 1964 1965
	if (status < 0) {
		mlog_errno(status);
		goto leave;
	}

1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980
	/*
	 * We're going to journal the change of i_flags and i_orphaned_slot.
	 * It's safe anyway, though some callers may duplicate the journaling.
	 * Journaling within the func just make the logic look more
	 * straightforward.
	 */
	status = ocfs2_journal_access_di(handle,
					 INODE_CACHE(inode),
					 fe_bh,
					 OCFS2_JOURNAL_ACCESS_WRITE);
	if (status < 0) {
		mlog_errno(status);
		goto leave;
	}

1981
	le32_add_cpu(&fe->i_flags, OCFS2_ORPHANED_FL);
1982
	OCFS2_I(inode)->ip_flags &= ~OCFS2_INODE_SKIP_ORPHAN_DIR;
1983 1984 1985 1986

	/* Record which orphan dir our inode now resides
	 * in. delete_inode will use this to determine which orphan
	 * dir to lock. */
T
Tiger Yang 已提交
1987
	fe->i_orphaned_slot = cpu_to_le16(osb->slot_num);
1988

1989 1990
	ocfs2_journal_dirty(handle, fe_bh);

1991 1992
	mlog(0, "Inode %llu orphaned in slot %d\n",
	     (unsigned long long)OCFS2_I(inode)->ip_blkno, osb->slot_num);
1993 1994

leave:
1995
	brelse(orphan_dir_bh);
1996 1997 1998 1999 2000 2001 2002

	mlog_exit(status);
	return status;
}

/* unlike orphan_add, we expect the orphan dir to already be locked here. */
int ocfs2_orphan_del(struct ocfs2_super *osb,
2003
		     handle_t *handle,
2004 2005 2006 2007 2008 2009 2010
		     struct inode *orphan_dir_inode,
		     struct inode *inode,
		     struct buffer_head *orphan_dir_bh)
{
	char name[OCFS2_ORPHAN_NAMELEN + 1];
	struct ocfs2_dinode *orphan_fe;
	int status = 0;
2011
	struct ocfs2_dir_lookup_result lookup = { NULL, };
2012 2013 2014 2015 2016 2017 2018 2019 2020

	mlog_entry_void();

	status = ocfs2_blkno_stringify(OCFS2_I(inode)->ip_blkno, name);
	if (status < 0) {
		mlog_errno(status);
		goto leave;
	}

2021 2022 2023
	mlog(0, "removing '%s' from orphan dir %llu (namelen=%d)\n",
	     name, (unsigned long long)OCFS2_I(orphan_dir_inode)->ip_blkno,
	     OCFS2_ORPHAN_NAMELEN);
2024 2025

	/* find it's spot in the orphan directory */
2026 2027 2028
	status = ocfs2_find_entry(name, OCFS2_ORPHAN_NAMELEN, orphan_dir_inode,
				  &lookup);
	if (status) {
2029 2030 2031 2032 2033
		mlog_errno(status);
		goto leave;
	}

	/* remove it from the orphan directory */
2034
	status = ocfs2_delete_entry(handle, orphan_dir_inode, &lookup);
2035 2036 2037 2038 2039
	if (status < 0) {
		mlog_errno(status);
		goto leave;
	}

2040 2041 2042
	status = ocfs2_journal_access_di(handle,
					 INODE_CACHE(orphan_dir_inode),
					 orphan_dir_bh,
2043
					 OCFS2_JOURNAL_ACCESS_WRITE);
2044 2045 2046 2047 2048 2049 2050 2051
	if (status < 0) {
		mlog_errno(status);
		goto leave;
	}

	/* do the i_nlink dance! :) */
	orphan_fe = (struct ocfs2_dinode *) orphan_dir_bh->b_data;
	if (S_ISDIR(inode->i_mode))
M
Mark Fasheh 已提交
2052 2053
		ocfs2_add_links_count(orphan_fe, -1);
	orphan_dir_inode->i_nlink = ocfs2_read_links_count(orphan_fe);
2054
	ocfs2_journal_dirty(handle, orphan_dir_bh);
2055 2056

leave:
2057
	ocfs2_free_dir_lookup_result(&lookup);
2058 2059 2060 2061 2062

	mlog_exit(status);
	return status;
}

2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120
int ocfs2_create_inode_in_orphan(struct inode *dir,
				 int mode,
				 struct inode **new_inode)
{
	int status, did_quota_inode = 0;
	struct inode *inode = NULL;
	struct inode *orphan_dir = NULL;
	struct ocfs2_super *osb = OCFS2_SB(dir->i_sb);
	struct ocfs2_dinode *di = NULL;
	handle_t *handle = NULL;
	char orphan_name[OCFS2_ORPHAN_NAMELEN + 1];
	struct buffer_head *parent_di_bh = NULL;
	struct buffer_head *new_di_bh = NULL;
	struct ocfs2_alloc_context *inode_ac = NULL;
	struct ocfs2_dir_lookup_result orphan_insert = { NULL, };

	status = ocfs2_inode_lock(dir, &parent_di_bh, 1);
	if (status < 0) {
		if (status != -ENOENT)
			mlog_errno(status);
		return status;
	}

	/*
	 * We give the orphan dir the root blkno to fake an orphan name,
	 * and allocate enough space for our insertion.
	 */
	status = ocfs2_prepare_orphan_dir(osb, &orphan_dir,
					  osb->root_blkno,
					  orphan_name, &orphan_insert);
	if (status < 0) {
		mlog_errno(status);
		goto leave;
	}

	/* reserve an inode spot */
	status = ocfs2_reserve_new_inode(osb, &inode_ac);
	if (status < 0) {
		if (status != -ENOSPC)
			mlog_errno(status);
		goto leave;
	}

	inode = ocfs2_get_init_inode(dir, mode);
	if (!inode) {
		status = -ENOMEM;
		mlog_errno(status);
		goto leave;
	}

	handle = ocfs2_start_trans(osb, ocfs2_mknod_credits(osb->sb, 0, 0));
	if (IS_ERR(handle)) {
		status = PTR_ERR(handle);
		handle = NULL;
		mlog_errno(status);
		goto leave;
	}

2121 2122
	status = dquot_alloc_inode(inode);
	if (status)
2123 2124 2125
		goto leave;
	did_quota_inode = 1;

2126
	inode->i_nlink = 0;
2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142
	/* do the real work now. */
	status = ocfs2_mknod_locked(osb, dir, inode,
				    0, &new_di_bh, parent_di_bh, handle,
				    inode_ac);
	if (status < 0) {
		mlog_errno(status);
		goto leave;
	}

	status = ocfs2_blkno_stringify(OCFS2_I(inode)->ip_blkno, orphan_name);
	if (status < 0) {
		mlog_errno(status);
		goto leave;
	}

	di = (struct ocfs2_dinode *)new_di_bh->b_data;
2143
	status = ocfs2_orphan_add(osb, handle, inode, new_di_bh, orphan_name,
2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154
				  &orphan_insert, orphan_dir);
	if (status < 0) {
		mlog_errno(status);
		goto leave;
	}

	/* get open lock so that only nodes can't remove it from orphan dir. */
	status = ocfs2_open_lock(inode);
	if (status < 0)
		mlog_errno(status);

2155
	insert_inode_hash(inode);
2156 2157
leave:
	if (status < 0 && did_quota_inode)
2158
		dquot_free_inode(inode);
2159 2160 2161 2162 2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286
	if (handle)
		ocfs2_commit_trans(osb, handle);

	if (orphan_dir) {
		/* This was locked for us in ocfs2_prepare_orphan_dir() */
		ocfs2_inode_unlock(orphan_dir, 1);
		mutex_unlock(&orphan_dir->i_mutex);
		iput(orphan_dir);
	}

	if (status == -ENOSPC)
		mlog(0, "Disk is full\n");

	if ((status < 0) && inode) {
		clear_nlink(inode);
		iput(inode);
	}

	if (inode_ac)
		ocfs2_free_alloc_context(inode_ac);

	brelse(new_di_bh);

	if (!status)
		*new_inode = inode;

	ocfs2_free_dir_lookup_result(&orphan_insert);

	ocfs2_inode_unlock(dir, 1);
	brelse(parent_di_bh);
	return status;
}

int ocfs2_mv_orphaned_inode_to_new(struct inode *dir,
				   struct inode *inode,
				   struct dentry *dentry)
{
	int status = 0;
	struct buffer_head *parent_di_bh = NULL;
	handle_t *handle = NULL;
	struct ocfs2_super *osb = OCFS2_SB(dir->i_sb);
	struct ocfs2_dinode *dir_di, *di;
	struct inode *orphan_dir_inode = NULL;
	struct buffer_head *orphan_dir_bh = NULL;
	struct buffer_head *di_bh = NULL;
	struct ocfs2_dir_lookup_result lookup = { NULL, };

	mlog_entry("(0x%p, 0x%p, %.*s')\n", dir, dentry,
		   dentry->d_name.len, dentry->d_name.name);

	status = ocfs2_inode_lock(dir, &parent_di_bh, 1);
	if (status < 0) {
		if (status != -ENOENT)
			mlog_errno(status);
		return status;
	}

	dir_di = (struct ocfs2_dinode *) parent_di_bh->b_data;
	if (!dir_di->i_links_count) {
		/* can't make a file in a deleted directory. */
		status = -ENOENT;
		goto leave;
	}

	status = ocfs2_check_dir_for_entry(dir, dentry->d_name.name,
					   dentry->d_name.len);
	if (status)
		goto leave;

	/* get a spot inside the dir. */
	status = ocfs2_prepare_dir_for_insert(osb, dir, parent_di_bh,
					      dentry->d_name.name,
					      dentry->d_name.len, &lookup);
	if (status < 0) {
		mlog_errno(status);
		goto leave;
	}

	orphan_dir_inode = ocfs2_get_system_file_inode(osb,
						       ORPHAN_DIR_SYSTEM_INODE,
						       osb->slot_num);
	if (!orphan_dir_inode) {
		status = -EEXIST;
		mlog_errno(status);
		goto leave;
	}

	mutex_lock(&orphan_dir_inode->i_mutex);

	status = ocfs2_inode_lock(orphan_dir_inode, &orphan_dir_bh, 1);
	if (status < 0) {
		mlog_errno(status);
		mutex_unlock(&orphan_dir_inode->i_mutex);
		iput(orphan_dir_inode);
		goto leave;
	}

	status = ocfs2_read_inode_block(inode, &di_bh);
	if (status < 0) {
		mlog_errno(status);
		goto orphan_unlock;
	}

	handle = ocfs2_start_trans(osb, ocfs2_rename_credits(osb->sb));
	if (IS_ERR(handle)) {
		status = PTR_ERR(handle);
		handle = NULL;
		mlog_errno(status);
		goto orphan_unlock;
	}

	status = ocfs2_journal_access_di(handle, INODE_CACHE(inode),
					 di_bh, OCFS2_JOURNAL_ACCESS_WRITE);
	if (status < 0) {
		mlog_errno(status);
		goto out_commit;
	}

	status = ocfs2_orphan_del(osb, handle, orphan_dir_inode, inode,
				  orphan_dir_bh);
	if (status < 0) {
		mlog_errno(status);
		goto out_commit;
	}

	di = (struct ocfs2_dinode *)di_bh->b_data;
	le32_add_cpu(&di->i_flags, -OCFS2_ORPHANED_FL);
	di->i_orphaned_slot = 0;
2287 2288
	inode->i_nlink = 1;
	ocfs2_set_links_count(di, inode->i_nlink);
2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329
	ocfs2_journal_dirty(handle, di_bh);

	status = ocfs2_add_entry(handle, dentry, inode,
				 OCFS2_I(inode)->ip_blkno, parent_di_bh,
				 &lookup);
	if (status < 0) {
		mlog_errno(status);
		goto out_commit;
	}

	status = ocfs2_dentry_attach_lock(dentry, inode,
					  OCFS2_I(dir)->ip_blkno);
	if (status) {
		mlog_errno(status);
		goto out_commit;
	}

	dentry->d_op = &ocfs2_dentry_ops;
	d_instantiate(dentry, inode);
	status = 0;
out_commit:
	ocfs2_commit_trans(osb, handle);
orphan_unlock:
	ocfs2_inode_unlock(orphan_dir_inode, 1);
	mutex_unlock(&orphan_dir_inode->i_mutex);
	iput(orphan_dir_inode);
leave:

	ocfs2_inode_unlock(dir, 1);

	brelse(di_bh);
	brelse(parent_di_bh);
	brelse(orphan_dir_bh);

	ocfs2_free_dir_lookup_result(&lookup);

	mlog_exit(status);

	return status;
}

2330
const struct inode_operations ocfs2_dir_iops = {
2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341
	.create		= ocfs2_create,
	.lookup		= ocfs2_lookup,
	.link		= ocfs2_link,
	.unlink		= ocfs2_unlink,
	.rmdir		= ocfs2_unlink,
	.symlink	= ocfs2_symlink,
	.mkdir		= ocfs2_mkdir,
	.mknod		= ocfs2_mknod,
	.rename		= ocfs2_rename,
	.setattr	= ocfs2_setattr,
	.getattr	= ocfs2_getattr,
T
Tiger Yang 已提交
2342
	.permission	= ocfs2_permission,
T
Tiger Yang 已提交
2343 2344 2345 2346
	.setxattr	= generic_setxattr,
	.getxattr	= generic_getxattr,
	.listxattr	= ocfs2_listxattr,
	.removexattr	= generic_removexattr,
2347
	.fiemap         = ocfs2_fiemap,
2348
};