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

#include <linux/slab.h>
#include <linux/spinlock.h>
#include <linux/completion.h>
#include <linux/buffer_head.h>
#include <linux/namei.h>
#include <linux/mm.h>
#include <linux/xattr.h>
#include <linux/posix_acl.h>
18
#include <linux/gfs2_ondisk.h>
19
#include <linux/crc32.h>
20
#include <linux/fiemap.h>
21
#include <linux/security.h>
D
David Teigland 已提交
22 23 24
#include <asm/uaccess.h>

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

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

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

repeat:
61
	inode = iget5_locked(sb, no_addr, iget_test, iget_set, &no_addr);
62 63 64 65 66 67 68
	if (!inode)
		return inode;
	if (is_bad_inode(inode)) {
		iput(inode);
		goto repeat;
	}
	return inode;
69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107
}

/**
 * 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
108 109 110 111 112 113 114 115 116 117
 * @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.
118 119 120 121 122
 *
 * Returns: A VFS inode, or an error
 */

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

133
	inode = gfs2_iget(sb, no_addr);
134
	if (!inode)
135
		return ERR_PTR(-ENOMEM);
136

137 138
	ip = GFS2_I(inode);

139 140 141 142 143 144 145 146 147 148 149 150 151
	if (inode->i_state & I_NEW) {
		struct gfs2_sbd *sdp = GFS2_SB(inode);
		ip->i_no_formal_ino = no_formal_ino;

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

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

152 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;
			unlock = true;

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

172 173 174
		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))
175
			goto fail_put;
176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193

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

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

		gfs2_set_iop(inode);
		unlock_new_inode(inode);
	}

194 195
	if (unlock)
		gfs2_glock_dq_uninit(&i_gh);
196 197 198
	return inode;

fail_refresh:
B
Bob Peterson 已提交
199
	ip->i_iopen_gh.gh_flags |= GL_NOCACHE;
200
	ip->i_iopen_gh.gh_gl->gl_object = NULL;
B
Bob Peterson 已提交
201 202
	gfs2_glock_dq_wait(&ip->i_iopen_gh);
	gfs2_holder_uninit(&ip->i_iopen_gh);
203
fail_put:
204 205
	if (io_gl)
		gfs2_glock_put(io_gl);
206 207
	if (unlock)
		gfs2_glock_dq_uninit(&i_gh);
208 209 210 211 212 213 214 215 216 217
	ip->i_gl->gl_object = NULL;
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;
218
	struct inode *inode;
