inode.c 49.1 KB
Newer Older
D
David Teigland 已提交
1 2
/*
 * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
3
 * Copyright (C) 2004-2011 Red Hat, Inc.  All rights reserved.
D
David Teigland 已提交
4 5 6
 *
 * This copyrighted material is made available to anyone wishing to use,
 * modify, copy, or redistribute it subject to the terms and conditions
7
 * of the GNU General Public License version 2.
D
David Teigland 已提交
8 9 10 11 12 13 14 15 16 17
 */

#include <linux/slab.h>
#include <linux/spinlock.h>
#include <linux/completion.h>
#include <linux/buffer_head.h>
#include <linux/namei.h>
#include <linux/mm.h>
#include <linux/xattr.h>
#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>
D
David Teigland 已提交
22 23 24
#include <asm/uaccess.h>

#include "gfs2.h"
25
#include "incore.h"
D
David Teigland 已提交
26 27 28
#include "acl.h"
#include "bmap.h"
#include "dir.h"
29
#include "xattr.h"
D
David Teigland 已提交
30 31 32 33 34 35
#include "glock.h"
#include "inode.h"
#include "meta_io.h"
#include "quota.h"
#include "rgrp.h"
#include "trans.h"
36
#include "util.h"
37
#include "super.h"
38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151
#include "glops.h"

struct gfs2_skip_data {
	u64 no_addr;
	int skipped;
	int non_block;
};

static int iget_test(struct inode *inode, void *opaque)
{
	struct gfs2_inode *ip = GFS2_I(inode);
	struct gfs2_skip_data *data = opaque;

	if (ip->i_no_addr == data->no_addr) {
		if (data->non_block &&
		    inode->i_state & (I_FREEING|I_CLEAR|I_WILL_FREE)) {
			data->skipped = 1;
			return 0;
		}
		return 1;
	}
	return 0;
}

static int iget_set(struct inode *inode, void *opaque)
{
	struct gfs2_inode *ip = GFS2_I(inode);
	struct gfs2_skip_data *data = opaque;

	if (data->skipped)
		return -ENOENT;
	inode->i_ino = (unsigned long)(data->no_addr);
	ip->i_no_addr = data->no_addr;
	return 0;
}

struct inode *gfs2_ilookup(struct super_block *sb, u64 no_addr, int non_block)
{
	unsigned long hash = (unsigned long)no_addr;
	struct gfs2_skip_data data;

	data.no_addr = no_addr;
	data.skipped = 0;
	data.non_block = non_block;
	return ilookup5(sb, hash, iget_test, &data);
}

static struct inode *gfs2_iget(struct super_block *sb, u64 no_addr,
			       int non_block)
{
	struct gfs2_skip_data data;
	unsigned long hash = (unsigned long)no_addr;

	data.no_addr = no_addr;
	data.skipped = 0;
	data.non_block = non_block;
	return iget5_locked(sb, hash, iget_test, iget_set, &data);
}

/**
 * gfs2_set_iop - Sets inode operations
 * @inode: The inode with correct i_mode filled in
 *
 * GFS2 lookup code fills in vfs inode contents based on info obtained
 * from directory entry inside gfs2_inode_lookup().
 */

static void gfs2_set_iop(struct inode *inode)
{
	struct gfs2_sbd *sdp = GFS2_SB(inode);
	umode_t mode = inode->i_mode;

	if (S_ISREG(mode)) {
		inode->i_op = &gfs2_file_iops;
		if (gfs2_localflocks(sdp))
			inode->i_fop = &gfs2_file_fops_nolock;
		else
			inode->i_fop = &gfs2_file_fops;
	} else if (S_ISDIR(mode)) {
		inode->i_op = &gfs2_dir_iops;
		if (gfs2_localflocks(sdp))
			inode->i_fop = &gfs2_dir_fops_nolock;
		else
			inode->i_fop = &gfs2_dir_fops;
	} else if (S_ISLNK(mode)) {
		inode->i_op = &gfs2_symlink_iops;
	} else {
		inode->i_op = &gfs2_file_iops;
		init_special_inode(inode, inode->i_mode, inode->i_rdev);
	}
}

/**
 * gfs2_inode_lookup - Lookup an inode
 * @sb: The super block
 * @no_addr: The inode number
 * @type: The type of the inode
 * non_block: Can we block on inodes that are being freed?
 *
 * Returns: A VFS inode, or an error
 */

struct inode *gfs2_inode_lookup(struct super_block *sb, unsigned int type,
				u64 no_addr, u64 no_formal_ino, int non_block)
{
	struct inode *inode;
	struct gfs2_inode *ip;
	struct gfs2_glock *io_gl = NULL;
	int error;

	inode = gfs2_iget(sb, no_addr, non_block);
	ip = GFS2_I(inode);

	if (!inode)
152
		return ERR_PTR(-ENOMEM);
153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191

	if (inode->i_state & I_NEW) {
		struct gfs2_sbd *sdp = GFS2_SB(inode);
		ip->i_no_formal_ino = no_formal_ino;

		error = gfs2_glock_get(sdp, no_addr, &gfs2_inode_glops, CREATE, &ip->i_gl);
		if (unlikely(error))
			goto fail;
		ip->i_gl->gl_object = ip;

		error = gfs2_glock_get(sdp, no_addr, &gfs2_iopen_glops, CREATE, &io_gl);
		if (unlikely(error))
			goto fail_put;

		set_bit(GIF_INVALID, &ip->i_flags);
		error = gfs2_glock_nq_init(io_gl, LM_ST_SHARED, GL_EXACT, &ip->i_iopen_gh);
		if (unlikely(error))
			goto fail_iopen;

		ip->i_iopen_gh.gh_gl->gl_object = ip;
		gfs2_glock_put(io_gl);
		io_gl = NULL;

		if (type == DT_UNKNOWN) {
			/* Inode glock must be locked already */
			error = gfs2_inode_refresh(GFS2_I(inode));
			if (error)
				goto fail_refresh;
		} else {
			inode->i_mode = DT2IF(type);
		}

		gfs2_set_iop(inode);
		unlock_new_inode(inode);
	}

	return inode;

fail_refresh:
B
Bob Peterson 已提交
192
	ip->i_iopen_gh.gh_flags |= GL_NOCACHE;
193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310
	ip->i_iopen_gh.gh_gl->gl_object = NULL;
	gfs2_glock_dq_uninit(&ip->i_iopen_gh);
fail_iopen:
	if (io_gl)
		gfs2_glock_put(io_gl);
fail_put:
	ip->i_gl->gl_object = NULL;
	gfs2_glock_put(ip->i_gl);
fail:
	iget_failed(inode);
	return ERR_PTR(error);
}

struct inode *gfs2_lookup_by_inum(struct gfs2_sbd *sdp, u64 no_addr,
				  u64 *no_formal_ino, unsigned int blktype)
{
	struct super_block *sb = sdp->sd_vfs;
	struct gfs2_holder i_gh;
	struct inode *inode = NULL;
	int error;

	/* Must not read in block until block type is verified */
	error = gfs2_glock_nq_num(sdp, no_addr, &gfs2_inode_glops,
				  LM_ST_EXCLUSIVE, GL_SKIP, &i_gh);
	if (error)
		return ERR_PTR(error);

	error = gfs2_check_blk_type(sdp, no_addr, blktype);
	if (error)
		goto fail;

	inode = gfs2_inode_lookup(sb, DT_UNKNOWN, no_addr, 0, 1);
	if (IS_ERR(inode))
		goto fail;

	/* Two extra checks for NFS only */
	if (no_formal_ino) {
		error = -ESTALE;
		if (GFS2_I(inode)->i_no_formal_ino != *no_formal_ino)
			goto fail_iput;

		error = -EIO;
		if (GFS2_I(inode)->i_diskflags & GFS2_DIF_SYSTEM)
			goto fail_iput;

		error = 0;
	}

fail:
	gfs2_glock_dq_uninit(&i_gh);
	return error ? ERR_PTR(error) : inode;
fail_iput:
	iput(inode);
	goto fail;
}


struct inode *gfs2_lookup_simple(struct inode *dip, const char *name)
{
	struct qstr qstr;
	struct inode *inode;
	gfs2_str2qstr(&qstr, name);
	inode = gfs2_lookupi(dip, &qstr, 1);
	/* gfs2_lookupi has inconsistent callers: vfs
	 * related routines expect NULL for no entry found,
	 * gfs2_lookup_simple callers expect ENOENT
	 * and do not check for NULL.
	 */
	if (inode == NULL)
		return ERR_PTR(-ENOENT);
	else
		return inode;
}


/**
 * gfs2_lookupi - Look up a filename in a directory and return its inode
 * @d_gh: An initialized holder for the directory glock
 * @name: The name of the inode to look for
 * @is_root: If 1, ignore the caller's permissions
 * @i_gh: An uninitialized holder for the new inode glock
 *
 * This can be called via the VFS filldir function when NFS is doing
 * a readdirplus and the inode which its intending to stat isn't
 * already in cache. In this case we must not take the directory glock
 * again, since the readdir call will have already taken that lock.
 *
 * Returns: errno
 */

struct inode *gfs2_lookupi(struct inode *dir, const struct qstr *name,
			   int is_root)
{
	struct super_block *sb = dir->i_sb;
	struct gfs2_inode *dip = GFS2_I(dir);
	struct gfs2_holder d_gh;
	int error = 0;
	struct inode *inode = NULL;
	int unlock = 0;

	if (!name->len || name->len > GFS2_FNAMESIZE)
		return ERR_PTR(-ENAMETOOLONG);

	if ((name->len == 1 && memcmp(name->name, ".", 1) == 0) ||
	    (name->len == 2 && memcmp(name->name, "..", 2) == 0 &&
	     dir == sb->s_root->d_inode)) {
		igrab(dir);
		return dir;
	}

	if (gfs2_glock_is_locked_by_me(dip->i_gl) == NULL) {
		error = gfs2_glock_nq_init(dip->i_gl, LM_ST_SHARED, 0, &d_gh);
		if (error)
			return ERR_PTR(error);
		unlock = 1;
	}

	if (!is_root) {
311
		error = gfs2_permission(dir, MAY_EXEC);
312 313 314 315
		if (error)
			goto out;
	}

316
	inode = gfs2_dir_search(dir, name, false);
317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336
	if (IS_ERR(inode))
		error = PTR_ERR(inode);
out:
	if (unlock)
		gfs2_glock_dq_uninit(&d_gh);
	if (error == -ENOENT)
		return NULL;
	return inode ? inode : ERR_PTR(error);
}

