inode.c 49.1 KB
Newer Older
1
// SPDX-License-Identifier: GPL-2.0-only
David Teigland's avatar
David Teigland committed
2 3
/*
 * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
4
 * Copyright (C) 2004-2011 Red Hat, Inc.  All rights reserved.
David Teigland's avatar
David Teigland committed
5 6 7 8 9 10 11 12
 */

#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>
13
#include <linux/cred.h>
David Teigland's avatar
David Teigland committed
14 15
#include <linux/xattr.h>
#include <linux/posix_acl.h>
16
#include <linux/gfs2_ondisk.h>
17
#include <linux/crc32.h>
18
#include <linux/iomap.h>
19
#include <linux/security.h>
20
#include <linux/uaccess.h>
David Teigland's avatar
David Teigland committed
21 22

#include "gfs2.h"
23
#include "incore.h"
David Teigland's avatar
David Teigland committed
24 25 26
#include "acl.h"
#include "bmap.h"
#include "dir.h"
27
#include "xattr.h"
David Teigland's avatar
David Teigland committed
28 29 30 31 32 33
#include "glock.h"
#include "inode.h"
#include "meta_io.h"
#include "quota.h"
#include "rgrp.h"
#include "trans.h"
34
#include "util.h"
35
#include "super.h"
36 37
#include "glops.h"

38
static int iget_test(struct inode *inode, void *opaque)
39
{
40 41 42 43 44 45 46 47 48 49 50 51 52 53
	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;
}

54 55 56 57 58
static struct inode *gfs2_iget(struct super_block *sb, u64 no_addr)
{
	struct inode *inode;

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

/**
 * 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
106 107 108
 * @no_addr: The inode number
 * @no_formal_ino: The inode generation number
 * @blktype: Requested block type (GFS2_BLKST_DINODE or GFS2_BLKST_UNLINKED;
109
 *           GFS2_BLKST_FREE to indicate not to verify)
110 111 112 113 114 115
 *
 * 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.
116 117 118 119 120
 *
 * Returns: A VFS inode, or an error
 */

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

130
	gfs2_holder_mark_uninitialized(&i_gh);
131
	inode = gfs2_iget(sb, no_addr);
132
	if (!inode)
133
		return ERR_PTR(-ENOMEM);
134

135 136
	ip = GFS2_I(inode);

137 138 139 140 141 142
	if (inode->i_state & I_NEW) {
		struct gfs2_sbd *sdp = GFS2_SB(inode);

		error = gfs2_glock_get(sdp, no_addr, &gfs2_inode_glops, CREATE, &ip->i_gl);
		if (unlikely(error))
			goto fail;
143
		flush_delayed_work(&ip->i_gl->gl_work);
144 145 146

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

149 150 151 152 153 154 155 156 157
		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)
158
				goto fail;
159 160 161 162 163

			if (blktype != GFS2_BLKST_FREE) {
				error = gfs2_check_blk_type(sdp, no_addr,
							    blktype);
				if (error)
164
					goto fail;
165 166 167
			}
		}

168
		glock_set_object(ip->i_gl, ip);
169 170 171
		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))
172
			goto fail;
173
		glock_set_object(ip->i_iopen_gh.gh_gl, ip);
174 175 176
		gfs2_glock_put(io_gl);
		io_gl = NULL;

177 178 179 180
		/* Lowest possible timestamp; will be overwritten in gfs2_dinode_in. */
		inode->i_atime.tv_sec = 1LL << (8 * sizeof(inode->i_atime.tv_sec) - 1);
		inode->i_atime.tv_nsec = 0;

181 182 183 184
		if (type == DT_UNKNOWN) {
			/* Inode glock must be locked already */
			error = gfs2_inode_refresh(GFS2_I(inode));
			if (error)
185
				goto fail;
186
		} else {
187
			ip->i_no_formal_ino = no_formal_ino;
188 189 190 191
			inode->i_mode = DT2IF(type);
		}

		gfs2_set_iop(inode);
192

193 194 195
		unlock_new_inode(inode);
	}

196
	if (gfs2_holder_initialized(&i_gh))
197
		gfs2_glock_dq_uninit(&i_gh);
198 199
	return inode;

200
fail:
201 202
	if (io_gl)
		gfs2_glock_put(io_gl);
203
	if (gfs2_holder_initialized(&i_gh))
204
		gfs2_glock_dq_uninit(&i_gh);
205 206 207 208 209 210 211 212
	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;
213
	struct inode *inode;
214 215
	int error;

216
	inode = gfs2_inode_lookup(sb, DT_UNKNOWN, no_addr, 0, blktype);
217
	if (IS_ERR(inode))
218
		return inode;
219 220 221 222 223 224 225 226 227 228 229

	/* 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;
	}
230
	return inode;
231 232 233

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


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;

280
	gfs2_holder_mark_uninitialized(&d_gh);
281 282 283 284 285
	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 &&
286
	     dir == d_inode(sb->s_root))) {
287 288 289 290 291 292 293 294 295 296 297
		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) {
298
		error = gfs2_permission(dir, MAY_EXEC);
299 300 301 302
		if (error)
			goto out;
	}

303
	inode = gfs2_dir_search(dir, name, false);
304 305 306
	if (IS_ERR(inode))
		error = PTR_ERR(inode);
out:
307
	if (gfs2_holder_initialized(&d_gh))
308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323
		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,
Al Viro's avatar
Al Viro committed
324
		     umode_t mode)
325 326 327
{
	int error;

328
	error = gfs2_permission(&dip->i_inode, MAY_WRITE | MAY_EXEC);
329 330 331 332 333 334 335 336 337 338 339 340 341 342 343
	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;
}

344 345
static void munge_mode_uid_gid(const struct gfs2_inode *dip,
			       struct inode *inode)
346 347
{
	if (GFS2_SB(&dip->i_inode)->sd_args.ar_suiddir &&
348 349
	    (dip->i_inode.i_mode & S_ISUID) &&
	    !uid_eq(dip->i_inode.i_uid, GLOBAL_ROOT_UID)) {
350 351
		if (S_ISDIR(inode->i_mode))
			inode->i_mode |= S_ISUID;
352
		else if (!uid_eq(dip->i_inode.i_uid, current_fsuid()))
353 354
			inode->i_mode &= ~07111;
		inode->i_uid = dip->i_inode.i_uid;
355
	} else
356
		inode->i_uid = current_fsuid();
357 358

	if (dip->i_inode.i_mode & S_ISGID) {
359 360 361
		if (S_ISDIR(inode->i_mode))
			inode->i_mode |= S_ISGID;
		inode->i_gid = dip->i_inode.i_gid;
362
	} else
363
		inode->i_gid = current_fsgid();
364 365
}

366
static int alloc_dinode(struct gfs2_inode *ip, u32 flags, unsigned *dblocks)
367
{
368
	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
369
	struct gfs2_alloc_parms ap = { .target = *dblocks, .aflags = flags, };
370 371
	int error;

372
	error = gfs2_quota_lock_check(ip, &ap);
373 374 375
	if (error)
		goto out;

376
	error = gfs2_inplace_reserve(ip, &ap);
377 378 379
	if (error)
		goto out_quota;

380
	error = gfs2_trans_begin(sdp, (*dblocks * RES_RG_BIT) + RES_STATFS + RES_QUOTA, 0);
381 382 383
	if (error)
		goto out_ipreserv;

384
	error = gfs2_alloc_blocks(ip, &ip->i_no_addr, dblocks, 1, &ip->i_generation);
385 386 387
	ip->i_no_formal_ino = ip->i_generation;
	ip->i_inode.i_ino = ip->i_no_addr;
	ip->i_goal = ip->i_no_addr;
388 389 390 391

	gfs2_trans_end(sdp);

out_ipreserv:
392
	gfs2_inplace_release(ip);
393 394
out_quota:
	gfs2_quota_unlock(ip);
395 396 397 398
out:
	return error;
}

399 400
static void gfs2_init_dir(struct buffer_head *dibh,
			  const struct gfs2_inode *parent)
Steven Whitehouse's avatar
Steven Whitehouse committed
401 402 403 404 405 406 407 408 409 410 411 412 413 414 415
{
	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);
	
}

416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442
/**
 * 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);
}

443 444
/**
 * init_dinode - Fill in a new dinode structure
445
 * @dip: The directory this inode is being created in
446
 * @ip: The inode
447 448
 * @symname: The symlink destination (if a symlink)
 * @bhp: The buffer head (returned to caller)
449 450 451
 *
 */