219 220
	int error;

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

	/* 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;
	}
235
	return inode;
236 237 238

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


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


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

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

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

	if ((name->len == 1 && memcmp(name->name, ".", 1) == 0) ||
	    (name->len == 2 && memcmp(name->name, "..", 2) == 0 &&
291
	     dir == d_inode(sb->s_root))) {
292 293 294 295 296 297 298 299 300 301 302 303
		igrab(dir);
		return dir;
	}

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

	if (!is_root) {
304
		error = gfs2_permission(dir, MAY_EXEC);
305 306 307 308
		if (error)
			goto out;
	}

309
	inode = gfs2_dir_search(dir, name, false);
310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329
	if (IS_ERR(inode))
		error = PTR_ERR(inode);
out:
	if (unlock)
		gfs2_glock_dq_uninit(&d_gh);
	if (error == -ENOENT)
		return NULL;
	return inode ? inode : ERR_PTR(error);
}

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

static int create_ok(struct gfs2_inode *dip, const struct qstr *name,
A
Al Viro 已提交
330
		     umode_t mode)
331 332 333
{
	int error;

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

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

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

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

378
	error = gfs2_quota_lock_check(ip, &ap);
379 380 381
	if (error)
		goto out;

382
	error = gfs2_inplace_reserve(ip, &ap);
383 384 385
	if (error)
		goto out_quota;

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

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

	gfs2_trans_end(sdp);

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

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

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

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

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

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

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

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

487
	set_buffer_uptodate(dibh);
488
	brelse(dibh);
489 490
}

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

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

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

525
		error = gfs2_inplace_reserve(dip, &ap);
526 527 528
		if (error)
			goto fail_quota_locks;

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

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

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

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

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

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

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

597
	error = gfs2_rsqa_alloc(dip);
598 599 600
	if (error)
		return error;

601 602 603 604
	error = gfs2_rindex_update(sdp);
	if (error)
		return error;

605
	error = gfs2_glock_nq_init(dip->i_gl, LM_ST_EXCLUSIVE, 0, ghs);
606 607 608 609
	if (error)
		goto fail;

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

635
	error = gfs2_diradd_alloc_required(dir, name, &da);
636 637 638
	if (error < 0)
		goto fail_gunlock;

639
	inode = new_inode(sdp->sd_vfs);
640 641 642 643
	error = -ENOMEM;
	if (!inode)
		goto fail_gunlock;

644 645
	error = posix_acl_create(dir, &mode, &default_acl, &acl);
	if (error)
646
		goto fail_gunlock;
647

648
	ip = GFS2_I(inode);
649
	error = gfs2_rsqa_alloc(ip);
650
	if (error)
651
		goto fail_free_acls;
652 653

	inode->i_mode = mode;
654
	set_nlink(inode, S_ISDIR(mode) ? 2 : 1);
655 656
	inode->i_rdev = dev;
	inode->i_size = size;
657
	inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
658
	gfs2_set_inode_blocks(inode, 1);
659
	munge_mode_uid_gid(dip, inode);
660
	check_and_update_goal(dip);
661
	ip->i_goal = dip->i_goal;
662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680
	ip->i_diskflags = 0;
	ip->i_eattr = 0;
	ip->i_height = 0;
	ip->i_depth = 0;
	ip->i_entries = 0;

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

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

686
	gfs2_set_inode_flags(inode);
687

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

692 693 694 695
	if (default_acl || acl)
		blocks++;

	error = alloc_dinode(ip, aflags, &blocks);
696
	if (error)
697
		goto fail_free_inode;
698

699 700
	gfs2_set_inode_blocks(inode, blocks);

701
	error = gfs2_glock_get(sdp, ip->i_no_addr, &gfs2_inode_glops, CREATE, &ip->i_gl);
702
	if (error)
703
		goto fail_free_inode;
704

705
	ip->i_gl->gl_object = ip;
706 707 708 709
	error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, GL_SKIP, ghs + 1);
	if (error)
		goto fail_free_inode;

710
	error = gfs2_trans_begin(sdp, blocks, 0);
711
	if (error)
712 713
		goto fail_gunlock2;

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

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

725 726
	BUG_ON(test_and_set_bit(GLF_INODE_CREATING, &io_gl->gl_flags));

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

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

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

749
	if (error)
750
		goto fail_gunlock3;
751

752 753
	error = security_inode_init_security(&ip->i_inode, &dip->i_inode, name,
					     &gfs2_initxattrs, NULL);
754
	if (error)
755
		goto fail_gunlock3;
756

757
	error = link_dinode(dip, name, ip, &da);
758
	if (error)
759
		goto fail_gunlock3;
760

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

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

D
David Teigland 已提交
803 804 805 806 807 808 809 810 811 812
/**
 * 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 已提交
813
		       umode_t mode, bool excl)
D
David Teigland 已提交
814
{
815
	return gfs2_create_inode(dir, dentry, NULL, S_IFREG | mode, 0, NULL, 0, excl, NULL);
D
David Teigland 已提交
816 817 818
}

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

829 830
static struct dentry *__gfs2_lookup(struct inode *dir, struct dentry *dentry,
				    struct file *file, int *opened)
D
David Teigland 已提交
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 859 860 861
	if (file && S_ISREG(inode->i_mode))
		error = finish_open(file, dentry, gfs2_open_common, opened);

	gfs2_glock_dq_uninit(&gh);
M
Miklos Szeredi 已提交
862 863
	if (error) {
		dput(d);
864
		return ERR_PTR(error);
M
Miklos Szeredi 已提交
865
	}
866 867 868 869 870 871 872
	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 已提交
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);
D
David Teigland 已提交
894
	struct gfs2_holder ghs[2];
895
	struct buffer_head *dibh;
896
	struct gfs2_diradd da = { .bh = NULL, .save_loc = 1, };
D
David Teigland 已提交
897 898
	int error;

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

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

D
David Teigland 已提交
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 */
D
David Teigland 已提交
914
	if (error)