/**
 * create_ok - OK to create a new on-disk inode here?
 * @dip:  Directory in which dinode is to be created
 * @name:  Name of new dinode
 * @mode:
 *
 * Returns: errno
 */

static int create_ok(struct gfs2_inode *dip, const struct qstr *name,
A
Al Viro 已提交
337
		     umode_t mode)
338 339 340
{
	int error;

341
	error = gfs2_permission(&dip->i_inode, MAY_WRITE | MAY_EXEC);
342 343 344 345 346 347 348 349 350 351 352 353 354 355 356
	if (error)
		return error;

	/*  Don't create entries in an unlinked directory  */
	if (!dip->i_inode.i_nlink)
		return -ENOENT;

	if (dip->i_entries == (u32)-1)
		return -EFBIG;
	if (S_ISDIR(mode) && dip->i_inode.i_nlink == (u32)-1)
		return -EMLINK;

	return 0;
}

357 358
static void munge_mode_uid_gid(const struct gfs2_inode *dip,
			       struct inode *inode)
359 360
{
	if (GFS2_SB(&dip->i_inode)->sd_args.ar_suiddir &&
361 362
	    (dip->i_inode.i_mode & S_ISUID) &&
	    !uid_eq(dip->i_inode.i_uid, GLOBAL_ROOT_UID)) {
363 364
		if (S_ISDIR(inode->i_mode))
			inode->i_mode |= S_ISUID;
365
		else if (!uid_eq(dip->i_inode.i_uid, current_fsuid()))
366 367
			inode->i_mode &= ~07111;
		inode->i_uid = dip->i_inode.i_uid;
368
	} else
369
		inode->i_uid = current_fsuid();
370 371

	if (dip->i_inode.i_mode & S_ISGID) {
372 373 374
		if (S_ISDIR(inode->i_mode))
			inode->i_mode |= S_ISGID;
		inode->i_gid = dip->i_inode.i_gid;
375
	} else
376
		inode->i_gid = current_fsgid();
377 378
}

379
static int alloc_dinode(struct gfs2_inode *ip, u32 flags, unsigned *dblocks)
380
{
381
	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
382
	struct gfs2_alloc_parms ap = { .target = *dblocks, .aflags = flags, };
383 384
	int error;

385
	error = gfs2_quota_lock_check(ip, &ap);
386 387 388
	if (error)
		goto out;

389
	error = gfs2_inplace_reserve(ip, &ap);
390 391 392
	if (error)
		goto out_quota;

393
	error = gfs2_trans_begin(sdp, (*dblocks * RES_RG_BIT) + RES_STATFS + RES_QUOTA, 0);
394 395 396
	if (error)
		goto out_ipreserv;

397
	error = gfs2_alloc_blocks(ip, &ip->i_no_addr, dblocks, 1, &ip->i_generation);
398 399 400
	ip->i_no_formal_ino = ip->i_generation;
	ip->i_inode.i_ino = ip->i_no_addr;
	ip->i_goal = ip->i_no_addr;
401 402 403 404

	gfs2_trans_end(sdp);

out_ipreserv:
405
	gfs2_inplace_release(ip);
406 407
out_quota:
	gfs2_quota_unlock(ip);
408 409 410 411
out:
	return error;
}

412 413
static void gfs2_init_dir(struct buffer_head *dibh,
			  const struct gfs2_inode *parent)
S
Steven Whitehouse 已提交
414 415 416 417 418 419 420 421 422 423 424 425 426 427 428
{
	struct gfs2_dinode *di = (struct gfs2_dinode *)dibh->b_data;
	struct gfs2_dirent *dent = (struct gfs2_dirent *)(di+1);

	gfs2_qstr2dirent(&gfs2_qdot, GFS2_DIRENT_SIZE(gfs2_qdot.len), dent);
	dent->de_inum = di->di_num; /* already GFS2 endian */
	dent->de_type = cpu_to_be16(DT_DIR);

	dent = (struct gfs2_dirent *)((char*)dent + GFS2_DIRENT_SIZE(1));
	gfs2_qstr2dirent(&gfs2_qdotdot, dibh->b_size - GFS2_DIRENT_SIZE(1) - sizeof(struct gfs2_dinode), dent);
	gfs2_inum_out(parent, dent);
	dent->de_type = cpu_to_be16(DT_DIR);
	
}

429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455
/**
 * gfs2_init_xattr - Initialise an xattr block for a new inode
 * @ip: The inode in question
 *
 * This sets up an empty xattr block for a new inode, ready to
 * take any ACLs, LSM xattrs, etc.
 */

static void gfs2_init_xattr(struct gfs2_inode *ip)
{
	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
	struct buffer_head *bh;
	struct gfs2_ea_header *ea;

	bh = gfs2_meta_new(ip->i_gl, ip->i_eattr);
	gfs2_trans_add_meta(ip->i_gl, bh);
	gfs2_metatype_set(bh, GFS2_METATYPE_EA, GFS2_FORMAT_EA);
	gfs2_buffer_clear_tail(bh, sizeof(struct gfs2_meta_header));

	ea = GFS2_EA_BH2FIRST(bh);
	ea->ea_rec_len = cpu_to_be32(sdp->sd_jbsize);
	ea->ea_type = GFS2_EATYPE_UNUSED;
	ea->ea_flags = GFS2_EAFLAG_LAST;

	brelse(bh);
}

456 457
/**
 * init_dinode - Fill in a new dinode structure
458
 * @dip: The directory this inode is being created in
459
 * @ip: The inode
460 461
 * @symname: The symlink destination (if a symlink)
 * @bhp: The buffer head (returned to caller)
462 463 464
 *
 */

465
static void init_dinode(struct gfs2_inode *dip, struct gfs2_inode *ip,
466
			const char *symname)
467 468 469 470
{
	struct gfs2_dinode *di;
	struct buffer_head *dibh;

471
	dibh = gfs2_meta_new(ip->i_gl, ip->i_no_addr);
472
	gfs2_trans_add_meta(ip->i_gl, dibh);
473
	di = (struct gfs2_dinode *)dibh->b_data;
474
	gfs2_dinode_out(ip, di);
475

476 477
	di->di_major = cpu_to_be32(MAJOR(ip->i_inode.i_rdev));
	di->di_minor = cpu_to_be32(MINOR(ip->i_inode.i_rdev));
478 479 480 481 482
	di->__pad1 = 0;
	di->__pad2 = 0;
	di->__pad3 = 0;
	memset(&di->__pad4, 0, sizeof(di->__pad4));
	memset(&di->di_reserved, 0, sizeof(di->di_reserved));
483
	gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode));
484

485
	switch(ip->i_inode.i_mode & S_IFMT) {
486
	case S_IFDIR:
S
Steven Whitehouse 已提交
487
		gfs2_init_dir(dibh, dip);
488 489
		break;
	case S_IFLNK:
490
		memcpy(dibh->b_data + sizeof(struct gfs2_dinode), symname, ip->i_inode.i_size);
491
		break;
S
Steven Whitehouse 已提交
492 493
	}

494
	set_buffer_uptodate(dibh);
495
	brelse(dibh);
496 497
}

498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519
/**
 * gfs2_trans_da_blocks - Calculate number of blocks to link inode
 * @dip: The directory we are linking into
 * @da: The dir add information
 * @nr_inodes: The number of inodes involved
 *
 * This calculate the number of blocks we need to reserve in a
 * transaction to link @nr_inodes into a directory. In most cases
 * @nr_inodes will be 2 (the directory plus the inode being linked in)
 * but in case of rename, 4 may be required.
 *
 * Returns: Number of blocks
 */

static unsigned gfs2_trans_da_blks(const struct gfs2_inode *dip,
				   const struct gfs2_diradd *da,
				   unsigned nr_inodes)
{
	return da->nr_blocks + gfs2_rg_blocks(dip, da->nr_blocks) +
	       (nr_inodes * RES_DINODE) + RES_QUOTA + RES_STATFS;
}

520
static int link_dinode(struct gfs2_inode *dip, const struct qstr *name,
521
		       struct gfs2_inode *ip, struct gfs2_diradd *da)
522 523
{
	struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
524
	struct gfs2_alloc_parms ap = { .target = da->nr_blocks, };
525 526
	int error;

527
	if (da->nr_blocks) {
528
		error = gfs2_quota_lock_check(dip, &ap);
529 530 531
		if (error)
			goto fail_quota_locks;

532
		error = gfs2_inplace_reserve(dip, &ap);
533 534 535
		if (error)
			goto fail_quota_locks;

536
		error = gfs2_trans_begin(sdp, gfs2_trans_da_blks(dip, da, 2), 0);
537 538 539 540 541 542 543 544
		if (error)
			goto fail_ipreserv;
	} else {
		error = gfs2_trans_begin(sdp, RES_LEAF + 2 * RES_DINODE, 0);
		if (error)
			goto fail_quota_locks;
	}

545
	error = gfs2_dir_add(&dip->i_inode, name, ip, da);
546 547 548

	gfs2_trans_end(sdp);
fail_ipreserv:
549
	gfs2_inplace_release(dip);
550 551 552 553 554
fail_quota_locks:
	gfs2_quota_unlock(dip);
	return error;
}

555
static int gfs2_initxattrs(struct inode *inode, const struct xattr *xattr_array,
556
		    void *fs_info)
557
{
558 559 560 561 562 563 564 565 566
	const struct xattr *xattr;
	int err = 0;

	for (xattr = xattr_array; xattr->name != NULL; xattr++) {
		err = __gfs2_xattr_set(inode, xattr->name, xattr->value,
				       xattr->value_len, 0,
				       GFS2_EATYPE_SECURITY);
		if (err < 0)
			break;
567 568 569
	}
	return err;
}
D
David Teigland 已提交
570