452
static void init_dinode(struct gfs2_inode *dip, struct gfs2_inode *ip,
453
			const char *symname)
454 455 456 457
{
	struct gfs2_dinode *di;
	struct buffer_head *dibh;

458
	dibh = gfs2_meta_new(ip->i_gl, ip->i_no_addr);
459
	gfs2_trans_add_meta(ip->i_gl, dibh);
460
	di = (struct gfs2_dinode *)dibh->b_data;
461
	gfs2_dinode_out(ip, di);
462

463 464
	di->di_major = cpu_to_be32(MAJOR(ip->i_inode.i_rdev));
	di->di_minor = cpu_to_be32(MINOR(ip->i_inode.i_rdev));
465 466 467 468 469
	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));
470
	gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode));
471

472
	switch(ip->i_inode.i_mode & S_IFMT) {
473
	case S_IFDIR:
Steven Whitehouse's avatar
Steven Whitehouse committed
474
		gfs2_init_dir(dibh, dip);
475 476
		break;
	case S_IFLNK:
477
		memcpy(dibh->b_data + sizeof(struct gfs2_dinode), symname, ip->i_inode.i_size);
478
		break;
Steven Whitehouse's avatar
Steven Whitehouse committed
479 480
	}

481
	set_buffer_uptodate(dibh);
482
	brelse(dibh);
483 484
}

485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506
/**
 * 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;
}

507
static int link_dinode(struct gfs2_inode *dip, const struct qstr *name,
508
		       struct gfs2_inode *ip, struct gfs2_diradd *da)
509 510
{
	struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
511
	struct gfs2_alloc_parms ap = { .target = da->nr_blocks, };
512 513
	int error;

514
	if (da->nr_blocks) {
515
		error = gfs2_quota_lock_check(dip, &ap);
516 517 518
		if (error)
			goto fail_quota_locks;

519
		error = gfs2_inplace_reserve(dip, &ap);
520 521 522
		if (error)
			goto fail_quota_locks;

523
		error = gfs2_trans_begin(sdp, gfs2_trans_da_blks(dip, da, 2), 0);
524 525 526 527 528 529 530 531
		if (error)
			goto fail_ipreserv;
	} else {
		error = gfs2_trans_begin(sdp, RES_LEAF + 2 * RES_DINODE, 0);
		if (error)
			goto fail_quota_locks;
	}

532
	error = gfs2_dir_add(&dip->i_inode, name, ip, da);
533 534 535

	gfs2_trans_end(sdp);
fail_ipreserv:
536
	gfs2_inplace_release(dip);
537 538 539 540 541
fail_quota_locks:
	gfs2_quota_unlock(dip);
	return error;
}

542
static int gfs2_initxattrs(struct inode *inode, const struct xattr *xattr_array,
543
		    void *fs_info)
544
{
545 546 547 548 549 550 551 552 553
	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;
554 555 556
	}
	return err;
}
David Teigland's avatar
David Teigland committed
557

558
/**
559 560 561
 * gfs2_create_inode - Create a new inode
 * @dir: The parent directory
 * @dentry: The new dentry
562
 * @file: If non-NULL, the file which is being opened
563 564 565 566
 * @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)
567
 *
568
 * Returns: 0 on success, or error code
569 570
 */

571
static int gfs2_create_inode(struct inode *dir, struct dentry *dentry,
572
			     struct file *file,
Al Viro's avatar
Al Viro committed
573
			     umode_t mode, dev_t dev, const char *symname,
574
			     unsigned int size, int excl)
575
{
576
	const struct qstr *name = &dentry->d_name;
577
	struct posix_acl *default_acl, *acl;
578
	struct gfs2_holder ghs[2];
579
	struct inode *inode = NULL;
580
	struct gfs2_inode *dip = GFS2_I(dir), *ip;
581
	struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
582
	struct gfs2_glock *io_gl = NULL;
583
	int error, free_vfs_inode = 1;
584
	u32 aflags = 0;
585
	unsigned blocks = 1;
586
	struct gfs2_diradd da = { .bh = NULL, .save_loc = 1, };
587 588

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

591
	error = gfs2_qa_alloc(dip);
592 593 594
	if (error)
		return error;

595 596 597 598
	error = gfs2_rindex_update(sdp);
	if (error)
		return error;

599
	error = gfs2_glock_nq_init(dip->i_gl, LM_ST_EXCLUSIVE, 0, ghs);
600 601
	if (error)
		goto fail;
602
	gfs2_holder_mark_uninitialized(ghs + 1);
603 604

	error = create_ok(dip, name, mode);
605 606 607 608 609 610
	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)) {
611 612 613 614 615
		if (S_ISDIR(inode->i_mode)) {
			iput(inode);
			inode = ERR_PTR(-EISDIR);
			goto fail_gunlock;
		}
616
		d_instantiate(dentry, inode);
617
		error = 0;
618
		if (file) {
619
			if (S_ISREG(inode->i_mode))
620
				error = finish_open(file, dentry, gfs2_open_common);
621 622
			else
				error = finish_no_open(file, NULL);
623
		}
624
		gfs2_glock_dq_uninit(ghs);
625
		return error;
626
	} else if (error != -ENOENT) {
627
		goto fail_gunlock;
628
	}
629

630
	error = gfs2_diradd_alloc_required(dir, name, &da);
631 632 633
	if (error < 0)
		goto fail_gunlock;

634
	inode = new_inode(sdp->sd_vfs);
