inode.c 48.5 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
 */

#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>
16
#include <linux/cred.h>
D
David Teigland 已提交
17 18
#include <linux/xattr.h>
#include <linux/posix_acl.h>
19
#include <linux/gfs2_ondisk.h>
20
#include <linux/crc32.h>
21
#include <linux/fiemap.h>
22
#include <linux/security.h>
23
#include <linux/uaccess.h>
D
David Teigland 已提交
24 25

#include "gfs2.h"
26
#include "incore.h"
D
David Teigland 已提交
27 28 29
#include "acl.h"
#include "bmap.h"
#include "dir.h"
30
#include "xattr.h"
D
David Teigland 已提交
31 32 33 34 35 36
#include "glock.h"
#include "inode.h"
#include "meta_io.h"
#include "quota.h"
#include "rgrp.h"
#include "trans.h"
37
#include "util.h"
38
#include "super.h"
39 40
#include "glops.h"

41
static int iget_test(struct inode *inode, void *opaque)
42
{
43 44 45 46 47 48 49 50 51 52 53 54 55 56
	u64 no_addr = *(u64 *)opaque;

	return GFS2_I(inode)->i_no_addr == no_addr;
}

static int iget_set(struct inode *inode, void *opaque)
{
	u64 no_addr = *(u64 *)opaque;

	GFS2_I(inode)->i_no_addr = no_addr;
	inode->i_ino = no_addr;
	return 0;
}

57 58 59 60 61
static struct inode *gfs2_iget(struct super_block *sb, u64 no_addr)
{
	struct inode *inode;

repeat:
62
	inode = iget5_locked(sb, no_addr, iget_test, iget_set, &no_addr);
63 64 65 66 67 68 69
	if (!inode)
		return inode;
	if (is_bad_inode(inode)) {
		iput(inode);
		goto repeat;
	}
	return inode;
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
}

/**
 * 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
 * @type: The type of the inode
109 110 111
 * @no_addr: The inode number
 * @no_formal_ino: The inode generation number
 * @blktype: Requested block type (GFS2_BLKST_DINODE or GFS2_BLKST_UNLINKED;
A
Andreas Gruenbacher 已提交
112
 *           GFS2_BLKST_FREE to indicate not to verify)
113 114 115 116 117 118
 *
 * If @type is DT_UNKNOWN, the inode type is fetched from disk.
 *
 * If @blktype is anything other than GFS2_BLKST_FREE (which is used as a
 * placeholder because it doesn't otherwise make sense), the on-disk block type
 * is verified to be @blktype.
119 120 121 122 123
 *
 * Returns: A VFS inode, or an error
 */

struct inode *gfs2_inode_lookup(struct super_block *sb, unsigned int type,
124 125
				u64 no_addr, u64 no_formal_ino,
				unsigned int blktype)
126 127 128 129
{
	struct inode *inode;
	struct gfs2_inode *ip;
	struct gfs2_glock *io_gl = NULL;
130
	struct gfs2_holder i_gh;
131 132
	int error;

A
Andreas Gruenbacher 已提交
133
	gfs2_holder_mark_uninitialized(&i_gh);
134
	inode = gfs2_iget(sb, no_addr);
135
	if (!inode)
136
		return ERR_PTR(-ENOMEM);
137

138 139
	ip = GFS2_I(inode);

140 141 142 143 144 145 146
	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;
147
		flush_delayed_work(&ip->i_gl->gl_work);
148 149 150 151 152

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

153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171
		if (type == DT_UNKNOWN || blktype != GFS2_BLKST_FREE) {
			/*
			 * The GL_SKIP flag indicates to skip reading the inode
			 * block.  We read the inode with gfs2_inode_refresh
			 * after possibly checking the block type.
			 */
			error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE,
						   GL_SKIP, &i_gh);
			if (error)
				goto fail_put;

			if (blktype != GFS2_BLKST_FREE) {
				error = gfs2_check_blk_type(sdp, no_addr,
							    blktype);
				if (error)
					goto fail_put;
			}
		}

172
		glock_set_object(ip->i_gl, ip);
173 174 175
		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))
176
			goto fail_put;
177
		glock_set_object(ip->i_iopen_gh.gh_gl, ip);
178 179 180 181 182 183 184 185 186 187 188 189 190
		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);
191

192 193
		/* Lowest possible timestamp; will be overwritten in gfs2_dinode_in. */
		inode->i_atime.tv_sec = 1LL << (8 * sizeof(inode->i_atime.tv_sec) - 1);
194 195
		inode->i_atime.tv_nsec = 0;

196 197 198
		unlock_new_inode(inode);
	}

A
Andreas Gruenbacher 已提交
199
	if (gfs2_holder_initialized(&i_gh))
200
		gfs2_glock_dq_uninit(&i_gh);
201 202 203
	return inode;

fail_refresh:
B
Bob Peterson 已提交
204
	ip->i_iopen_gh.gh_flags |= GL_NOCACHE;
205
	glock_clear_object(ip->i_iopen_gh.gh_gl, ip);
206
	gfs2_glock_dq_uninit(&ip->i_iopen_gh);
207
fail_put:
208 209
	if (io_gl)
		gfs2_glock_put(io_gl);
210
	glock_clear_object(ip->i_gl, ip);
A
Andreas Gruenbacher 已提交
211
	if (gfs2_holder_initialized(&i_gh))
212
		gfs2_glock_dq_uninit(&i_gh);
213 214 215 216 217 218 219 220 221
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;
222
	struct inode *inode;
223 224
	int error;

225
	inode = gfs2_inode_lookup(sb, DT_UNKNOWN, no_addr, 0, blktype);
226
	if (IS_ERR(inode))
227
		return inode;