571
/**
572 573 574
 * gfs2_create_inode - Create a new inode
 * @dir: The parent directory
 * @dentry: The new dentry
575
 * @file: If non-NULL, the file which is being opened
576 577 578 579
 * @mode: The permissions on the new inode
 * @dev: For device nodes, this is the device number
 * @symname: For symlinks, this is the link destination
 * @size: The initial size of the inode (ignored for directories)
580
 *
581
 * Returns: 0 on success, or error code
582 583
 */

584
static int gfs2_create_inode(struct inode *dir, struct dentry *dentry,
585
			     struct file *file,
A
Al Viro 已提交
586
			     umode_t mode, dev_t dev, const char *symname,
587
			     unsigned int size, int excl, int *opened)
588
{
589
	const struct qstr *name = &dentry->d_name;
590
	struct posix_acl *default_acl, *acl;
591
	struct gfs2_holder ghs[2];
592
	struct inode *inode = NULL;
B
Bob Peterson 已提交
593
	struct gfs2_inode *dip = GFS2_I(dir), *ip;
594
	struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
595
	struct gfs2_glock *io_gl;
596
	int error, free_vfs_inode = 0;
S
Steven Whitehouse 已提交
597
	u32 aflags = 0;
598
	unsigned blocks = 1;
599
	struct gfs2_diradd da = { .bh = NULL, .save_loc = 1, };
600 601

	if (!name->len || name->len > GFS2_FNAMESIZE)
602
		return -ENAMETOOLONG;
603

604 605 606 607
	error = gfs2_rs_alloc(dip);
	if (error)
		return error;

608 609 610 611
	error = gfs2_rindex_update(sdp);
	if (error)
		return error;

612
	error = gfs2_glock_nq_init(dip->i_gl, LM_ST_EXCLUSIVE, 0, ghs);
613 614 615 616
	if (error)
		goto fail;

	error = create_ok(dip, name, mode);
617 618 619 620 621 622
	if (error)
		goto fail_gunlock;

	inode = gfs2_dir_search(dir, &dentry->d_name, !S_ISREG(mode) || excl);
	error = PTR_ERR(inode);
	if (!IS_ERR(inode)) {
623 624 625 626 627
		if (S_ISDIR(inode->i_mode)) {
			iput(inode);
			inode = ERR_PTR(-EISDIR);
			goto fail_gunlock;
		}
628
		d_instantiate(dentry, inode);
629
		error = 0;
630
		if (file) {
631
			if (S_ISREG(inode->i_mode))
M
Miklos Szeredi 已提交
632
				error = finish_open(file, dentry, gfs2_open_common, opened);
633 634
			else
				error = finish_no_open(file, NULL);
635
		}
S
Steven Whitehouse 已提交
636
		gfs2_glock_dq_uninit(ghs);
637
		return error;
638
	} else if (error != -ENOENT) {
639
		goto fail_gunlock;
640
	}
641

642
	error = gfs2_diradd_alloc_required(dir, name, &da);
643 644 645
	if (error < 0)
		goto fail_gunlock;

646
	inode = new_inode(sdp->sd_vfs);
647 648 649 650
	error = -ENOMEM;
	if (!inode)
		goto fail_gunlock;

651 652 653 654
	error = posix_acl_create(dir, &mode, &default_acl, &acl);
	if (error)
		goto fail_free_vfs_inode;

655 656
	ip = GFS2_I(inode);
	error = gfs2_rs_alloc(ip);
657
	if (error)
658
		goto fail_free_acls;
659 660

	inode->i_mode = mode;
661
	set_nlink(inode, S_ISDIR(mode) ? 2 : 1);
662 663
	inode->i_rdev = dev;
	inode->i_size = size;
664
	inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
665
	gfs2_set_inode_blocks(inode, 1);
666
	munge_mode_uid_gid(dip, inode);
667
	check_and_update_goal(dip);
668
	ip->i_goal = dip->i_goal;
669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688
	ip->i_diskflags = 0;
	ip->i_eattr = 0;
	ip->i_height = 0;
	ip->i_depth = 0;
	ip->i_entries = 0;

	switch(mode & S_IFMT) {
	case S_IFREG:
		if ((dip->i_diskflags & GFS2_DIF_INHERIT_JDATA) ||
		    gfs2_tune_get(sdp, gt_new_files_jdata))
			ip->i_diskflags |= GFS2_DIF_JDATA;
		gfs2_set_aops(inode);
		break;
	case S_IFDIR:
		ip->i_diskflags |= (dip->i_diskflags & GFS2_DIF_INHERIT_JDATA);
		ip->i_diskflags |= GFS2_DIF_JDATA;
		ip->i_entries = 2;
		break;
	}
	gfs2_set_inode_flags(inode);
689

S
Steven Whitehouse 已提交
690 691 692 693
	if ((GFS2_I(sdp->sd_root_dir->d_inode) == dip) ||
	    (dip->i_diskflags & GFS2_DIF_TOPDIR))
		aflags |= GFS2_AF_ORLOV;

694 695 696 697
	if (default_acl || acl)
		blocks++;

	error = alloc_dinode(ip, aflags, &blocks);
698
	if (error)
699
		goto fail_free_inode;
700

701 702
	gfs2_set_inode_blocks(inode, blocks);

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 709 710 711
	error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, GL_SKIP, ghs + 1);
	if (error)
		goto fail_free_inode;

712
	error = gfs2_trans_begin(sdp, blocks, 0);
713
	if (error)
714 715
		goto fail_gunlock2;

716 717 718 719
	if (blocks > 1) {
		ip->i_eattr = ip->i_no_addr + 1;
		gfs2_init_xattr(ip);
	}
720
	init_dinode(dip, ip, symname);
721 722
	gfs2_trans_end(sdp);

723
	error = gfs2_glock_get(sdp, ip->i_no_addr, &gfs2_iopen_glops, CREATE, &io_gl);
724 725 726
	if (error)
		goto fail_gunlock2;

727
	error = gfs2_glock_nq_init(io_gl, LM_ST_SHARED, GL_EXACT, &ip->i_iopen_gh);
728 729
	if (error)
		goto fail_gunlock2;
730

731 732 733 734 735
	ip->i_iopen_gh.gh_gl->gl_object = ip;
	gfs2_glock_put(io_gl);
	gfs2_set_iop(inode);
	insert_inode_hash(inode);

736 737 738 739 740 741 742 743 744 745
	if (default_acl) {
		error = gfs2_set_acl(inode, default_acl, ACL_TYPE_DEFAULT);
		posix_acl_release(default_acl);
	}
	if (acl) {
		if (!error)
			error = gfs2_set_acl(inode, acl, ACL_TYPE_ACCESS);
		posix_acl_release(acl);
	}

746
	if (error)
747
		goto fail_gunlock3;
748

749 750
	error = security_inode_init_security(&ip->i_inode, &dip->i_inode, name,
					     &gfs2_initxattrs, NULL);
751
	if (error)
752
		goto fail_gunlock3;
753

754
	error = link_dinode(dip, name, ip, &da);
755
	if (error)
756
		goto fail_gunlock3;
757

758
	mark_inode_dirty(inode);
759
	d_instantiate(dentry, inode);
M
Miklos Szeredi 已提交
760 761
	if (file) {
		*opened |= FILE_CREATED;
762
		error = finish_open(file, dentry, gfs2_open_common, opened);
M
Miklos Szeredi 已提交
763
	}
764 765
	gfs2_glock_dq_uninit(ghs);
	gfs2_glock_dq_uninit(ghs + 1);
766
	return error;
767

768 769 770 771 772 773
fail_gunlock3:
	gfs2_glock_dq_uninit(ghs + 1);
	if (ip->i_gl)
		gfs2_glock_put(ip->i_gl);
	goto fail_gunlock;

774 775
fail_gunlock2:
	gfs2_glock_dq_uninit(ghs + 1);
776 777 778
fail_free_inode:
	if (ip->i_gl)
		gfs2_glock_put(ip->i_gl);
779
	gfs2_rs_delete(ip, NULL);
780 781 782 783 784 785
fail_free_acls:
	if (default_acl)
		posix_acl_release(default_acl);
	if (acl)
		posix_acl_release(acl);
fail_free_vfs_inode:
786
	free_vfs_inode = 1;
787
fail_gunlock:
788
	gfs2_dir_no_add(&da);
789
	gfs2_glock_dq_uninit(ghs);
790
	if (inode && !IS_ERR(inode)) {
791
		clear_nlink(inode);
792 793 794 795
		if (!free_vfs_inode)
			mark_inode_dirty(inode);
		set_bit(free_vfs_inode ? GIF_FREE_VFS_INODE : GIF_ALLOC_FAILED,
			&GFS2_I(inode)->i_flags);
796 797
		iput(inode);
	}
798
fail:
799
	return error;
800
}
801

D
David Teigland 已提交
802 803 804 805 806 807 808 809 810 811
/**
 * gfs2_create - Create a file
 * @dir: The directory in which to create the file
 * @dentry: The dentry of the new file
 * @mode: The mode of the new file
 *
 * Returns: errno
 */

static int gfs2_create(struct inode *dir, struct dentry *dentry,
A
Al Viro 已提交
812
		       umode_t mode, bool excl)
D
David Teigland 已提交
813
{
814
	return gfs2_create_inode(dir, dentry, NULL, S_IFREG | mode, 0, NULL, 0, excl, NULL);
D
David Teigland 已提交
815 816 817
}

/**
818
 * __gfs2_lookup - Look up a filename in a directory and return its inode
D
David Teigland 已提交
819 820
 * @dir: The directory inode
 * @dentry: The dentry of the new inode
821 822
 * @file: File to be opened
 * @opened: atomic_open flags
D
David Teigland 已提交
823 824 825 826 827
 *
 *
 * Returns: errno
 */

828 829
static struct dentry *__gfs2_lookup(struct inode *dir, struct dentry *dentry,
				    struct file *file, int *opened)