915
		goto out_child;
D
David Teigland 已提交
916

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

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

925
	error = gfs2_dir_check(dir, &dentry->d_name, NULL);
D
David Teigland 已提交
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)
D
David Teigland 已提交
937 938
		goto out_gunlock;
	error = -EFBIG;
939
	if (dip->i_entries == (u32)-1)
D
David Teigland 已提交
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)
D
David Teigland 已提交
946 947
		goto out_gunlock;
	error = -EMLINK;
948
	if (ip->i_inode.i_nlink == (u32)-1)
D
David Teigland 已提交
949 950
		goto out_gunlock;

951
	error = gfs2_diradd_alloc_required(dir, &dentry->d_name, &da);
952
	if (error < 0)
D
David Teigland 已提交
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);
D
David Teigland 已提交
958
		if (error)
959
			goto out_gunlock;
D
David Teigland 已提交
960

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

965
		error = gfs2_trans_begin(sdp, gfs2_trans_da_blks(dip, &da, 2), 0);
D
David Teigland 已提交
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);
D
David Teigland 已提交
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 984
	inc_nlink(&ip->i_inode);
	ip->i_inode.i_ctime = CURRENT_TIME;
S
Steven Whitehouse 已提交
985 986 987
	ihold(inode);
	d_instantiate(dentry, inode);
	mark_inode_dirty(inode);
D
David Teigland 已提交
988

989 990
out_brelse:
	brelse(dibh);
991
out_end_trans:
D
David Teigland 已提交
992
	gfs2_trans_end(sdp);
993
out_ipres:
994
	if (da.nr_blocks)
D
David Teigland 已提交
995
		gfs2_inplace_release(dip);
996
out_gunlock_q:
997
	if (da.nr_blocks)
D
David Teigland 已提交
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:
D
David Teigland 已提交
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
}

D
David Teigland 已提交
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 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082
	struct gfs2_inode *ip = GFS2_I(inode);
	int error;

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

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


/**
 * gfs2_unlink - Unlink an inode (this does rmdir as well)
 * @dir: The inode of the directory containing the inode to unlink
D
David Teigland 已提交
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.
D
David Teigland 已提交
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);
R
Russell Cattelan 已提交
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;
D
David Teigland 已提交
1106 1107

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

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

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


1117
	error = gfs2_glock_nq(ghs); /* parent */
D
David Teigland 已提交
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;
D
David Teigland 已提交
1138 1139 1140

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

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

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

1149 1150
out_end_trans:
	gfs2_trans_end(sdp);
1151
out_gunlock:
1152 1153 1154 1155 1156 1157
	gfs2_glock_dq(ghs + 2);
out_rgrp:
	gfs2_glock_dq(ghs + 1);
out_child:
	gfs2_glock_dq(ghs);
out_parent:
1158 1159 1160
	gfs2_holder_uninit(ghs + 2);
out_inodes:
	gfs2_holder_uninit(ghs + 1);
1161
	gfs2_holder_uninit(ghs);
D
David Teigland 已提交
1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176
	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)
{
1177
	struct gfs2_sbd *sdp = GFS2_SB(dir);
1178
	unsigned int size;
D
David Teigland 已提交
1179 1180 1181 1182 1183

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

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

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

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

/**
 * 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
1208
 * @dev: The device specification of the special file
D
David Teigland 已提交
1209 1210 1211
 *
 */

A
Al Viro 已提交
1212
static int gfs2_mknod(struct inode *dir, struct dentry *dentry, umode_t mode,
D
David Teigland 已提交
1213 1214
		      dev_t dev)
{
1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230
	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,
1231 1232
			    struct file *file, unsigned flags,
			    umode_t mode, int *opened)
1233 1234 1235 1236
{
	struct dentry *d;
	bool excl = !!(flags & O_EXCL);

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

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

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

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

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

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

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

		iput(dir);
		dir = tmp;
	}

	iput(dir);

	return error;
}

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

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

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

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