635 636 637 638
	error = -ENOMEM;
	if (!inode)
		goto fail_gunlock;

639 640
	error = posix_acl_create(dir, &mode, &default_acl, &acl);
	if (error)
641
		goto fail_gunlock;
642

643
	ip = GFS2_I(inode);
644
	error = gfs2_qa_alloc(ip);
645
	if (error)
646
		goto fail_free_acls;
647 648

	inode->i_mode = mode;
649
	set_nlink(inode, S_ISDIR(mode) ? 2 : 1);
650 651
	inode->i_rdev = dev;
	inode->i_size = size;
652
	inode->i_atime = inode->i_mtime = inode->i_ctime = current_time(inode);
653
	munge_mode_uid_gid(dip, inode);
654
	check_and_update_goal(dip);
655
	ip->i_goal = dip->i_goal;
656 657 658 659 660
	ip->i_diskflags = 0;
	ip->i_eattr = 0;
	ip->i_height = 0;
	ip->i_depth = 0;
	ip->i_entries = 0;
661
	ip->i_no_addr = 0; /* Temporarily zero until real addr is assigned */
662 663 664 665 666 667 668 669 670 671 672 673 674 675

	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;
	}
676 677 678 679 680

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

681
	gfs2_set_inode_flags(inode);
682

683
	if ((GFS2_I(d_inode(sdp->sd_root_dir)) == dip) ||
684 685 686
	    (dip->i_diskflags & GFS2_DIF_TOPDIR))
		aflags |= GFS2_AF_ORLOV;

687 688 689 690
	if (default_acl || acl)
		blocks++;

	error = alloc_dinode(ip, aflags, &blocks);
691
	if (error)
692
		goto fail_free_inode;
693

694 695
	gfs2_set_inode_blocks(inode, blocks);

696
	error = gfs2_glock_get(sdp, ip->i_no_addr, &gfs2_inode_glops, CREATE, &ip->i_gl);
697
	if (error)
698
		goto fail_free_inode;
699
	flush_delayed_work(&ip->i_gl->gl_work);
700
	glock_set_object(ip->i_gl, ip);
701

702 703 704 705
	error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, GL_SKIP, ghs + 1);
	if (error)
		goto fail_free_inode;

706
	error = gfs2_trans_begin(sdp, blocks, 0);
707
	if (error)
708
		goto fail_free_inode;
709

710 711 712 713
	if (blocks > 1) {
		ip->i_eattr = ip->i_no_addr + 1;
		gfs2_init_xattr(ip);
	}
714
	init_dinode(dip, ip, symname);
715 716
	gfs2_trans_end(sdp);

717
	error = gfs2_glock_get(sdp, ip->i_no_addr, &gfs2_iopen_glops, CREATE, &io_gl);
718
	if (error)
719
		goto fail_free_inode;
720

721 722
	BUG_ON(test_and_set_bit(GLF_INODE_CREATING, &io_gl->gl_flags));

723
	error = gfs2_glock_nq_init(io_gl, LM_ST_SHARED, GL_EXACT, &ip->i_iopen_gh);
724 725
	if (error)
		goto fail_gunlock2;
726

727
	glock_set_object(ip->i_iopen_gh.gh_gl, ip);
728 729 730
	gfs2_set_iop(inode);
	insert_inode_hash(inode);

731 732 733
	free_vfs_inode = 0; /* After this point, the inode is no longer
			       considered free. Any failures need to undo
			       the gfs2 structures. */
734
	if (default_acl) {
735
		error = __gfs2_set_acl(inode, default_acl, ACL_TYPE_DEFAULT);
736 737
		if (error)
			goto fail_gunlock3;
738
		posix_acl_release(default_acl);
739
		default_acl = NULL;
740 741
	}
	if (acl) {
742 743 744
		error = __gfs2_set_acl(inode, acl, ACL_TYPE_ACCESS);
		if (error)
			goto fail_gunlock3;
745
		posix_acl_release(acl);
746
		acl = NULL;
747 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);
760 761
	/* After instantiate, errors should result in evict which will destroy
	 * both inode and iopen glocks properly. */
Miklos Szeredi's avatar
Miklos Szeredi committed
762
	if (file) {
763
		file->f_mode |= FMODE_CREATED;
764
		error = finish_open(file, dentry, gfs2_open_common);
Miklos Szeredi's avatar
Miklos Szeredi committed
765
	}
766 767
	gfs2_glock_dq_uninit(ghs);
	gfs2_glock_dq_uninit(ghs + 1);
768
	clear_bit(GLF_INODE_CREATING, &io_gl->gl_flags);
769
	gfs2_glock_put(io_gl);
770
	return error;
771

772
fail_gunlock3:
773
	glock_clear_object(io_gl, ip);
774
	gfs2_glock_dq_uninit(&ip->i_iopen_gh);
775
fail_gunlock2:
776 777
	clear_bit(GLF_INODE_CREATING, &io_gl->gl_flags);
	gfs2_glock_put(io_gl);
778
fail_free_inode:
779 780
	if (ip->i_gl) {
		glock_clear_object(ip->i_gl, ip);
781
		gfs2_glock_put(ip->i_gl);
782
	}
783
	gfs2_rsqa_delete(ip, NULL);
784
fail_free_acls:
785 786
	posix_acl_release(default_acl);
	posix_acl_release(acl);
787
fail_gunlock:
788
	gfs2_dir_no_add(&da);
789
	gfs2_glock_dq_uninit(ghs);
Kefeng Wang's avatar
Kefeng Wang committed
790
	if (!IS_ERR_OR_NULL(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 799
	if (gfs2_holder_initialized(ghs + 1))
		gfs2_glock_dq_uninit(ghs + 1);
800
fail:
801
	return error;
802
}
803

David Teigland's avatar
David Teigland committed
804 805 806 807 808 809 810 811 812 813
/**
 * 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,
Al Viro's avatar
Al Viro committed
814
		       umode_t mode, bool excl)
David Teigland's avatar
David Teigland committed
815
{
816
	return gfs2_create_inode(dir, dentry, NULL, S_IFREG | mode, 0, NULL, 0, excl);
David Teigland's avatar
David Teigland committed
817 818 819
}

/**
820
 * __gfs2_lookup - Look up a filename in a directory and return its inode
David Teigland's avatar
David Teigland committed
821 822
 * @dir: The directory inode
 * @dentry: The dentry of the new inode
823
 * @file: File to be opened
David Teigland's avatar
David Teigland committed
824 825 826 827 828
 *
 *
 * Returns: errno
 */

829
static struct dentry *__gfs2_lookup(struct inode *dir, struct dentry *dentry,
830
				    struct file *file)
David Teigland's avatar
David Teigland committed
831
{
832 833 834 835 836 837 838
	struct inode *inode;
	struct dentry *d;
	struct gfs2_holder gh;
	struct gfs2_glock *gl;
	int error;

	inode = gfs2_lookupi(dir, &dentry->d_name, 0);
839 840
	if (inode == NULL) {
		d_add(dentry, NULL);
841
		return NULL;
842
	}
843 844 845 846 847 848 849 850
	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);
851
	}