228 229 230 231 232 233 234 235 236 237 238

	/* 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;
	}
239
	return inode;
240 241 242

fail_iput:
	iput(inode);
243
	return ERR_PTR(error);
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
}


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;

A
Andreas Gruenbacher 已提交
289
	gfs2_holder_mark_uninitialized(&d_gh);
290 291 292 293 294
	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 &&
295
	     dir == d_inode(sb->s_root))) {
296 297 298 299 300 301 302 303 304 305 306
		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);
	}

	if (!is_root) {
307
		error = gfs2_permission(dir, MAY_EXEC);
308 309 310 311
		if (error)
			goto out;
	}

312
	inode = gfs2_dir_search(dir, name, false);
313 314 315
	if (IS_ERR(inode))
		error = PTR_ERR(inode);
out:
A
Andreas Gruenbacher 已提交
316
	if (gfs2_holder_initialized(&d_gh))
317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332
		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 已提交
333
		     umode_t mode)
334 335 336
{
	int error;

337
	error = gfs2_permission(&dip->i_inode, MAY_WRITE | MAY_EXEC);
338 339 340 341 342 343 344 345 346 347 348 349 350 351 352
	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;
}

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

	if (dip->i_inode.i_mode & S_ISGID) {
368 369 370
		if (S_ISDIR(inode->i_mode))
			inode->i_mode |= S_ISGID;
		inode->i_gid = dip->i_inode.i_gid;
371
	} else
372
		inode->i_gid = current_fsgid();
373 374
}

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

381
	error = gfs2_quota_lock_check(ip, &ap);
382 383 384
	if (error)
		goto out;

385
	error = gfs2_inplace_reserve(ip, &ap);
386 387 388
	if (error)
		goto out_quota;

389
	error = gfs2_trans_begin(sdp, (*dblocks * RES_RG_BIT) + RES_STATFS + RES_QUOTA, 0);
390 391 392
	if (error)
		goto out_ipreserv;

393
	error = gfs2_alloc_blocks(ip, &ip->i_no_addr, dblocks, 1, &ip->i_generation);
394 395 396
	ip->i_no_formal_ino = ip->i_generation;
	ip->i_inode.i_ino = ip->i_no_addr;
	ip->i_goal = ip->i_no_addr;
397 398 399 400

	gfs2_trans_end(sdp);

out_ipreserv:
401
	gfs2_inplace_release(ip);
402 403
out_quota:
	gfs2_quota_unlock(ip);
404 405 406 407
out:
	return error;
}

408 409
static void gfs2_init_dir(struct buffer_head *dibh,
			  const struct gfs2_inode *parent)
S
Steven Whitehouse 已提交
410 411 412 413 414 415 416 417 418 419 420 421 422 423 424
{
	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);
	
}

425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451
/**
 * 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);
}

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

461
static void init_dinode(struct gfs2_inode *dip, struct gfs2_inode *ip,
462
			const char *symname)
463 464 465 466
{
	struct gfs2_dinode *di;
	struct buffer_head *dibh;

467
	dibh = gfs2_meta_new(ip->i_gl, ip->i_no_addr);
468
	gfs2_trans_add_meta(ip->i_gl, dibh);
469
	di = (struct gfs2_dinode *)dibh->b_data;
470
	gfs2_dinode_out(ip, di);
471

472 473
	di->di_major = cpu_to_be32(MAJOR(ip->i_inode.i_rdev));
	di->di_minor = cpu_to_be32(MINOR(ip->i_inode.i_rdev));
474 475 476 477 478
	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));
479
	gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode));
480

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

490
	set_buffer_uptodate(dibh);
491
	brelse(dibh);
492 493
}

494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515
/**
 * 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;
}

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

523
	if (da->nr_blocks) {
524
		error = gfs2_quota_lock_check(dip, &ap);
525 526 527
		if (error)
			goto fail_quota_locks;

528
		error = gfs2_inplace_reserve(dip, &ap);
529 530 531
		if (error)
			goto fail_quota_locks;

532
		error = gfs2_trans_begin(sdp, gfs2_trans_da_blks(dip, da, 2), 0);
533 534 535 536 537 538 539 540
		if (error)
			goto fail_ipreserv;
	} else {
		error = gfs2_trans_begin(sdp, RES_LEAF + 2 * RES_DINODE, 0);
		if (error)
			goto fail_quota_locks;
	}

541
	error = gfs2_dir_add(&dip->i_inode, name, ip, da);
542 543 544

	gfs2_trans_end(sdp);
fail_ipreserv:
545
	gfs2_inplace_release(dip);
546 547 548 549 550
fail_quota_locks:
	gfs2_quota_unlock(dip);
	return error;
}

551
static int gfs2_initxattrs(struct inode *inode, const struct xattr *xattr_array,
552
		    void *fs_info)
553
{
554 555 556 557 558 559 560 561 562
	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;
563 564 565
	}
	return err;
}
D
David Teigland 已提交
566

567
/**
568 569 570
 * gfs2_create_inode - Create a new inode
 * @dir: The parent directory
 * @dentry: The new dentry
571
 * @file: If non-NULL, the file which is being opened
572 573 574 575
 * @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)
576
 *
577
 * Returns: 0 on success, or error code
578 579
 */

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

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

600
	error = gfs2_rsqa_alloc(dip);
601 602 603
	if (error)
		return error;

604 605 606 607
	error = gfs2_rindex_update(sdp);
	if (error)
		return error;

608
	error = gfs2_glock_nq_init(dip->i_gl, LM_ST_EXCLUSIVE, 0, ghs);
609 610
	if (error)
		goto fail;
611
	gfs2_holder_mark_uninitialized(ghs + 1);
612 613

	error = create_ok(dip, name, mode);
614 615 616 617 618 619
	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)) {
620 621 622 623 624
		if (S_ISDIR(inode->i_mode)) {
			iput(inode);
			inode = ERR_PTR(-EISDIR);
			goto fail_gunlock;
		}
625
		d_instantiate(dentry, inode);
626
		error = 0;
627
		if (file) {
628
			if (S_ISREG(inode->i_mode))
M
Miklos Szeredi 已提交
629
				error = finish_open(file, dentry, gfs2_open_common, opened);
630 631
			else
				error = finish_no_open(file, NULL);
632
		}
S
Steven Whitehouse 已提交
633
		gfs2_glock_dq_uninit(ghs);
634
		return error;
635
	} else if (error != -ENOENT) {
636
		goto fail_gunlock;
637
	}
638

639
	error = gfs2_diradd_alloc_required(dir, name, &da);
640 641 642
	if (error < 0)
		goto fail_gunlock;

643
	inode = new_inode(sdp->sd_vfs);
644 645 646 647
	error = -ENOMEM;
	if (!inode)
		goto fail_gunlock;

648 649
	error = posix_acl_create(dir, &mode, &default_acl, &acl);
	if (error)
650
		goto fail_gunlock;
651

652
	ip = GFS2_I(inode);
653
	error = gfs2_rsqa_alloc(ip);
654
	if (error)
655
		goto fail_free_acls;
656 657

	inode->i_mode = mode;
658
	set_nlink(inode, S_ISDIR(mode) ? 2 : 1);
659 660
	inode->i_rdev = dev;
	inode->i_size = size;
661
	inode->i_atime = inode->i_mtime = inode->i_ctime = current_time(inode);
662
	gfs2_set_inode_blocks(inode, 1);
663
	munge_mode_uid_gid(dip, inode);
664
	check_and_update_goal(dip);
665
	ip->i_goal = dip->i_goal;
666 667 668 669 670
	ip->i_diskflags = 0;
	ip->i_eattr = 0;
	ip->i_height = 0;
	ip->i_depth = 0;
	ip->i_entries = 0;