D
David Teigland 已提交
830
{
831 832 833 834 835 836 837
	struct inode *inode;
	struct dentry *d;
	struct gfs2_holder gh;
	struct gfs2_glock *gl;
	int error;

	inode = gfs2_lookupi(dir, &dentry->d_name, 0);
838 839
	if (inode == NULL) {
		d_add(dentry, NULL);
840
		return NULL;
841
	}
842 843 844 845 846 847 848 849
	if (IS_ERR(inode))
		return ERR_CAST(inode);

	gl = GFS2_I(inode)->i_gl;
	error = gfs2_glock_nq_init(gl, LM_ST_SHARED, LM_FLAG_ANY, &gh);
	if (error) {
		iput(inode);
		return ERR_PTR(error);
850
	}
851 852

	d = d_splice_alias(inode, dentry);
853 854 855 856
	if (IS_ERR(d)) {
		gfs2_glock_dq_uninit(&gh);
		return d;
	}
857 858 859 860
	if (file && S_ISREG(inode->i_mode))
		error = finish_open(file, dentry, gfs2_open_common, opened);

	gfs2_glock_dq_uninit(&gh);
M
Miklos Szeredi 已提交
861 862
	if (error) {
		dput(d);
863
		return ERR_PTR(error);
M
Miklos Szeredi 已提交
864
	}
865 866 867 868 869 870 871
	return d;
}

static struct dentry *gfs2_lookup(struct inode *dir, struct dentry *dentry,
				  unsigned flags)
{
	return __gfs2_lookup(dir, dentry, NULL, NULL);
D
David Teigland 已提交
872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888
}

/**
 * gfs2_link - Link to a file
 * @old_dentry: The inode to link
 * @dir: Add link to this directory
 * @dentry: The name of the link
 *
 * Link the inode in "old_dentry" into the directory "dir" with the
 * name in "dentry".
 *
 * Returns: errno
 */

static int gfs2_link(struct dentry *old_dentry, struct inode *dir,
		     struct dentry *dentry)
{
889 890
	struct gfs2_inode *dip = GFS2_I(dir);
	struct gfs2_sbd *sdp = GFS2_SB(dir);
D
David Teigland 已提交
891
	struct inode *inode = old_dentry->d_inode;
892
	struct gfs2_inode *ip = GFS2_I(inode);
D
David Teigland 已提交
893
	struct gfs2_holder ghs[2];
894
	struct buffer_head *dibh;
895
	struct gfs2_diradd da = { .bh = NULL, .save_loc = 1, };
D
David Teigland 已提交
896 897
	int error;

898
	if (S_ISDIR(inode->i_mode))
D
David Teigland 已提交
899 900
		return -EPERM;

901 902 903 904
	error = gfs2_rs_alloc(dip);
	if (error)
		return error;

D
David Teigland 已提交
905 906 907
	gfs2_holder_init(dip->i_gl, LM_ST_EXCLUSIVE, 0, ghs);
	gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + 1);

908 909 910 911 912
	error = gfs2_glock_nq(ghs); /* parent */
	if (error)
		goto out_parent;

	error = gfs2_glock_nq(ghs + 1); /* child */
D
David Teigland 已提交
913
	if (error)
914
		goto out_child;
D
David Teigland 已提交
915

916 917 918 919
	error = -ENOENT;
	if (inode->i_nlink == 0)
		goto out_gunlock;

920
	error = gfs2_permission(dir, MAY_WRITE | MAY_EXEC);
D
David Teigland 已提交
921 922 923
	if (error)
		goto out_gunlock;

924
	error = gfs2_dir_check(dir, &dentry->d_name, NULL);
D
David Teigland 已提交
925 926 927 928 929 930 931 932 933 934
	switch (error) {
	case -ENOENT:
		break;
	case 0:
		error = -EEXIST;
	default:
		goto out_gunlock;
	}

	error = -EINVAL;
935
	if (!dip->i_inode.i_nlink)
D
David Teigland 已提交
936 937
		goto out_gunlock;
	error = -EFBIG;
938
	if (dip->i_entries == (u32)-1)
D
David Teigland 已提交
939 940 941 942 943
		goto out_gunlock;
	error = -EPERM;
	if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
		goto out_gunlock;
	error = -EINVAL;
944
	if (!ip->i_inode.i_nlink)
D
David Teigland 已提交
945 946
		goto out_gunlock;
	error = -EMLINK;
947
	if (ip->i_inode.i_nlink == (u32)-1)
D
David Teigland 已提交
948 949
		goto out_gunlock;

950
	error = gfs2_diradd_alloc_required(dir, &dentry->d_name, &da);
951
	if (error < 0)
D
David Teigland 已提交
952 953
		goto out_gunlock;

954 955
	if (da.nr_blocks) {
		struct gfs2_alloc_parms ap = { .target = da.nr_blocks, };
956
		error = gfs2_quota_lock_check(dip, &ap);
D
David Teigland 已提交
957
		if (error)
958
			goto out_gunlock;
D
David Teigland 已提交
959

960
		error = gfs2_inplace_reserve(dip, &ap);
D
David Teigland 已提交
961 962 963
		if (error)
			goto out_gunlock_q;

964
		error = gfs2_trans_begin(sdp, gfs2_trans_da_blks(dip, &da, 2), 0);
D
David Teigland 已提交
965 966 967 968 969 970 971 972
		if (error)
			goto out_ipres;
	} else {
		error = gfs2_trans_begin(sdp, 2 * RES_DINODE + RES_LEAF, 0);
		if (error)
			goto out_ipres;
	}

973
	error = gfs2_meta_inode_buffer(ip, &dibh);
D
David Teigland 已提交
974 975 976
	if (error)
		goto out_end_trans;

977
	error = gfs2_dir_add(dir, &dentry->d_name, ip, &da);
978 979 980
	if (error)
		goto out_brelse;

981
	gfs2_trans_add_meta(ip->i_gl, dibh);
982 983
	inc_nlink(&ip->i_inode);
	ip->i_inode.i_ctime = CURRENT_TIME;
S
Steven Whitehouse 已提交
984 985 986
	ihold(inode);
	d_instantiate(dentry, inode);
	mark_inode_dirty(inode);
D
David Teigland 已提交
987

988 989
out_brelse:
	brelse(dibh);
990
out_end_trans:
D
David Teigland 已提交
991
	gfs2_trans_end(sdp);
992
out_ipres:
993
	if (da.nr_blocks)
D
David Teigland 已提交
994
		gfs2_inplace_release(dip);
995
out_gunlock_q:
996
	if (da.nr_blocks)
D
David Teigland 已提交
997
		gfs2_quota_unlock(dip);
998
out_gunlock:
999
	gfs2_dir_no_add(&da);
1000 1001 1002 1003
	gfs2_glock_dq(ghs + 1);
out_child:
	gfs2_glock_dq(ghs);
out_parent:
D
David Teigland 已提交
1004 1005 1006 1007 1008
	gfs2_holder_uninit(ghs);
	gfs2_holder_uninit(ghs + 1);
	return error;
}

1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028
/*
 * gfs2_unlink_ok - check to see that a inode is still in a directory
 * @dip: the directory
 * @name: the name of the file
 * @ip: the inode
 *
 * Assumes that the lock on (at least) @dip is held.
 *
 * Returns: 0 if the parent/child relationship is correct, errno if it isn't
 */

static int gfs2_unlink_ok(struct gfs2_inode *dip, const struct qstr *name,
			  const struct gfs2_inode *ip)
{
	int error;

	if (IS_IMMUTABLE(&ip->i_inode) || IS_APPEND(&ip->i_inode))
		return -EPERM;

	if ((dip->i_inode.i_mode & S_ISVTX) &&
1029 1030
	    !uid_eq(dip->i_inode.i_uid, current_fsuid()) &&
	    !uid_eq(ip->i_inode.i_uid, current_fsuid()) && !capable(CAP_FOWNER))
1031 1032 1033 1034 1035
		return -EPERM;

	if (IS_APPEND(&dip->i_inode))
		return -EPERM;

1036
	error = gfs2_permission(&dip->i_inode, MAY_WRITE | MAY_EXEC);
1037 1038 1039
	if (error)
		return error;

1040
	return gfs2_dir_check(&dip->i_inode, name, ip);
1041 1042
}

D
David Teigland 已提交
1043
/**
1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055
 * gfs2_unlink_inode - Removes an inode from its parent dir and unlinks it
 * @dip: The parent directory
 * @name: The name of the entry in the parent directory
 * @inode: The inode to be removed
 *
 * Called with all the locks and in a transaction. This will only be
 * called for a directory after it has been checked to ensure it is empty.
 *
 * Returns: 0 on success, or an error
 */

static int gfs2_unlink_inode(struct gfs2_inode *dip,
1056
			     const struct dentry *dentry)
1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081
{
	struct inode *inode = dentry->d_inode;
	struct gfs2_inode *ip = GFS2_I(inode);
	int error;

	error = gfs2_dir_del(dip, dentry);
	if (error)
		return error;

	ip->i_entries = 0;
	inode->i_ctime = CURRENT_TIME;
	if (S_ISDIR(inode->i_mode))
		clear_nlink(inode);
	else
		drop_nlink(inode);
	mark_inode_dirty(inode);
	if (inode->i_nlink == 0)
		gfs2_unlink_di(inode);
	return 0;
}


/**
 * gfs2_unlink - Unlink an inode (this does rmdir as well)
 * @dir: The inode of the directory containing the inode to unlink
D
David Teigland 已提交
1082 1083
 * @dentry: The file itself
 *
1084 1085
 * This routine uses the type of the inode as a flag to figure out
 * whether this is an unlink or an rmdir.
D
David Teigland 已提交
1086 1087 1088 1089 1090 1091
 *
 * Returns: errno
 */