852 853

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

	gfs2_glock_dq_uninit(&gh);
Miklos Szeredi's avatar
Miklos Szeredi committed
862 863
	if (error) {
		dput(d);
864
		return ERR_PTR(error);
Miklos Szeredi's avatar
Miklos Szeredi committed
865
	}
866 867 868 869 870 871
	return d;
}

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

/**
 * 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)
{
890 891
	struct gfs2_inode *dip = GFS2_I(dir);
	struct gfs2_sbd *sdp = GFS2_SB(dir);
892
	struct inode *inode = d_inode(old_dentry);
893
	struct gfs2_inode *ip = GFS2_I(inode);
David Teigland's avatar
David Teigland committed
894
	struct gfs2_holder ghs[2];
895
	struct buffer_head *dibh;
896
	struct gfs2_diradd da = { .bh = NULL, .save_loc = 1, };
David Teigland's avatar
David Teigland committed
897 898
	int error;

899
	if (S_ISDIR(inode->i_mode))
David Teigland's avatar
David Teigland committed
900 901
		return -EPERM;

902
	error = gfs2_qa_alloc(dip);
903 904 905
	if (error)
		return error;

David Teigland's avatar
David Teigland committed
906 907 908
	gfs2_holder_init(dip->i_gl, LM_ST_EXCLUSIVE, 0, ghs);
	gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + 1);

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

	error = gfs2_glock_nq(ghs + 1); /* child */
David Teigland's avatar
David Teigland committed
914
	if (error)
915
		goto out_child;
David Teigland's avatar
David Teigland committed
916

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

921
	error = gfs2_permission(dir, MAY_WRITE | MAY_EXEC);
David Teigland's avatar
David Teigland committed
922 923 924
	if (error)
		goto out_gunlock;

925
	error = gfs2_dir_check(dir, &dentry->d_name, NULL);
David Teigland's avatar
David Teigland committed
926 927 928 929 930 931 932 933 934 935
	switch (error) {
	case -ENOENT:
		break;
	case 0:
		error = -EEXIST;
	default:
		goto out_gunlock;
	}

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

951
	error = gfs2_diradd_alloc_required(dir, &dentry->d_name, &da);
952
	if (error < 0)
David Teigland's avatar
David Teigland committed
953 954
		goto out_gunlock;

955 956
	if (da.nr_blocks) {
		struct gfs2_alloc_parms ap = { .target = da.nr_blocks, };
957
		error = gfs2_quota_lock_check(dip, &ap);
David Teigland's avatar
David Teigland committed
958
		if (error)
959
			goto out_gunlock;
David Teigland's avatar
David Teigland committed
960

961
		error = gfs2_inplace_reserve(dip, &ap);
David Teigland's avatar
David Teigland committed
962 963 964
		if (error)
			goto out_gunlock_q;

965
		error = gfs2_trans_begin(sdp, gfs2_trans_da_blks(dip, &da, 2), 0);
David Teigland's avatar
David Teigland committed
966 967 968 969 970 971 972 973
		if (error)
			goto out_ipres;
	} else {
		error = gfs2_trans_begin(sdp, 2 * RES_DINODE + RES_LEAF, 0);
		if (error)
			goto out_ipres;
	}

974
	error = gfs2_meta_inode_buffer(ip, &dibh);
David Teigland's avatar
David Teigland committed
975 976 977
	if (error)
		goto out_end_trans;

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

982
	gfs2_trans_add_meta(ip->i_gl, dibh);
983
	inc_nlink(&ip->i_inode);
984
	ip->i_inode.i_ctime = current_time(&ip->i_inode);
985 986 987
	ihold(inode);
	d_instantiate(dentry, inode);
	mark_inode_dirty(inode);
David Teigland's avatar
David Teigland committed
988

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

1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029
/*
 * 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) &&
1030 1031
	    !uid_eq(dip->i_inode.i_uid, current_fsuid()) &&
	    !uid_eq(ip->i_inode.i_uid, current_fsuid()) && !capable(CAP_FOWNER))
1032 1033 1034 1035 1036
		return -EPERM;

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

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

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

David Teigland's avatar
David Teigland committed
1044
/**
1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056
 * 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,
1057
			     const struct dentry *dentry)
1058
{
1059
	struct inode *inode = d_inode(dentry);
1060 1061 1062 1063 1064 1065 1066 1067
	struct gfs2_inode *ip = GFS2_I(inode);
	int error;

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

	ip->i_entries = 0;
1068
	inode->i_ctime = current_time(inode);
1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082
	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
David Teigland's avatar
David Teigland committed
1083 1084
 * @dentry: The file itself
 *
1085 1086
 * This routine uses the type of the inode as a flag to figure out
 * whether this is an unlink or an rmdir.
David Teigland's avatar
David Teigland committed
1087 1088 1089 1090 1091 1092
 *
 * Returns: errno
 */

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

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

	error = -EROFS;
David Teigland's avatar
David Teigland committed
1106 1107

	gfs2_holder_init(dip->i_gl, LM_ST_EXCLUSIVE, 0, ghs);
1108
	gfs2_holder_init(ip->i_gl,  LM_ST_EXCLUSIVE, 0, ghs + 1);
David Teigland's avatar
David Teigland committed
1109

1110
	rgd = gfs2_blk2rgrpd(sdp, ip->i_no_addr, 1);
1111
	if (!rgd)
1112
		goto out_inodes;
1113

1114 1115 1116
	gfs2_holder_init(rgd->rd_gl, LM_ST_EXCLUSIVE, 0, ghs + 2);


1117
	error = gfs2_glock_nq(ghs); /* parent */
David Teigland's avatar
David Teigland committed
1118
	if (error)
1119 1120 1121 1122 1123 1124
		goto out_parent;

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

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

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

1135 1136 1137
	error = gfs2_glock_nq(ghs + 2); /* rgrp */
	if (error)
		goto out_rgrp;
David Teigland's avatar
David Teigland committed
1138 1139 1140

	error = gfs2_unlink_ok(dip, &dentry->d_name, ip);
	if (error)
1141
		goto out_gunlock;
David Teigland's avatar
David Teigland committed
1142

1143 1144
	error = gfs2_trans_begin(sdp, 2*RES_DINODE + 3*RES_LEAF + RES_RG_BIT, 0);
	if (error)
1145
		goto out_gunlock;
David Teigland's avatar
David Teigland committed
1146

1147
	error = gfs2_unlink_inode(dip, dentry);
1148
	gfs2_trans_end(sdp);
1149

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);
David Teigland's avatar
David Teigland committed
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
	unsigned int size;
David Teigland's avatar
David Teigland committed
1177 1178

	size = strlen(symname);
1179
	if (size >= gfs2_max_stuffed_size(GFS2_I(dir)))