671
	ip->i_no_addr = 0; /* Temporarily zero until real addr is assigned */
672 673 674 675 676 677 678 679 680 681 682 683 684 685

	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;
	}
686 687 688 689 690

	/* Force SYSTEM flag on all files and subdirs of a SYSTEM directory */
	if (dip->i_diskflags & GFS2_DIF_SYSTEM)
		ip->i_diskflags |= GFS2_DIF_SYSTEM;

691
	gfs2_set_inode_flags(inode);
692

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

697 698 699 700
	if (default_acl || acl)
		blocks++;

	error = alloc_dinode(ip, aflags, &blocks);
701
	if (error)
702
		goto fail_free_inode;
703

704 705
	gfs2_set_inode_blocks(inode, blocks);

706
	error = gfs2_glock_get(sdp, ip->i_no_addr, &gfs2_inode_glops, CREATE, &ip->i_gl);
707
	if (error)
708
		goto fail_free_inode;
709
	flush_delayed_work(&ip->i_gl->gl_work);
710
	glock_set_object(ip->i_gl, ip);
711

712 713 714 715
	error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, GL_SKIP, ghs + 1);
	if (error)
		goto fail_free_inode;

716
	error = gfs2_trans_begin(sdp, blocks, 0);
717
	if (error)
718 719
		goto fail_gunlock2;

720 721 722 723
	if (blocks > 1) {
		ip->i_eattr = ip->i_no_addr + 1;
		gfs2_init_xattr(ip);
	}
724
	init_dinode(dip, ip, symname);
725 726
	gfs2_trans_end(sdp);

727
	error = gfs2_glock_get(sdp, ip->i_no_addr, &gfs2_iopen_glops, CREATE, &io_gl);
728 729 730
	if (error)
		goto fail_gunlock2;

731 732
	BUG_ON(test_and_set_bit(GLF_INODE_CREATING, &io_gl->gl_flags));

733
	error = gfs2_glock_nq_init(io_gl, LM_ST_SHARED, GL_EXACT, &ip->i_iopen_gh);
734 735
	if (error)
		goto fail_gunlock2;
736

737
	glock_set_object(ip->i_iopen_gh.gh_gl, ip);
738 739 740 741
	gfs2_glock_put(io_gl);
	gfs2_set_iop(inode);
	insert_inode_hash(inode);

742 743 744
	free_vfs_inode = 0; /* After this point, the inode is no longer
			       considered free. Any failures need to undo
			       the gfs2 structures. */
745
	if (default_acl) {
A
Al Viro 已提交
746
		error = __gfs2_set_acl(inode, default_acl, ACL_TYPE_DEFAULT);
747 748 749 750
		posix_acl_release(default_acl);
	}
	if (acl) {
		if (!error)
A
Al Viro 已提交
751
			error = __gfs2_set_acl(inode, acl, ACL_TYPE_ACCESS);
752 753 754
		posix_acl_release(acl);
	}

755
	if (error)
756
		goto fail_gunlock3;
757

758 759
	error = security_inode_init_security(&ip->i_inode, &dip->i_inode, name,
					     &gfs2_initxattrs, NULL);
760
	if (error)
761
		goto fail_gunlock3;
762

763
	error = link_dinode(dip, name, ip, &da);
764
	if (error)
765
		goto fail_gunlock3;
766

767
	mark_inode_dirty(inode);
768
	d_instantiate(dentry, inode);
M
Miklos Szeredi 已提交
769 770
	if (file) {
		*opened |= FILE_CREATED;
771
		error = finish_open(file, dentry, gfs2_open_common, opened);
M
Miklos Szeredi 已提交
772
	}
773 774
	gfs2_glock_dq_uninit(ghs);
	gfs2_glock_dq_uninit(ghs + 1);
775
	clear_bit(GLF_INODE_CREATING, &io_gl->gl_flags);
776
	return error;
777

778
fail_gunlock3:
779
	glock_clear_object(io_gl, ip);
780 781
	gfs2_glock_dq_uninit(&ip->i_iopen_gh);
	gfs2_glock_put(io_gl);
782
fail_gunlock2:
783 784
	if (io_gl)
		clear_bit(GLF_INODE_CREATING, &io_gl->gl_flags);
785
fail_free_inode:
786 787
	if (ip->i_gl) {
		glock_clear_object(ip->i_gl, ip);
788
		gfs2_glock_put(ip->i_gl);
789
	}
790
	gfs2_rsqa_delete(ip, NULL);
791 792 793 794 795
fail_free_acls:
	if (default_acl)
		posix_acl_release(default_acl);
	if (acl)
		posix_acl_release(acl);
796
fail_gunlock:
797
	gfs2_dir_no_add(&da);
798
	gfs2_glock_dq_uninit(ghs);
799
	if (inode && !IS_ERR(inode)) {
800
		clear_nlink(inode);
801 802 803 804
		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);
805 806
		iput(inode);
	}
807 808
	if (gfs2_holder_initialized(ghs + 1))
		gfs2_glock_dq_uninit(ghs + 1);
809
fail:
810
	return error;
811
}
812

D
David Teigland 已提交
813 814 815 816 817 818 819 820 821 822
/**
 * 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 已提交
823
		       umode_t mode, bool excl)
D
David Teigland 已提交
824
{
825
	return gfs2_create_inode(dir, dentry, NULL, S_IFREG | mode, 0, NULL, 0, excl, NULL);
D
David Teigland 已提交
826 827 828
}

/**
829
 * __gfs2_lookup - Look up a filename in a directory and return its inode
D
David Teigland 已提交
830 831
 * @dir: The directory inode
 * @dentry: The dentry of the new inode
832 833
 * @file: File to be opened
 * @opened: atomic_open flags
D
David Teigland 已提交
834 835 836 837 838
 *
 *
 * Returns: errno
 */

839 840
static struct dentry *__gfs2_lookup(struct inode *dir, struct dentry *dentry,
				    struct file *file, int *opened)
D
David Teigland 已提交
841
{
842 843 844 845 846 847 848
	struct inode *inode;
	struct dentry *d;
	struct gfs2_holder gh;
	struct gfs2_glock *gl;
	int error;

	inode = gfs2_lookupi(dir, &dentry->d_name, 0);
849 850
	if (inode == NULL) {
		d_add(dentry, NULL);
851
		return NULL;
852
	}
853 854 855 856 857 858 859 860
	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);
861
	}
862 863

	d = d_splice_alias(inode, dentry);
864 865 866 867
	if (IS_ERR(d)) {
		gfs2_glock_dq_uninit(&gh);
		return d;
	}