static int gfs2_unlink(struct inode *dir, struct dentry *dentry)
{
1092 1093
	struct gfs2_inode *dip = GFS2_I(dir);
	struct gfs2_sbd *sdp = GFS2_SB(dir);
1094 1095
	struct inode *inode = dentry->d_inode;
	struct gfs2_inode *ip = GFS2_I(inode);
R
Russell Cattelan 已提交
1096 1097
	struct gfs2_holder ghs[3];
	struct gfs2_rgrpd *rgd;
1098 1099 1100 1101 1102 1103 1104
	int error;

	error = gfs2_rindex_update(sdp);
	if (error)
		return error;

	error = -EROFS;
D
David Teigland 已提交
1105 1106

	gfs2_holder_init(dip->i_gl, LM_ST_EXCLUSIVE, 0, ghs);
R
Russell Cattelan 已提交
1107
	gfs2_holder_init(ip->i_gl,  LM_ST_EXCLUSIVE, 0, ghs + 1);
D
David Teigland 已提交
1108

S
Steven Whitehouse 已提交
1109
	rgd = gfs2_blk2rgrpd(sdp, ip->i_no_addr, 1);
1110
	if (!rgd)
1111
		goto out_inodes;
1112

R
Russell Cattelan 已提交
1113 1114 1115
	gfs2_holder_init(rgd->rd_gl, LM_ST_EXCLUSIVE, 0, ghs + 2);


1116
	error = gfs2_glock_nq(ghs); /* parent */
D
David Teigland 已提交
1117
	if (error)
1118 1119 1120 1121 1122 1123
		goto out_parent;

	error = gfs2_glock_nq(ghs + 1); /* child */
	if (error)
		goto out_child;

1124
	error = -ENOENT;
1125
	if (inode->i_nlink == 0)
1126 1127
		goto out_rgrp;

1128 1129 1130 1131 1132 1133
	if (S_ISDIR(inode->i_mode)) {
		error = -ENOTEMPTY;
		if (ip->i_entries > 2 || inode->i_nlink > 2)
			goto out_rgrp;
	}

1134 1135 1136
	error = gfs2_glock_nq(ghs + 2); /* rgrp */
	if (error)
		goto out_rgrp;
D
David Teigland 已提交
1137 1138 1139

	error = gfs2_unlink_ok(dip, &dentry->d_name, ip);
	if (error)
1140
		goto out_gunlock;
D
David Teigland 已提交
1141

1142 1143 1144
	error = gfs2_trans_begin(sdp, 2*RES_DINODE + 3*RES_LEAF + RES_RG_BIT, 0);
	if (error)
		goto out_end_trans;
D
David Teigland 已提交
1145

1146
	error = gfs2_unlink_inode(dip, dentry);
D
David Teigland 已提交
1147

1148 1149
out_end_trans:
	gfs2_trans_end(sdp);
1150
out_gunlock:
1151 1152 1153 1154 1155 1156
	gfs2_glock_dq(ghs + 2);
out_rgrp:
	gfs2_glock_dq(ghs + 1);
out_child:
	gfs2_glock_dq(ghs);
out_parent:
1157 1158 1159
	gfs2_holder_uninit(ghs + 2);
out_inodes:
	gfs2_holder_uninit(ghs + 1);
1160
	gfs2_holder_uninit(ghs);
D
David Teigland 已提交
1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175
	return error;
}

/**
 * gfs2_symlink - Create a symlink
 * @dir: The directory to create the symlink in
 * @dentry: The dentry to put the symlink in
 * @symname: The thing which the link points to
 *
 * Returns: errno
 */

static int gfs2_symlink(struct inode *dir, struct dentry *dentry,
			const char *symname)
{
1176
	struct gfs2_sbd *sdp = GFS2_SB(dir);
1177
	unsigned int size;
D
David Teigland 已提交
1178 1179 1180 1181 1182

	size = strlen(symname);
	if (size > sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode) - 1)
		return -ENAMETOOLONG;

1183
	return gfs2_create_inode(dir, dentry, NULL, S_IFLNK | S_IRWXUGO, 0, symname, size, 0, NULL);
D
David Teigland 已提交
1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194
}

/**
 * gfs2_mkdir - Make a directory
 * @dir: The parent directory of the new one
 * @dentry: The dentry of the new directory
 * @mode: The mode of the new directory
 *
 * Returns: errno
 */

1195
static int gfs2_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
D
David Teigland 已提交
1196
{
1197 1198
	struct gfs2_sbd *sdp = GFS2_SB(dir);
	unsigned dsize = sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode);
1199
	return gfs2_create_inode(dir, dentry, NULL, S_IFDIR | mode, 0, NULL, dsize, 0, NULL);
D
David Teigland 已提交
1200 1201 1202 1203 1204 1205 1206
}

/**
 * gfs2_mknod - Make a special file
 * @dir: The directory in which the special file will reside
 * @dentry: The dentry of the special file
 * @mode: The mode of the special file
1207
 * @dev: The device specification of the special file
D
David Teigland 已提交
1208 1209 1210
 *
 */

A
Al Viro 已提交
1211
static int gfs2_mknod(struct inode *dir, struct dentry *dentry, umode_t mode,
D
David Teigland 已提交
1212 1213
		      dev_t dev)
{
1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229
	return gfs2_create_inode(dir, dentry, NULL, mode, dev, NULL, 0, 0, NULL);
}

/**
 * gfs2_atomic_open - Atomically open a file
 * @dir: The directory
 * @dentry: The proposed new entry
 * @file: The proposed new struct file
 * @flags: open flags
 * @mode: File mode
 * @opened: Flag to say whether the file has been opened or not
 *
 * Returns: error code or 0 for success
 */

static int gfs2_atomic_open(struct inode *dir, struct dentry *dentry,
1230 1231
			    struct file *file, unsigned flags,
			    umode_t mode, int *opened)
1232 1233 1234 1235
{
	struct dentry *d;
	bool excl = !!(flags & O_EXCL);

1236 1237 1238
	if (!d_unhashed(dentry))
		goto skip_lookup;

1239 1240 1241
	d = __gfs2_lookup(dir, dentry, file, opened);
	if (IS_ERR(d))
		return PTR_ERR(d);
M
Miklos Szeredi 已提交
1242 1243 1244
	if (d != NULL)
		dentry = d;
	if (dentry->d_inode) {
1245 1246
		if (!(*opened & FILE_OPENED))
			return finish_no_open(file, d);
M
Miklos Szeredi 已提交
1247
		dput(d);
1248 1249 1250
		return 0;
	}

M
Miklos Szeredi 已提交
1251
	BUG_ON(d != NULL);
1252 1253

skip_lookup:
1254 1255 1256 1257
	if (!(flags & O_CREAT))
		return -ENOENT;

	return gfs2_create_inode(dir, dentry, file, S_IFREG | mode, 0, NULL, 0, excl, opened);
D
David Teigland 已提交
1258 1259
}

1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289
/*
 * gfs2_ok_to_move - check if it's ok to move a directory to another directory
 * @this: move this
 * @to: to here
 *
 * Follow @to back to the root and make sure we don't encounter @this
 * Assumes we already hold the rename lock.
 *
 * Returns: errno
 */

static int gfs2_ok_to_move(struct gfs2_inode *this, struct gfs2_inode *to)
{
	struct inode *dir = &to->i_inode;
	struct super_block *sb = dir->i_sb;
	struct inode *tmp;
	int error = 0;

	igrab(dir);

	for (;;) {
		if (dir == &this->i_inode) {
			error = -EINVAL;
			break;
		}
		if (dir == sb->s_root->d_inode) {
			error = 0;
			break;
		}

1290
		tmp = gfs2_lookupi(dir, &gfs2_qdotdot, 1);
1291 1292 1293 1294
		if (!tmp) {
			error = -ENOENT;
			break;
		}
1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308
		if (IS_ERR(tmp)) {
			error = PTR_ERR(tmp);
			break;
		}

		iput(dir);
		dir = tmp;
	}

	iput(dir);

	return error;
}

1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337
/**
 * update_moved_ino - Update an inode that's being moved
 * @ip: The inode being moved
 * @ndip: The parent directory of the new filename
 * @dir_rename: True of ip is a directory
 *
 * Returns: errno
 */

static int update_moved_ino(struct gfs2_inode *ip, struct gfs2_inode *ndip,
			    int dir_rename)
{
	int error;
	struct buffer_head *dibh;

	if (dir_rename)
		return gfs2_dir_mvino(ip, &gfs2_qdotdot, ndip, DT_DIR);

	error = gfs2_meta_inode_buffer(ip, &dibh);
	if (error)
		return error;
	ip->i_inode.i_ctime = CURRENT_TIME;
	gfs2_trans_add_meta(ip->i_gl, dibh);
	gfs2_dinode_out(ip, dibh->b_data);
	brelse(dibh);
	return 0;
}


D
David Teigland 已提交
1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350
/**
 * gfs2_rename - Rename a file
 * @odir: Parent directory of old file name
 * @odentry: The old dentry of the file
 * @ndir: Parent directory of new file name
 * @ndentry: The new dentry of the file
 *
 * Returns: errno
 */

static int gfs2_rename(struct inode *odir, struct dentry *odentry,
		       struct inode *ndir, struct dentry *ndentry)
{
1351 1352 1353
	struct gfs2_inode *odip = GFS2_I(odir);
	struct gfs2_inode *ndip = GFS2_I(ndir);
	struct gfs2_inode *ip = GFS2_I(odentry->d_inode);
D
David Teigland 已提交
1354
	struct gfs2_inode *nip = NULL;
1355
	struct gfs2_sbd *sdp = GFS2_SB(odir);
1356
	struct gfs2_holder ghs[5], r_gh = { .gh_gl = NULL, };
R
Russell Cattelan 已提交
1357
	struct gfs2_rgrpd *nrgd;
D
David Teigland 已提交
1358 1359
	unsigned int num_gh;
	int dir_rename = 0;
1360
	struct gfs2_diradd da = { .nr_blocks = 0, .save_loc = 0, };
D
David Teigland 已提交
1361 1362 1363 1364
	unsigned int x;
	int error;