David Teigland's avatar
David Teigland committed
1180 1181
		return -ENAMETOOLONG;

1182
	return gfs2_create_inode(dir, dentry, NULL, S_IFLNK | S_IRWXUGO, 0, symname, size, 0);
David Teigland's avatar
David Teigland committed
1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193
}

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

1194
static int gfs2_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
David Teigland's avatar
David Teigland committed
1195
{
1196
	unsigned dsize = gfs2_max_stuffed_size(GFS2_I(dir));
1197
	return gfs2_create_inode(dir, dentry, NULL, S_IFDIR | mode, 0, NULL, dsize, 0);
David Teigland's avatar
David Teigland committed
1198 1199 1200 1201 1202 1203 1204
}

/**
 * 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
1205
 * @dev: The device specification of the special file
David Teigland's avatar
David Teigland committed
1206 1207 1208
 *
 */

Al Viro's avatar
Al Viro committed
1209
static int gfs2_mknod(struct inode *dir, struct dentry *dentry, umode_t mode,
David Teigland's avatar
David Teigland committed
1210 1211
		      dev_t dev)
{
1212
	return gfs2_create_inode(dir, dentry, NULL, mode, dev, NULL, 0, 0);
1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226
}

/**
 * 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
 *
 * Returns: error code or 0 for success
 */

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

1233
	if (!d_in_lookup(dentry))
1234 1235
		goto skip_lookup;

1236
	d = __gfs2_lookup(dir, dentry, file);
1237 1238
	if (IS_ERR(d))
		return PTR_ERR(d);
Miklos Szeredi's avatar
Miklos Szeredi committed
1239 1240
	if (d != NULL)
		dentry = d;
1241
	if (d_really_is_positive(dentry)) {
1242
		if (!(file->f_mode & FMODE_OPENED))
1243
			return finish_no_open(file, d);
Miklos Szeredi's avatar
Miklos Szeredi committed
1244
		dput(d);
1245 1246 1247
		return 0;
	}

Miklos Szeredi's avatar
Miklos Szeredi committed
1248
	BUG_ON(d != NULL);
1249 1250

skip_lookup:
1251 1252 1253
	if (!(flags & O_CREAT))
		return -ENOENT;

1254
	return gfs2_create_inode(dir, dentry, file, S_IFREG | mode, 0, NULL, 0, excl);
David Teigland's avatar
David Teigland committed
1255 1256
}

1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281
/*
 * 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;
		}
1282
		if (dir == d_inode(sb->s_root)) {
1283 1284 1285 1286
			error = 0;
			break;
		}

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

		iput(dir);
		dir = tmp;
	}

	iput(dir);

	return error;
}

1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320
/**
 * 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)
{
	if (dir_rename)
		return gfs2_dir_mvino(ip, &gfs2_qdotdot, ndip, DT_DIR);

1321
	ip->i_inode.i_ctime = current_time(&ip->i_inode);
1322
	mark_inode_dirty_sync(&ip->i_inode);
1323 1324 1325 1326
	return 0;
}


David Teigland's avatar
David Teigland committed
1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339
/**
 * 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)
{
1340 1341
	struct gfs2_inode *odip = GFS2_I(odir);
	struct gfs2_inode *ndip = GFS2_I(ndir);
1342
	struct gfs2_inode *ip = GFS2_I(d_inode(odentry));
David Teigland's avatar
David Teigland committed
1343
	struct gfs2_inode *nip = NULL;
1344
	struct gfs2_sbd *sdp = GFS2_SB(odir);
1345
	struct gfs2_holder ghs[4], r_gh, rd_gh;
1346
	struct gfs2_rgrpd *nrgd;
David Teigland's avatar
David Teigland committed
1347 1348
	unsigned int num_gh;
	int dir_rename = 0;
1349
	struct gfs2_diradd da = { .nr_blocks = 0, .save_loc = 0, };
David Teigland's avatar
David Teigland committed
1350 1351 1352
	unsigned int x;
	int error;

1353
	gfs2_holder_mark_uninitialized(&r_gh);
1354
	gfs2_holder_mark_uninitialized(&rd_gh);
1355 1356
	if (d_really_is_positive(ndentry)) {
		nip = GFS2_I(d_inode(ndentry));
David Teigland's avatar
David Teigland committed
1357 1358 1359 1360
		if (ip == nip)
			return 0;
	}

1361 1362 1363 1364
	error = gfs2_rindex_update(sdp);
	if (error)
		return error;

1365
	error = gfs2_qa_alloc(ndip);
1366 1367 1368
	if (error)
		return error;

1369 1370 1371
	if (odip != ndip) {
		error = gfs2_glock_nq_init(sdp->sd_rename_gl, LM_ST_EXCLUSIVE,
					   0, &r_gh);
David Teigland's avatar
David Teigland committed
1372 1373 1374
		if (error)
			goto out;

1375 1376
		if (S_ISDIR(ip->i_inode.i_mode)) {
			dir_rename = 1;
1377
			/* don't move a directory into its subdir */
1378 1379 1380 1381
			error = gfs2_ok_to_move(ip, ndip);
			if (error)
				goto out_gunlock_r;
		}
David Teigland's avatar
David Teigland committed
1382 1383
	}

1384
	num_gh = 1;
1385
	gfs2_holder_init(odip->i_gl, LM_ST_EXCLUSIVE, GL_ASYNC, ghs);
1386
	if (odip != ndip) {
1387 1388
		gfs2_holder_init(ndip->i_gl, LM_ST_EXCLUSIVE,GL_ASYNC,
				 ghs + num_gh);
1389 1390
		num_gh++;
	}
1391
	gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, GL_ASYNC, ghs + num_gh);
1392
	num_gh++;
David Teigland's avatar
David Teigland committed
1393

1394
	if (nip) {
1395 1396
		gfs2_holder_init(nip->i_gl, LM_ST_EXCLUSIVE, GL_ASYNC,
				 ghs + num_gh);
1397 1398
		num_gh++;
	}
David Teigland's avatar
David Teigland committed
1399

1400 1401 1402 1403 1404
	for (x = 0; x < num_gh; x++) {
		error = gfs2_glock_nq(ghs + x);
		if (error)
			goto out_gunlock;
	}
1405 1406 1407
	error = gfs2_glock_async_wait(num_gh, ghs);
	if (error)
		goto out_gunlock;
David Teigland's avatar
David Teigland committed
1408

1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424
	if (nip) {
		/* Grab the resource group glock for unlink flag twiddling.
		 * This is the case where the target dinode already exists
		 * so we unlink before doing the rename.
		 */
		nrgd = gfs2_blk2rgrpd(sdp, nip->i_no_addr, 1);
		if (!nrgd) {
			error = -ENOENT;
			goto out_gunlock;
		}
		error = gfs2_glock_nq_init(nrgd->rd_gl, LM_ST_EXCLUSIVE, 0,
					   &rd_gh);
		if (error)
			goto out_gunlock;
	}