868 869 870 871
	if (file && S_ISREG(inode->i_mode))
		error = finish_open(file, dentry, gfs2_open_common, opened);

	gfs2_glock_dq_uninit(&gh);
M
Miklos Szeredi 已提交
872 873
	if (error) {
		dput(d);
874
		return ERR_PTR(error);
M
Miklos Szeredi 已提交
875
	}
876 877 878 879 880 881 882
	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 已提交
883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899
}

/**
 * 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)
{
900 901
	struct gfs2_inode *dip = GFS2_I(dir);
	struct gfs2_sbd *sdp = GFS2_SB(dir);
902
	struct inode *inode = d_inode(old_dentry);
903
	struct gfs2_inode *ip = GFS2_I(inode);
D
David Teigland 已提交
904
	struct gfs2_holder ghs[2];
905
	struct buffer_head *dibh;
906
	struct gfs2_diradd da = { .bh = NULL, .save_loc = 1, };
D
David Teigland 已提交
907 908
	int error;

909
	if (S_ISDIR(inode->i_mode))
D
David Teigland 已提交
910 911
		return -EPERM;

912
	error = gfs2_rsqa_alloc(dip);
913 914 915
	if (error)
		return error;

D
David Teigland 已提交
916 917 918
	gfs2_holder_init(dip->i_gl, LM_ST_EXCLUSIVE, 0, ghs);
	gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + 1);

919 920 921 922 923
	error = gfs2_glock_nq(ghs); /* parent */
	if (error)
		goto out_parent;

	error = gfs2_glock_nq(ghs + 1); /* child */
D
David Teigland 已提交
924
	if (error)
925
		goto out_child;
D
David Teigland 已提交
926

927 928 929 930
	error = -ENOENT;
	if (inode->i_nlink == 0)
		goto out_gunlock;

931
	error = gfs2_permission(dir, MAY_WRITE | MAY_EXEC);
D
David Teigland 已提交
932 933 934
	if (error)
		goto out_gunlock;

935
	error = gfs2_dir_check(dir, &dentry->d_name, NULL);
D
David Teigland 已提交
936 937 938 939 940 941 942 943 944 945
	switch (error) {
	case -ENOENT:
		break;
	case 0:
		error = -EEXIST;
	default:
		goto out_gunlock;
	}

	error = -EINVAL;
946
	if (!dip->i_inode.i_nlink)
D
David Teigland 已提交
947 948
		goto out_gunlock;
	error = -EFBIG;
949
	if (dip->i_entries == (u32)-1)
D
David Teigland 已提交
950 951 952 953 954
		goto out_gunlock;
	error = -EPERM;
	if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
		goto out_gunlock;
	error = -EINVAL;
955
	if (!ip->i_inode.i_nlink)
D
David Teigland 已提交
956 957
		goto out_gunlock;
	error = -EMLINK;
958
	if (ip->i_inode.i_nlink == (u32)-1)
D
David Teigland 已提交
959 960
		goto out_gunlock;

961
	error = gfs2_diradd_alloc_required(dir, &dentry->d_name, &da);
962
	if (error < 0)
D
David Teigland 已提交
963 964
		goto out_gunlock;

965 966
	if (da.nr_blocks) {
		struct gfs2_alloc_parms ap = { .target = da.nr_blocks, };
967
		error = gfs2_quota_lock_check(dip, &ap);
D
David Teigland 已提交
968
		if (error)
969
			goto out_gunlock;
D
David Teigland 已提交
970

971
		error = gfs2_inplace_reserve(dip, &ap);
D
David Teigland 已提交
972 973 974
		if (error)
			goto out_gunlock_q;

975
		error = gfs2_trans_begin(sdp, gfs2_trans_da_blks(dip, &da, 2), 0);
D
David Teigland 已提交
976 977 978 979 980 981 982 983
		if (error)
			goto out_ipres;
	} else {
		error = gfs2_trans_begin(sdp, 2 * RES_DINODE + RES_LEAF, 0);
		if (error)
			goto out_ipres;
	}

984
	error = gfs2_meta_inode_buffer(ip, &dibh);
D
David Teigland 已提交
985 986 987
	if (error)
		goto out_end_trans;

988
	error = gfs2_dir_add(dir, &dentry->d_name, ip, &da);
989 990 991
	if (error)
		goto out_brelse;

992
	gfs2_trans_add_meta(ip->i_gl, dibh);
993
	inc_nlink(&ip->i_inode);
994
	ip->i_inode.i_ctime = current_time(&ip->i_inode);
S
Steven Whitehouse 已提交
995 996 997
	ihold(inode);
	d_instantiate(dentry, inode);
	mark_inode_dirty(inode);
D
David Teigland 已提交
998

999 1000
out_brelse:
	brelse(dibh);
1001
out_end_trans:
D
David Teigland 已提交
1002
	gfs2_trans_end(sdp);
1003
out_ipres:
1004
	if (da.nr_blocks)
D
David Teigland 已提交
1005
		gfs2_inplace_release(dip);
1006
out_gunlock_q:
1007
	if (da.nr_blocks)
D
David Teigland 已提交
1008
		gfs2_quota_unlock(dip);
1009
out_gunlock:
1010
	gfs2_dir_no_add(&da);
1011 1012 1013 1014
	gfs2_glock_dq(ghs + 1);
out_child:
	gfs2_glock_dq(ghs);
out_parent:
D
David Teigland 已提交
1015 1016 1017 1018 1019
	gfs2_holder_uninit(ghs);
	gfs2_holder_uninit(ghs + 1);
	return error;
}

1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039
/*
 * 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) &&
1040 1041
	    !uid_eq(dip->i_inode.i_uid, current_fsuid()) &&
	    !uid_eq(ip->i_inode.i_uid, current_fsuid()) && !capable(CAP_FOWNER))
1042 1043 1044 1045 1046
		return -EPERM;

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

1047
	error = gfs2_permission(&dip->i_inode, MAY_WRITE | MAY_EXEC);
1048 1049 1050
	if (error)
		return error;

1051
	return gfs2_dir_check(&dip->i_inode, name, ip);
1052 1053
}

D
David Teigland 已提交
1054
/**
1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066
 * 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,
1067
			     const struct dentry *dentry)
1068
{
1069
	struct inode *inode = d_inode(dentry);
1070 1071 1072 1073 1074 1075 1076 1077
	struct gfs2_inode *ip = GFS2_I(inode);
	int error;

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

	ip->i_entries = 0;
1078
	inode->i_ctime = current_time(inode);
1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092
	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 已提交
1093 1094
 * @dentry: The file itself
 *
1095 1096
 * 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 已提交
1097 1098 1099 1100 1101 1102
 *
 * Returns: errno
 */