D
David Teigland 已提交
1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351
/**
 * 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)
{
1352 1353
	struct gfs2_inode *odip = GFS2_I(odir);
	struct gfs2_inode *ndip = GFS2_I(ndir);
1354
	struct gfs2_inode *ip = GFS2_I(d_inode(odentry));
D
David Teigland 已提交
1355
	struct gfs2_inode *nip = NULL;
1356
	struct gfs2_sbd *sdp = GFS2_SB(odir);
1357
	struct gfs2_holder ghs[5], r_gh = { .gh_gl = NULL, };
R
Russell Cattelan 已提交
1358
	struct gfs2_rgrpd *nrgd;
D
David Teigland 已提交
1359 1360
	unsigned int num_gh;
	int dir_rename = 0;
1361
	struct gfs2_diradd da = { .nr_blocks = 0, .save_loc = 0, };
D
David Teigland 已提交
1362 1363 1364
	unsigned int x;
	int error;

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

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

1375
	error = gfs2_rsqa_alloc(ndip);
1376 1377 1378
	if (error)
		return error;

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

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

1394
	num_gh = 1;
D
David Teigland 已提交
1395
	gfs2_holder_init(odip->i_gl, LM_ST_EXCLUSIVE, 0, ghs);
1396 1397 1398 1399 1400 1401
	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 已提交
1402

1403 1404 1405
	if (nip) {
		gfs2_holder_init(nip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + num_gh);
		num_gh++;
R
Russell Cattelan 已提交
1406 1407 1408 1409
		/* 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 已提交
1410
		nrgd = gfs2_blk2rgrpd(sdp, nip->i_no_addr, 1);
R
Russell Cattelan 已提交
1411 1412
		if (nrgd)
			gfs2_holder_init(nrgd->rd_gl, LM_ST_EXCLUSIVE, 0, ghs + num_gh++);
1413
	}
D
David Teigland 已提交
1414

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

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

D
David Teigland 已提交
1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437
	/* 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;

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

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

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

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

	/* Check out the dir to be renamed */

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	if (flags & ~RENAME_EXCHANGE)
		return -EINVAL;

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

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

1715
/**
1716
 * gfs2_get_link - Follow a symbolic link
A
Al Viro 已提交
1717
 * @dentry: The dentry of the link
1718
 * @inode: The inode of the link
1719
 * @done: destructor for return value
1720
 *
A
Al Viro 已提交
1721
 * This can handle symlinks of any size.
1722
 *
A
Al Viro 已提交
1723
 * Returns: 0 on success or error code
1724 1725
 */

1726
static const char *gfs2_get_link(struct dentry *dentry,
1727 1728
				 struct inode *inode,
				 struct delayed_call *done)
1729
{
1730
	struct gfs2_inode *ip = GFS2_I(inode);
1731 1732
	struct gfs2_holder i_gh;
	struct buffer_head *dibh;
1733
	unsigned int size;
A
Al Viro 已提交
1734
	char *buf;
1735 1736
	int error;

1737 1738 1739
	if (!dentry)
		return ERR_PTR(-ECHILD);

1740 1741 1742 1743
	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);
1744
		return ERR_PTR(error);
1745 1746
	}

S
Steven Whitehouse 已提交
1747 1748
	size = (unsigned int)i_size_read(&ip->i_inode);
	if (size == 0) {
1749
		gfs2_consist_inode(ip);
A
Al Viro 已提交
1750
		buf = ERR_PTR(-EIO);
1751 1752 1753 1754
		goto out;
	}

	error = gfs2_meta_inode_buffer(ip, &dibh);
A
Al Viro 已提交
1755 1756
	if (error) {
		buf = ERR_PTR(error);
1757 1758 1759
		goto out;
	}

1760
	buf = kzalloc(size + 1, GFP_NOFS);
A
Al Viro 已提交
1761 1762 1763
	if (!buf)
		buf = ERR_PTR(-ENOMEM);
	else
1764
		memcpy(buf, dibh->b_data + sizeof(struct gfs2_dinode), size);
1765 1766 1767
	brelse(dibh);
out:
	gfs2_glock_dq_uninit(&i_gh);
1768
	if (!IS_ERR(buf))
1769
		set_delayed_call(done, kfree_link, buf);
