PageRenderTime 6ms CodeModel.GetById 6ms app.highlight 122ms RepoModel.GetById 1ms app.codeStats 0ms

/fs/gfs2/inode.c

https://bitbucket.org/digetx/picasso-kernel
C | 1861 lines | 1349 code | 274 blank | 238 comment | 304 complexity | 76b26c794c89b05f9eb314c91878d6be MD5 | raw file
   1/*
   2 * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
   3 * Copyright (C) 2004-2011 Red Hat, Inc.  All rights reserved.
   4 *
   5 * This copyrighted material is made available to anyone wishing to use,
   6 * modify, copy, or redistribute it subject to the terms and conditions
   7 * of the GNU General Public License version 2.
   8 */
   9
  10#include <linux/slab.h>
  11#include <linux/spinlock.h>
  12#include <linux/completion.h>
  13#include <linux/buffer_head.h>
  14#include <linux/namei.h>
  15#include <linux/mm.h>
  16#include <linux/xattr.h>
  17#include <linux/posix_acl.h>
  18#include <linux/gfs2_ondisk.h>
  19#include <linux/crc32.h>
  20#include <linux/fiemap.h>
  21#include <linux/security.h>
  22#include <asm/uaccess.h>
  23
  24#include "gfs2.h"
  25#include "incore.h"
  26#include "acl.h"
  27#include "bmap.h"
  28#include "dir.h"
  29#include "xattr.h"
  30#include "glock.h"
  31#include "inode.h"
  32#include "meta_io.h"
  33#include "quota.h"
  34#include "rgrp.h"
  35#include "trans.h"
  36#include "util.h"
  37#include "super.h"
  38#include "glops.h"
  39
  40struct gfs2_skip_data {
  41	u64 no_addr;
  42	int skipped;
  43	int non_block;
  44};
  45
  46static int iget_test(struct inode *inode, void *opaque)
  47{
  48	struct gfs2_inode *ip = GFS2_I(inode);
  49	struct gfs2_skip_data *data = opaque;
  50
  51	if (ip->i_no_addr == data->no_addr) {
  52		if (data->non_block &&
  53		    inode->i_state & (I_FREEING|I_CLEAR|I_WILL_FREE)) {
  54			data->skipped = 1;
  55			return 0;
  56		}
  57		return 1;
  58	}
  59	return 0;
  60}
  61
  62static int iget_set(struct inode *inode, void *opaque)
  63{
  64	struct gfs2_inode *ip = GFS2_I(inode);
  65	struct gfs2_skip_data *data = opaque;
  66
  67	if (data->skipped)
  68		return -ENOENT;
  69	inode->i_ino = (unsigned long)(data->no_addr);
  70	ip->i_no_addr = data->no_addr;
  71	return 0;
  72}
  73
  74struct inode *gfs2_ilookup(struct super_block *sb, u64 no_addr, int non_block)
  75{
  76	unsigned long hash = (unsigned long)no_addr;
  77	struct gfs2_skip_data data;
  78
  79	data.no_addr = no_addr;
  80	data.skipped = 0;
  81	data.non_block = non_block;
  82	return ilookup5(sb, hash, iget_test, &data);
  83}
  84
  85static struct inode *gfs2_iget(struct super_block *sb, u64 no_addr,
  86			       int non_block)
  87{
  88	struct gfs2_skip_data data;
  89	unsigned long hash = (unsigned long)no_addr;
  90
  91	data.no_addr = no_addr;
  92	data.skipped = 0;
  93	data.non_block = non_block;
  94	return iget5_locked(sb, hash, iget_test, iget_set, &data);
  95}
  96
  97/**
  98 * gfs2_set_iop - Sets inode operations
  99 * @inode: The inode with correct i_mode filled in
 100 *
 101 * GFS2 lookup code fills in vfs inode contents based on info obtained
 102 * from directory entry inside gfs2_inode_lookup().
 103 */
 104
 105static void gfs2_set_iop(struct inode *inode)
 106{
 107	struct gfs2_sbd *sdp = GFS2_SB(inode);
 108	umode_t mode = inode->i_mode;
 109
 110	if (S_ISREG(mode)) {
 111		inode->i_op = &gfs2_file_iops;
 112		if (gfs2_localflocks(sdp))
 113			inode->i_fop = &gfs2_file_fops_nolock;
 114		else
 115			inode->i_fop = &gfs2_file_fops;
 116	} else if (S_ISDIR(mode)) {
 117		inode->i_op = &gfs2_dir_iops;
 118		if (gfs2_localflocks(sdp))
 119			inode->i_fop = &gfs2_dir_fops_nolock;
 120		else
 121			inode->i_fop = &gfs2_dir_fops;
 122	} else if (S_ISLNK(mode)) {
 123		inode->i_op = &gfs2_symlink_iops;
 124	} else {
 125		inode->i_op = &gfs2_file_iops;
 126		init_special_inode(inode, inode->i_mode, inode->i_rdev);
 127	}
 128}
 129
 130/**
 131 * gfs2_inode_lookup - Lookup an inode
 132 * @sb: The super block
 133 * @no_addr: The inode number
 134 * @type: The type of the inode
 135 * non_block: Can we block on inodes that are being freed?
 136 *
 137 * Returns: A VFS inode, or an error
 138 */
 139
 140struct inode *gfs2_inode_lookup(struct super_block *sb, unsigned int type,
 141				u64 no_addr, u64 no_formal_ino, int non_block)
 142{
 143	struct inode *inode;
 144	struct gfs2_inode *ip;
 145	struct gfs2_glock *io_gl = NULL;
 146	int error;
 147
 148	inode = gfs2_iget(sb, no_addr, non_block);
 149	ip = GFS2_I(inode);
 150
 151	if (!inode)
 152		return ERR_PTR(-ENOBUFS);
 153
 154	if (inode->i_state & I_NEW) {
 155		struct gfs2_sbd *sdp = GFS2_SB(inode);
 156		ip->i_no_formal_ino = no_formal_ino;
 157
 158		error = gfs2_glock_get(sdp, no_addr, &gfs2_inode_glops, CREATE, &ip->i_gl);
 159		if (unlikely(error))
 160			goto fail;
 161		ip->i_gl->gl_object = ip;
 162
 163		error = gfs2_glock_get(sdp, no_addr, &gfs2_iopen_glops, CREATE, &io_gl);
 164		if (unlikely(error))
 165			goto fail_put;
 166
 167		set_bit(GIF_INVALID, &ip->i_flags);
 168		error = gfs2_glock_nq_init(io_gl, LM_ST_SHARED, GL_EXACT, &ip->i_iopen_gh);
 169		if (unlikely(error))
 170			goto fail_iopen;
 171
 172		ip->i_iopen_gh.gh_gl->gl_object = ip;
 173		gfs2_glock_put(io_gl);
 174		io_gl = NULL;
 175
 176		if (type == DT_UNKNOWN) {
 177			/* Inode glock must be locked already */
 178			error = gfs2_inode_refresh(GFS2_I(inode));
 179			if (error)
 180				goto fail_refresh;
 181		} else {
 182			inode->i_mode = DT2IF(type);
 183		}
 184
 185		gfs2_set_iop(inode);
 186		unlock_new_inode(inode);
 187	}
 188
 189	return inode;
 190
 191fail_refresh:
 192	ip->i_iopen_gh.gh_gl->gl_object = NULL;
 193	gfs2_glock_dq_uninit(&ip->i_iopen_gh);
 194fail_iopen:
 195	if (io_gl)
 196		gfs2_glock_put(io_gl);
 197fail_put:
 198	ip->i_gl->gl_object = NULL;
 199	gfs2_glock_put(ip->i_gl);
 200fail:
 201	iget_failed(inode);
 202	return ERR_PTR(error);
 203}
 204
 205struct inode *gfs2_lookup_by_inum(struct gfs2_sbd *sdp, u64 no_addr,
 206				  u64 *no_formal_ino, unsigned int blktype)
 207{
 208	struct super_block *sb = sdp->sd_vfs;
 209	struct gfs2_holder i_gh;
 210	struct inode *inode = NULL;
 211	int error;
 212
 213	/* Must not read in block until block type is verified */
 214	error = gfs2_glock_nq_num(sdp, no_addr, &gfs2_inode_glops,
 215				  LM_ST_EXCLUSIVE, GL_SKIP, &i_gh);
 216	if (error)
 217		return ERR_PTR(error);
 218
 219	error = gfs2_check_blk_type(sdp, no_addr, blktype);
 220	if (error)
 221		goto fail;
 222
 223	inode = gfs2_inode_lookup(sb, DT_UNKNOWN, no_addr, 0, 1);
 224	if (IS_ERR(inode))
 225		goto fail;
 226
 227	/* Two extra checks for NFS only */
 228	if (no_formal_ino) {
 229		error = -ESTALE;
 230		if (GFS2_I(inode)->i_no_formal_ino != *no_formal_ino)
 231			goto fail_iput;
 232
 233		error = -EIO;
 234		if (GFS2_I(inode)->i_diskflags & GFS2_DIF_SYSTEM)
 235			goto fail_iput;
 236
 237		error = 0;
 238	}
 239
 240fail:
 241	gfs2_glock_dq_uninit(&i_gh);
 242	return error ? ERR_PTR(error) : inode;
 243fail_iput:
 244	iput(inode);
 245	goto fail;
 246}
 247
 248
 249struct inode *gfs2_lookup_simple(struct inode *dip, const char *name)
 250{
 251	struct qstr qstr;
 252	struct inode *inode;
 253	gfs2_str2qstr(&qstr, name);
 254	inode = gfs2_lookupi(dip, &qstr, 1);
 255	/* gfs2_lookupi has inconsistent callers: vfs
 256	 * related routines expect NULL for no entry found,
 257	 * gfs2_lookup_simple callers expect ENOENT
 258	 * and do not check for NULL.
 259	 */
 260	if (inode == NULL)
 261		return ERR_PTR(-ENOENT);
 262	else
 263		return inode;
 264}
 265
 266
 267/**
 268 * gfs2_lookupi - Look up a filename in a directory and return its inode
 269 * @d_gh: An initialized holder for the directory glock
 270 * @name: The name of the inode to look for
 271 * @is_root: If 1, ignore the caller's permissions
 272 * @i_gh: An uninitialized holder for the new inode glock
 273 *
 274 * This can be called via the VFS filldir function when NFS is doing
 275 * a readdirplus and the inode which its intending to stat isn't
 276 * already in cache. In this case we must not take the directory glock
 277 * again, since the readdir call will have already taken that lock.
 278 *
 279 * Returns: errno
 280 */
 281
 282struct inode *gfs2_lookupi(struct inode *dir, const struct qstr *name,
 283			   int is_root)
 284{
 285	struct super_block *sb = dir->i_sb;
 286	struct gfs2_inode *dip = GFS2_I(dir);
 287	struct gfs2_holder d_gh;
 288	int error = 0;
 289	struct inode *inode = NULL;
 290	int unlock = 0;
 291
 292	if (!name->len || name->len > GFS2_FNAMESIZE)
 293		return ERR_PTR(-ENAMETOOLONG);
 294
 295	if ((name->len == 1 && memcmp(name->name, ".", 1) == 0) ||
 296	    (name->len == 2 && memcmp(name->name, "..", 2) == 0 &&
 297	     dir == sb->s_root->d_inode)) {
 298		igrab(dir);
 299		return dir;
 300	}
 301
 302	if (gfs2_glock_is_locked_by_me(dip->i_gl) == NULL) {
 303		error = gfs2_glock_nq_init(dip->i_gl, LM_ST_SHARED, 0, &d_gh);
 304		if (error)
 305			return ERR_PTR(error);
 306		unlock = 1;
 307	}
 308
 309	if (!is_root) {
 310		error = gfs2_permission(dir, MAY_EXEC);
 311		if (error)
 312			goto out;
 313	}
 314
 315	inode = gfs2_dir_search(dir, name);
 316	if (IS_ERR(inode))
 317		error = PTR_ERR(inode);
 318out:
 319	if (unlock)
 320		gfs2_glock_dq_uninit(&d_gh);
 321	if (error == -ENOENT)
 322		return NULL;
 323	return inode ? inode : ERR_PTR(error);
 324}
 325
 326/**
 327 * create_ok - OK to create a new on-disk inode here?
 328 * @dip:  Directory in which dinode is to be created
 329 * @name:  Name of new dinode
 330 * @mode:
 331 *
 332 * Returns: errno
 333 */
 334
 335static int create_ok(struct gfs2_inode *dip, const struct qstr *name,
 336		     umode_t mode)
 337{
 338	int error;
 339
 340	error = gfs2_permission(&dip->i_inode, MAY_WRITE | MAY_EXEC);
 341	if (error)
 342		return error;
 343
 344	/*  Don't create entries in an unlinked directory  */
 345	if (!dip->i_inode.i_nlink)
 346		return -ENOENT;
 347
 348	error = gfs2_dir_check(&dip->i_inode, name, NULL);
 349	switch (error) {
 350	case -ENOENT:
 351		error = 0;
 352		break;
 353	case 0:
 354		return -EEXIST;
 355	default:
 356		return error;
 357	}
 358
 359	if (dip->i_entries == (u32)-1)
 360		return -EFBIG;
 361	if (S_ISDIR(mode) && dip->i_inode.i_nlink == (u32)-1)
 362		return -EMLINK;
 363
 364	return 0;
 365}
 366
 367static void munge_mode_uid_gid(const struct gfs2_inode *dip,
 368			       struct inode *inode)
 369{
 370	if (GFS2_SB(&dip->i_inode)->sd_args.ar_suiddir &&
 371	    (dip->i_inode.i_mode & S_ISUID) && dip->i_inode.i_uid) {
 372		if (S_ISDIR(inode->i_mode))
 373			inode->i_mode |= S_ISUID;
 374		else if (dip->i_inode.i_uid != current_fsuid())
 375			inode->i_mode &= ~07111;
 376		inode->i_uid = dip->i_inode.i_uid;
 377	} else
 378		inode->i_uid = current_fsuid();
 379
 380	if (dip->i_inode.i_mode & S_ISGID) {
 381		if (S_ISDIR(inode->i_mode))
 382			inode->i_mode |= S_ISGID;
 383		inode->i_gid = dip->i_inode.i_gid;
 384	} else
 385		inode->i_gid = current_fsgid();
 386}
 387
 388static int alloc_dinode(struct gfs2_inode *ip, u32 flags)
 389{
 390	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
 391	int error;
 392	int dblocks = 1;
 393
 394	error = gfs2_inplace_reserve(ip, RES_DINODE, flags);
 395	if (error)
 396		goto out;
 397
 398	error = gfs2_trans_begin(sdp, RES_RG_BIT + RES_STATFS, 0);
 399	if (error)
 400		goto out_ipreserv;
 401
 402	error = gfs2_alloc_blocks(ip, &ip->i_no_addr, &dblocks, 1, &ip->i_generation);
 403	ip->i_no_formal_ino = ip->i_generation;
 404	ip->i_inode.i_ino = ip->i_no_addr;
 405	ip->i_goal = ip->i_no_addr;
 406
 407	gfs2_trans_end(sdp);
 408
 409out_ipreserv:
 410	gfs2_inplace_release(ip);
 411out:
 412	return error;
 413}
 414
 415static void gfs2_init_dir(struct buffer_head *dibh,
 416			  const struct gfs2_inode *parent)
 417{
 418	struct gfs2_dinode *di = (struct gfs2_dinode *)dibh->b_data;
 419	struct gfs2_dirent *dent = (struct gfs2_dirent *)(di+1);
 420
 421	gfs2_qstr2dirent(&gfs2_qdot, GFS2_DIRENT_SIZE(gfs2_qdot.len), dent);
 422	dent->de_inum = di->di_num; /* already GFS2 endian */
 423	dent->de_type = cpu_to_be16(DT_DIR);
 424
 425	dent = (struct gfs2_dirent *)((char*)dent + GFS2_DIRENT_SIZE(1));
 426	gfs2_qstr2dirent(&gfs2_qdotdot, dibh->b_size - GFS2_DIRENT_SIZE(1) - sizeof(struct gfs2_dinode), dent);
 427	gfs2_inum_out(parent, dent);
 428	dent->de_type = cpu_to_be16(DT_DIR);
 429	
 430}
 431
 432/**
 433 * init_dinode - Fill in a new dinode structure
 434 * @dip: The directory this inode is being created in
 435 * @ip: The inode
 436 * @symname: The symlink destination (if a symlink)
 437 * @bhp: The buffer head (returned to caller)
 438 *
 439 */
 440
 441static void init_dinode(struct gfs2_inode *dip, struct gfs2_inode *ip,
 442			const char *symname, struct buffer_head **bhp)
 443{
 444	struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
 445	struct gfs2_dinode *di;
 446	struct buffer_head *dibh;
 447	struct timespec tv = CURRENT_TIME;
 448
 449	dibh = gfs2_meta_new(ip->i_gl, ip->i_no_addr);
 450	gfs2_trans_add_bh(ip->i_gl, dibh, 1);
 451	gfs2_metatype_set(dibh, GFS2_METATYPE_DI, GFS2_FORMAT_DI);
 452	gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode));
 453	di = (struct gfs2_dinode *)dibh->b_data;
 454
 455	di->di_num.no_formal_ino = cpu_to_be64(ip->i_no_formal_ino);
 456	di->di_num.no_addr = cpu_to_be64(ip->i_no_addr);
 457	di->di_mode = cpu_to_be32(ip->i_inode.i_mode);
 458	di->di_uid = cpu_to_be32(ip->i_inode.i_uid);
 459	di->di_gid = cpu_to_be32(ip->i_inode.i_gid);
 460	di->di_nlink = 0;
 461	di->di_size = cpu_to_be64(ip->i_inode.i_size);
 462	di->di_blocks = cpu_to_be64(1);
 463	di->di_atime = di->di_mtime = di->di_ctime = cpu_to_be64(tv.tv_sec);
 464	di->di_major = cpu_to_be32(MAJOR(ip->i_inode.i_rdev));
 465	di->di_minor = cpu_to_be32(MINOR(ip->i_inode.i_rdev));
 466	di->di_goal_meta = di->di_goal_data = cpu_to_be64(ip->i_no_addr);
 467	di->di_generation = cpu_to_be64(ip->i_generation);
 468	di->di_flags = 0;
 469	di->__pad1 = 0;
 470	di->di_payload_format = cpu_to_be32(S_ISDIR(ip->i_inode.i_mode) ? GFS2_FORMAT_DE : 0);
 471	di->di_height = 0;
 472	di->__pad2 = 0;
 473	di->__pad3 = 0;
 474	di->di_depth = 0;
 475	di->di_entries = 0;
 476	memset(&di->__pad4, 0, sizeof(di->__pad4));
 477	di->di_eattr = 0;
 478	di->di_atime_nsec = cpu_to_be32(tv.tv_nsec);
 479	di->di_mtime_nsec = cpu_to_be32(tv.tv_nsec);
 480	di->di_ctime_nsec = cpu_to_be32(tv.tv_nsec);
 481	memset(&di->di_reserved, 0, sizeof(di->di_reserved));
 482
 483	switch(ip->i_inode.i_mode & S_IFMT) {
 484	case S_IFREG:
 485		if ((dip->i_diskflags & GFS2_DIF_INHERIT_JDATA) ||
 486		    gfs2_tune_get(sdp, gt_new_files_jdata))
 487			di->di_flags |= cpu_to_be32(GFS2_DIF_JDATA);
 488		break;
 489	case S_IFDIR:
 490		di->di_flags |= cpu_to_be32(dip->i_diskflags &
 491					    GFS2_DIF_INHERIT_JDATA);
 492		di->di_flags |= cpu_to_be32(GFS2_DIF_JDATA);
 493		di->di_size = cpu_to_be64(sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode));
 494		di->di_entries = cpu_to_be32(2);
 495		gfs2_init_dir(dibh, dip);
 496		break;
 497	case S_IFLNK:
 498		memcpy(dibh->b_data + sizeof(struct gfs2_dinode), symname, ip->i_inode.i_size);
 499		break;
 500	}
 501
 502	set_buffer_uptodate(dibh);
 503
 504	*bhp = dibh;
 505}
 506
 507static int make_dinode(struct gfs2_inode *dip, struct gfs2_inode *ip,
 508		       const char *symname, struct buffer_head **bhp)
 509{
 510	struct inode *inode = &ip->i_inode;
 511	struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
 512	int error;
 513
 514	error = gfs2_rindex_update(sdp);
 515	if (error)
 516		return error;
 517
 518	error = gfs2_quota_lock(dip, inode->i_uid, inode->i_gid);
 519	if (error)
 520		return error;
 521
 522	error = gfs2_quota_check(dip, inode->i_uid, inode->i_gid);
 523	if (error)
 524		goto out_quota;
 525
 526	error = gfs2_trans_begin(sdp, RES_DINODE + RES_QUOTA, 0);
 527	if (error)
 528		goto out_quota;
 529
 530	init_dinode(dip, ip, symname, bhp);
 531	gfs2_quota_change(dip, +1, inode->i_uid, inode->i_gid);
 532	gfs2_trans_end(sdp);
 533
 534out_quota:
 535	gfs2_quota_unlock(dip);
 536	return error;
 537}
 538
 539static int link_dinode(struct gfs2_inode *dip, const struct qstr *name,
 540		       struct gfs2_inode *ip)
 541{
 542	struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
 543	int alloc_required;
 544	struct buffer_head *dibh;
 545	int error;
 546
 547	error = gfs2_rindex_update(sdp);
 548	if (error)
 549		return error;
 550
 551	error = gfs2_quota_lock(dip, NO_QUOTA_CHANGE, NO_QUOTA_CHANGE);
 552	if (error)
 553		goto fail;
 554
 555	error = alloc_required = gfs2_diradd_alloc_required(&dip->i_inode, name);
 556	if (alloc_required < 0)
 557		goto fail_quota_locks;
 558	if (alloc_required) {
 559		error = gfs2_quota_check(dip, dip->i_inode.i_uid, dip->i_inode.i_gid);
 560		if (error)
 561			goto fail_quota_locks;
 562
 563		error = gfs2_inplace_reserve(dip, sdp->sd_max_dirres, 0);
 564		if (error)
 565			goto fail_quota_locks;
 566
 567		error = gfs2_trans_begin(sdp, sdp->sd_max_dirres +
 568					 dip->i_rgd->rd_length +
 569					 2 * RES_DINODE +
 570					 RES_STATFS + RES_QUOTA, 0);
 571		if (error)
 572			goto fail_ipreserv;
 573	} else {
 574		error = gfs2_trans_begin(sdp, RES_LEAF + 2 * RES_DINODE, 0);
 575		if (error)
 576			goto fail_quota_locks;
 577	}
 578
 579	error = gfs2_dir_add(&dip->i_inode, name, ip);
 580	if (error)
 581		goto fail_end_trans;
 582
 583	error = gfs2_meta_inode_buffer(ip, &dibh);
 584	if (error)
 585		goto fail_end_trans;
 586	set_nlink(&ip->i_inode, S_ISDIR(ip->i_inode.i_mode) ? 2 : 1);
 587	gfs2_trans_add_bh(ip->i_gl, dibh, 1);
 588	gfs2_dinode_out(ip, dibh->b_data);
 589	brelse(dibh);
 590	return 0;
 591
 592fail_end_trans:
 593	gfs2_trans_end(sdp);
 594
 595fail_ipreserv:
 596	if (alloc_required)
 597		gfs2_inplace_release(dip);
 598
 599fail_quota_locks:
 600	gfs2_quota_unlock(dip);
 601
 602fail:
 603	return error;
 604}
 605
 606static int gfs2_initxattrs(struct inode *inode, const struct xattr *xattr_array,
 607		    void *fs_info)
 608{
 609	const struct xattr *xattr;
 610	int err = 0;
 611
 612	for (xattr = xattr_array; xattr->name != NULL; xattr++) {
 613		err = __gfs2_xattr_set(inode, xattr->name, xattr->value,
 614				       xattr->value_len, 0,
 615				       GFS2_EATYPE_SECURITY);
 616		if (err < 0)
 617			break;
 618	}
 619	return err;
 620}
 621
 622static int gfs2_security_init(struct gfs2_inode *dip, struct gfs2_inode *ip,
 623			      const struct qstr *qstr)
 624{
 625	return security_inode_init_security(&ip->i_inode, &dip->i_inode, qstr,
 626					    &gfs2_initxattrs, NULL);
 627}
 628
 629/**
 630 * gfs2_create_inode - Create a new inode
 631 * @dir: The parent directory
 632 * @dentry: The new dentry
 633 * @mode: The permissions on the new inode
 634 * @dev: For device nodes, this is the device number
 635 * @symname: For symlinks, this is the link destination
 636 * @size: The initial size of the inode (ignored for directories)
 637 *
 638 * Returns: 0 on success, or error code
 639 */
 640
 641static int gfs2_create_inode(struct inode *dir, struct dentry *dentry,
 642			     umode_t mode, dev_t dev, const char *symname,
 643			     unsigned int size, int excl)
 644{
 645	const struct qstr *name = &dentry->d_name;
 646	struct gfs2_holder ghs[2];
 647	struct inode *inode = NULL;
 648	struct gfs2_inode *dip = GFS2_I(dir), *ip;
 649	struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
 650	struct gfs2_glock *io_gl;
 651	int error;
 652	struct buffer_head *bh = NULL;
 653	u32 aflags = 0;
 654
 655	if (!name->len || name->len > GFS2_FNAMESIZE)
 656		return -ENAMETOOLONG;
 657
 658	error = gfs2_rs_alloc(dip);
 659	if (error)
 660		return error;
 661
 662	error = gfs2_glock_nq_init(dip->i_gl, LM_ST_EXCLUSIVE, 0, ghs);
 663	if (error)
 664		goto fail;
 665
 666	error = create_ok(dip, name, mode);
 667	if ((error == -EEXIST) && S_ISREG(mode) && !excl) {
 668		inode = gfs2_lookupi(dir, &dentry->d_name, 0);
 669		gfs2_glock_dq_uninit(ghs);
 670		d_instantiate(dentry, inode);
 671		return IS_ERR(inode) ? PTR_ERR(inode) : 0;
 672	}
 673	if (error)
 674		goto fail_gunlock;
 675
 676	inode = new_inode(sdp->sd_vfs);
 677	if (!inode) {
 678		gfs2_glock_dq_uninit(ghs);
 679		return -ENOMEM;
 680	}
 681	ip = GFS2_I(inode);
 682	error = gfs2_rs_alloc(ip);
 683	if (error)
 684		goto fail_free_inode;
 685
 686	set_bit(GIF_INVALID, &ip->i_flags);
 687	inode->i_mode = mode;
 688	inode->i_rdev = dev;
 689	inode->i_size = size;
 690	munge_mode_uid_gid(dip, inode);
 691	ip->i_goal = dip->i_goal;
 692
 693	if ((GFS2_I(sdp->sd_root_dir->d_inode) == dip) ||
 694	    (dip->i_diskflags & GFS2_DIF_TOPDIR))
 695		aflags |= GFS2_AF_ORLOV;
 696
 697	error = alloc_dinode(ip, aflags);
 698	if (error)
 699		goto fail_free_inode;
 700
 701	error = gfs2_glock_get(sdp, ip->i_no_addr, &gfs2_inode_glops, CREATE, &ip->i_gl);
 702	if (error)
 703		goto fail_free_inode;
 704
 705	ip->i_gl->gl_object = ip;
 706	error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, GL_SKIP, ghs + 1);
 707	if (error)
 708		goto fail_free_inode;
 709
 710	error = make_dinode(dip, ip, symname, &bh);
 711	if (error)
 712		goto fail_gunlock2;
 713
 714	error = gfs2_glock_get(sdp, ip->i_no_addr, &gfs2_iopen_glops, CREATE, &io_gl);
 715	if (error)
 716		goto fail_gunlock2;
 717
 718	error = gfs2_glock_nq_init(io_gl, LM_ST_SHARED, GL_EXACT, &ip->i_iopen_gh);
 719	if (error)
 720		goto fail_gunlock2;
 721
 722	ip->i_iopen_gh.gh_gl->gl_object = ip;
 723	gfs2_glock_put(io_gl);
 724	gfs2_set_iop(inode);
 725	insert_inode_hash(inode);
 726
 727	error = gfs2_inode_refresh(ip);
 728	if (error)
 729		goto fail_gunlock3;
 730
 731	error = gfs2_acl_create(dip, inode);
 732	if (error)
 733		goto fail_gunlock3;
 734
 735	error = gfs2_security_init(dip, ip, name);
 736	if (error)
 737		goto fail_gunlock3;
 738
 739	error = link_dinode(dip, name, ip);
 740	if (error)
 741		goto fail_gunlock3;
 742
 743	if (bh)
 744		brelse(bh);
 745
 746	gfs2_trans_end(sdp);
 747	gfs2_inplace_release(dip);
 748	gfs2_quota_unlock(dip);
 749	mark_inode_dirty(inode);
 750	gfs2_glock_dq_uninit_m(2, ghs);
 751	d_instantiate(dentry, inode);
 752	return 0;
 753
 754fail_gunlock3:
 755	gfs2_glock_dq_uninit(ghs + 1);
 756	if (ip->i_gl)
 757		gfs2_glock_put(ip->i_gl);
 758	goto fail_gunlock;
 759
 760fail_gunlock2:
 761	gfs2_glock_dq_uninit(ghs + 1);
 762fail_free_inode:
 763	if (ip->i_gl)
 764		gfs2_glock_put(ip->i_gl);
 765	gfs2_rs_delete(ip);
 766	free_inode_nonrcu(inode);
 767	inode = NULL;
 768fail_gunlock:
 769	gfs2_glock_dq_uninit(ghs);
 770	if (inode && !IS_ERR(inode)) {
 771		set_bit(GIF_ALLOC_FAILED, &GFS2_I(inode)->i_flags);
 772		iput(inode);
 773	}
 774fail:
 775	if (bh)
 776		brelse(bh);
 777	return error;
 778}
 779
 780/**
 781 * gfs2_create - Create a file
 782 * @dir: The directory in which to create the file
 783 * @dentry: The dentry of the new file
 784 * @mode: The mode of the new file
 785 *
 786 * Returns: errno
 787 */
 788
 789static int gfs2_create(struct inode *dir, struct dentry *dentry,
 790		       umode_t mode, bool excl)
 791{
 792	return gfs2_create_inode(dir, dentry, S_IFREG | mode, 0, NULL, 0, excl);
 793}
 794
 795/**
 796 * gfs2_lookup - Look up a filename in a directory and return its inode
 797 * @dir: The directory inode
 798 * @dentry: The dentry of the new inode
 799 * @nd: passed from Linux VFS, ignored by us
 800 *
 801 * Called by the VFS layer. Lock dir and call gfs2_lookupi()
 802 *
 803 * Returns: errno
 804 */
 805
 806static struct dentry *gfs2_lookup(struct inode *dir, struct dentry *dentry,
 807				  unsigned int flags)
 808{
 809	struct inode *inode = gfs2_lookupi(dir, &dentry->d_name, 0);
 810	if (inode && !IS_ERR(inode)) {
 811		struct gfs2_glock *gl = GFS2_I(inode)->i_gl;
 812		struct gfs2_holder gh;
 813		int error;
 814		error = gfs2_glock_nq_init(gl, LM_ST_SHARED, LM_FLAG_ANY, &gh);
 815		if (error) {
 816			iput(inode);
 817			return ERR_PTR(error);
 818		}
 819		gfs2_glock_dq_uninit(&gh);
 820	}
 821	return d_splice_alias(inode, dentry);
 822}
 823
 824/**
 825 * gfs2_link - Link to a file
 826 * @old_dentry: The inode to link
 827 * @dir: Add link to this directory
 828 * @dentry: The name of the link
 829 *
 830 * Link the inode in "old_dentry" into the directory "dir" with the
 831 * name in "dentry".
 832 *
 833 * Returns: errno
 834 */
 835
 836static int gfs2_link(struct dentry *old_dentry, struct inode *dir,
 837		     struct dentry *dentry)
 838{
 839	struct gfs2_inode *dip = GFS2_I(dir);
 840	struct gfs2_sbd *sdp = GFS2_SB(dir);
 841	struct inode *inode = old_dentry->d_inode;
 842	struct gfs2_inode *ip = GFS2_I(inode);
 843	struct gfs2_holder ghs[2];
 844	struct buffer_head *dibh;
 845	int alloc_required;
 846	int error;
 847
 848	if (S_ISDIR(inode->i_mode))
 849		return -EPERM;
 850
 851	error = gfs2_rs_alloc(dip);
 852	if (error)
 853		return error;
 854
 855	gfs2_holder_init(dip->i_gl, LM_ST_EXCLUSIVE, 0, ghs);
 856	gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + 1);
 857
 858	error = gfs2_glock_nq(ghs); /* parent */
 859	if (error)
 860		goto out_parent;
 861
 862	error = gfs2_glock_nq(ghs + 1); /* child */
 863	if (error)
 864		goto out_child;
 865
 866	error = -ENOENT;
 867	if (inode->i_nlink == 0)
 868		goto out_gunlock;
 869
 870	error = gfs2_permission(dir, MAY_WRITE | MAY_EXEC);
 871	if (error)
 872		goto out_gunlock;
 873
 874	error = gfs2_dir_check(dir, &dentry->d_name, NULL);
 875	switch (error) {
 876	case -ENOENT:
 877		break;
 878	case 0:
 879		error = -EEXIST;
 880	default:
 881		goto out_gunlock;
 882	}
 883
 884	error = -EINVAL;
 885	if (!dip->i_inode.i_nlink)
 886		goto out_gunlock;
 887	error = -EFBIG;
 888	if (dip->i_entries == (u32)-1)
 889		goto out_gunlock;
 890	error = -EPERM;
 891	if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
 892		goto out_gunlock;
 893	error = -EINVAL;
 894	if (!ip->i_inode.i_nlink)
 895		goto out_gunlock;
 896	error = -EMLINK;
 897	if (ip->i_inode.i_nlink == (u32)-1)
 898		goto out_gunlock;
 899
 900	alloc_required = error = gfs2_diradd_alloc_required(dir, &dentry->d_name);
 901	if (error < 0)
 902		goto out_gunlock;
 903	error = 0;
 904
 905	if (alloc_required) {
 906		error = gfs2_quota_lock_check(dip);
 907		if (error)
 908			goto out_gunlock;
 909
 910		error = gfs2_inplace_reserve(dip, sdp->sd_max_dirres, 0);
 911		if (error)
 912			goto out_gunlock_q;
 913
 914		error = gfs2_trans_begin(sdp, sdp->sd_max_dirres +
 915					 gfs2_rg_blocks(dip, sdp->sd_max_dirres) +
 916					 2 * RES_DINODE + RES_STATFS +
 917					 RES_QUOTA, 0);
 918		if (error)
 919			goto out_ipres;
 920	} else {
 921		error = gfs2_trans_begin(sdp, 2 * RES_DINODE + RES_LEAF, 0);
 922		if (error)
 923			goto out_ipres;
 924	}
 925
 926	error = gfs2_meta_inode_buffer(ip, &dibh);
 927	if (error)
 928		goto out_end_trans;
 929
 930	error = gfs2_dir_add(dir, &dentry->d_name, ip);
 931	if (error)
 932		goto out_brelse;
 933
 934	gfs2_trans_add_bh(ip->i_gl, dibh, 1);
 935	inc_nlink(&ip->i_inode);
 936	ip->i_inode.i_ctime = CURRENT_TIME;
 937	ihold(inode);
 938	d_instantiate(dentry, inode);
 939	mark_inode_dirty(inode);
 940
 941out_brelse:
 942	brelse(dibh);
 943out_end_trans:
 944	gfs2_trans_end(sdp);
 945out_ipres:
 946	if (alloc_required)
 947		gfs2_inplace_release(dip);
 948out_gunlock_q:
 949	if (alloc_required)
 950		gfs2_quota_unlock(dip);
 951out_gunlock:
 952	gfs2_glock_dq(ghs + 1);
 953out_child:
 954	gfs2_glock_dq(ghs);
 955out_parent:
 956	gfs2_holder_uninit(ghs);
 957	gfs2_holder_uninit(ghs + 1);
 958	return error;
 959}
 960
 961/*
 962 * gfs2_unlink_ok - check to see that a inode is still in a directory
 963 * @dip: the directory
 964 * @name: the name of the file
 965 * @ip: the inode
 966 *
 967 * Assumes that the lock on (at least) @dip is held.
 968 *
 969 * Returns: 0 if the parent/child relationship is correct, errno if it isn't
 970 */
 971
 972static int gfs2_unlink_ok(struct gfs2_inode *dip, const struct qstr *name,
 973			  const struct gfs2_inode *ip)
 974{
 975	int error;
 976
 977	if (IS_IMMUTABLE(&ip->i_inode) || IS_APPEND(&ip->i_inode))
 978		return -EPERM;
 979
 980	if ((dip->i_inode.i_mode & S_ISVTX) &&
 981	    dip->i_inode.i_uid != current_fsuid() &&
 982	    ip->i_inode.i_uid != current_fsuid() && !capable(CAP_FOWNER))
 983		return -EPERM;
 984
 985	if (IS_APPEND(&dip->i_inode))
 986		return -EPERM;
 987
 988	error = gfs2_permission(&dip->i_inode, MAY_WRITE | MAY_EXEC);
 989	if (error)
 990		return error;
 991
 992	error = gfs2_dir_check(&dip->i_inode, name, ip);
 993	if (error)
 994		return error;
 995
 996	return 0;
 997}
 998
 999/**
1000 * gfs2_unlink_inode - Removes an inode from its parent dir and unlinks it
1001 * @dip: The parent directory
1002 * @name: The name of the entry in the parent directory
1003 * @inode: The inode to be removed
1004 *
1005 * Called with all the locks and in a transaction. This will only be
1006 * called for a directory after it has been checked to ensure it is empty.
1007 *
1008 * Returns: 0 on success, or an error
1009 */
1010
1011static int gfs2_unlink_inode(struct gfs2_inode *dip,
1012			     const struct dentry *dentry)
1013{
1014	struct inode *inode = dentry->d_inode;
1015	struct gfs2_inode *ip = GFS2_I(inode);
1016	int error;
1017
1018	error = gfs2_dir_del(dip, dentry);
1019	if (error)
1020		return error;
1021
1022	ip->i_entries = 0;
1023	inode->i_ctime = CURRENT_TIME;
1024	if (S_ISDIR(inode->i_mode))
1025		clear_nlink(inode);
1026	else
1027		drop_nlink(inode);
1028	mark_inode_dirty(inode);
1029	if (inode->i_nlink == 0)
1030		gfs2_unlink_di(inode);
1031	return 0;
1032}
1033
1034
1035/**
1036 * gfs2_unlink - Unlink an inode (this does rmdir as well)
1037 * @dir: The inode of the directory containing the inode to unlink
1038 * @dentry: The file itself
1039 *
1040 * This routine uses the type of the inode as a flag to figure out
1041 * whether this is an unlink or an rmdir.
1042 *
1043 * Returns: errno
1044 */
1045
1046static int gfs2_unlink(struct inode *dir, struct dentry *dentry)
1047{
1048	struct gfs2_inode *dip = GFS2_I(dir);
1049	struct gfs2_sbd *sdp = GFS2_SB(dir);
1050	struct inode *inode = dentry->d_inode;
1051	struct gfs2_inode *ip = GFS2_I(inode);
1052	struct gfs2_holder ghs[3];
1053	struct gfs2_rgrpd *rgd;
1054	int error;
1055
1056	error = gfs2_rindex_update(sdp);
1057	if (error)
1058		return error;
1059
1060	error = -EROFS;
1061
1062	gfs2_holder_init(dip->i_gl, LM_ST_EXCLUSIVE, 0, ghs);
1063	gfs2_holder_init(ip->i_gl,  LM_ST_EXCLUSIVE, 0, ghs + 1);
1064
1065	rgd = gfs2_blk2rgrpd(sdp, ip->i_no_addr, 1);
1066	if (!rgd)
1067		goto out_inodes;
1068
1069	gfs2_holder_init(rgd->rd_gl, LM_ST_EXCLUSIVE, 0, ghs + 2);
1070
1071
1072	error = gfs2_glock_nq(ghs); /* parent */
1073	if (error)
1074		goto out_parent;
1075
1076	error = gfs2_glock_nq(ghs + 1); /* child */
1077	if (error)
1078		goto out_child;
1079
1080	error = -ENOENT;
1081	if (inode->i_nlink == 0)
1082		goto out_rgrp;
1083
1084	if (S_ISDIR(inode->i_mode)) {
1085		error = -ENOTEMPTY;
1086		if (ip->i_entries > 2 || inode->i_nlink > 2)
1087			goto out_rgrp;
1088	}
1089
1090	error = gfs2_glock_nq(ghs + 2); /* rgrp */
1091	if (error)
1092		goto out_rgrp;
1093
1094	error = gfs2_unlink_ok(dip, &dentry->d_name, ip);
1095	if (error)
1096		goto out_gunlock;
1097
1098	error = gfs2_trans_begin(sdp, 2*RES_DINODE + 3*RES_LEAF + RES_RG_BIT, 0);
1099	if (error)
1100		goto out_end_trans;
1101
1102	error = gfs2_unlink_inode(dip, dentry);
1103
1104out_end_trans:
1105	gfs2_trans_end(sdp);
1106out_gunlock:
1107	gfs2_glock_dq(ghs + 2);
1108out_rgrp:
1109	gfs2_glock_dq(ghs + 1);
1110out_child:
1111	gfs2_glock_dq(ghs);
1112out_parent:
1113	gfs2_holder_uninit(ghs + 2);
1114out_inodes:
1115	gfs2_holder_uninit(ghs + 1);
1116	gfs2_holder_uninit(ghs);
1117	return error;
1118}
1119
1120/**
1121 * gfs2_symlink - Create a symlink
1122 * @dir: The directory to create the symlink in
1123 * @dentry: The dentry to put the symlink in
1124 * @symname: The thing which the link points to
1125 *
1126 * Returns: errno
1127 */
1128
1129static int gfs2_symlink(struct inode *dir, struct dentry *dentry,
1130			const char *symname)
1131{
1132	struct gfs2_sbd *sdp = GFS2_SB(dir);
1133	unsigned int size;
1134
1135	size = strlen(symname);
1136	if (size > sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode) - 1)
1137		return -ENAMETOOLONG;
1138
1139	return gfs2_create_inode(dir, dentry, S_IFLNK | S_IRWXUGO, 0, symname, size, 0);
1140}
1141
1142/**
1143 * gfs2_mkdir - Make a directory
1144 * @dir: The parent directory of the new one
1145 * @dentry: The dentry of the new directory
1146 * @mode: The mode of the new directory
1147 *
1148 * Returns: errno
1149 */
1150
1151static int gfs2_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
1152{
1153	return gfs2_create_inode(dir, dentry, S_IFDIR | mode, 0, NULL, 0, 0);
1154}
1155
1156/**
1157 * gfs2_mknod - Make a special file
1158 * @dir: The directory in which the special file will reside
1159 * @dentry: The dentry of the special file
1160 * @mode: The mode of the special file
1161 * @dev: The device specification of the special file
1162 *
1163 */
1164
1165static int gfs2_mknod(struct inode *dir, struct dentry *dentry, umode_t mode,
1166		      dev_t dev)
1167{
1168	return gfs2_create_inode(dir, dentry, mode, dev, NULL, 0, 0);
1169}
1170
1171/*
1172 * gfs2_ok_to_move - check if it's ok to move a directory to another directory
1173 * @this: move this
1174 * @to: to here
1175 *
1176 * Follow @to back to the root and make sure we don't encounter @this
1177 * Assumes we already hold the rename lock.
1178 *
1179 * Returns: errno
1180 */
1181
1182static int gfs2_ok_to_move(struct gfs2_inode *this, struct gfs2_inode *to)
1183{
1184	struct inode *dir = &to->i_inode;
1185	struct super_block *sb = dir->i_sb;
1186	struct inode *tmp;
1187	int error = 0;
1188
1189	igrab(dir);
1190
1191	for (;;) {
1192		if (dir == &this->i_inode) {
1193			error = -EINVAL;
1194			break;
1195		}
1196		if (dir == sb->s_root->d_inode) {
1197			error = 0;
1198			break;
1199		}
1200
1201		tmp = gfs2_lookupi(dir, &gfs2_qdotdot, 1);
1202		if (IS_ERR(tmp)) {
1203			error = PTR_ERR(tmp);
1204			break;
1205		}
1206
1207		iput(dir);
1208		dir = tmp;
1209	}
1210
1211	iput(dir);
1212
1213	return error;
1214}
1215
1216/**
1217 * gfs2_rename - Rename a file
1218 * @odir: Parent directory of old file name
1219 * @odentry: The old dentry of the file
1220 * @ndir: Parent directory of new file name
1221 * @ndentry: The new dentry of the file
1222 *
1223 * Returns: errno
1224 */
1225
1226static int gfs2_rename(struct inode *odir, struct dentry *odentry,
1227		       struct inode *ndir, struct dentry *ndentry)
1228{
1229	struct gfs2_inode *odip = GFS2_I(odir);
1230	struct gfs2_inode *ndip = GFS2_I(ndir);
1231	struct gfs2_inode *ip = GFS2_I(odentry->d_inode);
1232	struct gfs2_inode *nip = NULL;
1233	struct gfs2_sbd *sdp = GFS2_SB(odir);
1234	struct gfs2_holder ghs[5], r_gh = { .gh_gl = NULL, };
1235	struct gfs2_rgrpd *nrgd;
1236	unsigned int num_gh;
1237	int dir_rename = 0;
1238	int alloc_required = 0;
1239	unsigned int x;
1240	int error;
1241
1242	if (ndentry->d_inode) {
1243		nip = GFS2_I(ndentry->d_inode);
1244		if (ip == nip)
1245			return 0;
1246	}
1247
1248	error = gfs2_rindex_update(sdp);
1249	if (error)
1250		return error;
1251
1252	error = gfs2_rs_alloc(ndip);
1253	if (error)
1254		return error;
1255
1256	if (odip != ndip) {
1257		error = gfs2_glock_nq_init(sdp->sd_rename_gl, LM_ST_EXCLUSIVE,
1258					   0, &r_gh);
1259		if (error)
1260			goto out;
1261
1262		if (S_ISDIR(ip->i_inode.i_mode)) {
1263			dir_rename = 1;
1264			/* don't move a dirctory into it's subdir */
1265			error = gfs2_ok_to_move(ip, ndip);
1266			if (error)
1267				goto out_gunlock_r;
1268		}
1269	}
1270
1271	num_gh = 1;
1272	gfs2_holder_init(odip->i_gl, LM_ST_EXCLUSIVE, 0, ghs);
1273	if (odip != ndip) {
1274		gfs2_holder_init(ndip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + num_gh);
1275		num_gh++;
1276	}
1277	gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + num_gh);
1278	num_gh++;
1279
1280	if (nip) {
1281		gfs2_holder_init(nip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + num_gh);
1282		num_gh++;
1283		/* grab the resource lock for unlink flag twiddling 
1284		 * this is the case of the target file already existing
1285		 * so we unlink before doing the rename
1286		 */
1287		nrgd = gfs2_blk2rgrpd(sdp, nip->i_no_addr, 1);
1288		if (nrgd)
1289			gfs2_holder_init(nrgd->rd_gl, LM_ST_EXCLUSIVE, 0, ghs + num_gh++);
1290	}
1291
1292	for (x = 0; x < num_gh; x++) {
1293		error = gfs2_glock_nq(ghs + x);
1294		if (error)
1295			goto out_gunlock;
1296	}
1297
1298	error = -ENOENT;
1299	if (ip->i_inode.i_nlink == 0)
1300		goto out_gunlock;
1301
1302	/* Check out the old directory */
1303
1304	error = gfs2_unlink_ok(odip, &odentry->d_name, ip);
1305	if (error)
1306		goto out_gunlock;
1307
1308	/* Check out the new directory */
1309
1310	if (nip) {
1311		error = gfs2_unlink_ok(ndip, &ndentry->d_name, nip);
1312		if (error)
1313			goto out_gunlock;
1314
1315		if (nip->i_inode.i_nlink == 0) {
1316			error = -EAGAIN;
1317			goto out_gunlock;
1318		}
1319
1320		if (S_ISDIR(nip->i_inode.i_mode)) {
1321			if (nip->i_entries < 2) {
1322				gfs2_consist_inode(nip);
1323				error = -EIO;
1324				goto out_gunlock;
1325			}
1326			if (nip->i_entries > 2) {
1327				error = -ENOTEMPTY;
1328				goto out_gunlock;
1329			}
1330		}
1331	} else {
1332		error = gfs2_permission(ndir, MAY_WRITE | MAY_EXEC);
1333		if (error)
1334			goto out_gunlock;
1335
1336		error = gfs2_dir_check(ndir, &ndentry->d_name, NULL);
1337		switch (error) {
1338		case -ENOENT:
1339			error = 0;
1340			break;
1341		case 0:
1342			error = -EEXIST;
1343		default:
1344			goto out_gunlock;
1345		};
1346
1347		if (odip != ndip) {
1348			if (!ndip->i_inode.i_nlink) {
1349				error = -ENOENT;
1350				goto out_gunlock;
1351			}
1352			if (ndip->i_entries == (u32)-1) {
1353				error = -EFBIG;
1354				goto out_gunlock;
1355			}
1356			if (S_ISDIR(ip->i_inode.i_mode) &&
1357			    ndip->i_inode.i_nlink == (u32)-1) {
1358				error = -EMLINK;
1359				goto out_gunlock;
1360			}
1361		}
1362	}
1363
1364	/* Check out the dir to be renamed */
1365
1366	if (dir_rename) {
1367		error = gfs2_permission(odentry->d_inode, MAY_WRITE);
1368		if (error)
1369			goto out_gunlock;
1370	}
1371
1372	if (nip == NULL)
1373		alloc_required = gfs2_diradd_alloc_required(ndir, &ndentry->d_name);
1374	error = alloc_required;
1375	if (error < 0)
1376		goto out_gunlock;
1377
1378	if (alloc_required) {
1379		error = gfs2_quota_lock_check(ndip);
1380		if (error)
1381			goto out_gunlock;
1382
1383		error = gfs2_inplace_reserve(ndip, sdp->sd_max_dirres, 0);
1384		if (error)
1385			goto out_gunlock_q;
1386
1387		error = gfs2_trans_begin(sdp, sdp->sd_max_dirres +
1388					 gfs2_rg_blocks(ndip, sdp->sd_max_dirres) +
1389					 4 * RES_DINODE + 4 * RES_LEAF +
1390					 RES_STATFS + RES_QUOTA + 4, 0);
1391		if (error)
1392			goto out_ipreserv;
1393	} else {
1394		error = gfs2_trans_begin(sdp, 4 * RES_DINODE +
1395					 5 * RES_LEAF + 4, 0);
1396		if (error)
1397			goto out_gunlock;
1398	}
1399
1400	/* Remove the target file, if it exists */
1401
1402	if (nip)
1403		error = gfs2_unlink_inode(ndip, ndentry);
1404
1405	if (dir_rename) {
1406		error = gfs2_dir_mvino(ip, &gfs2_qdotdot, ndip, DT_DIR);
1407		if (error)
1408			goto out_end_trans;
1409	} else {
1410		struct buffer_head *dibh;
1411		error = gfs2_meta_inode_buffer(ip, &dibh);
1412		if (error)
1413			goto out_end_trans;
1414		ip->i_inode.i_ctime = CURRENT_TIME;
1415		gfs2_trans_add_bh(ip->i_gl, dibh, 1);
1416		gfs2_dinode_out(ip, dibh->b_data);
1417		brelse(dibh);
1418	}
1419
1420	error = gfs2_dir_del(odip, odentry);
1421	if (error)
1422		goto out_end_trans;
1423
1424	error = gfs2_dir_add(ndir, &ndentry->d_name, ip);
1425	if (error)
1426		goto out_end_trans;
1427
1428out_end_trans:
1429	gfs2_trans_end(sdp);
1430out_ipreserv:
1431	if (alloc_required)
1432		gfs2_inplace_release(ndip);
1433out_gunlock_q:
1434	if (alloc_required)
1435		gfs2_quota_unlock(ndip);
1436out_gunlock:
1437	while (x--) {
1438		gfs2_glock_dq(ghs + x);
1439		gfs2_holder_uninit(ghs + x);
1440	}
1441out_gunlock_r:
1442	if (r_gh.gh_gl)
1443		gfs2_glock_dq_uninit(&r_gh);
1444out:
1445	return error;
1446}
1447
1448/**
1449 * gfs2_follow_link - Follow a symbolic link
1450 * @dentry: The dentry of the link
1451 * @nd: Data that we pass to vfs_follow_link()
1452 *
1453 * This can handle symlinks of any size.
1454 *
1455 * Returns: 0 on success or error code
1456 */
1457
1458static void *gfs2_follow_link(struct dentry *dentry, struct nameidata *nd)
1459{
1460	struct gfs2_inode *ip = GFS2_I(dentry->d_inode);
1461	struct gfs2_holder i_gh;
1462	struct buffer_head *dibh;
1463	unsigned int size;
1464	char *buf;
1465	int error;
1466
1467	gfs2_holder_init(ip->i_gl, LM_ST_SHARED, 0, &i_gh);
1468	error = gfs2_glock_nq(&i_gh);
1469	if (error) {
1470		gfs2_holder_uninit(&i_gh);
1471		nd_set_link(nd, ERR_PTR(error));
1472		return NULL;
1473	}
1474
1475	size = (unsigned int)i_size_read(&ip->i_inode);
1476	if (size == 0) {
1477		gfs2_consist_inode(ip);
1478		buf = ERR_PTR(-EIO);
1479		goto out;
1480	}
1481
1482	error = gfs2_meta_inode_buffer(ip, &dibh);
1483	if (error) {
1484		buf = ERR_PTR(error);
1485		goto out;
1486	}
1487
1488	buf = kzalloc(size + 1, GFP_NOFS);
1489	if (!buf)
1490		buf = ERR_PTR(-ENOMEM);
1491	else
1492		memcpy(buf, dibh->b_data + sizeof(struct gfs2_dinode), size);
1493	brelse(dibh);
1494out:
1495	gfs2_glock_dq_uninit(&i_gh);
1496	nd_set_link(nd, buf);
1497	return NULL;
1498}
1499
1500static void gfs2_put_link(struct dentry *dentry, struct nameidata *nd, void *p)
1501{
1502	char *s = nd_get_link(nd);
1503	if (!IS_ERR(s))
1504		kfree(s);
1505}
1506
1507/**
1508 * gfs2_permission -
1509 * @inode: The inode
1510 * @mask: The mask to be tested
1511 * @flags: Indicates whether this is an RCU path walk or not
1512 *
1513 * This may be called from the VFS directly, or from within GFS2 with the
1514 * inode locked, so we look to see if the glock is already locked and only
1515 * lock the glock if its not already been done.
1516 *
1517 * Returns: errno
1518 */
1519
1520int gfs2_permission(struct inode *inode, int mask)
1521{
1522	struct gfs2_inode *ip;
1523	struct gfs2_holder i_gh;
1524	int error;
1525	int unlock = 0;
1526
1527
1528	ip = GFS2_I(inode);
1529	if (gfs2_glock_is_locked_by_me(ip->i_gl) == NULL) {
1530		if (mask & MAY_NOT_BLOCK)
1531			return -ECHILD;
1532		error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, &i_gh);
1533		if (error)
1534			return error;
1535		unlock = 1;
1536	}
1537
1538	if ((mask & MAY_WRITE) && IS_IMMUTABLE(inode))
1539		error = -EACCES;
1540	else
1541		error = generic_permission(inode, mask);
1542	if (unlock)
1543		gfs2_glock_dq_uninit(&i_gh);
1544
1545	return error;
1546}
1547
1548static int __gfs2_setattr_simple(struct inode *inode, struct iattr *attr)
1549{
1550	setattr_copy(inode, attr);
1551	mark_inode_dirty(inode);
1552	return 0;
1553}
1554
1555/**
1556 * gfs2_setattr_simple -
1557 * @ip:
1558 * @attr:
1559 *
1560 * Returns: errno
1561 */
1562
1563int gfs2_setattr_simple(struct inode *inode, struct iattr *attr)
1564{
1565	int error;
1566
1567	if (current->journal_info)
1568		return __gfs2_setattr_simple(inode, attr);
1569
1570	error = gfs2_trans_begin(GFS2_SB(inode), RES_DINODE, 0);
1571	if (error)
1572		return error;
1573
1574	error = __gfs2_setattr_simple(inode, attr);
1575	gfs2_trans_end(GFS2_SB(inode));
1576	return error;
1577}
1578
1579static int setattr_chown(struct inode *inode, struct iattr *attr)
1580{
1581	struct gfs2_inode *ip = GFS2_I(inode);
1582	struct gfs2_sbd *sdp = GFS2_SB(inode);
1583	u32 ouid, ogid, nuid, ngid;
1584	int error;
1585
1586	ouid = inode->i_uid;
1587	ogid = inode->i_gid;
1588	nuid = attr->ia_uid;
1589	ngid = attr->ia_gid;
1590
1591	if (!(attr->ia_valid & ATTR_UID) || ouid == nuid)
1592		ouid = nuid = NO_QUOTA_CHANGE;
1593	if (!(attr->ia_valid & ATTR_GID) || ogid == ngid)
1594		ogid = ngid = NO_QUOTA_CHANGE;
1595
1596	error = gfs2_quota_lock(ip, nuid, ngid);
1597	if (error)
1598		return error;
1599
1600	if (ouid != NO_QUOTA_CHANGE || ogid != NO_QUOTA_CHANGE) {
1601		error = gfs2_quota_check(ip, nuid, ngid);
1602		if (error)
1603			goto out_gunlock_q;
1604	}
1605
1606	error = gfs2_trans_begin(sdp, RES_DINODE + 2 * RES_QUOTA, 0);
1607	if (error)
1608		goto out_gunlock_q;
1609
1610	error = gfs2_setattr_simple(inode, attr);
1611	if (error)
1612		goto out_end_trans;
1613
1614	if (ouid != NO_QUOTA_CHANGE || ogid != NO_QUOTA_CHANGE) {
1615		u64 blocks = gfs2_get_inode_blocks(&ip->i_inode);
1616		gfs2_quota_change(ip, -blocks, ouid, ogid);
1617		gfs2_quota_change(ip, blocks, nuid, ngid);
1618	}
1619
1620out_end_trans:
1621	gfs2_trans_end(sdp);
1622out_gunlock_q:
1623	gfs2_quota_unlock(ip);
1624	return error;
1625}
1626
1627/**
1628 * gfs2_setattr - Change attributes on an inode
1629 * @dentry: The dentry which is changing
1630 * @attr: The structure describing the change
1631 *
1632 * The VFS layer wants to change one or more of an inodes attributes.  Write
1633 * that change out to disk.
1634 *
1635 * Returns: errno
1636 */
1637
1638static int gfs2_setattr(struct dentry *dentry, struct iattr *attr)
1639{
1640	struct inode *inode = dentry->d_inode;
1641	struct gfs2_inode *ip = GFS2_I(inode);
1642	struct gfs2_holder i_gh;
1643	int error;
1644
1645	error = gfs2_rs_alloc(ip);
1646	if (error)
1647		return error;
1648
1649	error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &i_gh);
1650	if (error)
1651		return error;
1652
1653	error = -EPERM;
1654	if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
1655		goto out;
1656
1657	error = inode_change_ok(inode, attr);
1658	if (error)
1659		goto out;
1660
1661	if (attr->ia_valid & ATTR_SIZE)
1662		error = gfs2_setattr_size(inode, attr->ia_size);
1663	else if (attr->ia_valid & (ATTR_UID | ATTR_GID))
1664		error = setattr_chown(inode, attr);
1665	else if ((attr->ia_valid & ATTR_MODE) && IS_POSIXACL(inode))
1666		error = gfs2_acl_chmod(ip, attr);
1667	else
1668		error = gfs2_setattr_simple(inode, attr);
1669
1670out:
1671	if (!error)
1672		mark_inode_dirty(inode);
1673	gfs2_glock_dq_uninit(&i_gh);
1674	return error;
1675}
1676
1677/**
1678 * gfs2_getattr - Read out an inode's attributes
1679 * @mnt: The vfsmount the inode is being accessed from
1680 * @dentry: The dentry to stat
1681 * @stat: The inode's stats
1682 *
1683 * This may be called from the VFS directly, or from within GFS2 with the
1684 * inode locked, so we look to see if the glock is already locked and only
1685 * lock the glock if its not already been done. Note that its the NFS
1686 * readdirplus operation which causes this to be called (from filldir)
1687 * with the glock already held.
1688 *
1689 * Returns: errno
1690 */
1691
1692static int gfs2_getattr(struct vfsmount *mnt, struct dentry *dentry,
1693			struct kstat *stat)
1694{
1695	struct inode *inode = dentry->d_inode;
1696	struct gfs2_inode *ip = GFS2_I(inode);
1697	struct gfs2_holder gh;
1698	int error;
1699	int unlock = 0;
1700
1701	if (gfs2_glock_is_locked_by_me(ip->i_gl) == NULL) {
1702		error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, &gh);
1703		if (error)
1704			return error;
1705		unlock = 1;
1706	}
1707
1708	generic_fillattr(inode, stat);
1709	if (unlock)
1710		gfs2_glock_dq_uninit(&gh);
1711
1712	return 0;
1713}
1714
1715static int gfs2_setxattr(struct dentry *dentry, const char *name,
1716			 const void *data, size_t size, int flags)
1717{
1718	struct inode *inode = dentry->d_inode;
1719	struct gfs2_inode *ip = GFS2_I(inode);
1720	struct gfs2_holder gh;
1721	int ret;
1722
1723	gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);
1724	ret = gfs2_glock_nq(&gh);
1725	if (ret == 0) {
1726		ret = gfs2_rs_alloc(ip);
1727		if (ret == 0)
1728			ret = generic_setxattr(dentry, name, data, size, flags);
1729		gfs2_glock_dq(&gh);
1730	}
1731	gfs2_holder_uninit(&gh);
1732	return ret;
1733}
1734
1735static ssize_t gfs2_getxattr(struct dentry *dentry, const char *name,
1736			     void *data, size_t size)
1737{
1738	struct inode *inode = dentry->d_inode;
1739	struct gfs2_inode *ip = GFS2_I(inode);
1740	struct gfs2_holder gh;
1741	int ret;
1742
1743	gfs2_holder_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, &gh);
1744	ret = gfs2_glock_nq(&gh);
1745	if (ret == 0) {
1746		ret = generic_getxattr(dentry, name, data, size);
1747		gfs2_glock_dq(&gh);
1748	}
1749	gfs2_holder_uninit(&gh);
1750	return ret;
1751}
1752
1753static int gfs2_removexattr(struct dentry *dentry, const char *name)
1754{
1755	struct inode *inode = dentry->d_inode;
1756	struct gfs2_inode *ip = GFS2_I(inode);
1757	struct gfs2_holder gh;
1758	int ret;
1759
1760	gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);
1761	ret = gfs2_glock_nq(&gh);
1762	if (ret == 0) {
1763		ret = gfs2_rs_alloc(ip);
1764		if (ret == 0)
1765			ret = generic_removexattr(dentry, name);
1766		gfs2_glock_dq(&gh);
1767	}
1768	gfs2_holder_uninit(&gh);
1769	return ret;
1770}
1771
1772static int gfs2_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
1773		       u64 start, u64 len)
1774{
1775	struct gfs2_inode *ip = GFS2_I(inode);
1776	struct gfs2_holder gh;
1777	int ret;
1778
1779	ret = fiemap_check_flags(fieinfo, FIEMAP_FLAG_SYNC);
1780	if (ret)
1781		return ret;
1782
1783	mutex_lock(&inode->i_mutex);
1784
1785	ret = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, 0, &gh);
1786	if (ret)
1787		goto out;
1788
1789	if (gfs2_is_stuffed(ip)) {
1790		u64 phys = ip->i_no_addr << inode->i_blkbits;
1791		u64 size = i_size_read(inode);
1792		u32 flags = FIEMAP_EXTENT_LAST|FIEMAP_EXTENT_NOT_ALIGNED|
1793			    FIEMAP_EXTENT_DATA_INLINE;
1794		phys += sizeof(struct gfs2_dinode);
1795		phys += start;
1796		if (start + len > size)
1797			len = size - start;
1798		if (start < size)
1799			ret = fiemap_fill_next_extent(fieinfo, start, phys,
1800						      len, flags);
1801		if (ret == 1)
1802			ret = 0;
1803	} else {
1804		ret = __generic_block_fiemap(inode, fieinfo, start, len,
1805					     gfs2_block_map);
1806	}
1807
1808	gfs2_glock_dq_uninit(&gh);
1809out:
1810	mutex_unlock(&inode->i_mutex);
1811	return ret;
1812}
1813
1814const struct inode_operations gfs2_file_iops = {
1815	.permission = gfs2_permission,
1816	.setattr = gfs2_setattr,
1817	.getattr = gfs2_getattr,
1818	.setxattr = gfs2_setxattr,
1819	.getxattr = gfs2_getxattr,
1820	.listxattr = gfs2_listxattr,
1821	.removexattr = gfs2_removexattr,
1822	.fiemap = gfs2_fiemap,
1823	.get_acl = gfs2_get_acl,
1824};
1825
1826const struct inode_operations gfs2_dir_iops = {
1827	.create = gfs2_create,
1828	.lookup = gfs2_lookup,
1829	.link = gfs2_link,
1830	.unlink = gfs2_unlink,
1831	.symlink = gfs2_symlink,
1832	.mkdir = gfs2_mkdir,
1833	.rmdir = gfs2_unlink,
1834	.mknod = gfs2_mknod,
1835	.rename = gfs2_rename,
1836	.permission = gfs2_permission,
1837	.setattr = gfs2_setattr,
1838	.getattr = gfs2_getattr,
1839	.setxattr = gfs2_setxattr,
1840	.getxattr = gfs2_getxattr,
1841	.listxattr = gfs2_listxattr,
1842	.removexattr = gfs2_removexattr,
1843	.fiemap = gfs2_fiemap,
1844	.get_acl = gfs2_get_acl,
1845};
1846
1847const struct inode_operations gfs2_symlink_iops = {
1848	.readlink = generic_readlink,
1849	.follow_link = gfs2_follow_link,
1850	.put_link = gfs2_put_link,
1851	.permission = gfs2_permission,
1852	.setattr = gfs2_setattr,
1853	.getattr = gfs2_getattr,
1854	.setxattr = gfs2_setxattr,
1855	.getxattr = gfs2_getxattr,
1856	.listxattr = gfs2_listxattr,
1857	.removexattr = gfs2_removexattr,
1858	.fiemap = gfs2_fiemap,
1859	.get_acl = gfs2_get_acl,
1860};
1861