static int gfs2_unlink(struct inode *dir, struct dentry *dentry)
{
1103 1104
	struct gfs2_inode *dip = GFS2_I(dir);
	struct gfs2_sbd *sdp = GFS2_SB(dir);
1105
	struct inode *inode = d_inode(dentry);
1106
	struct gfs2_inode *ip = GFS2_I(inode);
R
Russell Cattelan 已提交
1107 1108
	struct gfs2_holder ghs[3];
	struct gfs2_rgrpd *rgd;
1109 1110 1111 1112 1113 1114 1115
	int error;

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

	error = -EROFS;
D
David Teigland 已提交
1116 1117

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

S
Steven Whitehouse 已提交
1120
	rgd = gfs2_blk2rgrpd(sdp, ip->i_no_addr, 1);
1121
	if (!rgd)
1122
		goto out_inodes;
1123

R
Russell Cattelan 已提交
1124 1125 1126
	gfs2_holder_init(rgd->rd_gl, LM_ST_EXCLUSIVE, 0, ghs + 2);


1127
	error = gfs2_glock_nq(ghs); /* parent */
D
David Teigland 已提交
1128
	if (error)
1129 1130 1131 1132 1133 1134
		goto out_parent;

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

1135
	error = -ENOENT;
1136
	if (inode->i_nlink == 0)
1137 1138
		goto out_rgrp;

1139 1140 1141 1142 1143 1144
	if (S_ISDIR(inode->i_mode)) {
		error = -ENOTEMPTY;
		if (ip->i_entries > 2 || inode->i_nlink > 2)
			goto out_rgrp;
	}

1145 1146 1147
	error = gfs2_glock_nq(ghs + 2); /* rgrp */
	if (error)
		goto out_rgrp;
D
David Teigland 已提交
1148 1149 1150

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

1153 1154 1155
	error = gfs2_trans_begin(sdp, 2*RES_DINODE + 3*RES_LEAF + RES_RG_BIT, 0);
	if (error)
		goto out_end_trans;
D
David Teigland 已提交
1156

1157
	error = gfs2_unlink_inode(dip, dentry);
D
David Teigland 已提交
1158

1159 1160
out_end_trans:
	gfs2_trans_end(sdp);
1161
out_gunlock:
1162 1163 1164 1165 1166 1167
	gfs2_glock_dq(ghs + 2);
out_rgrp:
	gfs2_glock_dq(ghs + 1);
out_child:
	gfs2_glock_dq(ghs);
out_parent:
1168 1169 1170
	gfs2_holder_uninit(ghs + 2);
out_inodes:
	gfs2_holder_uninit(ghs + 1);
1171
	gfs2_holder_uninit(ghs);
D
David Teigland 已提交
1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186
	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)
{
1187
	struct gfs2_sbd *sdp = GFS2_SB(dir);
1188
	unsigned int size;
D
David Teigland 已提交
1189 1190 1191 1192 1193

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

1194
	return gfs2_create_inode(dir, dentry, NULL, S_IFLNK | S_IRWXUGO, 0, symname, size, 0, NULL);
D
David Teigland 已提交
1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205
}

/**
 * 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
 */

1206
static int gfs2_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
D
David Teigland 已提交
1207
{
1208 1209
	struct gfs2_sbd *sdp = GFS2_SB(dir);
	unsigned dsize = sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode);
1210
	return gfs2_create_inode(dir, dentry, NULL, S_IFDIR | mode, 0, NULL, dsize, 0, NULL);
D
David Teigland 已提交
1211 1212 1213 1214 1215 1216 1217
}

/**
 * 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
1218
 * @dev: The device specification of the special file
D
David Teigland 已提交
1219 1220 1221
 *
 */

A
Al Viro 已提交
1222
static int gfs2_mknod(struct inode *dir, struct dentry *dentry, umode_t mode,
D
David Teigland 已提交
1223 1224
		      dev_t dev)
{
1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240
	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,
1241 1242
			    struct file *file, unsigned flags,
			    umode_t mode, int *opened)
1243 1244 1245 1246
{
	struct dentry *d;
	bool excl = !!(flags & O_EXCL);

1247
	if (!d_in_lookup(dentry))
1248 1249
		goto skip_lookup;

1250 1251 1252
	d = __gfs2_lookup(dir, dentry, file, opened);
	if (IS_ERR(d))
		return PTR_ERR(d);
M
Miklos Szeredi 已提交
1253 1254
	if (d != NULL)
		dentry = d;
1255
	if (d_really_is_positive(dentry)) {
1256 1257
		if (!(*opened & FILE_OPENED))
			return finish_no_open(file, d);
M
Miklos Szeredi 已提交
1258
		dput(d);
1259 1260 1261
		return 0;
	}

M
Miklos Szeredi 已提交
1262
	BUG_ON(d != NULL);
1263 1264

skip_lookup:
1265 1266 1267 1268
	if (!(flags & O_CREAT))
		return -ENOENT;

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

1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295
/*
 * 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;
		}
1296
		if (dir == d_inode(sb->s_root)) {
1297 1298 1299 1300
			error = 0;
			break;
		}

1301
		tmp = gfs2_lookupi(dir, &gfs2_qdotdot, 1);
1302 1303 1304 1305
		if (!tmp) {
			error = -ENOENT;
			break;
		}
1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319
		if (IS_ERR(tmp)) {
			error = PTR_ERR(tmp);
			break;
		}

		iput(dir);
		dir = tmp;
	}

	iput(dir);

	return error;
}

1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340
/**
 * 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;
1341
	ip->i_inode.i_ctime = current_time(&ip->i_inode);
1342 1343 1344 1345 1346 1347 1348
	gfs2_trans_add_meta(ip->i_gl, dibh);
	gfs2_dinode_out(ip, dibh->b_data);
	brelse(dibh);
	return 0;
}


D
David Teigland 已提交
1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361
/**
 * 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)
{
1362 1363
	struct gfs2_inode *odip = GFS2_I(odir);
	struct gfs2_inode *ndip = GFS2_I(ndir);
1364
	struct gfs2_inode *ip = GFS2_I(d_inode(odentry));
D
David Teigland 已提交
1365
	struct gfs2_inode *nip = NULL;
1366
	struct gfs2_sbd *sdp = GFS2_SB(odir);
A
Andreas Gruenbacher 已提交
1367
	struct gfs2_holder ghs[5], r_gh;
R
Russell Cattelan 已提交
1368
	struct gfs2_rgrpd *nrgd;
D
David Teigland 已提交
1369 1370
	unsigned int num_gh;
	int dir_rename = 0;
1371
	struct gfs2_diradd da = { .nr_blocks = 0, .save_loc = 0, };
D
David Teigland 已提交
1372 1373 1374
	unsigned int x;
	int error;

A
Andreas Gruenbacher 已提交
1375
	gfs2_holder_mark_uninitialized(&r_gh);
1376 1377
	if (d_really_is_positive(ndentry)) {
		nip = GFS2_I(d_inode(ndentry));
D
David Teigland 已提交
1378 1379 1380 1381
		if (ip == nip)
			return 0;
	}

1382 1383 1384 1385
	error = gfs2_rindex_update(sdp);
	if (error)
		return error;

1386
	error = gfs2_rsqa_alloc(ndip);
1387 1388 1389
	if (error)
		return error;

1390 1391 1392
	if (odip != ndip) {
		error = gfs2_glock_nq_init(sdp->sd_rename_gl, LM_ST_EXCLUSIVE,
					   0, &r_gh);
D
David Teigland 已提交
1393 1394 1395
		if (error)
			goto out;

1396 1397
		if (S_ISDIR(ip->i_inode.i_mode)) {
			dir_rename = 1;
1398
			/* don't move a directory into its subdir */
1399 1400 1401 1402
			error = gfs2_ok_to_move(ip, ndip);
			if (error)
				goto out_gunlock_r;
		}