	if (ndentry->d_inode) {
1365
		nip = GFS2_I(ndentry->d_inode);
D
David Teigland 已提交
1366 1367 1368 1369
		if (ip == nip)
			return 0;
	}

1370 1371 1372 1373
	error = gfs2_rindex_update(sdp);
	if (error)
		return error;

1374 1375 1376 1377
	error = gfs2_rs_alloc(ndip);
	if (error)
		return error;

1378 1379 1380
	if (odip != ndip) {
		error = gfs2_glock_nq_init(sdp->sd_rename_gl, LM_ST_EXCLUSIVE,
					   0, &r_gh);
D
David Teigland 已提交
1381 1382 1383
		if (error)
			goto out;

1384 1385
		if (S_ISDIR(ip->i_inode.i_mode)) {
			dir_rename = 1;
1386
			/* don't move a directory into its subdir */
1387 1388 1389 1390
			error = gfs2_ok_to_move(ip, ndip);
			if (error)
				goto out_gunlock_r;
		}
D
David Teigland 已提交
1391 1392
	}

1393
	num_gh = 1;
D
David Teigland 已提交
1394
	gfs2_holder_init(odip->i_gl, LM_ST_EXCLUSIVE, 0, ghs);
1395 1396 1397 1398 1399 1400
	if (odip != ndip) {
		gfs2_holder_init(ndip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + num_gh);
		num_gh++;
	}
	gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + num_gh);
	num_gh++;
D
David Teigland 已提交
1401

1402 1403 1404
	if (nip) {
		gfs2_holder_init(nip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + num_gh);
		num_gh++;
R
Russell Cattelan 已提交
1405 1406 1407 1408
		/* grab the resource lock for unlink flag twiddling 
		 * this is the case of the target file already existing
		 * so we unlink before doing the rename
		 */
S
Steven Whitehouse 已提交
1409
		nrgd = gfs2_blk2rgrpd(sdp, nip->i_no_addr, 1);
R
Russell Cattelan 已提交
1410 1411
		if (nrgd)
			gfs2_holder_init(nrgd->rd_gl, LM_ST_EXCLUSIVE, 0, ghs + num_gh++);
1412
	}
D
David Teigland 已提交
1413

1414 1415 1416 1417 1418
	for (x = 0; x < num_gh; x++) {
		error = gfs2_glock_nq(ghs + x);
		if (error)
			goto out_gunlock;
	}
D
David Teigland 已提交
1419

1420 1421 1422 1423
	error = -ENOENT;
	if (ip->i_inode.i_nlink == 0)
		goto out_gunlock;

D
David Teigland 已提交
1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436
	/* Check out the old directory */

	error = gfs2_unlink_ok(odip, &odentry->d_name, ip);
	if (error)
		goto out_gunlock;

	/* Check out the new directory */

	if (nip) {
		error = gfs2_unlink_ok(ndip, &ndentry->d_name, nip);
		if (error)
			goto out_gunlock;

1437 1438 1439 1440 1441
		if (nip->i_inode.i_nlink == 0) {
			error = -EAGAIN;
			goto out_gunlock;
		}

1442
		if (S_ISDIR(nip->i_inode.i_mode)) {
1443
			if (nip->i_entries < 2) {
1444
				gfs2_consist_inode(nip);
D
David Teigland 已提交
1445 1446 1447
				error = -EIO;
				goto out_gunlock;
			}
1448
			if (nip->i_entries > 2) {
D
David Teigland 已提交
1449 1450 1451 1452 1453
				error = -ENOTEMPTY;
				goto out_gunlock;
			}
		}
	} else {
1454
		error = gfs2_permission(ndir, MAY_WRITE | MAY_EXEC);
D
David Teigland 已提交
1455 1456 1457
		if (error)
			goto out_gunlock;

1458
		error = gfs2_dir_check(ndir, &ndentry->d_name, NULL);
D
David Teigland 已提交
1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469
		switch (error) {
		case -ENOENT:
			error = 0;
			break;
		case 0:
			error = -EEXIST;
		default:
			goto out_gunlock;
		};

		if (odip != ndip) {
1470
			if (!ndip->i_inode.i_nlink) {
1471
				error = -ENOENT;
D
David Teigland 已提交
1472 1473
				goto out_gunlock;
			}
1474
			if (ndip->i_entries == (u32)-1) {
D
David Teigland 已提交
1475 1476 1477
				error = -EFBIG;
				goto out_gunlock;
			}
1478
			if (S_ISDIR(ip->i_inode.i_mode) &&
1479
			    ndip->i_inode.i_nlink == (u32)-1) {
D
David Teigland 已提交
1480 1481 1482 1483 1484 1485 1486 1487 1488
				error = -EMLINK;
				goto out_gunlock;
			}
		}
	}

	/* Check out the dir to be renamed */

	if (dir_rename) {
1489
		error = gfs2_permission(odentry->d_inode, MAY_WRITE);
D
David Teigland 已提交
1490 1491 1492 1493
		if (error)
			goto out_gunlock;
	}

1494 1495 1496 1497 1498
	if (nip == NULL) {
		error = gfs2_diradd_alloc_required(ndir, &ndentry->d_name, &da);
		if (error)
			goto out_gunlock;
	}
D
David Teigland 已提交
1499

1500 1501
	if (da.nr_blocks) {
		struct gfs2_alloc_parms ap = { .target = da.nr_blocks, };
1502
		error = gfs2_quota_lock_check(ndip, &ap);
D
David Teigland 已提交
1503
		if (error)
1504
			goto out_gunlock;
D
David Teigland 已提交
1505

1506
		error = gfs2_inplace_reserve(ndip, &ap);
D
David Teigland 已提交
1507 1508 1509
		if (error)
			goto out_gunlock_q;

1510 1511
		error = gfs2_trans_begin(sdp, gfs2_trans_da_blks(ndip, &da, 4) +
					 4 * RES_LEAF + 4, 0);
D
David Teigland 已提交
1512 1513 1514 1515
		if (error)
			goto out_ipreserv;
	} else {
		error = gfs2_trans_begin(sdp, 4 * RES_DINODE +
S
S. Wendy Cheng 已提交
1516
					 5 * RES_LEAF + 4, 0);
D
David Teigland 已提交
1517 1518 1519 1520 1521 1522
		if (error)
			goto out_gunlock;
	}

	/* Remove the target file, if it exists */

1523 1524
	if (nip)
		error = gfs2_unlink_inode(ndip, ndentry);
D
David Teigland 已提交
1525

1526 1527 1528
	error = update_moved_ino(ip, ndip, dir_rename);
	if (error)
		goto out_end_trans;
D
David Teigland 已提交
1529

1530
	error = gfs2_dir_del(odip, odentry);
D
David Teigland 已提交
1531 1532 1533
	if (error)
		goto out_end_trans;

1534
	error = gfs2_dir_add(ndir, &ndentry->d_name, ip, &da);
D
David Teigland 已提交
1535 1536 1537
	if (error)
		goto out_end_trans;

1538
out_end_trans:
D
David Teigland 已提交
1539
	gfs2_trans_end(sdp);
1540
out_ipreserv:
1541
	if (da.nr_blocks)
D
David Teigland 已提交
1542
		gfs2_inplace_release(ndip);
1543
out_gunlock_q:
1544
	if (da.nr_blocks)
D
David Teigland 已提交
1545
		gfs2_quota_unlock(ndip);
1546
out_gunlock:
1547
	gfs2_dir_no_add(&da);
1548 1549
	while (x--) {
		gfs2_glock_dq(ghs + x);
D
David Teigland 已提交
1550
		gfs2_holder_uninit(ghs + x);
1551
	}
1552
out_gunlock_r:
1553
	if (r_gh.gh_gl)
D
David Teigland 已提交
1554
		gfs2_glock_dq_uninit(&r_gh);
1555
out:
D
David Teigland 已提交
1556 1557 1558
	return error;
}

1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713
/**
 * gfs2_exchange - exchange two files
 * @odir: Parent directory of old file name
 * @odentry: The old dentry of the file
 * @ndir: Parent directory of new file name
 * @ndentry: The new dentry of the file
 * @flags: The rename flags
 *
 * Returns: errno
 */

static int gfs2_exchange(struct inode *odir, struct dentry *odentry,
			 struct inode *ndir, struct dentry *ndentry,
			 unsigned int flags)
{
	struct gfs2_inode *odip = GFS2_I(odir);
	struct gfs2_inode *ndip = GFS2_I(ndir);
	struct gfs2_inode *oip = GFS2_I(odentry->d_inode);
	struct gfs2_inode *nip = GFS2_I(ndentry->d_inode);
	struct gfs2_sbd *sdp = GFS2_SB(odir);
	struct gfs2_holder ghs[5], r_gh = { .gh_gl = NULL, };
	unsigned int num_gh;
	unsigned int x;
	umode_t old_mode = oip->i_inode.i_mode;
	umode_t new_mode = nip->i_inode.i_mode;
	int error;

	error = gfs2_rindex_update(sdp);
	if (error)
		return error;

	if (odip != ndip) {
		error = gfs2_glock_nq_init(sdp->sd_rename_gl, LM_ST_EXCLUSIVE,
					   0, &r_gh);
		if (error)
			goto out;

		if (S_ISDIR(old_mode)) {
			/* don't move a directory into its subdir */
			error = gfs2_ok_to_move(oip, ndip);
			if (error)
				goto out_gunlock_r;
		}

		if (S_ISDIR(new_mode)) {
			/* don't move a directory into its subdir */
			error = gfs2_ok_to_move(nip, odip);
			if (error)
				goto out_gunlock_r;
		}
	}

	num_gh = 1;
	gfs2_holder_init(odip->i_gl, LM_ST_EXCLUSIVE, 0, ghs);
	if (odip != ndip) {
		gfs2_holder_init(ndip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + num_gh);
		num_gh++;
	}
	gfs2_holder_init(oip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + num_gh);
	num_gh++;

	gfs2_holder_init(nip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + num_gh);
	num_gh++;

	for (x = 0; x < num_gh; x++) {
		error = gfs2_glock_nq(ghs + x);
		if (error)
			goto out_gunlock;
	}

	error = -ENOENT;
	if (oip->i_inode.i_nlink == 0 || nip->i_inode.i_nlink == 0)
		goto out_gunlock;

	error = gfs2_unlink_ok(odip, &odentry->d_name, oip);
	if (error)
		goto out_gunlock;
	error = gfs2_unlink_ok(ndip, &ndentry->d_name, nip);
	if (error)
		goto out_gunlock;

	if (S_ISDIR(old_mode)) {
		error = gfs2_permission(odentry->d_inode, MAY_WRITE);
		if (error)
			goto out_gunlock;
	}
	if (S_ISDIR(new_mode)) {
		error = gfs2_permission(ndentry->d_inode, MAY_WRITE);
		if (error)
			goto out_gunlock;
	}
	error = gfs2_trans_begin(sdp, 4 * RES_DINODE + 4 * RES_LEAF, 0);
	if (error)
		goto out_gunlock;

	error = update_moved_ino(oip, ndip, S_ISDIR(old_mode));
	if (error)
		goto out_end_trans;

	error = update_moved_ino(nip, odip, S_ISDIR(new_mode));
	if (error)
		goto out_end_trans;

	error = gfs2_dir_mvino(ndip, &ndentry->d_name, oip,
			       IF2DT(old_mode));
	if (error)
		goto out_end_trans;

	error = gfs2_dir_mvino(odip, &odentry->d_name, nip,
			       IF2DT(new_mode));
	if (error)
		goto out_end_trans;

	if (odip != ndip) {
		if (S_ISDIR(new_mode) && !S_ISDIR(old_mode)) {
			inc_nlink(&odip->i_inode);
			drop_nlink(&ndip->i_inode);
		} else if (S_ISDIR(old_mode) && !S_ISDIR(new_mode)) {
			inc_nlink(&ndip->i_inode);
			drop_nlink(&odip->i_inode);
		}
	}
	mark_inode_dirty(&ndip->i_inode);
	if (odip != ndip)
		mark_inode_dirty(&odip->i_inode);

out_end_trans:
	gfs2_trans_end(sdp);
out_gunlock:
	while (x--) {
		gfs2_glock_dq(ghs + x);
		gfs2_holder_uninit(ghs + x);
	}
out_gunlock_r:
	if (r_gh.gh_gl)
		gfs2_glock_dq_uninit(&r_gh);
out:
	return error;
}