1425 1426 1427 1428
	error = -ENOENT;
	if (ip->i_inode.i_nlink == 0)
		goto out_gunlock;

David Teigland's avatar
David Teigland committed
1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441
	/* 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;

1442 1443 1444 1445 1446
		if (nip->i_inode.i_nlink == 0) {
			error = -EAGAIN;
			goto out_gunlock;
		}

1447
		if (S_ISDIR(nip->i_inode.i_mode)) {
1448
			if (nip->i_entries < 2) {
1449
				gfs2_consist_inode(nip);
David Teigland's avatar
David Teigland committed
1450 1451 1452
				error = -EIO;
				goto out_gunlock;
			}
1453
			if (nip->i_entries > 2) {
David Teigland's avatar
David Teigland committed
1454 1455 1456 1457 1458
				error = -ENOTEMPTY;
				goto out_gunlock;
			}
		}
	} else {
1459
		error = gfs2_permission(ndir, MAY_WRITE | MAY_EXEC);
David Teigland's avatar
David Teigland committed
1460 1461 1462
		if (error)
			goto out_gunlock;

1463
		error = gfs2_dir_check(ndir, &ndentry->d_name, NULL);
David Teigland's avatar
David Teigland committed
1464 1465 1466 1467 1468 1469 1470 1471
		switch (error) {
		case -ENOENT:
			error = 0;
			break;
		case 0:
			error = -EEXIST;
		default:
			goto out_gunlock;
1472
		}
David Teigland's avatar
David Teigland committed
1473 1474

		if (odip != ndip) {
1475
			if (!ndip->i_inode.i_nlink) {
1476
				error = -ENOENT;
David Teigland's avatar
David Teigland committed
1477 1478
				goto out_gunlock;
			}
1479
			if (ndip->i_entries == (u32)-1) {
David Teigland's avatar
David Teigland committed
1480 1481 1482
				error = -EFBIG;
				goto out_gunlock;
			}
1483
			if (S_ISDIR(ip->i_inode.i_mode) &&
1484
			    ndip->i_inode.i_nlink == (u32)-1) {
David Teigland's avatar
David Teigland committed
1485 1486 1487 1488 1489 1490 1491 1492 1493
				error = -EMLINK;
				goto out_gunlock;
			}
		}
	}

	/* Check out the dir to be renamed */

	if (dir_rename) {
1494
		error = gfs2_permission(d_inode(odentry), MAY_WRITE);
David Teigland's avatar
David Teigland committed
1495 1496 1497 1498
		if (error)
			goto out_gunlock;
	}

1499 1500 1501 1502 1503
	if (nip == NULL) {
		error = gfs2_diradd_alloc_required(ndir, &ndentry->d_name, &da);
		if (error)
			goto out_gunlock;
	}
David Teigland's avatar
David Teigland committed
1504

1505 1506
	if (da.nr_blocks) {
		struct gfs2_alloc_parms ap = { .target = da.nr_blocks, };
1507
		error = gfs2_quota_lock_check(ndip, &ap);
David Teigland's avatar
David Teigland committed
1508
		if (error)
1509
			goto out_gunlock;
David Teigland's avatar
David Teigland committed
1510

1511
		error = gfs2_inplace_reserve(ndip, &ap);
David Teigland's avatar
David Teigland committed
1512 1513 1514
		if (error)
			goto out_gunlock_q;

1515 1516
		error = gfs2_trans_begin(sdp, gfs2_trans_da_blks(ndip, &da, 4) +
					 4 * RES_LEAF + 4, 0);
David Teigland's avatar
David Teigland committed
1517 1518 1519 1520
		if (error)
			goto out_ipreserv;
	} else {
		error = gfs2_trans_begin(sdp, 4 * RES_DINODE +
1521
					 5 * RES_LEAF + 4, 0);
David Teigland's avatar
David Teigland committed
1522 1523 1524 1525 1526 1527
		if (error)
			goto out_gunlock;
	}

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

1528 1529
	if (nip)
		error = gfs2_unlink_inode(ndip, ndentry);
David Teigland's avatar
David Teigland committed
1530

1531 1532 1533
	error = update_moved_ino(ip, ndip, dir_rename);
	if (error)
		goto out_end_trans;
David Teigland's avatar
David Teigland committed
1534

1535
	error = gfs2_dir_del(odip, odentry);
David Teigland's avatar
David Teigland committed
1536 1537 1538
	if (error)
		goto out_end_trans;

1539
	error = gfs2_dir_add(ndir, &ndentry->d_name, ip, &da);
David Teigland's avatar
David Teigland committed
1540 1541 1542
	if (error)
		goto out_end_trans;

1543
out_end_trans:
David Teigland's avatar
David Teigland committed
1544
	gfs2_trans_end(sdp);
1545
out_ipreserv:
1546
	if (da.nr_blocks)
David Teigland's avatar
David Teigland committed
1547
		gfs2_inplace_release(ndip);
1548
out_gunlock_q:
1549
	if (da.nr_blocks)
David Teigland's avatar
David Teigland committed
1550
		gfs2_quota_unlock(ndip);
1551
out_gunlock:
1552
	gfs2_dir_no_add(&da);
1553 1554 1555
	if (gfs2_holder_initialized(&rd_gh))
		gfs2_glock_dq_uninit(&rd_gh);

1556
	while (x--) {
1557 1558
		if (gfs2_holder_queued(ghs + x))
			gfs2_glock_dq(ghs + x);
David Teigland's avatar
David Teigland committed
1559
		gfs2_holder_uninit(ghs + x);
1560
	}
1561
out_gunlock_r:
1562
	if (gfs2_holder_initialized(&r_gh))
David Teigland's avatar
David Teigland committed
1563
		gfs2_glock_dq_uninit(&r_gh);
1564
out:
David Teigland's avatar
David Teigland committed
1565 1566 1567
	return error;
}

1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587
/**
 * 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);
1588
	struct gfs2_holder ghs[4], r_gh;
1589 1590 1591 1592 1593 1594
	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;

1595
	gfs2_holder_mark_uninitialized(&r_gh);
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
	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;
1622
	gfs2_holder_init(odip->i_gl, LM_ST_EXCLUSIVE, GL_ASYNC, ghs);
1623
	if (odip != ndip) {
1624 1625
		gfs2_holder_init(ndip->i_gl, LM_ST_EXCLUSIVE, GL_ASYNC,
				 ghs + num_gh);
1626 1627
		num_gh++;
	}
1628
	gfs2_holder_init(oip->i_gl, LM_ST_EXCLUSIVE, GL_ASYNC, ghs + num_gh);
1629 1630
	num_gh++;

1631
	gfs2_holder_init(nip->i_gl, LM_ST_EXCLUSIVE, GL_ASYNC, ghs + num_gh);
1632 1633 1634 1635 1636 1637 1638 1639
	num_gh++;

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

1640 1641 1642 1643
	error = gfs2_glock_async_wait(num_gh, ghs);
	if (error)
		goto out_gunlock;

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
	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--) {
1704 1705
		if (gfs2_holder_queued(ghs + x))
			gfs2_glock_dq(ghs + x);
1706 1707 1708
		gfs2_holder_uninit(ghs + x);
	}
out_gunlock_r:
1709
	if (gfs2_holder_initialized(&r_gh))
1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729
		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);
}

1730
/**
1731
 * gfs2_get_link - Follow a symbolic link
Al Viro's avatar
Al Viro committed
1732
 * @dentry: The dentry of the link
1733
 * @inode: The inode of the link
1734
 * @done: destructor for return value
1735
 *
Al Viro's avatar
Al Viro committed
1736
 * This can handle symlinks of any size.
1737
 *
Al Viro's avatar
Al Viro committed
1738
 * Returns: 0 on success or error code
1739 1740
 */