D
David Teigland 已提交
1403 1404
	}

1405
	num_gh = 1;
D
David Teigland 已提交
1406
	gfs2_holder_init(odip->i_gl, LM_ST_EXCLUSIVE, 0, ghs);
1407 1408 1409 1410 1411 1412
	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 已提交
1413

1414 1415 1416
	if (nip) {
		gfs2_holder_init(nip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + num_gh);
		num_gh++;
R
Russell Cattelan 已提交
1417 1418 1419 1420
		/* 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 已提交
1421
		nrgd = gfs2_blk2rgrpd(sdp, nip->i_no_addr, 1);
R
Russell Cattelan 已提交
1422 1423
		if (nrgd)
			gfs2_holder_init(nrgd->rd_gl, LM_ST_EXCLUSIVE, 0, ghs + num_gh++);
1424
	}
D
David Teigland 已提交
1425

1426 1427 1428 1429 1430
	for (x = 0; x < num_gh; x++) {
		error = gfs2_glock_nq(ghs + x);
		if (error)
			goto out_gunlock;
	}
D
David Teigland 已提交
1431

1432 1433 1434 1435
	error = -ENOENT;
	if (ip->i_inode.i_nlink == 0)
		goto out_gunlock;

D
David Teigland 已提交
1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448
	/* 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;

1449 1450 1451 1452 1453
		if (nip->i_inode.i_nlink == 0) {
			error = -EAGAIN;
			goto out_gunlock;
		}

1454
		if (S_ISDIR(nip->i_inode.i_mode)) {
1455
			if (nip->i_entries < 2) {
1456
				gfs2_consist_inode(nip);
D
David Teigland 已提交
1457 1458 1459
				error = -EIO;
				goto out_gunlock;
			}
1460
			if (nip->i_entries > 2) {
D
David Teigland 已提交
1461 1462 1463 1464 1465
				error = -ENOTEMPTY;
				goto out_gunlock;
			}
		}
	} else {
1466
		error = gfs2_permission(ndir, MAY_WRITE | MAY_EXEC);
D
David Teigland 已提交
1467 1468 1469
		if (error)
			goto out_gunlock;

1470
		error = gfs2_dir_check(ndir, &ndentry->d_name, NULL);
D
David Teigland 已提交
1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481
		switch (error) {
		case -ENOENT:
			error = 0;
			break;
		case 0:
			error = -EEXIST;
		default:
			goto out_gunlock;
		};

		if (odip != ndip) {
1482
			if (!ndip->i_inode.i_nlink) {
1483
				error = -ENOENT;
D
David Teigland 已提交
1484 1485
				goto out_gunlock;
			}
1486
			if (ndip->i_entries == (u32)-1) {
D
David Teigland 已提交
1487 1488 1489
				error = -EFBIG;
				goto out_gunlock;
			}
1490
			if (S_ISDIR(ip->i_inode.i_mode) &&
1491
			    ndip->i_inode.i_nlink == (u32)-1) {
D
David Teigland 已提交
1492 1493 1494 1495 1496 1497 1498 1499 1500
				error = -EMLINK;
				goto out_gunlock;
			}
		}
	}

	/* Check out the dir to be renamed */

	if (dir_rename) {
1501
		error = gfs2_permission(d_inode(odentry), MAY_WRITE);
D
David Teigland 已提交
1502 1503 1504 1505
		if (error)
			goto out_gunlock;
	}

1506 1507 1508 1509 1510
	if (nip == NULL) {
		error = gfs2_diradd_alloc_required(ndir, &ndentry->d_name, &da);
		if (error)
			goto out_gunlock;
	}
D
David Teigland 已提交
1511

1512 1513
	if (da.nr_blocks) {
		struct gfs2_alloc_parms ap = { .target = da.nr_blocks, };
1514
		error = gfs2_quota_lock_check(ndip, &ap);
D
David Teigland 已提交
1515
		if (error)
1516
			goto out_gunlock;
D
David Teigland 已提交
1517

1518
		error = gfs2_inplace_reserve(ndip, &ap);
D
David Teigland 已提交
1519 1520 1521
		if (error)
			goto out_gunlock_q;

1522 1523
		error = gfs2_trans_begin(sdp, gfs2_trans_da_blks(ndip, &da, 4) +
					 4 * RES_LEAF + 4, 0);
D
David Teigland 已提交
1524 1525 1526 1527
		if (error)
			goto out_ipreserv;
	} else {
		error = gfs2_trans_begin(sdp, 4 * RES_DINODE +
S
S. Wendy Cheng 已提交
1528
					 5 * RES_LEAF + 4, 0);
D
David Teigland 已提交
1529 1530 1531 1532 1533 1534
		if (error)
			goto out_gunlock;
	}

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

1535 1536
	if (nip)
		error = gfs2_unlink_inode(ndip, ndentry);
D
David Teigland 已提交
1537

1538 1539 1540
	error = update_moved_ino(ip, ndip, dir_rename);
	if (error)
		goto out_end_trans;
D
David Teigland 已提交
1541

1542
	error = gfs2_dir_del(odip, odentry);
D
David Teigland 已提交
1543 1544 1545
	if (error)
		goto out_end_trans;

1546
	error = gfs2_dir_add(ndir, &ndentry->d_name, ip, &da);
D
David Teigland 已提交
1547 1548 1549
	if (error)
		goto out_end_trans;

1550
out_end_trans:
D
David Teigland 已提交
1551
	gfs2_trans_end(sdp);
1552
out_ipreserv:
1553
	if (da.nr_blocks)
D
David Teigland 已提交
1554
		gfs2_inplace_release(ndip);
1555
out_gunlock_q:
1556
	if (da.nr_blocks)
D
David Teigland 已提交
1557
		gfs2_quota_unlock(ndip);
1558
out_gunlock:
1559
	gfs2_dir_no_add(&da);
1560 1561
	while (x--) {
		gfs2_glock_dq(ghs + x);
D
David Teigland 已提交
1562
		gfs2_holder_uninit(ghs + x);
1563
	}
1564
out_gunlock_r:
A
Andreas Gruenbacher 已提交
1565
	if (gfs2_holder_initialized(&r_gh))
D
David Teigland 已提交
1566
		gfs2_glock_dq_uninit(&r_gh);
1567
out:
D
David Teigland 已提交
1568 1569 1570
	return error;
}