1770
	return buf;
D
David Teigland 已提交
1771 1772 1773 1774
}

/**
 * gfs2_permission -
1775 1776 1777
 * @inode: The inode
 * @mask: The mask to be tested
 * @flags: Indicates whether this is an RCU path walk or not
D
David Teigland 已提交
1778
 *
1779 1780 1781 1782
 * 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 已提交
1783 1784 1785
 * Returns: errno
 */

1786
int gfs2_permission(struct inode *inode, int mask)
D
David Teigland 已提交
1787
{
1788
	struct gfs2_inode *ip;
D
David Teigland 已提交
1789 1790
	struct gfs2_holder i_gh;
	int error;
1791
	int unlock = 0;
D
David Teigland 已提交
1792

1793 1794

	ip = GFS2_I(inode);
1795
	if (gfs2_glock_is_locked_by_me(ip->i_gl) == NULL) {
1796 1797 1798 1799 1800 1801
		if (mask & MAY_NOT_BLOCK)
			return -ECHILD;
		error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, &i_gh);
		if (error)
			return error;
		unlock = 1;
1802
	}
D
David Teigland 已提交
1803

M
Miklos Szeredi 已提交
1804 1805 1806
	if ((mask & MAY_WRITE) && IS_IMMUTABLE(inode))
		error = -EACCES;
	else
1807
		error = generic_permission(inode, mask);
1808
	if (unlock)
D
David Teigland 已提交
1809 1810 1811 1812 1813
		gfs2_glock_dq_uninit(&i_gh);

	return error;
}

S
Steven Whitehouse 已提交
1814
static int __gfs2_setattr_simple(struct inode *inode, struct iattr *attr)
1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828
{
	setattr_copy(inode, attr);
	mark_inode_dirty(inode);
	return 0;
}

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

S
Steven Whitehouse 已提交
1829
int gfs2_setattr_simple(struct inode *inode, struct iattr *attr)
1830 1831 1832 1833
{
	int error;

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

S
Steven Whitehouse 已提交
1836
	error = gfs2_trans_begin(GFS2_SB(inode), RES_DINODE, 0);
1837 1838 1839
	if (error)
		return error;

S
Steven Whitehouse 已提交
1840 1841
	error = __gfs2_setattr_simple(inode, attr);
	gfs2_trans_end(GFS2_SB(inode));
1842 1843 1844
	return error;
}