1741
static const char *gfs2_get_link(struct dentry *dentry,
1742 1743
				 struct inode *inode,
				 struct delayed_call *done)
1744
{
1745
	struct gfs2_inode *ip = GFS2_I(inode);
1746 1747
	struct gfs2_holder i_gh;
	struct buffer_head *dibh;
1748
	unsigned int size;
Al Viro's avatar
Al Viro committed
1749
	char *buf;
1750 1751
	int error;

1752 1753 1754
	if (!dentry)
		return ERR_PTR(-ECHILD);

1755 1756 1757 1758
	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);
1759
		return ERR_PTR(error);
1760 1761
	}

Steven Whitehouse's avatar
Steven Whitehouse committed
1762 1763
	size = (unsigned int)i_size_read(&ip->i_inode);
	if (size == 0) {
1764
		gfs2_consist_inode(ip);
Al Viro's avatar
Al Viro committed
1765
		buf = ERR_PTR(-EIO);
1766 1767 1768 1769
		goto out;
	}

	error = gfs2_meta_inode_buffer(ip, &dibh);
Al Viro's avatar
Al Viro committed
1770 1771
	if (error) {
		buf = ERR_PTR(error);
1772 1773 1774
		goto out;
	}

1775
	buf = kzalloc(size + 1, GFP_NOFS);
Al Viro's avatar
Al Viro committed
1776 1777 1778
	if (!buf)
		buf = ERR_PTR(-ENOMEM);
	else
1779
		memcpy(buf, dibh->b_data + sizeof(struct gfs2_dinode), size);
1780 1781 1782
	brelse(dibh);
out:
	gfs2_glock_dq_uninit(&i_gh);
1783
	if (!IS_ERR(buf))
1784
		set_delayed_call(done, kfree_link, buf);
1785
	return buf;
David Teigland's avatar
David Teigland committed
1786 1787 1788 1789
}

/**
 * gfs2_permission -
1790 1791 1792
 * @inode: The inode
 * @mask: The mask to be tested
 * @flags: Indicates whether this is an RCU path walk or not
David Teigland's avatar
David Teigland committed
1793
 *
1794 1795 1796 1797
 * 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.
 *
David Teigland's avatar
David Teigland committed
1798 1799 1800
 * Returns: errno
 */

1801
int gfs2_permission(struct inode *inode, int mask)
David Teigland's avatar
David Teigland committed
1802
{
1803
	struct gfs2_inode *ip;
David Teigland's avatar
David Teigland committed
1804 1805
	struct gfs2_holder i_gh;
	int error;
1806

1807
	gfs2_holder_mark_uninitialized(&i_gh);
1808
	ip = GFS2_I(inode);
1809
	if (gfs2_glock_is_locked_by_me(ip->i_gl) == NULL) {
1810 1811 1812 1813 1814
		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;
1815
	}
David Teigland's avatar
David Teigland committed
1816

1817
	if ((mask & MAY_WRITE) && IS_IMMUTABLE(inode))
1818
		error = -EPERM;
1819
	else
1820
		error = generic_permission(inode, mask);
1821
	if (gfs2_holder_initialized(&i_gh))
David Teigland's avatar
David Teigland committed
1822 1823 1824 1825 1826
		gfs2_glock_dq_uninit(&i_gh);

	return error;
}

1827
static int __gfs2_setattr_simple(struct inode *inode, struct iattr *attr)
1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841
{
	setattr_copy(inode, attr);
	mark_inode_dirty(inode);
	return 0;
}

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

1842
int gfs2_setattr_simple(struct inode *inode, struct iattr *attr)
1843 1844 1845 1846
{
	int error;

	if (current->journal_info)
1847
		return __gfs2_setattr_simple(inode, attr);
1848

1849
	error = gfs2_trans_begin(GFS2_SB(inode), RES_DINODE, 0);
1850 1851 1852
	if (error)
		return error;

1853 1854
	error = __gfs2_setattr_simple(inode, attr);
	gfs2_trans_end(GFS2_SB(inode));
1855 1856 1857
	return error;
}

David Teigland's avatar
David Teigland committed
1858 1859
static int setattr_chown(struct inode *inode, struct iattr *attr)
{
1860 1861
	struct gfs2_inode *ip = GFS2_I(inode);
	struct gfs2_sbd *sdp = GFS2_SB(inode);
1862 1863
	kuid_t ouid, nuid;
	kgid_t ogid, ngid;
David Teigland's avatar
David Teigland committed
1864
	int error;
1865
	struct gfs2_alloc_parms ap;
David Teigland's avatar
David Teigland committed
1866

1867 1868
	ouid = inode->i_uid;
	ogid = inode->i_gid;
David Teigland's avatar
David Teigland committed
1869 1870 1871
	nuid = attr->ia_uid;
	ngid = attr->ia_gid;

1872
	if (!(attr->ia_valid & ATTR_UID) || uid_eq(ouid, nuid))
1873
		ouid = nuid = NO_UID_QUOTA_CHANGE;
1874
	if (!(attr->ia_valid & ATTR_GID) || gid_eq(ogid, ngid))
1875
		ogid = ngid = NO_GID_QUOTA_CHANGE;
David Teigland's avatar
David Teigland committed
1876

1877
	error = gfs2_qa_alloc(ip);
1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888
	if (error)
		goto out;

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

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

1889 1890
	ap.target = gfs2_get_inode_blocks(&ip->i_inode);

1891 1892
	if (!uid_eq(ouid, NO_UID_QUOTA_CHANGE) ||
	    !gid_eq(ogid, NO_GID_QUOTA_CHANGE)) {
1893
		error = gfs2_quota_check(ip, nuid, ngid, &ap);
David Teigland's avatar
David Teigland committed
1894 1895 1896 1897 1898 1899 1900 1901
		if (error)
			goto out_gunlock_q;
	}

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

1902
	error = gfs2_setattr_simple(inode, attr);
David Teigland's avatar
David Teigland committed
1903 1904 1905
	if (error)
		goto out_end_trans;

1906 1907
	if (!uid_eq(ouid, NO_UID_QUOTA_CHANGE) ||
	    !gid_eq(ogid, NO_GID_QUOTA_CHANGE)) {
1908
		gfs2_quota_change(ip, -(s64)ap.target, ouid, ogid);
1909
		gfs2_quota_change(ip, ap.target, nuid, ngid);
David Teigland's avatar
David Teigland committed
1910 1911
	}

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

1938
	error = gfs2_qa_alloc(ip);
1939 1940 1941
	if (error)
		return error;

David Teigland's avatar
David Teigland committed
1942 1943 1944 1945 1946 1947 1948 1949
	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;

1950
	error = setattr_prepare(dentry, attr);
David Teigland's avatar
David Teigland committed
1951 1952 1953 1954
	if (error)
		goto out;

	if (attr->ia_valid & ATTR_SIZE)
1955
		error = gfs2_setattr_size(inode, attr->ia_size);
David Teigland's avatar
David Teigland committed
1956 1957
	else if (attr->ia_valid & (ATTR_UID | ATTR_GID))
		error = setattr_chown(inode, attr);
1958
	else {
1959
		error = gfs2_setattr_simple(inode, attr);
1960 1961 1962
		if (!error && attr->ia_valid & ATTR_MODE)
			error = posix_acl_chmod(inode, inode->i_mode);
	}
David Teigland's avatar
David Teigland committed
1963

1964
out:
David Teigland's avatar
David Teigland committed
1965 1966
	if (!error)
		mark_inode_dirty(inode);
1967
	gfs2_glock_dq_uninit(&i_gh);
David Teigland's avatar
David Teigland committed
1968 1969 1970 1971 1972
	return error;
}

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

