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