static int gfs2_rename2(struct inode *odir, struct dentry *odentry,
			struct inode *ndir, struct dentry *ndentry,
			unsigned int flags)
{
	flags &= ~RENAME_NOREPLACE;

	if (flags & ~RENAME_EXCHANGE)
		return -EINVAL;

	if (flags & RENAME_EXCHANGE)
		return gfs2_exchange(odir, odentry, ndir, ndentry, flags);

	return gfs2_rename(odir, odentry, ndir, ndentry);
}

1714
/**
A
Al Viro 已提交
1715 1716 1717
 * gfs2_follow_link - Follow a symbolic link
 * @dentry: The dentry of the link
 * @nd: Data that we pass to vfs_follow_link()
1718
 *
A
Al Viro 已提交
1719
 * This can handle symlinks of any size.
1720
 *
A
Al Viro 已提交
1721
 * Returns: 0 on success or error code
1722 1723
 */

A
Al Viro 已提交
1724
static void *gfs2_follow_link(struct dentry *dentry, struct nameidata *nd)
1725
{
A
Al Viro 已提交
1726
	struct gfs2_inode *ip = GFS2_I(dentry->d_inode);
1727 1728
	struct gfs2_holder i_gh;
	struct buffer_head *dibh;
1729
	unsigned int size;
A
Al Viro 已提交
1730
	char *buf;
1731 1732 1733 1734 1735 1736
	int error;

	gfs2_holder_init(ip->i_gl, LM_ST_SHARED, 0, &i_gh);
	error = gfs2_glock_nq(&i_gh);
	if (error) {
		gfs2_holder_uninit(&i_gh);
A
Al Viro 已提交
1737 1738
		nd_set_link(nd, ERR_PTR(error));
		return NULL;
1739 1740
	}

S
Steven Whitehouse 已提交
1741 1742
	size = (unsigned int)i_size_read(&ip->i_inode);
	if (size == 0) {
1743
		gfs2_consist_inode(ip);
A
Al Viro 已提交
1744
		buf = ERR_PTR(-EIO);
1745 1746 1747 1748
		goto out;
	}

	error = gfs2_meta_inode_buffer(ip, &dibh);
A
Al Viro 已提交
1749 1750
	if (error) {
		buf = ERR_PTR(error);
1751 1752 1753
		goto out;
	}

1754
	buf = kzalloc(size + 1, GFP_NOFS);
A
Al Viro 已提交
1755 1756 1757
	if (!buf)
		buf = ERR_PTR(-ENOMEM);
	else
1758
		memcpy(buf, dibh->b_data + sizeof(struct gfs2_dinode), size);
1759 1760 1761
	brelse(dibh);
out:
	gfs2_glock_dq_uninit(&i_gh);
A
Al Viro 已提交
1762 1763
	nd_set_link(nd, buf);
	return NULL;
D
David Teigland 已提交
1764 1765 1766 1767
}

/**
 * gfs2_permission -
1768 1769 1770
 * @inode: The inode
 * @mask: The mask to be tested
 * @flags: Indicates whether this is an RCU path walk or not
D
David Teigland 已提交
1771
 *
1772 1773 1774 1775
 * This may be called from the VFS directly, or from within GFS2 with the
 * inode locked, so we look to see if the glock is already locked and only
 * lock the glock if its not already been done.
 *
D
David Teigland 已提交
1776 1777 1778
 * Returns: errno
 */

1779
int gfs2_permission(struct inode *inode, int mask)
D
David Teigland 已提交
1780
{
1781
	struct gfs2_inode *ip;
D
David Teigland 已提交
1782 1783
	struct gfs2_holder i_gh;
	int error;
1784
	int unlock = 0;
D
David Teigland 已提交
1785

1786 1787

	ip = GFS2_I(inode);
1788
	if (gfs2_glock_is_locked_by_me(ip->i_gl) == NULL) {
1789 1790 1791 1792 1793 1794
		if (mask & MAY_NOT_BLOCK)
			return -ECHILD;
		error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, &i_gh);
		if (error)
			return error;
		unlock = 1;
1795
	}
D
David Teigland 已提交
1796

M
Miklos Szeredi 已提交
1797 1798 1799
	if ((mask & MAY_WRITE) && IS_IMMUTABLE(inode))
		error = -EACCES;
	else
1800
		error = generic_permission(inode, mask);
1801
	if (unlock)
D
David Teigland 已提交
1802 1803 1804 1805 1806
		gfs2_glock_dq_uninit(&i_gh);

	return error;
}

S
Steven Whitehouse 已提交
1807
static int __gfs2_setattr_simple(struct inode *inode, struct iattr *attr)
1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821
{
	setattr_copy(inode, attr);
	mark_inode_dirty(inode);
	return 0;
}

/**
 * gfs2_setattr_simple -
 * @ip:
 * @attr:
 *
 * Returns: errno
 */

S
Steven Whitehouse 已提交
1822
int gfs2_setattr_simple(struct inode *inode, struct iattr *attr)
1823 1824 1825 1826
{
	int error;

	if (current->journal_info)
S
Steven Whitehouse 已提交
1827
		return __gfs2_setattr_simple(inode, attr);
1828

S
Steven Whitehouse 已提交
1829
	error = gfs2_trans_begin(GFS2_SB(inode), RES_DINODE, 0);
1830 1831 1832
	if (error)
		return error;

S
Steven Whitehouse 已提交
1833 1834
	error = __gfs2_setattr_simple(inode, attr);
	gfs2_trans_end(GFS2_SB(inode));
1835 1836 1837
	return error;
}

D
David Teigland 已提交
1838 1839
static int setattr_chown(struct inode *inode, struct iattr *attr)
{
1840 1841
	struct gfs2_inode *ip = GFS2_I(inode);
	struct gfs2_sbd *sdp = GFS2_SB(inode);
1842 1843
	kuid_t ouid, nuid;
	kgid_t ogid, ngid;
D
David Teigland 已提交
1844
	int error;
1845
	struct gfs2_alloc_parms ap;
D
David Teigland 已提交
1846

1847 1848
	ouid = inode->i_uid;
	ogid = inode->i_gid;
D
David Teigland 已提交
1849 1850 1851
	nuid = attr->ia_uid;
	ngid = attr->ia_gid;

1852
	if (!(attr->ia_valid & ATTR_UID) || uid_eq(ouid, nuid))
1853
		ouid = nuid = NO_UID_QUOTA_CHANGE;
1854
	if (!(attr->ia_valid & ATTR_GID) || gid_eq(ogid, ngid))
1855
		ogid = ngid = NO_GID_QUOTA_CHANGE;
D
David Teigland 已提交
1856

1857
	error = get_write_access(inode);
D
David Teigland 已提交
1858
	if (error)
1859
		return error;
D
David Teigland 已提交
1860

1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872
	error = gfs2_rs_alloc(ip);
	if (error)
		goto out;

	error = gfs2_rindex_update(sdp);
	if (error)
		goto out;

	error = gfs2_quota_lock(ip, nuid, ngid);
	if (error)
		goto out;

1873 1874
	ap.target = gfs2_get_inode_blocks(&ip->i_inode);

1875 1876
	if (!uid_eq(ouid, NO_UID_QUOTA_CHANGE) ||
	    !gid_eq(ogid, NO_GID_QUOTA_CHANGE)) {
1877
		error = gfs2_quota_check(ip, nuid, ngid, &ap);
D
David Teigland 已提交
1878 1879 1880 1881 1882 1883 1884 1885
		if (error)
			goto out_gunlock_q;
	}

	error = gfs2_trans_begin(sdp, RES_DINODE + 2 * RES_QUOTA, 0);
	if (error)
		goto out_gunlock_q;

S
Steven Whitehouse 已提交
1886
	error = gfs2_setattr_simple(inode, attr);
D
David Teigland 已提交
1887 1888 1889
	if (error)
		goto out_end_trans;

1890 1891
	if (!uid_eq(ouid, NO_UID_QUOTA_CHANGE) ||
	    !gid_eq(ogid, NO_GID_QUOTA_CHANGE)) {
1892 1893
		gfs2_quota_change(ip, -ap.target, ouid, ogid);
		gfs2_quota_change(ip, ap.target, nuid, ngid);
D
David Teigland 已提交
1894 1895
	}

1896
out_end_trans:
D
David Teigland 已提交
1897
	gfs2_trans_end(sdp);
1898
out_gunlock_q:
D
David Teigland 已提交
1899
	gfs2_quota_unlock(ip);
1900 1901
out:
	put_write_access(inode);
D
David Teigland 已提交
1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918
	return error;
}