1987 1988
static int gfs2_getattr(const struct path *path, struct kstat *stat,
			u32 request_mask, unsigned int flags)
David Teigland's avatar
David Teigland committed
1989
{
1990
	struct inode *inode = d_inode(path->dentry);
1991
	struct gfs2_inode *ip = GFS2_I(inode);
David Teigland's avatar
David Teigland committed
1992
	struct gfs2_holder gh;
1993
	u32 gfsflags;
David Teigland's avatar
David Teigland committed
1994 1995
	int error;

1996
	gfs2_holder_mark_uninitialized(&gh);
1997
	if (gfs2_glock_is_locked_by_me(ip->i_gl) == NULL) {
1998 1999 2000
		error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, &gh);
		if (error)
			return error;
David Teigland's avatar
David Teigland committed
2001 2002
	}

2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014
	gfsflags = ip->i_diskflags;
	if (gfsflags & GFS2_DIF_APPENDONLY)
		stat->attributes |= STATX_ATTR_APPEND;
	if (gfsflags & GFS2_DIF_IMMUTABLE)
		stat->attributes |= STATX_ATTR_IMMUTABLE;

	stat->attributes_mask |= (STATX_ATTR_APPEND |
				  STATX_ATTR_COMPRESSED |
				  STATX_ATTR_ENCRYPTED |
				  STATX_ATTR_IMMUTABLE |
				  STATX_ATTR_NODUMP);

2015
	generic_fillattr(inode, stat);
2016

2017
	if (gfs2_holder_initialized(&gh))
2018 2019 2020
		gfs2_glock_dq_uninit(&gh);

	return 0;
David Teigland's avatar
David Teigland committed
2021 2022
}

2023 2024 2025 2026 2027 2028 2029
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;

2030
	inode_lock_shared(inode);
2031 2032 2033 2034 2035

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

2036
	ret = iomap_fiemap(inode, fieinfo, start, len, &gfs2_iomap_ops);
2037 2038

	gfs2_glock_dq_uninit(&gh);
2039

2040
out:
2041
	inode_unlock_shared(inode);
2042 2043 2044
	return ret;
}

2045 2046 2047 2048 2049 2050 2051 2052 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
loff_t gfs2_seek_data(struct file *file, loff_t offset)
{
	struct inode *inode = file->f_mapping->host;
	struct gfs2_inode *ip = GFS2_I(inode);
	struct gfs2_holder gh;
	loff_t ret;

	inode_lock_shared(inode);
	ret = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, 0, &gh);
	if (!ret)
		ret = iomap_seek_data(inode, offset, &gfs2_iomap_ops);
	gfs2_glock_dq_uninit(&gh);
	inode_unlock_shared(inode);

	if (ret < 0)
		return ret;
	return vfs_setpos(file, ret, inode->i_sb->s_maxbytes);
}

loff_t gfs2_seek_hole(struct file *file, loff_t offset)
{
	struct inode *inode = file->f_mapping->host;
	struct gfs2_inode *ip = GFS2_I(inode);
	struct gfs2_holder gh;
	loff_t ret;

	inode_lock_shared(inode);
	ret = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, 0, &gh);
	if (!ret)
		ret = iomap_seek_hole(inode, offset, &gfs2_iomap_ops);
	gfs2_glock_dq_uninit(&gh);
	inode_unlock_shared(inode);

	if (ret < 0)
		return ret;
	return vfs_setpos(file, ret, inode->i_sb->s_maxbytes);
}

2083
const struct inode_operations gfs2_file_iops = {
2084
	.permission = gfs2_permission,
David Teigland's avatar
David Teigland committed
2085 2086 2087
	.setattr = gfs2_setattr,
	.getattr = gfs2_getattr,
	.listxattr = gfs2_listxattr,
2088
	.fiemap = gfs2_fiemap,
2089
	.get_acl = gfs2_get_acl,
2090
	.set_acl = gfs2_set_acl,
David Teigland's avatar
David Teigland committed
2091 2092
};

2093
const struct inode_operations gfs2_dir_iops = {
David Teigland's avatar
David Teigland committed
2094 2095 2096 2097 2098 2099
	.create = gfs2_create,
	.lookup = gfs2_lookup,
	.link = gfs2_link,
	.unlink = gfs2_unlink,
	.symlink = gfs2_symlink,
	.mkdir = gfs2_mkdir,
2100
	.rmdir = gfs2_unlink,
David Teigland's avatar
David Teigland committed
2101
	.mknod = gfs2_mknod,
2102
	.rename = gfs2_rename2,
2103
	.permission = gfs2_permission,
David Teigland's avatar
David Teigland committed
2104 2105 2106
	.setattr = gfs2_setattr,
	.getattr = gfs2_getattr,
	.listxattr = gfs2_listxattr,
2107
	.fiemap = gfs2_fiemap,
2108
	.get_acl = gfs2_get_acl,
2109
	.set_acl = gfs2_set_acl,
2110
	.atomic_open = gfs2_atomic_open,
David Teigland's avatar
David Teigland committed
2111 2112
};

2113
const struct inode_operations gfs2_symlink_iops = {
2114
	.get_link = gfs2_get_link,
2115
	.permission = gfs2_permission,
David Teigland's avatar
David Teigland committed
2116 2117 2118
	.setattr = gfs2_setattr,
	.getattr = gfs2_getattr,
	.listxattr = gfs2_listxattr,
2119
	.fiemap = gfs2_fiemap,
David Teigland's avatar
David Teigland committed
2120 2121
};