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