inode.c 48.4 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 112 113 114 115 116 117 118
 * @no_addr: The inode number
 * @no_formal_ino: The inode generation number
 * @blktype: Requested block type (GFS2_BLKST_DINODE or GFS2_BLKST_UNLINKED;
 *           GFS2_BLKST_FREE do indicate not to verify)
 *
 * 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 194

		inode->i_atime.tv_sec = 0;
		inode->i_atime.tv_nsec = 0;

195 196 197
		unlock_new_inode(inode);
	}

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

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

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

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

fail_iput:
	iput(inode);
242
	return ERR_PTR(error);
243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287
}


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 已提交
288
	gfs2_holder_mark_uninitialized(&d_gh);
289 290 291 292 293
	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 &&
294
	     dir == d_inode(sb->s_root))) {
295 296 297 298 299 300 301 302 303 304 305
		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) {
306
		error = gfs2_permission(dir, MAY_EXEC);
307 308 309 310
		if (error)
			goto out;
	}

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

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

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

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

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

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

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

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

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

	gfs2_trans_end(sdp);

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

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

424 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
/**
 * 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);
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

690
	gfs2_set_inode_flags(inode);
691

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

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

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

703 704
	gfs2_set_inode_blocks(inode, blocks);

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

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

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

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

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

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

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

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

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

754
	if (error)
755
		goto fail_gunlock3;
756

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	return gfs2_create_inode(dir, dentry, file, S_IFREG | mode, 0, NULL, 0, excl, opened);
D
David Teigland 已提交
1268 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
/*
 * 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;
		}
1295
		if (dir == d_inode(sb->s_root)) {
1296 1297 1298 1299
			error = 0;
			break;
		}

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

		iput(dir);
		dir = tmp;
	}

	iput(dir);

	return error;
}

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	/* Check out the dir to be renamed */

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

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

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

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

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

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

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

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

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

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

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

1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589
/**
 * 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 已提交
1590
	struct gfs2_holder ghs[5], r_gh;
1591 1592 1593 1594 1595 1596
	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 已提交
1597
	gfs2_holder_mark_uninitialized(&r_gh);
1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704
	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 已提交
1705
	if (gfs2_holder_initialized(&r_gh))
1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725
		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);
}

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

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

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

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

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

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

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

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

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

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

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

	return error;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015
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 已提交
2016
	inode_lock(inode);
2017 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

	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 已提交
2043
	inode_unlock(inode);
2044 2045 2046
	return ret;
}

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

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

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