/**
 * gfs2_setattr - Change attributes on an inode
 * @dentry: The dentry which is changing
 * @attr: The structure describing the change
 *
 * The VFS layer wants to change one or more of an inodes attributes.  Write
 * that change out to disk.
 *
 * Returns: errno
 */

static int gfs2_setattr(struct dentry *dentry, struct iattr *attr)
{
	struct inode *inode = dentry->d_inode;
1919
	struct gfs2_inode *ip = GFS2_I(inode);
D
David Teigland 已提交
1920 1921 1922
	struct gfs2_holder i_gh;
	int error;

1923 1924 1925 1926
	error = gfs2_rs_alloc(ip);
	if (error)
		return error;

D
David Teigland 已提交
1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939
	error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &i_gh);
	if (error)
		return error;

	error = -EPERM;
	if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
		goto out;

	error = inode_change_ok(inode, attr);
	if (error)
		goto out;

	if (attr->ia_valid & ATTR_SIZE)
S
Steven Whitehouse 已提交
1940
		error = gfs2_setattr_size(inode, attr->ia_size);
D
David Teigland 已提交
1941 1942
	else if (attr->ia_valid & (ATTR_UID | ATTR_GID))
		error = setattr_chown(inode, attr);
1943
	else {
S
Steven Whitehouse 已提交
1944
		error = gfs2_setattr_simple(inode, attr);
1945 1946 1947
		if (!error && attr->ia_valid & ATTR_MODE)
			error = posix_acl_chmod(inode, inode->i_mode);
	}
D
David Teigland 已提交
1948

1949
out:
D
David Teigland 已提交
1950 1951
	if (!error)
		mark_inode_dirty(inode);
S
Steven Whitehouse 已提交
1952
	gfs2_glock_dq_uninit(&i_gh);
D
David Teigland 已提交
1953 1954 1955 1956 1957
	return error;
}

/**
 * gfs2_getattr - Read out an inode's attributes
1958
 * @mnt: The vfsmount the inode is being accessed from
D
David Teigland 已提交
1959 1960 1961
 * @dentry: The dentry to stat
 * @stat: The inode's stats
 *
1962 1963 1964 1965 1966 1967
 * This may be called from the VFS directly, or from within GFS2 with the
 * inode locked, so we look to see if the glock is already locked and only
 * lock the glock if its not already been done. Note that its the NFS
 * readdirplus operation which causes this to be called (from filldir)
 * with the glock already held.
 *
D
David Teigland 已提交
1968 1969 1970 1971 1972 1973 1974
 * Returns: errno
 */

static int gfs2_getattr(struct vfsmount *mnt, struct dentry *dentry,
			struct kstat *stat)
{
	struct inode *inode = dentry->d_inode;
1975
	struct gfs2_inode *ip = GFS2_I(inode);
D
David Teigland 已提交
1976 1977
	struct gfs2_holder gh;
	int error;
1978
	int unlock = 0;
D
David Teigland 已提交
1979

1980
	if (gfs2_glock_is_locked_by_me(ip->i_gl) == NULL) {
1981 1982 1983 1984
		error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, &gh);
		if (error)
			return error;
		unlock = 1;
D
David Teigland 已提交
1985 1986
	}

1987
	generic_fillattr(inode, stat);
1988
	if (unlock)
1989 1990 1991
		gfs2_glock_dq_uninit(&gh);

	return 0;
D
David Teigland 已提交
1992 1993 1994 1995 1996
}

static int gfs2_setxattr(struct dentry *dentry, const char *name,
			 const void *data, size_t size, int flags)
{
1997
	struct inode *inode = dentry->d_inode;
1998 1999 2000
	struct gfs2_inode *ip = GFS2_I(inode);
	struct gfs2_holder gh;
	int ret;
D
David Teigland 已提交
2001

2002 2003 2004
	gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);
	ret = gfs2_glock_nq(&gh);
	if (ret == 0) {
2005 2006 2007
		ret = gfs2_rs_alloc(ip);
		if (ret == 0)
			ret = generic_setxattr(dentry, name, data, size, flags);
2008 2009 2010 2011
		gfs2_glock_dq(&gh);
	}
	gfs2_holder_uninit(&gh);
	return ret;
D
David Teigland 已提交
2012 2013 2014 2015 2016
}

static ssize_t gfs2_getxattr(struct dentry *dentry, const char *name,
			     void *data, size_t size)
{
2017 2018 2019 2020
	struct inode *inode = dentry->d_inode;
	struct gfs2_inode *ip = GFS2_I(inode);
	struct gfs2_holder gh;
	int ret;
D
David Teigland 已提交
2021

2022 2023 2024 2025
	/* For selinux during lookup */
	if (gfs2_glock_is_locked_by_me(ip->i_gl))
		return generic_getxattr(dentry, name, data, size);

2026 2027 2028 2029 2030 2031 2032 2033
	gfs2_holder_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, &gh);
	ret = gfs2_glock_nq(&gh);
	if (ret == 0) {
		ret = generic_getxattr(dentry, name, data, size);
		gfs2_glock_dq(&gh);
	}
	gfs2_holder_uninit(&gh);
	return ret;
D
David Teigland 已提交
2034 2035 2036 2037
}

static int gfs2_removexattr(struct dentry *dentry, const char *name)
{
2038 2039 2040 2041
	struct inode *inode = dentry->d_inode;
	struct gfs2_inode *ip = GFS2_I(inode);
	struct gfs2_holder gh;
	int ret;
D
David Teigland 已提交
2042

2043 2044 2045
	gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);
	ret = gfs2_glock_nq(&gh);
	if (ret == 0) {
2046 2047 2048
		ret = gfs2_rs_alloc(ip);
		if (ret == 0)
			ret = generic_removexattr(dentry, name);
2049 2050 2051 2052
		gfs2_glock_dq(&gh);
	}
	gfs2_holder_uninit(&gh);
	return ret;
D
David Teigland 已提交
2053 2054
}

2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096
static int gfs2_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
		       u64 start, u64 len)
{
	struct gfs2_inode *ip = GFS2_I(inode);
	struct gfs2_holder gh;
	int ret;

	ret = fiemap_check_flags(fieinfo, FIEMAP_FLAG_SYNC);
	if (ret)
		return ret;

	mutex_lock(&inode->i_mutex);

	ret = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, 0, &gh);
	if (ret)
		goto out;

	if (gfs2_is_stuffed(ip)) {
		u64 phys = ip->i_no_addr << inode->i_blkbits;
		u64 size = i_size_read(inode);
		u32 flags = FIEMAP_EXTENT_LAST|FIEMAP_EXTENT_NOT_ALIGNED|
			    FIEMAP_EXTENT_DATA_INLINE;
		phys += sizeof(struct gfs2_dinode);
		phys += start;
		if (start + len > size)
			len = size - start;
		if (start < size)
			ret = fiemap_fill_next_extent(fieinfo, start, phys,
						      len, flags);
		if (ret == 1)
			ret = 0;
	} else {
		ret = __generic_block_fiemap(inode, fieinfo, start, len,
					     gfs2_block_map);
	}

	gfs2_glock_dq_uninit(&gh);
out:
	mutex_unlock(&inode->i_mutex);
	return ret;
}

2097
const struct inode_operations gfs2_file_iops = {
2098
	.permission = gfs2_permission,
D
David Teigland 已提交
2099 2100 2101 2102 2103 2104
	.setattr = gfs2_setattr,
	.getattr = gfs2_getattr,
	.setxattr = gfs2_setxattr,
	.getxattr = gfs2_getxattr,
	.listxattr = gfs2_listxattr,
	.removexattr = gfs2_removexattr,
2105
	.fiemap = gfs2_fiemap,
2106
	.get_acl = gfs2_get_acl,
2107
	.set_acl = gfs2_set_acl,
D
David Teigland 已提交
2108 2109
};

2110
const struct inode_operations gfs2_dir_iops = {
D
David Teigland 已提交
2111 2112 2113 2114 2115 2116
	.create = gfs2_create,
	.lookup = gfs2_lookup,
	.link = gfs2_link,
	.unlink = gfs2_unlink,
	.symlink = gfs2_symlink,
	.mkdir = gfs2_mkdir,
2117
	.rmdir = gfs2_unlink,
D
David Teigland 已提交
2118
	.mknod = gfs2_mknod,
2119
	.rename2 = gfs2_rename2,
2120
	.permission = gfs2_permission,
D
David Teigland 已提交
2121 2122 2123 2124 2125 2126
	.setattr = gfs2_setattr,
	.getattr = gfs2_getattr,
	.setxattr = gfs2_setxattr,
	.getxattr = gfs2_getxattr,
	.listxattr = gfs2_listxattr,
	.removexattr = gfs2_removexattr,
2127
	.fiemap = gfs2_fiemap,
2128
	.get_acl = gfs2_get_acl,
2129
	.set_acl = gfs2_set_acl,
2130
	.atomic_open = gfs2_atomic_open,
D
David Teigland 已提交
2131 2132
};

2133
const struct inode_operations gfs2_symlink_iops = {
A
Al Viro 已提交
2134
	.readlink = generic_readlink,
D
David Teigland 已提交
2135
	.follow_link = gfs2_follow_link,
A
Al Viro 已提交
2136
	.put_link = kfree_put_link,
2137
	.permission = gfs2_permission,
D
David Teigland 已提交
2138 2139 2140 2141 2142 2143
	.setattr = gfs2_setattr,
	.getattr = gfs2_getattr,
	.setxattr = gfs2_setxattr,
	.getxattr = gfs2_getxattr,
	.listxattr = gfs2_listxattr,
	.removexattr = gfs2_removexattr,
2144
	.fiemap = gfs2_fiemap,
D
David Teigland 已提交
2145 2146
};