1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590
/**
 * 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);
A
Andreas Gruenbacher 已提交
1591
	struct gfs2_holder ghs[5], r_gh;
1592 1593 1594 1595 1596 1597
	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;

A
Andreas Gruenbacher 已提交
1598
	gfs2_holder_mark_uninitialized(&r_gh);
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
	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:
A
Andreas Gruenbacher 已提交
1706
	if (gfs2_holder_initialized(&r_gh))
1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726
		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);
}

1727
/**
1728
 * gfs2_get_link - Follow a symbolic link
A
Al Viro 已提交
1729
 * @dentry: The dentry of the link
1730
 * @inode: The inode of the link
1731
 * @done: destructor for return value
1732
 *
A
Al Viro 已提交
1733
 * This can handle symlinks of any size.
1734
 *
A
Al Viro 已提交
1735
 * Returns: 0 on success or error code
1736 1737
 */

1738
static const char *gfs2_get_link(struct dentry *dentry,
1739 1740
				 struct inode *inode,
				 struct delayed_call *done)
1741
{
1742
	struct gfs2_inode *ip = GFS2_I(inode);
1743 1744
	struct gfs2_holder i_gh;
	struct buffer_head *dibh;
1745
	unsigned int size;
A
Al Viro 已提交
1746
	char *buf;
1747 1748
	int error;

1749 1750 1751
	if (!dentry)
		return ERR_PTR(-ECHILD);

1752 1753 1754 1755
	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);
1756
		return ERR_PTR(error);
1757 1758
	}

S
Steven Whitehouse 已提交
1759 1760
	size = (unsigned int)i_size_read(&ip->i_inode);
	if (size == 0) {
1761
		gfs2_consist_inode(ip);
A
Al Viro 已提交
1762
		buf = ERR_PTR(-EIO);
1763 1764 1765 1766
		goto out;
	}

	error = gfs2_meta_inode_buffer(ip, &dibh);
A
Al Viro 已提交
1767 1768
	if (error) {
		buf = ERR_PTR(error);
1769 1770 1771
		goto out;
	}

1772
	buf = kzalloc(size + 1, GFP_NOFS);
A
Al Viro 已提交
1773 1774 1775
	if (!buf)
		buf = ERR_PTR(-ENOMEM);
	else
1776
		memcpy(buf, dibh->b_data + sizeof(struct gfs2_dinode), size);
1777 1778 1779
	brelse(dibh);
out:
	gfs2_glock_dq_uninit(&i_gh);
1780
	if (!IS_ERR(buf))
1781
		set_delayed_call(done, kfree_link, buf);
1782
	return buf;
D
David Teigland 已提交
1783 1784 1785 1786
}

/**
 * gfs2_permission -
1787 1788 1789
 * @inode: The inode
 * @mask: The mask to be tested
 * @flags: Indicates whether this is an RCU path walk or not
D
David Teigland 已提交
1790
 *
1791 1792 1793 1794
 * 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 已提交
1795 1796 1797
 * Returns: errno
 */

1798
int gfs2_permission(struct inode *inode, int mask)
D
David Teigland 已提交
1799
{
1800
	struct gfs2_inode *ip;
D
David Teigland 已提交
1801 1802
	struct gfs2_holder i_gh;
	int error;
1803

A
Andreas Gruenbacher 已提交
1804
	gfs2_holder_mark_uninitialized(&i_gh);
1805
	ip = GFS2_I(inode);
1806
	if (gfs2_glock_is_locked_by_me(ip->i_gl) == NULL) {
1807 1808 1809 1810 1811
		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;
1812
	}
D
David Teigland 已提交
1813

M
Miklos Szeredi 已提交
1814
	if ((mask & MAY_WRITE) && IS_IMMUTABLE(inode))
E
Eryu Guan 已提交
1815
		error = -EPERM;
M
Miklos Szeredi 已提交
1816
	else
1817
		error = generic_permission(inode, mask);
A
Andreas Gruenbacher 已提交
1818
	if (gfs2_holder_initialized(&i_gh))
D
David Teigland 已提交
1819 1820 1821 1822 1823
		gfs2_glock_dq_uninit(&i_gh);

	return error;
}

S
Steven Whitehouse 已提交
1824
static int __gfs2_setattr_simple(struct inode *inode, struct iattr *attr)
1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838
{
	setattr_copy(inode, attr);
	mark_inode_dirty(inode);
	return 0;
}

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

S
Steven Whitehouse 已提交
1839
int gfs2_setattr_simple(struct inode *inode, struct iattr *attr)
1840 1841 1842 1843
{
	int error;

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

S
Steven Whitehouse 已提交
1846
	error = gfs2_trans_begin(GFS2_SB(inode), RES_DINODE, 0);
1847 1848 1849
	if (error)
		return error;

S
Steven Whitehouse 已提交
1850 1851
	error = __gfs2_setattr_simple(inode, attr);
	gfs2_trans_end(GFS2_SB(inode));
1852 1853 1854
	return error;
}