D
David Teigland 已提交
1845 1846
static int setattr_chown(struct inode *inode, struct iattr *attr)
{
1847 1848
	struct gfs2_inode *ip = GFS2_I(inode);
	struct gfs2_sbd *sdp = GFS2_SB(inode);
1849 1850
	kuid_t ouid, nuid;
	kgid_t ogid, ngid;
D
David Teigland 已提交
1851
	int error;
1852
	struct gfs2_alloc_parms ap;
D
David Teigland 已提交
1853

1854 1855
	ouid = inode->i_uid;
	ogid = inode->i_gid;
D
David Teigland 已提交
1856 1857 1858
	nuid = attr->ia_uid;
	ngid = attr->ia_gid;

1859
	if (!(attr->ia_valid & ATTR_UID) || uid_eq(ouid, nuid))
1860
		ouid = nuid = NO_UID_QUOTA_CHANGE;
1861
	if (!(attr->ia_valid & ATTR_GID) || gid_eq(ogid, ngid))
1862
		ogid = ngid = NO_GID_QUOTA_CHANGE;
D
David Teigland 已提交
1863

1864
	error = gfs2_rsqa_alloc(ip);
1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875
	if (error)
		goto out;

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

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

1876 1877
	ap.target = gfs2_get_inode_blocks(&ip->i_inode);

1878 1879
	if (!uid_eq(ouid, NO_UID_QUOTA_CHANGE) ||
	    !gid_eq(ogid, NO_GID_QUOTA_CHANGE)) {
1880
		error = gfs2_quota_check(ip, nuid, ngid, &ap);
D
David Teigland 已提交
1881 1882 1883 1884 1885 1886 1887 1888
		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 已提交
1889
	error = gfs2_setattr_simple(inode, attr);
D
David Teigland 已提交
1890 1891 1892
	if (error)
		goto out_end_trans;

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

1899
out_end_trans:
D
David Teigland 已提交
1900
	gfs2_trans_end(sdp);
1901
out_gunlock_q:
D
David Teigland 已提交
1902
	gfs2_quota_unlock(ip);
1903
out:
D
David Teigland 已提交
1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919
	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)
{
1920
	struct inode *inode = d_inode(dentry);
1921
	struct gfs2_inode *ip = GFS2_I(inode);
D
David Teigland 已提交
1922 1923 1924
	struct gfs2_holder i_gh;
	int error;

1925
	error = gfs2_rsqa_alloc(ip);
1926 1927 1928
	if (error)
		return error;

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

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

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

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

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

/**
 * gfs2_getattr - Read out an inode's attributes
1960
 * @mnt: The vfsmount the inode is being accessed from
D
David Teigland 已提交
1961 1962 1963
 * @dentry: The dentry to stat
 * @stat: The inode's stats
 *
1964 1965 1966 1967 1968 1969
 * 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 已提交
1970 1971 1972 1973 1974 1975
 * Returns: errno
 */

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

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

1989
	generic_fillattr(inode, stat);
1990
	if (unlock)
1991 1992 1993
		gfs2_glock_dq_uninit(&gh);

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

1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006
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 已提交
2007
	inode_lock(inode);
2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033

	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 已提交
2034
	inode_unlock(inode);
2035 2036 2037
	return ret;
}

2038
const struct inode_operations gfs2_file_iops = {
2039
	.permission = gfs2_permission,
D
David Teigland 已提交
2040 2041
	.setattr = gfs2_setattr,
	.getattr = gfs2_getattr,
A
Al Viro 已提交
2042 2043
	.setxattr = generic_setxattr,
	.getxattr = generic_getxattr,
D
David Teigland 已提交
2044
	.listxattr = gfs2_listxattr,
A
Al Viro 已提交
2045
	.removexattr = generic_removexattr,
2046
	.fiemap = gfs2_fiemap,
2047
	.get_acl = gfs2_get_acl,
2048
	.set_acl = gfs2_set_acl,
D
David Teigland 已提交
2049 2050
};

2051
const struct inode_operations gfs2_dir_iops = {
D
David Teigland 已提交
2052 2053 2054 2055 2056 2057
	.create = gfs2_create,
	.lookup = gfs2_lookup,
	.link = gfs2_link,
	.unlink = gfs2_unlink,
	.symlink = gfs2_symlink,
	.mkdir = gfs2_mkdir,
2058
	.rmdir = gfs2_unlink,
D
David Teigland 已提交
2059
	.mknod = gfs2_mknod,
2060
	.rename2 = gfs2_rename2,
2061
	.permission = gfs2_permission,
D
David Teigland 已提交
2062 2063
	.setattr = gfs2_setattr,
	.getattr = gfs2_getattr,
A
Al Viro 已提交
2064 2065
	.setxattr = generic_setxattr,
	.getxattr = generic_getxattr,
D
David Teigland 已提交
2066
	.listxattr = gfs2_listxattr,
A
Al Viro 已提交
2067
	.removexattr = generic_removexattr,
2068
	.fiemap = gfs2_fiemap,
2069
	.get_acl = gfs2_get_acl,
2070
	.set_acl = gfs2_set_acl,
2071
	.atomic_open = gfs2_atomic_open,
D
David Teigland 已提交
2072 2073
};

2074
const struct inode_operations gfs2_symlink_iops = {
A
Al Viro 已提交
2075
	.readlink = generic_readlink,
2076
	.get_link = gfs2_get_link,
2077
	.permission = gfs2_permission,
D
David Teigland 已提交
2078 2079
	.setattr = gfs2_setattr,
	.getattr = gfs2_getattr,
A
Al Viro 已提交
2080 2081
	.setxattr = generic_setxattr,
	.getxattr = generic_getxattr,
D
David Teigland 已提交
2082
	.listxattr = gfs2_listxattr,
A
Al Viro 已提交
2083
	.removexattr = generic_removexattr,
2084
	.fiemap = gfs2_fiemap,
D
David Teigland 已提交
2085 2086
};