D
David Teigland 已提交
1855 1856
static int setattr_chown(struct inode *inode, struct iattr *attr)
{
1857 1858
	struct gfs2_inode *ip = GFS2_I(inode);
	struct gfs2_sbd *sdp = GFS2_SB(inode);
1859 1860
	kuid_t ouid, nuid;
	kgid_t ogid, ngid;
D
David Teigland 已提交
1861
	int error;
1862
	struct gfs2_alloc_parms ap;
D
David Teigland 已提交
1863

1864 1865
	ouid = inode->i_uid;
	ogid = inode->i_gid;
D
David Teigland 已提交
1866 1867 1868
	nuid = attr->ia_uid;
	ngid = attr->ia_gid;

1869
	if (!(attr->ia_valid & ATTR_UID) || uid_eq(ouid, nuid))
1870
		ouid = nuid = NO_UID_QUOTA_CHANGE;
1871
	if (!(attr->ia_valid & ATTR_GID) || gid_eq(ogid, ngid))
1872
		ogid = ngid = NO_GID_QUOTA_CHANGE;
D
David Teigland 已提交
1873

1874
	error = gfs2_rsqa_alloc(ip);
1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885
	if (error)
		goto out;

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

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

1886 1887
	ap.target = gfs2_get_inode_blocks(&ip->i_inode);

1888 1889
	if (!uid_eq(ouid, NO_UID_QUOTA_CHANGE) ||
	    !gid_eq(ogid, NO_GID_QUOTA_CHANGE)) {
1890
		error = gfs2_quota_check(ip, nuid, ngid, &ap);
D
David Teigland 已提交
1891 1892 1893 1894 1895 1896 1897 1898
		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 已提交
1899
	error = gfs2_setattr_simple(inode, attr);
D
David Teigland 已提交
1900 1901 1902
	if (error)
		goto out_end_trans;

1903 1904
	if (!uid_eq(ouid, NO_UID_QUOTA_CHANGE) ||
	    !gid_eq(ogid, NO_GID_QUOTA_CHANGE)) {
1905
		gfs2_quota_change(ip, -(s64)ap.target, ouid, ogid);
1906
		gfs2_quota_change(ip, ap.target, nuid, ngid);
D
David Teigland 已提交
1907 1908
	}

1909
out_end_trans:
D
David Teigland 已提交
1910
	gfs2_trans_end(sdp);
1911
out_gunlock_q:
D
David Teigland 已提交
1912
	gfs2_quota_unlock(ip);
1913
out:
D
David Teigland 已提交
1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929
	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)
{
1930
	struct inode *inode = d_inode(dentry);
1931
	struct gfs2_inode *ip = GFS2_I(inode);
D
David Teigland 已提交
1932 1933 1934
	struct gfs2_holder i_gh;
	int error;

1935
	error = gfs2_rsqa_alloc(ip);
1936 1937 1938
	if (error)
		return error;

D
David Teigland 已提交
1939 1940 1941 1942 1943 1944 1945 1946
	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;

1947
	error = setattr_prepare(dentry, attr);
D
David Teigland 已提交
1948 1949 1950 1951
	if (error)
		goto out;

	if (attr->ia_valid & ATTR_SIZE)
S
Steven Whitehouse 已提交
1952
		error = gfs2_setattr_size(inode, attr->ia_size);
D
David Teigland 已提交
1953 1954
	else if (attr->ia_valid & (ATTR_UID | ATTR_GID))
		error = setattr_chown(inode, attr);
1955
	else {
S
Steven Whitehouse 已提交
1956
		error = gfs2_setattr_simple(inode, attr);
1957 1958 1959
		if (!error && attr->ia_valid & ATTR_MODE)
			error = posix_acl_chmod(inode, inode->i_mode);
	}
D
David Teigland 已提交
1960

1961
out:
D
David Teigland 已提交
1962 1963
	if (!error)
		mark_inode_dirty(inode);
S
Steven Whitehouse 已提交
1964
	gfs2_glock_dq_uninit(&i_gh);
D
David Teigland 已提交
1965 1966 1967 1968 1969
	return error;
}

/**
 * gfs2_getattr - Read out an inode's attributes
1970
 * @path: Object to query
D
David Teigland 已提交
1971
 * @stat: The inode's stats
1972 1973
 * @request_mask: Mask of STATX_xxx flags indicating the caller's interests
 * @flags: AT_STATX_xxx setting
D
David Teigland 已提交
1974
 *
1975 1976 1977 1978 1979 1980
 * 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 已提交
1981 1982 1983
 * Returns: errno
 */

1984 1985
static int gfs2_getattr(const struct path *path, struct kstat *stat,
			u32 request_mask, unsigned int flags)
D
David Teigland 已提交
1986
{
1987
	struct inode *inode = d_inode(path->dentry);
1988
	struct gfs2_inode *ip = GFS2_I(inode);
D
David Teigland 已提交
1989 1990 1991
	struct gfs2_holder gh;
	int error;

A
Andreas Gruenbacher 已提交
1992
	gfs2_holder_mark_uninitialized(&gh);
1993
	if (gfs2_glock_is_locked_by_me(ip->i_gl) == NULL) {
1994 1995 1996
		error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, &gh);
		if (error)
			return error;
D
David Teigland 已提交
1997 1998
	}

1999
	generic_fillattr(inode, stat);
A
Andreas Gruenbacher 已提交
2000
	if (gfs2_holder_initialized(&gh))
2001 2002 2003
		gfs2_glock_dq_uninit(&gh);

	return 0;
D
David Teigland 已提交
2004 2005
}

2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016
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;

A
Al Viro 已提交
2017
	inode_lock(inode);
2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043

	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:
A
Al Viro 已提交
2044
	inode_unlock(inode);
2045 2046 2047
	return ret;
}

2048
const struct inode_operations gfs2_file_iops = {
2049
	.permission = gfs2_permission,
D
David Teigland 已提交
2050 2051 2052
	.setattr = gfs2_setattr,
	.getattr = gfs2_getattr,
	.listxattr = gfs2_listxattr,
2053
	.fiemap = gfs2_fiemap,
2054
	.get_acl = gfs2_get_acl,
2055
	.set_acl = gfs2_set_acl,
D
David Teigland 已提交
2056 2057
};

2058
const struct inode_operations gfs2_dir_iops = {
D
David Teigland 已提交
2059 2060 2061 2062 2063 2064
	.create = gfs2_create,
	.lookup = gfs2_lookup,
	.link = gfs2_link,
	.unlink = gfs2_unlink,
	.symlink = gfs2_symlink,
	.mkdir = gfs2_mkdir,
2065
	.rmdir = gfs2_unlink,
D
David Teigland 已提交
2066
	.mknod = gfs2_mknod,
2067
	.rename = gfs2_rename2,
2068
	.permission = gfs2_permission,
D
David Teigland 已提交
2069 2070 2071
	.setattr = gfs2_setattr,
	.getattr = gfs2_getattr,
	.listxattr = gfs2_listxattr,
2072
	.fiemap = gfs2_fiemap,
2073
	.get_acl = gfs2_get_acl,
2074
	.set_acl = gfs2_set_acl,
2075
	.atomic_open = gfs2_atomic_open,
D
David Teigland 已提交
2076 2077
};

2078
const struct inode_operations gfs2_symlink_iops = {
2079
	.get_link = gfs2_get_link,
2080
	.permission = gfs2_permission,
D
David Teigland 已提交
2081 2082 2083
	.setattr = gfs2_setattr,
	.getattr = gfs2_getattr,
	.listxattr = gfs2_listxattr,
2084
	.fiemap = gfs2_fiemap,
D
David Teigland 已提交
2085 2086
};