Linux Audio

Check our new training course

Loading...
v4.6
 
   1/*
   2 * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
   3 * Copyright (C) 2004-2011 Red Hat, Inc.  All rights reserved.
   4 *
   5 * This copyrighted material is made available to anyone wishing to use,
   6 * modify, copy, or redistribute it subject to the terms and conditions
   7 * of the GNU General Public License version 2.
   8 */
   9
  10#include <linux/slab.h>
  11#include <linux/spinlock.h>
  12#include <linux/completion.h>
  13#include <linux/buffer_head.h>
  14#include <linux/namei.h>
  15#include <linux/mm.h>
 
  16#include <linux/xattr.h>
  17#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>
  22#include <asm/uaccess.h>
 
  23
  24#include "gfs2.h"
  25#include "incore.h"
  26#include "acl.h"
  27#include "bmap.h"
  28#include "dir.h"
  29#include "xattr.h"
  30#include "glock.h"
  31#include "inode.h"
  32#include "meta_io.h"
  33#include "quota.h"
  34#include "rgrp.h"
  35#include "trans.h"
  36#include "util.h"
  37#include "super.h"
  38#include "glops.h"
  39
  40struct inode *gfs2_ilookup(struct super_block *sb, u64 no_addr)
  41{
  42	return ilookup(sb, (unsigned long)no_addr);
  43}
  44
  45/**
  46 * gfs2_set_iop - Sets inode operations
  47 * @inode: The inode with correct i_mode filled in
  48 *
  49 * GFS2 lookup code fills in vfs inode contents based on info obtained
  50 * from directory entry inside gfs2_inode_lookup().
  51 */
  52
  53static void gfs2_set_iop(struct inode *inode)
  54{
  55	struct gfs2_sbd *sdp = GFS2_SB(inode);
  56	umode_t mode = inode->i_mode;
  57
  58	if (S_ISREG(mode)) {
  59		inode->i_op = &gfs2_file_iops;
  60		if (gfs2_localflocks(sdp))
  61			inode->i_fop = &gfs2_file_fops_nolock;
  62		else
  63			inode->i_fop = &gfs2_file_fops;
  64	} else if (S_ISDIR(mode)) {
  65		inode->i_op = &gfs2_dir_iops;
  66		if (gfs2_localflocks(sdp))
  67			inode->i_fop = &gfs2_dir_fops_nolock;
  68		else
  69			inode->i_fop = &gfs2_dir_fops;
  70	} else if (S_ISLNK(mode)) {
  71		inode->i_op = &gfs2_symlink_iops;
  72	} else {
  73		inode->i_op = &gfs2_file_iops;
  74		init_special_inode(inode, inode->i_mode, inode->i_rdev);
  75	}
  76}
  77
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
  78/**
  79 * gfs2_inode_lookup - Lookup an inode
  80 * @sb: The super block
  81 * @no_addr: The inode number
  82 * @type: The type of the inode
 
 
 
 
 
 
 
 
 
 
 
 
 
 
  83 *
  84 * Returns: A VFS inode, or an error
  85 */
  86
  87struct inode *gfs2_inode_lookup(struct super_block *sb, unsigned int type,
  88				u64 no_addr, u64 no_formal_ino)
 
  89{
  90	struct inode *inode;
  91	struct gfs2_inode *ip;
  92	struct gfs2_glock *io_gl = NULL;
  93	int error;
  94
  95	inode = iget_locked(sb, (unsigned long)no_addr);
  96	ip = GFS2_I(inode);
  97	ip->i_no_addr = no_addr;
  98
  99	if (!inode)
 100		return ERR_PTR(-ENOMEM);
 101
 
 
 102	if (inode->i_state & I_NEW) {
 103		struct gfs2_sbd *sdp = GFS2_SB(inode);
 104		ip->i_no_formal_ino = no_formal_ino;
 
 105
 106		error = gfs2_glock_get(sdp, no_addr, &gfs2_inode_glops, CREATE, &ip->i_gl);
 
 107		if (unlikely(error))
 108			goto fail;
 109		ip->i_gl->gl_object = ip;
 110
 111		error = gfs2_glock_get(sdp, no_addr, &gfs2_iopen_glops, CREATE, &io_gl);
 
 112		if (unlikely(error))
 113			goto fail_put;
 114
 115		set_bit(GIF_INVALID, &ip->i_flags);
 116		error = gfs2_glock_nq_init(io_gl, LM_ST_SHARED, GL_EXACT, &ip->i_iopen_gh);
 
 
 
 
 
 
 
 
 
 
 
 117		if (unlikely(error))
 118			goto fail_iopen;
 119
 120		ip->i_iopen_gh.gh_gl->gl_object = ip;
 121		gfs2_glock_put(io_gl);
 122		io_gl = NULL;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 123
 124		if (type == DT_UNKNOWN) {
 125			/* Inode glock must be locked already */
 126			error = gfs2_inode_refresh(GFS2_I(inode));
 127			if (error)
 128				goto fail_refresh;
 
 
 129		} else {
 
 130			inode->i_mode = DT2IF(type);
 131		}
 132
 
 
 
 
 133		gfs2_set_iop(inode);
 134		unlock_new_inode(inode);
 135	}
 136
 
 
 
 
 
 
 137	return inode;
 138
 139fail_refresh:
 140	ip->i_iopen_gh.gh_flags |= GL_NOCACHE;
 141	ip->i_iopen_gh.gh_gl->gl_object = NULL;
 142	gfs2_glock_dq_wait(&ip->i_iopen_gh);
 143	gfs2_holder_uninit(&ip->i_iopen_gh);
 144fail_iopen:
 145	if (io_gl)
 146		gfs2_glock_put(io_gl);
 147fail_put:
 148	ip->i_gl->gl_object = NULL;
 149fail:
 
 
 
 
 
 
 
 
 
 
 150	iget_failed(inode);
 151	return ERR_PTR(error);
 152}
 153
 
 
 
 
 
 
 
 154struct inode *gfs2_lookup_by_inum(struct gfs2_sbd *sdp, u64 no_addr,
 155				  u64 *no_formal_ino, unsigned int blktype)
 156{
 157	struct super_block *sb = sdp->sd_vfs;
 158	struct gfs2_holder i_gh;
 159	struct inode *inode = NULL;
 160	int error;
 161
 162	/* Must not read in block until block type is verified */
 163	error = gfs2_glock_nq_num(sdp, no_addr, &gfs2_inode_glops,
 164				  LM_ST_EXCLUSIVE, GL_SKIP, &i_gh);
 165	if (error)
 166		return ERR_PTR(error);
 167
 168	error = gfs2_check_blk_type(sdp, no_addr, blktype);
 169	if (error)
 170		goto fail;
 171
 172	inode = gfs2_inode_lookup(sb, DT_UNKNOWN, no_addr, 0);
 173	if (IS_ERR(inode))
 174		goto fail;
 175
 176	/* Two extra checks for NFS only */
 177	if (no_formal_ino) {
 178		error = -ESTALE;
 179		if (GFS2_I(inode)->i_no_formal_ino != *no_formal_ino)
 180			goto fail_iput;
 181
 182		error = -EIO;
 183		if (GFS2_I(inode)->i_diskflags & GFS2_DIF_SYSTEM)
 184			goto fail_iput;
 185
 186		error = 0;
 187	}
 
 188
 189fail:
 190	gfs2_glock_dq_uninit(&i_gh);
 191	return error ? ERR_PTR(error) : inode;
 192fail_iput:
 193	iput(inode);
 194	goto fail;
 195}
 196
 197
 198struct inode *gfs2_lookup_simple(struct inode *dip, const char *name)
 
 
 
 
 
 199{
 200	struct qstr qstr;
 201	struct inode *inode;
 
 202	gfs2_str2qstr(&qstr, name);
 203	inode = gfs2_lookupi(dip, &qstr, 1);
 204	/* gfs2_lookupi has inconsistent callers: vfs
 205	 * related routines expect NULL for no entry found,
 206	 * gfs2_lookup_simple callers expect ENOENT
 207	 * and do not check for NULL.
 
 
 208	 */
 209	if (inode == NULL)
 210		return ERR_PTR(-ENOENT);
 211	else
 212		return inode;
 213}
 214
 215
 216/**
 217 * gfs2_lookupi - Look up a filename in a directory and return its inode
 218 * @d_gh: An initialized holder for the directory glock
 219 * @name: The name of the inode to look for
 220 * @is_root: If 1, ignore the caller's permissions
 221 * @i_gh: An uninitialized holder for the new inode glock
 222 *
 223 * This can be called via the VFS filldir function when NFS is doing
 224 * a readdirplus and the inode which its intending to stat isn't
 225 * already in cache. In this case we must not take the directory glock
 226 * again, since the readdir call will have already taken that lock.
 227 *
 228 * Returns: errno
 229 */
 230
 231struct inode *gfs2_lookupi(struct inode *dir, const struct qstr *name,
 232			   int is_root)
 233{
 234	struct super_block *sb = dir->i_sb;
 235	struct gfs2_inode *dip = GFS2_I(dir);
 236	struct gfs2_holder d_gh;
 237	int error = 0;
 238	struct inode *inode = NULL;
 239	int unlock = 0;
 240
 
 241	if (!name->len || name->len > GFS2_FNAMESIZE)
 242		return ERR_PTR(-ENAMETOOLONG);
 243
 244	if ((name->len == 1 && memcmp(name->name, ".", 1) == 0) ||
 245	    (name->len == 2 && memcmp(name->name, "..", 2) == 0 &&
 246	     dir == d_inode(sb->s_root))) {
 247		igrab(dir);
 248		return dir;
 249	}
 250
 251	if (gfs2_glock_is_locked_by_me(dip->i_gl) == NULL) {
 252		error = gfs2_glock_nq_init(dip->i_gl, LM_ST_SHARED, 0, &d_gh);
 253		if (error)
 254			return ERR_PTR(error);
 255		unlock = 1;
 256	}
 257
 258	if (!is_root) {
 259		error = gfs2_permission(dir, MAY_EXEC);
 260		if (error)
 261			goto out;
 262	}
 263
 264	inode = gfs2_dir_search(dir, name, false);
 265	if (IS_ERR(inode))
 266		error = PTR_ERR(inode);
 267out:
 268	if (unlock)
 269		gfs2_glock_dq_uninit(&d_gh);
 270	if (error == -ENOENT)
 271		return NULL;
 272	return inode ? inode : ERR_PTR(error);
 273}
 274
 275/**
 276 * create_ok - OK to create a new on-disk inode here?
 277 * @dip:  Directory in which dinode is to be created
 278 * @name:  Name of new dinode
 279 * @mode:
 280 *
 281 * Returns: errno
 282 */
 283
 284static int create_ok(struct gfs2_inode *dip, const struct qstr *name,
 285		     umode_t mode)
 286{
 287	int error;
 288
 289	error = gfs2_permission(&dip->i_inode, MAY_WRITE | MAY_EXEC);
 
 290	if (error)
 291		return error;
 292
 293	/*  Don't create entries in an unlinked directory  */
 294	if (!dip->i_inode.i_nlink)
 295		return -ENOENT;
 296
 297	if (dip->i_entries == (u32)-1)
 298		return -EFBIG;
 299	if (S_ISDIR(mode) && dip->i_inode.i_nlink == (u32)-1)
 300		return -EMLINK;
 301
 302	return 0;
 303}
 304
 305static void munge_mode_uid_gid(const struct gfs2_inode *dip,
 306			       struct inode *inode)
 307{
 308	if (GFS2_SB(&dip->i_inode)->sd_args.ar_suiddir &&
 309	    (dip->i_inode.i_mode & S_ISUID) &&
 310	    !uid_eq(dip->i_inode.i_uid, GLOBAL_ROOT_UID)) {
 311		if (S_ISDIR(inode->i_mode))
 312			inode->i_mode |= S_ISUID;
 313		else if (!uid_eq(dip->i_inode.i_uid, current_fsuid()))
 314			inode->i_mode &= ~07111;
 315		inode->i_uid = dip->i_inode.i_uid;
 316	} else
 317		inode->i_uid = current_fsuid();
 318
 319	if (dip->i_inode.i_mode & S_ISGID) {
 320		if (S_ISDIR(inode->i_mode))
 321			inode->i_mode |= S_ISGID;
 322		inode->i_gid = dip->i_inode.i_gid;
 323	} else
 324		inode->i_gid = current_fsgid();
 325}
 326
 327static int alloc_dinode(struct gfs2_inode *ip, u32 flags, unsigned *dblocks)
 328{
 329	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
 330	struct gfs2_alloc_parms ap = { .target = *dblocks, .aflags = flags, };
 331	int error;
 332
 333	error = gfs2_quota_lock_check(ip, &ap);
 334	if (error)
 335		goto out;
 336
 337	error = gfs2_inplace_reserve(ip, &ap);
 338	if (error)
 339		goto out_quota;
 340
 341	error = gfs2_trans_begin(sdp, (*dblocks * RES_RG_BIT) + RES_STATFS + RES_QUOTA, 0);
 342	if (error)
 343		goto out_ipreserv;
 344
 345	error = gfs2_alloc_blocks(ip, &ip->i_no_addr, dblocks, 1, &ip->i_generation);
 
 
 
 346	ip->i_no_formal_ino = ip->i_generation;
 347	ip->i_inode.i_ino = ip->i_no_addr;
 348	ip->i_goal = ip->i_no_addr;
 
 
 349
 
 350	gfs2_trans_end(sdp);
 351
 352out_ipreserv:
 353	gfs2_inplace_release(ip);
 354out_quota:
 355	gfs2_quota_unlock(ip);
 356out:
 357	return error;
 358}
 359
 360static void gfs2_init_dir(struct buffer_head *dibh,
 361			  const struct gfs2_inode *parent)
 362{
 363	struct gfs2_dinode *di = (struct gfs2_dinode *)dibh->b_data;
 364	struct gfs2_dirent *dent = (struct gfs2_dirent *)(di+1);
 365
 366	gfs2_qstr2dirent(&gfs2_qdot, GFS2_DIRENT_SIZE(gfs2_qdot.len), dent);
 367	dent->de_inum = di->di_num; /* already GFS2 endian */
 368	dent->de_type = cpu_to_be16(DT_DIR);
 369
 370	dent = (struct gfs2_dirent *)((char*)dent + GFS2_DIRENT_SIZE(1));
 371	gfs2_qstr2dirent(&gfs2_qdotdot, dibh->b_size - GFS2_DIRENT_SIZE(1) - sizeof(struct gfs2_dinode), dent);
 372	gfs2_inum_out(parent, dent);
 373	dent->de_type = cpu_to_be16(DT_DIR);
 374	
 375}
 376
 377/**
 378 * gfs2_init_xattr - Initialise an xattr block for a new inode
 379 * @ip: The inode in question
 380 *
 381 * This sets up an empty xattr block for a new inode, ready to
 382 * take any ACLs, LSM xattrs, etc.
 383 */
 384
 385static void gfs2_init_xattr(struct gfs2_inode *ip)
 386{
 387	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
 388	struct buffer_head *bh;
 389	struct gfs2_ea_header *ea;
 390
 391	bh = gfs2_meta_new(ip->i_gl, ip->i_eattr);
 392	gfs2_trans_add_meta(ip->i_gl, bh);
 393	gfs2_metatype_set(bh, GFS2_METATYPE_EA, GFS2_FORMAT_EA);
 394	gfs2_buffer_clear_tail(bh, sizeof(struct gfs2_meta_header));
 395
 396	ea = GFS2_EA_BH2FIRST(bh);
 397	ea->ea_rec_len = cpu_to_be32(sdp->sd_jbsize);
 398	ea->ea_type = GFS2_EATYPE_UNUSED;
 399	ea->ea_flags = GFS2_EAFLAG_LAST;
 400
 401	brelse(bh);
 402}
 403
 404/**
 405 * init_dinode - Fill in a new dinode structure
 406 * @dip: The directory this inode is being created in
 407 * @ip: The inode
 408 * @symname: The symlink destination (if a symlink)
 409 * @bhp: The buffer head (returned to caller)
 410 *
 411 */
 412
 413static void init_dinode(struct gfs2_inode *dip, struct gfs2_inode *ip,
 414			const char *symname)
 415{
 416	struct gfs2_dinode *di;
 417	struct buffer_head *dibh;
 418
 419	dibh = gfs2_meta_new(ip->i_gl, ip->i_no_addr);
 420	gfs2_trans_add_meta(ip->i_gl, dibh);
 421	di = (struct gfs2_dinode *)dibh->b_data;
 422	gfs2_dinode_out(ip, di);
 423
 424	di->di_major = cpu_to_be32(MAJOR(ip->i_inode.i_rdev));
 425	di->di_minor = cpu_to_be32(MINOR(ip->i_inode.i_rdev));
 426	di->__pad1 = 0;
 427	di->__pad2 = 0;
 428	di->__pad3 = 0;
 429	memset(&di->__pad4, 0, sizeof(di->__pad4));
 430	memset(&di->di_reserved, 0, sizeof(di->di_reserved));
 431	gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode));
 432
 433	switch(ip->i_inode.i_mode & S_IFMT) {
 434	case S_IFDIR:
 435		gfs2_init_dir(dibh, dip);
 436		break;
 437	case S_IFLNK:
 438		memcpy(dibh->b_data + sizeof(struct gfs2_dinode), symname, ip->i_inode.i_size);
 439		break;
 440	}
 441
 442	set_buffer_uptodate(dibh);
 443	brelse(dibh);
 444}
 445
 446/**
 447 * gfs2_trans_da_blocks - Calculate number of blocks to link inode
 448 * @dip: The directory we are linking into
 449 * @da: The dir add information
 450 * @nr_inodes: The number of inodes involved
 451 *
 452 * This calculate the number of blocks we need to reserve in a
 453 * transaction to link @nr_inodes into a directory. In most cases
 454 * @nr_inodes will be 2 (the directory plus the inode being linked in)
 455 * but in case of rename, 4 may be required.
 456 *
 457 * Returns: Number of blocks
 458 */
 459
 460static unsigned gfs2_trans_da_blks(const struct gfs2_inode *dip,
 461				   const struct gfs2_diradd *da,
 462				   unsigned nr_inodes)
 463{
 464	return da->nr_blocks + gfs2_rg_blocks(dip, da->nr_blocks) +
 465	       (nr_inodes * RES_DINODE) + RES_QUOTA + RES_STATFS;
 466}
 467
 468static int link_dinode(struct gfs2_inode *dip, const struct qstr *name,
 469		       struct gfs2_inode *ip, struct gfs2_diradd *da)
 470{
 471	struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
 472	struct gfs2_alloc_parms ap = { .target = da->nr_blocks, };
 473	int error;
 474
 475	if (da->nr_blocks) {
 476		error = gfs2_quota_lock_check(dip, &ap);
 477		if (error)
 478			goto fail_quota_locks;
 479
 480		error = gfs2_inplace_reserve(dip, &ap);
 481		if (error)
 482			goto fail_quota_locks;
 483
 484		error = gfs2_trans_begin(sdp, gfs2_trans_da_blks(dip, da, 2), 0);
 485		if (error)
 486			goto fail_ipreserv;
 487	} else {
 488		error = gfs2_trans_begin(sdp, RES_LEAF + 2 * RES_DINODE, 0);
 489		if (error)
 490			goto fail_quota_locks;
 491	}
 492
 493	error = gfs2_dir_add(&dip->i_inode, name, ip, da);
 494
 495	gfs2_trans_end(sdp);
 496fail_ipreserv:
 497	gfs2_inplace_release(dip);
 498fail_quota_locks:
 499	gfs2_quota_unlock(dip);
 500	return error;
 501}
 502
 503static int gfs2_initxattrs(struct inode *inode, const struct xattr *xattr_array,
 504		    void *fs_info)
 505{
 506	const struct xattr *xattr;
 507	int err = 0;
 508
 509	for (xattr = xattr_array; xattr->name != NULL; xattr++) {
 510		err = __gfs2_xattr_set(inode, xattr->name, xattr->value,
 511				       xattr->value_len, 0,
 512				       GFS2_EATYPE_SECURITY);
 513		if (err < 0)
 514			break;
 515	}
 516	return err;
 517}
 518
 519/**
 520 * gfs2_create_inode - Create a new inode
 521 * @dir: The parent directory
 522 * @dentry: The new dentry
 523 * @file: If non-NULL, the file which is being opened
 524 * @mode: The permissions on the new inode
 525 * @dev: For device nodes, this is the device number
 526 * @symname: For symlinks, this is the link destination
 527 * @size: The initial size of the inode (ignored for directories)
 
 
 
 
 
 
 
 528 *
 529 * Returns: 0 on success, or error code
 530 */
 531
 532static int gfs2_create_inode(struct inode *dir, struct dentry *dentry,
 533			     struct file *file,
 534			     umode_t mode, dev_t dev, const char *symname,
 535			     unsigned int size, int excl, int *opened)
 536{
 537	const struct qstr *name = &dentry->d_name;
 538	struct posix_acl *default_acl, *acl;
 539	struct gfs2_holder ghs[2];
 540	struct inode *inode = NULL;
 541	struct gfs2_inode *dip = GFS2_I(dir), *ip;
 542	struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
 543	struct gfs2_glock *io_gl = NULL;
 544	int error, free_vfs_inode = 1;
 545	u32 aflags = 0;
 546	unsigned blocks = 1;
 547	struct gfs2_diradd da = { .bh = NULL, .save_loc = 1, };
 548
 549	if (!name->len || name->len > GFS2_FNAMESIZE)
 550		return -ENAMETOOLONG;
 551
 552	error = gfs2_rsqa_alloc(dip);
 553	if (error)
 554		return error;
 555
 556	error = gfs2_rindex_update(sdp);
 557	if (error)
 558		return error;
 559
 560	error = gfs2_glock_nq_init(dip->i_gl, LM_ST_EXCLUSIVE, 0, ghs);
 561	if (error)
 562		goto fail;
 
 563
 564	error = create_ok(dip, name, mode);
 565	if (error)
 566		goto fail_gunlock;
 567
 568	inode = gfs2_dir_search(dir, &dentry->d_name, !S_ISREG(mode) || excl);
 569	error = PTR_ERR(inode);
 570	if (!IS_ERR(inode)) {
 571		if (S_ISDIR(inode->i_mode)) {
 572			iput(inode);
 573			inode = ERR_PTR(-EISDIR);
 574			goto fail_gunlock;
 575		}
 576		d_instantiate(dentry, inode);
 577		error = 0;
 578		if (file) {
 579			if (S_ISREG(inode->i_mode))
 580				error = finish_open(file, dentry, gfs2_open_common, opened);
 581			else
 582				error = finish_no_open(file, NULL);
 583		}
 584		gfs2_glock_dq_uninit(ghs);
 585		return error;
 586	} else if (error != -ENOENT) {
 587		goto fail_gunlock;
 588	}
 589
 590	error = gfs2_diradd_alloc_required(dir, name, &da);
 591	if (error < 0)
 592		goto fail_gunlock;
 593
 594	inode = new_inode(sdp->sd_vfs);
 595	error = -ENOMEM;
 596	if (!inode)
 597		goto fail_gunlock;
 
 598
 599	error = posix_acl_create(dir, &mode, &default_acl, &acl);
 600	if (error)
 601		goto fail_gunlock;
 602
 603	ip = GFS2_I(inode);
 604	error = gfs2_rsqa_alloc(ip);
 605	if (error)
 606		goto fail_free_acls;
 607
 608	inode->i_mode = mode;
 609	set_nlink(inode, S_ISDIR(mode) ? 2 : 1);
 610	inode->i_rdev = dev;
 611	inode->i_size = size;
 612	inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
 613	gfs2_set_inode_blocks(inode, 1);
 614	munge_mode_uid_gid(dip, inode);
 615	check_and_update_goal(dip);
 616	ip->i_goal = dip->i_goal;
 617	ip->i_diskflags = 0;
 618	ip->i_eattr = 0;
 619	ip->i_height = 0;
 620	ip->i_depth = 0;
 621	ip->i_entries = 0;
 
 622
 623	switch(mode & S_IFMT) {
 624	case S_IFREG:
 625		if ((dip->i_diskflags & GFS2_DIF_INHERIT_JDATA) ||
 626		    gfs2_tune_get(sdp, gt_new_files_jdata))
 627			ip->i_diskflags |= GFS2_DIF_JDATA;
 628		gfs2_set_aops(inode);
 629		break;
 630	case S_IFDIR:
 631		ip->i_diskflags |= (dip->i_diskflags & GFS2_DIF_INHERIT_JDATA);
 632		ip->i_diskflags |= GFS2_DIF_JDATA;
 633		ip->i_entries = 2;
 634		break;
 635	}
 636
 637	/* Force SYSTEM flag on all files and subdirs of a SYSTEM directory */
 638	if (dip->i_diskflags & GFS2_DIF_SYSTEM)
 639		ip->i_diskflags |= GFS2_DIF_SYSTEM;
 640
 641	gfs2_set_inode_flags(inode);
 642
 643	if ((GFS2_I(d_inode(sdp->sd_root_dir)) == dip) ||
 644	    (dip->i_diskflags & GFS2_DIF_TOPDIR))
 645		aflags |= GFS2_AF_ORLOV;
 646
 647	if (default_acl || acl)
 648		blocks++;
 649
 650	error = alloc_dinode(ip, aflags, &blocks);
 651	if (error)
 652		goto fail_free_inode;
 653
 654	gfs2_set_inode_blocks(inode, blocks);
 655
 656	error = gfs2_glock_get(sdp, ip->i_no_addr, &gfs2_inode_glops, CREATE, &ip->i_gl);
 657	if (error)
 658		goto fail_free_inode;
 659
 660	ip->i_gl->gl_object = ip;
 661	error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, GL_SKIP, ghs + 1);
 662	if (error)
 663		goto fail_free_inode;
 
 
 664
 665	error = gfs2_trans_begin(sdp, blocks, 0);
 
 
 
 666	if (error)
 667		goto fail_gunlock2;
 668
 669	if (blocks > 1) {
 670		ip->i_eattr = ip->i_no_addr + 1;
 671		gfs2_init_xattr(ip);
 672	}
 673	init_dinode(dip, ip, symname);
 674	gfs2_trans_end(sdp);
 675
 676	error = gfs2_glock_get(sdp, ip->i_no_addr, &gfs2_iopen_glops, CREATE, &io_gl);
 677	if (error)
 678		goto fail_gunlock2;
 679
 680	BUG_ON(test_and_set_bit(GLF_INODE_CREATING, &io_gl->gl_flags));
 
 
 681
 682	error = gfs2_glock_nq_init(io_gl, LM_ST_SHARED, GL_EXACT, &ip->i_iopen_gh);
 683	if (error)
 684		goto fail_gunlock2;
 685
 686	ip->i_iopen_gh.gh_gl->gl_object = ip;
 687	gfs2_glock_put(io_gl);
 
 
 
 
 
 688	gfs2_set_iop(inode);
 689	insert_inode_hash(inode);
 690
 691	free_vfs_inode = 0; /* After this point, the inode is no longer
 692			       considered free. Any failures need to undo
 693			       the gfs2 structures. */
 694	if (default_acl) {
 695		error = gfs2_set_acl(inode, default_acl, ACL_TYPE_DEFAULT);
 
 
 696		posix_acl_release(default_acl);
 
 697	}
 698	if (acl) {
 699		if (!error)
 700			error = gfs2_set_acl(inode, acl, ACL_TYPE_ACCESS);
 
 701		posix_acl_release(acl);
 
 702	}
 703
 704	if (error)
 705		goto fail_gunlock3;
 706
 707	error = security_inode_init_security(&ip->i_inode, &dip->i_inode, name,
 708					     &gfs2_initxattrs, NULL);
 709	if (error)
 710		goto fail_gunlock3;
 711
 712	error = link_dinode(dip, name, ip, &da);
 713	if (error)
 714		goto fail_gunlock3;
 715
 716	mark_inode_dirty(inode);
 717	d_instantiate(dentry, inode);
 
 
 718	if (file) {
 719		*opened |= FILE_CREATED;
 720		error = finish_open(file, dentry, gfs2_open_common, opened);
 721	}
 722	gfs2_glock_dq_uninit(ghs);
 723	gfs2_glock_dq_uninit(ghs + 1);
 724	clear_bit(GLF_INODE_CREATING, &io_gl->gl_flags);
 
 
 
 725	return error;
 726
 
 
 
 727fail_gunlock3:
 728	gfs2_glock_dq_uninit(&ip->i_iopen_gh);
 729	gfs2_glock_put(io_gl);
 730fail_gunlock2:
 731	if (io_gl)
 732		clear_bit(GLF_INODE_CREATING, &io_gl->gl_flags);
 733	gfs2_glock_dq_uninit(ghs + 1);
 734fail_free_inode:
 735	if (ip->i_gl)
 736		gfs2_glock_put(ip->i_gl);
 737	gfs2_rsqa_delete(ip, NULL);
 
 
 
 738fail_free_acls:
 739	if (default_acl)
 740		posix_acl_release(default_acl);
 741	if (acl)
 742		posix_acl_release(acl);
 743fail_gunlock:
 744	gfs2_dir_no_add(&da);
 745	gfs2_glock_dq_uninit(ghs);
 746	if (inode && !IS_ERR(inode)) {
 
 747		clear_nlink(inode);
 748		if (!free_vfs_inode)
 749			mark_inode_dirty(inode);
 750		set_bit(free_vfs_inode ? GIF_FREE_VFS_INODE : GIF_ALLOC_FAILED,
 751			&GFS2_I(inode)->i_flags);
 752		iput(inode);
 
 753	}
 
 
 754fail:
 
 755	return error;
 756}
 757
 758/**
 759 * gfs2_create - Create a file
 
 760 * @dir: The directory in which to create the file
 761 * @dentry: The dentry of the new file
 762 * @mode: The mode of the new file
 
 763 *
 764 * Returns: errno
 765 */
 766
 767static int gfs2_create(struct inode *dir, struct dentry *dentry,
 768		       umode_t mode, bool excl)
 769{
 770	return gfs2_create_inode(dir, dentry, NULL, S_IFREG | mode, 0, NULL, 0, excl, NULL);
 771}
 772
 773/**
 774 * __gfs2_lookup - Look up a filename in a directory and return its inode
 775 * @dir: The directory inode
 776 * @dentry: The dentry of the new inode
 777 * @file: File to be opened
 778 * @opened: atomic_open flags
 779 *
 780 *
 781 * Returns: errno
 782 */
 783
 784static struct dentry *__gfs2_lookup(struct inode *dir, struct dentry *dentry,
 785				    struct file *file, int *opened)
 786{
 787	struct inode *inode;
 788	struct dentry *d;
 789	struct gfs2_holder gh;
 790	struct gfs2_glock *gl;
 791	int error;
 792
 793	inode = gfs2_lookupi(dir, &dentry->d_name, 0);
 794	if (inode == NULL) {
 795		d_add(dentry, NULL);
 796		return NULL;
 797	}
 798	if (IS_ERR(inode))
 799		return ERR_CAST(inode);
 800
 801	gl = GFS2_I(inode)->i_gl;
 802	error = gfs2_glock_nq_init(gl, LM_ST_SHARED, LM_FLAG_ANY, &gh);
 803	if (error) {
 804		iput(inode);
 805		return ERR_PTR(error);
 806	}
 807
 808	d = d_splice_alias(inode, dentry);
 809	if (IS_ERR(d)) {
 810		gfs2_glock_dq_uninit(&gh);
 811		return d;
 812	}
 813	if (file && S_ISREG(inode->i_mode))
 814		error = finish_open(file, dentry, gfs2_open_common, opened);
 815
 816	gfs2_glock_dq_uninit(&gh);
 817	if (error) {
 818		dput(d);
 819		return ERR_PTR(error);
 820	}
 821	return d;
 822}
 823
 824static struct dentry *gfs2_lookup(struct inode *dir, struct dentry *dentry,
 825				  unsigned flags)
 826{
 827	return __gfs2_lookup(dir, dentry, NULL, NULL);
 828}
 829
 830/**
 831 * gfs2_link - Link to a file
 832 * @old_dentry: The inode to link
 833 * @dir: Add link to this directory
 834 * @dentry: The name of the link
 835 *
 836 * Link the inode in "old_dentry" into the directory "dir" with the
 837 * name in "dentry".
 838 *
 839 * Returns: errno
 840 */
 841
 842static int gfs2_link(struct dentry *old_dentry, struct inode *dir,
 843		     struct dentry *dentry)
 844{
 845	struct gfs2_inode *dip = GFS2_I(dir);
 846	struct gfs2_sbd *sdp = GFS2_SB(dir);
 847	struct inode *inode = d_inode(old_dentry);
 848	struct gfs2_inode *ip = GFS2_I(inode);
 849	struct gfs2_holder ghs[2];
 850	struct buffer_head *dibh;
 851	struct gfs2_diradd da = { .bh = NULL, .save_loc = 1, };
 852	int error;
 853
 854	if (S_ISDIR(inode->i_mode))
 855		return -EPERM;
 856
 857	error = gfs2_rsqa_alloc(dip);
 858	if (error)
 859		return error;
 860
 861	gfs2_holder_init(dip->i_gl, LM_ST_EXCLUSIVE, 0, ghs);
 862	gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + 1);
 863
 864	error = gfs2_glock_nq(ghs); /* parent */
 865	if (error)
 866		goto out_parent;
 867
 868	error = gfs2_glock_nq(ghs + 1); /* child */
 869	if (error)
 870		goto out_child;
 871
 872	error = -ENOENT;
 873	if (inode->i_nlink == 0)
 874		goto out_gunlock;
 875
 876	error = gfs2_permission(dir, MAY_WRITE | MAY_EXEC);
 877	if (error)
 878		goto out_gunlock;
 879
 880	error = gfs2_dir_check(dir, &dentry->d_name, NULL);
 881	switch (error) {
 882	case -ENOENT:
 883		break;
 884	case 0:
 885		error = -EEXIST;
 
 886	default:
 887		goto out_gunlock;
 888	}
 889
 890	error = -EINVAL;
 891	if (!dip->i_inode.i_nlink)
 892		goto out_gunlock;
 893	error = -EFBIG;
 894	if (dip->i_entries == (u32)-1)
 895		goto out_gunlock;
 896	error = -EPERM;
 897	if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
 898		goto out_gunlock;
 899	error = -EINVAL;
 900	if (!ip->i_inode.i_nlink)
 901		goto out_gunlock;
 902	error = -EMLINK;
 903	if (ip->i_inode.i_nlink == (u32)-1)
 904		goto out_gunlock;
 905
 906	error = gfs2_diradd_alloc_required(dir, &dentry->d_name, &da);
 907	if (error < 0)
 908		goto out_gunlock;
 909
 910	if (da.nr_blocks) {
 911		struct gfs2_alloc_parms ap = { .target = da.nr_blocks, };
 912		error = gfs2_quota_lock_check(dip, &ap);
 913		if (error)
 914			goto out_gunlock;
 915
 916		error = gfs2_inplace_reserve(dip, &ap);
 917		if (error)
 918			goto out_gunlock_q;
 919
 920		error = gfs2_trans_begin(sdp, gfs2_trans_da_blks(dip, &da, 2), 0);
 921		if (error)
 922			goto out_ipres;
 923	} else {
 924		error = gfs2_trans_begin(sdp, 2 * RES_DINODE + RES_LEAF, 0);
 925		if (error)
 926			goto out_ipres;
 927	}
 928
 929	error = gfs2_meta_inode_buffer(ip, &dibh);
 930	if (error)
 931		goto out_end_trans;
 932
 933	error = gfs2_dir_add(dir, &dentry->d_name, ip, &da);
 934	if (error)
 935		goto out_brelse;
 936
 937	gfs2_trans_add_meta(ip->i_gl, dibh);
 938	inc_nlink(&ip->i_inode);
 939	ip->i_inode.i_ctime = CURRENT_TIME;
 940	ihold(inode);
 941	d_instantiate(dentry, inode);
 942	mark_inode_dirty(inode);
 943
 944out_brelse:
 945	brelse(dibh);
 946out_end_trans:
 947	gfs2_trans_end(sdp);
 948out_ipres:
 949	if (da.nr_blocks)
 950		gfs2_inplace_release(dip);
 951out_gunlock_q:
 952	if (da.nr_blocks)
 953		gfs2_quota_unlock(dip);
 954out_gunlock:
 955	gfs2_dir_no_add(&da);
 956	gfs2_glock_dq(ghs + 1);
 957out_child:
 958	gfs2_glock_dq(ghs);
 959out_parent:
 960	gfs2_holder_uninit(ghs);
 961	gfs2_holder_uninit(ghs + 1);
 
 962	return error;
 963}
 964
 965/*
 966 * gfs2_unlink_ok - check to see that a inode is still in a directory
 967 * @dip: the directory
 968 * @name: the name of the file
 969 * @ip: the inode
 970 *
 971 * Assumes that the lock on (at least) @dip is held.
 972 *
 973 * Returns: 0 if the parent/child relationship is correct, errno if it isn't
 974 */
 975
 976static int gfs2_unlink_ok(struct gfs2_inode *dip, const struct qstr *name,
 977			  const struct gfs2_inode *ip)
 978{
 979	int error;
 980
 981	if (IS_IMMUTABLE(&ip->i_inode) || IS_APPEND(&ip->i_inode))
 982		return -EPERM;
 983
 984	if ((dip->i_inode.i_mode & S_ISVTX) &&
 985	    !uid_eq(dip->i_inode.i_uid, current_fsuid()) &&
 986	    !uid_eq(ip->i_inode.i_uid, current_fsuid()) && !capable(CAP_FOWNER))
 987		return -EPERM;
 988
 989	if (IS_APPEND(&dip->i_inode))
 990		return -EPERM;
 991
 992	error = gfs2_permission(&dip->i_inode, MAY_WRITE | MAY_EXEC);
 
 993	if (error)
 994		return error;
 995
 996	return gfs2_dir_check(&dip->i_inode, name, ip);
 997}
 998
 999/**
1000 * gfs2_unlink_inode - Removes an inode from its parent dir and unlinks it
1001 * @dip: The parent directory
1002 * @name: The name of the entry in the parent directory
1003 * @inode: The inode to be removed
1004 *
1005 * Called with all the locks and in a transaction. This will only be
1006 * called for a directory after it has been checked to ensure it is empty.
1007 *
1008 * Returns: 0 on success, or an error
1009 */
1010
1011static int gfs2_unlink_inode(struct gfs2_inode *dip,
1012			     const struct dentry *dentry)
1013{
1014	struct inode *inode = d_inode(dentry);
1015	struct gfs2_inode *ip = GFS2_I(inode);
1016	int error;
1017
1018	error = gfs2_dir_del(dip, dentry);
1019	if (error)
1020		return error;
1021
1022	ip->i_entries = 0;
1023	inode->i_ctime = CURRENT_TIME;
1024	if (S_ISDIR(inode->i_mode))
1025		clear_nlink(inode);
1026	else
1027		drop_nlink(inode);
1028	mark_inode_dirty(inode);
1029	if (inode->i_nlink == 0)
1030		gfs2_unlink_di(inode);
1031	return 0;
1032}
1033
1034
1035/**
1036 * gfs2_unlink - Unlink an inode (this does rmdir as well)
1037 * @dir: The inode of the directory containing the inode to unlink
1038 * @dentry: The file itself
1039 *
1040 * This routine uses the type of the inode as a flag to figure out
1041 * whether this is an unlink or an rmdir.
1042 *
1043 * Returns: errno
1044 */
1045
1046static int gfs2_unlink(struct inode *dir, struct dentry *dentry)
1047{
1048	struct gfs2_inode *dip = GFS2_I(dir);
1049	struct gfs2_sbd *sdp = GFS2_SB(dir);
1050	struct inode *inode = d_inode(dentry);
1051	struct gfs2_inode *ip = GFS2_I(inode);
1052	struct gfs2_holder ghs[3];
1053	struct gfs2_rgrpd *rgd;
1054	int error;
1055
1056	error = gfs2_rindex_update(sdp);
1057	if (error)
1058		return error;
1059
1060	error = -EROFS;
1061
1062	gfs2_holder_init(dip->i_gl, LM_ST_EXCLUSIVE, 0, ghs);
1063	gfs2_holder_init(ip->i_gl,  LM_ST_EXCLUSIVE, 0, ghs + 1);
1064
1065	rgd = gfs2_blk2rgrpd(sdp, ip->i_no_addr, 1);
1066	if (!rgd)
1067		goto out_inodes;
1068
1069	gfs2_holder_init(rgd->rd_gl, LM_ST_EXCLUSIVE, 0, ghs + 2);
1070
1071
1072	error = gfs2_glock_nq(ghs); /* parent */
1073	if (error)
1074		goto out_parent;
1075
1076	error = gfs2_glock_nq(ghs + 1); /* child */
1077	if (error)
1078		goto out_child;
1079
1080	error = -ENOENT;
1081	if (inode->i_nlink == 0)
1082		goto out_rgrp;
1083
1084	if (S_ISDIR(inode->i_mode)) {
1085		error = -ENOTEMPTY;
1086		if (ip->i_entries > 2 || inode->i_nlink > 2)
1087			goto out_rgrp;
1088	}
1089
1090	error = gfs2_glock_nq(ghs + 2); /* rgrp */
1091	if (error)
1092		goto out_rgrp;
1093
1094	error = gfs2_unlink_ok(dip, &dentry->d_name, ip);
1095	if (error)
1096		goto out_gunlock;
1097
1098	error = gfs2_trans_begin(sdp, 2*RES_DINODE + 3*RES_LEAF + RES_RG_BIT, 0);
1099	if (error)
1100		goto out_end_trans;
1101
1102	error = gfs2_unlink_inode(dip, dentry);
1103
1104out_end_trans:
1105	gfs2_trans_end(sdp);
 
1106out_gunlock:
1107	gfs2_glock_dq(ghs + 2);
1108out_rgrp:
1109	gfs2_glock_dq(ghs + 1);
1110out_child:
1111	gfs2_glock_dq(ghs);
1112out_parent:
1113	gfs2_holder_uninit(ghs + 2);
1114out_inodes:
1115	gfs2_holder_uninit(ghs + 1);
1116	gfs2_holder_uninit(ghs);
1117	return error;
1118}
1119
1120/**
1121 * gfs2_symlink - Create a symlink
 
1122 * @dir: The directory to create the symlink in
1123 * @dentry: The dentry to put the symlink in
1124 * @symname: The thing which the link points to
1125 *
1126 * Returns: errno
1127 */
1128
1129static int gfs2_symlink(struct inode *dir, struct dentry *dentry,
1130			const char *symname)
1131{
1132	struct gfs2_sbd *sdp = GFS2_SB(dir);
1133	unsigned int size;
1134
1135	size = strlen(symname);
1136	if (size > sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode) - 1)
1137		return -ENAMETOOLONG;
1138
1139	return gfs2_create_inode(dir, dentry, NULL, S_IFLNK | S_IRWXUGO, 0, symname, size, 0, NULL);
1140}
1141
1142/**
1143 * gfs2_mkdir - Make a directory
 
1144 * @dir: The parent directory of the new one
1145 * @dentry: The dentry of the new directory
1146 * @mode: The mode of the new directory
1147 *
1148 * Returns: errno
1149 */
1150
1151static int gfs2_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
 
1152{
1153	struct gfs2_sbd *sdp = GFS2_SB(dir);
1154	unsigned dsize = sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode);
1155	return gfs2_create_inode(dir, dentry, NULL, S_IFDIR | mode, 0, NULL, dsize, 0, NULL);
1156}
1157
1158/**
1159 * gfs2_mknod - Make a special file
 
1160 * @dir: The directory in which the special file will reside
1161 * @dentry: The dentry of the special file
1162 * @mode: The mode of the special file
1163 * @dev: The device specification of the special file
1164 *
1165 */
1166
1167static int gfs2_mknod(struct inode *dir, struct dentry *dentry, umode_t mode,
1168		      dev_t dev)
1169{
1170	return gfs2_create_inode(dir, dentry, NULL, mode, dev, NULL, 0, 0, NULL);
1171}
1172
1173/**
1174 * gfs2_atomic_open - Atomically open a file
1175 * @dir: The directory
1176 * @dentry: The proposed new entry
1177 * @file: The proposed new struct file
1178 * @flags: open flags
1179 * @mode: File mode
1180 * @opened: Flag to say whether the file has been opened or not
1181 *
1182 * Returns: error code or 0 for success
1183 */
1184
1185static int gfs2_atomic_open(struct inode *dir, struct dentry *dentry,
1186			    struct file *file, unsigned flags,
1187			    umode_t mode, int *opened)
1188{
1189	struct dentry *d;
1190	bool excl = !!(flags & O_EXCL);
1191
1192	if (!d_unhashed(dentry))
1193		goto skip_lookup;
1194
1195	d = __gfs2_lookup(dir, dentry, file, opened);
1196	if (IS_ERR(d))
1197		return PTR_ERR(d);
1198	if (d != NULL)
1199		dentry = d;
1200	if (d_really_is_positive(dentry)) {
1201		if (!(*opened & FILE_OPENED))
1202			return finish_no_open(file, d);
1203		dput(d);
1204		return 0;
1205	}
1206
1207	BUG_ON(d != NULL);
1208
1209skip_lookup:
1210	if (!(flags & O_CREAT))
1211		return -ENOENT;
1212
1213	return gfs2_create_inode(dir, dentry, file, S_IFREG | mode, 0, NULL, 0, excl, opened);
1214}
1215
1216/*
1217 * gfs2_ok_to_move - check if it's ok to move a directory to another directory
1218 * @this: move this
1219 * @to: to here
1220 *
1221 * Follow @to back to the root and make sure we don't encounter @this
1222 * Assumes we already hold the rename lock.
1223 *
1224 * Returns: errno
1225 */
1226
1227static int gfs2_ok_to_move(struct gfs2_inode *this, struct gfs2_inode *to)
1228{
1229	struct inode *dir = &to->i_inode;
1230	struct super_block *sb = dir->i_sb;
1231	struct inode *tmp;
1232	int error = 0;
1233
1234	igrab(dir);
1235
1236	for (;;) {
1237		if (dir == &this->i_inode) {
1238			error = -EINVAL;
1239			break;
1240		}
1241		if (dir == d_inode(sb->s_root)) {
1242			error = 0;
1243			break;
1244		}
1245
1246		tmp = gfs2_lookupi(dir, &gfs2_qdotdot, 1);
1247		if (!tmp) {
1248			error = -ENOENT;
1249			break;
1250		}
1251		if (IS_ERR(tmp)) {
1252			error = PTR_ERR(tmp);
1253			break;
1254		}
1255
1256		iput(dir);
1257		dir = tmp;
1258	}
1259
1260	iput(dir);
1261
1262	return error;
1263}
1264
1265/**
1266 * update_moved_ino - Update an inode that's being moved
1267 * @ip: The inode being moved
1268 * @ndip: The parent directory of the new filename
1269 * @dir_rename: True of ip is a directory
1270 *
1271 * Returns: errno
1272 */
1273
1274static int update_moved_ino(struct gfs2_inode *ip, struct gfs2_inode *ndip,
1275			    int dir_rename)
1276{
1277	int error;
1278	struct buffer_head *dibh;
1279
1280	if (dir_rename)
1281		return gfs2_dir_mvino(ip, &gfs2_qdotdot, ndip, DT_DIR);
1282
1283	error = gfs2_meta_inode_buffer(ip, &dibh);
1284	if (error)
1285		return error;
1286	ip->i_inode.i_ctime = CURRENT_TIME;
1287	gfs2_trans_add_meta(ip->i_gl, dibh);
1288	gfs2_dinode_out(ip, dibh->b_data);
1289	brelse(dibh);
1290	return 0;
1291}
1292
1293
1294/**
1295 * gfs2_rename - Rename a file
1296 * @odir: Parent directory of old file name
1297 * @odentry: The old dentry of the file
1298 * @ndir: Parent directory of new file name
1299 * @ndentry: The new dentry of the file
1300 *
1301 * Returns: errno
1302 */
1303
1304static int gfs2_rename(struct inode *odir, struct dentry *odentry,
1305		       struct inode *ndir, struct dentry *ndentry)
1306{
1307	struct gfs2_inode *odip = GFS2_I(odir);
1308	struct gfs2_inode *ndip = GFS2_I(ndir);
1309	struct gfs2_inode *ip = GFS2_I(d_inode(odentry));
1310	struct gfs2_inode *nip = NULL;
1311	struct gfs2_sbd *sdp = GFS2_SB(odir);
1312	struct gfs2_holder ghs[5], r_gh = { .gh_gl = NULL, };
1313	struct gfs2_rgrpd *nrgd;
1314	unsigned int num_gh;
1315	int dir_rename = 0;
1316	struct gfs2_diradd da = { .nr_blocks = 0, .save_loc = 0, };
1317	unsigned int x;
1318	int error;
1319
 
 
1320	if (d_really_is_positive(ndentry)) {
1321		nip = GFS2_I(d_inode(ndentry));
1322		if (ip == nip)
1323			return 0;
1324	}
1325
1326	error = gfs2_rindex_update(sdp);
1327	if (error)
1328		return error;
1329
1330	error = gfs2_rsqa_alloc(ndip);
1331	if (error)
1332		return error;
1333
1334	if (odip != ndip) {
1335		error = gfs2_glock_nq_init(sdp->sd_rename_gl, LM_ST_EXCLUSIVE,
1336					   0, &r_gh);
1337		if (error)
1338			goto out;
1339
1340		if (S_ISDIR(ip->i_inode.i_mode)) {
1341			dir_rename = 1;
1342			/* don't move a directory into its subdir */
1343			error = gfs2_ok_to_move(ip, ndip);
1344			if (error)
1345				goto out_gunlock_r;
1346		}
1347	}
1348
1349	num_gh = 1;
1350	gfs2_holder_init(odip->i_gl, LM_ST_EXCLUSIVE, 0, ghs);
1351	if (odip != ndip) {
1352		gfs2_holder_init(ndip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + num_gh);
 
1353		num_gh++;
1354	}
1355	gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + num_gh);
1356	num_gh++;
1357
1358	if (nip) {
1359		gfs2_holder_init(nip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + num_gh);
 
1360		num_gh++;
1361		/* grab the resource lock for unlink flag twiddling 
1362		 * this is the case of the target file already existing
1363		 * so we unlink before doing the rename
1364		 */
1365		nrgd = gfs2_blk2rgrpd(sdp, nip->i_no_addr, 1);
1366		if (nrgd)
1367			gfs2_holder_init(nrgd->rd_gl, LM_ST_EXCLUSIVE, 0, ghs + num_gh++);
1368	}
1369
1370	for (x = 0; x < num_gh; x++) {
1371		error = gfs2_glock_nq(ghs + x);
1372		if (error)
1373			goto out_gunlock;
1374	}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1375
1376	error = -ENOENT;
1377	if (ip->i_inode.i_nlink == 0)
1378		goto out_gunlock;
1379
1380	/* Check out the old directory */
1381
1382	error = gfs2_unlink_ok(odip, &odentry->d_name, ip);
1383	if (error)
1384		goto out_gunlock;
1385
1386	/* Check out the new directory */
1387
1388	if (nip) {
1389		error = gfs2_unlink_ok(ndip, &ndentry->d_name, nip);
1390		if (error)
1391			goto out_gunlock;
1392
1393		if (nip->i_inode.i_nlink == 0) {
1394			error = -EAGAIN;
1395			goto out_gunlock;
1396		}
1397
1398		if (S_ISDIR(nip->i_inode.i_mode)) {
1399			if (nip->i_entries < 2) {
1400				gfs2_consist_inode(nip);
1401				error = -EIO;
1402				goto out_gunlock;
1403			}
1404			if (nip->i_entries > 2) {
1405				error = -ENOTEMPTY;
1406				goto out_gunlock;
1407			}
1408		}
1409	} else {
1410		error = gfs2_permission(ndir, MAY_WRITE | MAY_EXEC);
 
1411		if (error)
1412			goto out_gunlock;
1413
1414		error = gfs2_dir_check(ndir, &ndentry->d_name, NULL);
1415		switch (error) {
1416		case -ENOENT:
1417			error = 0;
1418			break;
1419		case 0:
1420			error = -EEXIST;
 
1421		default:
1422			goto out_gunlock;
1423		};
1424
1425		if (odip != ndip) {
1426			if (!ndip->i_inode.i_nlink) {
1427				error = -ENOENT;
1428				goto out_gunlock;
1429			}
1430			if (ndip->i_entries == (u32)-1) {
1431				error = -EFBIG;
1432				goto out_gunlock;
1433			}
1434			if (S_ISDIR(ip->i_inode.i_mode) &&
1435			    ndip->i_inode.i_nlink == (u32)-1) {
1436				error = -EMLINK;
1437				goto out_gunlock;
1438			}
1439		}
1440	}
1441
1442	/* Check out the dir to be renamed */
1443
1444	if (dir_rename) {
1445		error = gfs2_permission(d_inode(odentry), MAY_WRITE);
 
1446		if (error)
1447			goto out_gunlock;
1448	}
1449
1450	if (nip == NULL) {
1451		error = gfs2_diradd_alloc_required(ndir, &ndentry->d_name, &da);
1452		if (error)
1453			goto out_gunlock;
1454	}
1455
1456	if (da.nr_blocks) {
1457		struct gfs2_alloc_parms ap = { .target = da.nr_blocks, };
1458		error = gfs2_quota_lock_check(ndip, &ap);
1459		if (error)
1460			goto out_gunlock;
1461
1462		error = gfs2_inplace_reserve(ndip, &ap);
1463		if (error)
1464			goto out_gunlock_q;
1465
1466		error = gfs2_trans_begin(sdp, gfs2_trans_da_blks(ndip, &da, 4) +
1467					 4 * RES_LEAF + 4, 0);
1468		if (error)
1469			goto out_ipreserv;
1470	} else {
1471		error = gfs2_trans_begin(sdp, 4 * RES_DINODE +
1472					 5 * RES_LEAF + 4, 0);
1473		if (error)
1474			goto out_gunlock;
1475	}
1476
1477	/* Remove the target file, if it exists */
1478
1479	if (nip)
1480		error = gfs2_unlink_inode(ndip, ndentry);
1481
1482	error = update_moved_ino(ip, ndip, dir_rename);
1483	if (error)
1484		goto out_end_trans;
1485
1486	error = gfs2_dir_del(odip, odentry);
1487	if (error)
1488		goto out_end_trans;
1489
1490	error = gfs2_dir_add(ndir, &ndentry->d_name, ip, &da);
1491	if (error)
1492		goto out_end_trans;
1493
1494out_end_trans:
1495	gfs2_trans_end(sdp);
1496out_ipreserv:
1497	if (da.nr_blocks)
1498		gfs2_inplace_release(ndip);
1499out_gunlock_q:
1500	if (da.nr_blocks)
1501		gfs2_quota_unlock(ndip);
1502out_gunlock:
1503	gfs2_dir_no_add(&da);
 
 
 
1504	while (x--) {
1505		gfs2_glock_dq(ghs + x);
 
1506		gfs2_holder_uninit(ghs + x);
1507	}
1508out_gunlock_r:
1509	if (r_gh.gh_gl)
1510		gfs2_glock_dq_uninit(&r_gh);
1511out:
 
1512	return error;
1513}
1514
1515/**
1516 * gfs2_exchange - exchange two files
1517 * @odir: Parent directory of old file name
1518 * @odentry: The old dentry of the file
1519 * @ndir: Parent directory of new file name
1520 * @ndentry: The new dentry of the file
1521 * @flags: The rename flags
1522 *
1523 * Returns: errno
1524 */
1525
1526static int gfs2_exchange(struct inode *odir, struct dentry *odentry,
1527			 struct inode *ndir, struct dentry *ndentry,
1528			 unsigned int flags)
1529{
1530	struct gfs2_inode *odip = GFS2_I(odir);
1531	struct gfs2_inode *ndip = GFS2_I(ndir);
1532	struct gfs2_inode *oip = GFS2_I(odentry->d_inode);
1533	struct gfs2_inode *nip = GFS2_I(ndentry->d_inode);
1534	struct gfs2_sbd *sdp = GFS2_SB(odir);
1535	struct gfs2_holder ghs[5], r_gh = { .gh_gl = NULL, };
1536	unsigned int num_gh;
1537	unsigned int x;
1538	umode_t old_mode = oip->i_inode.i_mode;
1539	umode_t new_mode = nip->i_inode.i_mode;
1540	int error;
1541
 
1542	error = gfs2_rindex_update(sdp);
1543	if (error)
1544		return error;
1545
1546	if (odip != ndip) {
1547		error = gfs2_glock_nq_init(sdp->sd_rename_gl, LM_ST_EXCLUSIVE,
1548					   0, &r_gh);
1549		if (error)
1550			goto out;
1551
1552		if (S_ISDIR(old_mode)) {
1553			/* don't move a directory into its subdir */
1554			error = gfs2_ok_to_move(oip, ndip);
1555			if (error)
1556				goto out_gunlock_r;
1557		}
1558
1559		if (S_ISDIR(new_mode)) {
1560			/* don't move a directory into its subdir */
1561			error = gfs2_ok_to_move(nip, odip);
1562			if (error)
1563				goto out_gunlock_r;
1564		}
1565	}
1566
1567	num_gh = 1;
1568	gfs2_holder_init(odip->i_gl, LM_ST_EXCLUSIVE, 0, ghs);
1569	if (odip != ndip) {
1570		gfs2_holder_init(ndip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + num_gh);
 
1571		num_gh++;
1572	}
1573	gfs2_holder_init(oip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + num_gh);
1574	num_gh++;
1575
1576	gfs2_holder_init(nip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + num_gh);
1577	num_gh++;
1578
1579	for (x = 0; x < num_gh; x++) {
1580		error = gfs2_glock_nq(ghs + x);
1581		if (error)
1582			goto out_gunlock;
1583	}
1584
 
 
 
 
1585	error = -ENOENT;
1586	if (oip->i_inode.i_nlink == 0 || nip->i_inode.i_nlink == 0)
1587		goto out_gunlock;
1588
1589	error = gfs2_unlink_ok(odip, &odentry->d_name, oip);
1590	if (error)
1591		goto out_gunlock;
1592	error = gfs2_unlink_ok(ndip, &ndentry->d_name, nip);
1593	if (error)
1594		goto out_gunlock;
1595
1596	if (S_ISDIR(old_mode)) {
1597		error = gfs2_permission(odentry->d_inode, MAY_WRITE);
 
1598		if (error)
1599			goto out_gunlock;
1600	}
1601	if (S_ISDIR(new_mode)) {
1602		error = gfs2_permission(ndentry->d_inode, MAY_WRITE);
 
1603		if (error)
1604			goto out_gunlock;
1605	}
1606	error = gfs2_trans_begin(sdp, 4 * RES_DINODE + 4 * RES_LEAF, 0);
1607	if (error)
1608		goto out_gunlock;
1609
1610	error = update_moved_ino(oip, ndip, S_ISDIR(old_mode));
1611	if (error)
1612		goto out_end_trans;
1613
1614	error = update_moved_ino(nip, odip, S_ISDIR(new_mode));
1615	if (error)
1616		goto out_end_trans;
1617
1618	error = gfs2_dir_mvino(ndip, &ndentry->d_name, oip,
1619			       IF2DT(old_mode));
1620	if (error)
1621		goto out_end_trans;
1622
1623	error = gfs2_dir_mvino(odip, &odentry->d_name, nip,
1624			       IF2DT(new_mode));
1625	if (error)
1626		goto out_end_trans;
1627
1628	if (odip != ndip) {
1629		if (S_ISDIR(new_mode) && !S_ISDIR(old_mode)) {
1630			inc_nlink(&odip->i_inode);
1631			drop_nlink(&ndip->i_inode);
1632		} else if (S_ISDIR(old_mode) && !S_ISDIR(new_mode)) {
1633			inc_nlink(&ndip->i_inode);
1634			drop_nlink(&odip->i_inode);
1635		}
1636	}
1637	mark_inode_dirty(&ndip->i_inode);
1638	if (odip != ndip)
1639		mark_inode_dirty(&odip->i_inode);
1640
1641out_end_trans:
1642	gfs2_trans_end(sdp);
1643out_gunlock:
1644	while (x--) {
1645		gfs2_glock_dq(ghs + x);
 
1646		gfs2_holder_uninit(ghs + x);
1647	}
1648out_gunlock_r:
1649	if (r_gh.gh_gl)
1650		gfs2_glock_dq_uninit(&r_gh);
1651out:
1652	return error;
1653}
1654
1655static int gfs2_rename2(struct inode *odir, struct dentry *odentry,
1656			struct inode *ndir, struct dentry *ndentry,
1657			unsigned int flags)
1658{
1659	flags &= ~RENAME_NOREPLACE;
1660
1661	if (flags & ~RENAME_EXCHANGE)
1662		return -EINVAL;
1663
1664	if (flags & RENAME_EXCHANGE)
1665		return gfs2_exchange(odir, odentry, ndir, ndentry, flags);
1666
1667	return gfs2_rename(odir, odentry, ndir, ndentry);
1668}
1669
1670/**
1671 * gfs2_get_link - Follow a symbolic link
1672 * @dentry: The dentry of the link
1673 * @inode: The inode of the link
1674 * @done: destructor for return value
1675 *
1676 * This can handle symlinks of any size.
1677 *
1678 * Returns: 0 on success or error code
1679 */
1680
1681static const char *gfs2_get_link(struct dentry *dentry,
1682				 struct inode *inode,
1683				 struct delayed_call *done)
1684{
1685	struct gfs2_inode *ip = GFS2_I(inode);
1686	struct gfs2_holder i_gh;
1687	struct buffer_head *dibh;
1688	unsigned int size;
1689	char *buf;
1690	int error;
1691
1692	if (!dentry)
1693		return ERR_PTR(-ECHILD);
1694
1695	gfs2_holder_init(ip->i_gl, LM_ST_SHARED, 0, &i_gh);
1696	error = gfs2_glock_nq(&i_gh);
1697	if (error) {
1698		gfs2_holder_uninit(&i_gh);
1699		return ERR_PTR(error);
1700	}
1701
1702	size = (unsigned int)i_size_read(&ip->i_inode);
1703	if (size == 0) {
1704		gfs2_consist_inode(ip);
1705		buf = ERR_PTR(-EIO);
1706		goto out;
1707	}
1708
1709	error = gfs2_meta_inode_buffer(ip, &dibh);
1710	if (error) {
1711		buf = ERR_PTR(error);
1712		goto out;
1713	}
1714
1715	buf = kzalloc(size + 1, GFP_NOFS);
1716	if (!buf)
1717		buf = ERR_PTR(-ENOMEM);
1718	else
1719		memcpy(buf, dibh->b_data + sizeof(struct gfs2_dinode), size);
1720	brelse(dibh);
1721out:
1722	gfs2_glock_dq_uninit(&i_gh);
1723	if (!IS_ERR(buf))
1724		set_delayed_call(done, kfree_link, buf);
1725	return buf;
1726}
1727
1728/**
1729 * gfs2_permission -
 
1730 * @inode: The inode
1731 * @mask: The mask to be tested
1732 * @flags: Indicates whether this is an RCU path walk or not
1733 *
1734 * This may be called from the VFS directly, or from within GFS2 with the
1735 * inode locked, so we look to see if the glock is already locked and only
1736 * lock the glock if its not already been done.
1737 *
1738 * Returns: errno
1739 */
1740
1741int gfs2_permission(struct inode *inode, int mask)
 
1742{
 
1743	struct gfs2_inode *ip;
1744	struct gfs2_holder i_gh;
 
1745	int error;
1746	int unlock = 0;
1747
1748
 
1749	ip = GFS2_I(inode);
1750	if (gfs2_glock_is_locked_by_me(ip->i_gl) == NULL) {
1751		if (mask & MAY_NOT_BLOCK)
 
 
 
 
 
 
1752			return -ECHILD;
1753		error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, &i_gh);
1754		if (error)
1755			return error;
1756		unlock = 1;
1757	}
1758
1759	if ((mask & MAY_WRITE) && IS_IMMUTABLE(inode))
1760		error = -EACCES;
1761	else
1762		error = generic_permission(inode, mask);
1763	if (unlock)
1764		gfs2_glock_dq_uninit(&i_gh);
1765
1766	return error;
1767}
1768
1769static int __gfs2_setattr_simple(struct inode *inode, struct iattr *attr)
1770{
1771	setattr_copy(inode, attr);
1772	mark_inode_dirty(inode);
1773	return 0;
1774}
1775
1776/**
1777 * gfs2_setattr_simple -
1778 * @ip:
1779 * @attr:
1780 *
1781 * Returns: errno
1782 */
1783
1784int gfs2_setattr_simple(struct inode *inode, struct iattr *attr)
1785{
1786	int error;
1787
1788	if (current->journal_info)
1789		return __gfs2_setattr_simple(inode, attr);
1790
1791	error = gfs2_trans_begin(GFS2_SB(inode), RES_DINODE, 0);
1792	if (error)
1793		return error;
1794
1795	error = __gfs2_setattr_simple(inode, attr);
1796	gfs2_trans_end(GFS2_SB(inode));
1797	return error;
1798}
1799
1800static int setattr_chown(struct inode *inode, struct iattr *attr)
1801{
1802	struct gfs2_inode *ip = GFS2_I(inode);
1803	struct gfs2_sbd *sdp = GFS2_SB(inode);
1804	kuid_t ouid, nuid;
1805	kgid_t ogid, ngid;
1806	int error;
1807	struct gfs2_alloc_parms ap;
1808
1809	ouid = inode->i_uid;
1810	ogid = inode->i_gid;
1811	nuid = attr->ia_uid;
1812	ngid = attr->ia_gid;
1813
1814	if (!(attr->ia_valid & ATTR_UID) || uid_eq(ouid, nuid))
1815		ouid = nuid = NO_UID_QUOTA_CHANGE;
1816	if (!(attr->ia_valid & ATTR_GID) || gid_eq(ogid, ngid))
1817		ogid = ngid = NO_GID_QUOTA_CHANGE;
1818
1819	error = gfs2_rsqa_alloc(ip);
1820	if (error)
1821		goto out;
1822
1823	error = gfs2_rindex_update(sdp);
1824	if (error)
1825		goto out;
1826
1827	error = gfs2_quota_lock(ip, nuid, ngid);
1828	if (error)
1829		goto out;
1830
1831	ap.target = gfs2_get_inode_blocks(&ip->i_inode);
1832
1833	if (!uid_eq(ouid, NO_UID_QUOTA_CHANGE) ||
1834	    !gid_eq(ogid, NO_GID_QUOTA_CHANGE)) {
1835		error = gfs2_quota_check(ip, nuid, ngid, &ap);
1836		if (error)
1837			goto out_gunlock_q;
1838	}
1839
1840	error = gfs2_trans_begin(sdp, RES_DINODE + 2 * RES_QUOTA, 0);
1841	if (error)
1842		goto out_gunlock_q;
1843
1844	error = gfs2_setattr_simple(inode, attr);
1845	if (error)
1846		goto out_end_trans;
1847
1848	if (!uid_eq(ouid, NO_UID_QUOTA_CHANGE) ||
1849	    !gid_eq(ogid, NO_GID_QUOTA_CHANGE)) {
1850		gfs2_quota_change(ip, -(s64)ap.target, ouid, ogid);
1851		gfs2_quota_change(ip, ap.target, nuid, ngid);
1852	}
1853
1854out_end_trans:
1855	gfs2_trans_end(sdp);
1856out_gunlock_q:
1857	gfs2_quota_unlock(ip);
1858out:
 
1859	return error;
1860}
1861
1862/**
1863 * gfs2_setattr - Change attributes on an inode
 
1864 * @dentry: The dentry which is changing
1865 * @attr: The structure describing the change
1866 *
1867 * The VFS layer wants to change one or more of an inodes attributes.  Write
1868 * that change out to disk.
1869 *
1870 * Returns: errno
1871 */
1872
1873static int gfs2_setattr(struct dentry *dentry, struct iattr *attr)
 
1874{
1875	struct inode *inode = d_inode(dentry);
1876	struct gfs2_inode *ip = GFS2_I(inode);
1877	struct gfs2_holder i_gh;
1878	int error;
1879
1880	error = gfs2_rsqa_alloc(ip);
1881	if (error)
1882		return error;
1883
1884	error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &i_gh);
1885	if (error)
1886		return error;
1887
1888	error = -EPERM;
1889	if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
1890		goto out;
1891
1892	error = inode_change_ok(inode, attr);
1893	if (error)
1894		goto out;
 
 
 
 
1895
1896	if (attr->ia_valid & ATTR_SIZE)
1897		error = gfs2_setattr_size(inode, attr->ia_size);
1898	else if (attr->ia_valid & (ATTR_UID | ATTR_GID))
1899		error = setattr_chown(inode, attr);
1900	else {
1901		error = gfs2_setattr_simple(inode, attr);
1902		if (!error && attr->ia_valid & ATTR_MODE)
1903			error = posix_acl_chmod(inode, inode->i_mode);
 
1904	}
1905
1906out:
1907	if (!error)
1908		mark_inode_dirty(inode);
1909	gfs2_glock_dq_uninit(&i_gh);
 
 
1910	return error;
1911}
1912
1913/**
1914 * gfs2_getattr - Read out an inode's attributes
1915 * @mnt: The vfsmount the inode is being accessed from
1916 * @dentry: The dentry to stat
1917 * @stat: The inode's stats
 
 
1918 *
1919 * This may be called from the VFS directly, or from within GFS2 with the
1920 * inode locked, so we look to see if the glock is already locked and only
1921 * lock the glock if its not already been done. Note that its the NFS
1922 * readdirplus operation which causes this to be called (from filldir)
1923 * with the glock already held.
1924 *
1925 * Returns: errno
1926 */
1927
1928static int gfs2_getattr(struct vfsmount *mnt, struct dentry *dentry,
1929			struct kstat *stat)
 
1930{
1931	struct inode *inode = d_inode(dentry);
1932	struct gfs2_inode *ip = GFS2_I(inode);
1933	struct gfs2_holder gh;
 
1934	int error;
1935	int unlock = 0;
1936
 
1937	if (gfs2_glock_is_locked_by_me(ip->i_gl) == NULL) {
1938		error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, &gh);
1939		if (error)
1940			return error;
1941		unlock = 1;
1942	}
1943
1944	generic_fillattr(inode, stat);
1945	if (unlock)
 
 
 
 
 
 
 
 
 
 
 
 
 
1946		gfs2_glock_dq_uninit(&gh);
1947
1948	return 0;
1949}
1950
1951static int gfs2_setxattr(struct dentry *dentry, const char *name,
1952			 const void *data, size_t size, int flags)
1953{
1954	struct inode *inode = d_inode(dentry);
1955	struct gfs2_inode *ip = GFS2_I(inode);
1956	struct gfs2_holder gh;
1957	int ret;
1958
1959	gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);
1960	ret = gfs2_glock_nq(&gh);
1961	if (ret == 0) {
1962		ret = gfs2_rsqa_alloc(ip);
1963		if (ret == 0)
1964			ret = generic_setxattr(dentry, name, data, size, flags);
1965		gfs2_glock_dq(&gh);
1966	}
1967	gfs2_holder_uninit(&gh);
1968	return ret;
1969}
1970
1971static ssize_t gfs2_getxattr(struct dentry *dentry, const char *name,
1972			     void *data, size_t size)
1973{
1974	struct inode *inode = d_inode(dentry);
1975	struct gfs2_inode *ip = GFS2_I(inode);
1976	struct gfs2_holder gh;
1977	int ret;
1978
1979	/* For selinux during lookup */
1980	if (gfs2_glock_is_locked_by_me(ip->i_gl))
1981		return generic_getxattr(dentry, name, data, size);
1982
1983	gfs2_holder_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, &gh);
1984	ret = gfs2_glock_nq(&gh);
1985	if (ret == 0) {
1986		ret = generic_getxattr(dentry, name, data, size);
1987		gfs2_glock_dq(&gh);
1988	}
1989	gfs2_holder_uninit(&gh);
1990	return ret;
1991}
1992
1993static int gfs2_removexattr(struct dentry *dentry, const char *name)
1994{
1995	struct inode *inode = d_inode(dentry);
1996	struct gfs2_inode *ip = GFS2_I(inode);
1997	struct gfs2_holder gh;
1998	int ret;
1999
2000	gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);
2001	ret = gfs2_glock_nq(&gh);
2002	if (ret == 0) {
2003		ret = gfs2_rsqa_alloc(ip);
2004		if (ret == 0)
2005			ret = generic_removexattr(dentry, name);
2006		gfs2_glock_dq(&gh);
2007	}
2008	gfs2_holder_uninit(&gh);
2009	return ret;
2010}
2011
2012static int gfs2_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
2013		       u64 start, u64 len)
2014{
 
2015	struct gfs2_inode *ip = GFS2_I(inode);
2016	struct gfs2_holder gh;
2017	int ret;
2018
2019	ret = fiemap_check_flags(fieinfo, FIEMAP_FLAG_SYNC);
2020	if (ret)
2021		return ret;
 
 
 
2022
2023	inode_lock(inode);
 
 
 
2024
2025	ret = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, 0, &gh);
2026	if (ret)
2027		goto out;
 
 
 
2028
2029	if (gfs2_is_stuffed(ip)) {
2030		u64 phys = ip->i_no_addr << inode->i_blkbits;
2031		u64 size = i_size_read(inode);
2032		u32 flags = FIEMAP_EXTENT_LAST|FIEMAP_EXTENT_NOT_ALIGNED|
2033			    FIEMAP_EXTENT_DATA_INLINE;
2034		phys += sizeof(struct gfs2_dinode);
2035		phys += start;
2036		if (start + len > size)
2037			len = size - start;
2038		if (start < size)
2039			ret = fiemap_fill_next_extent(fieinfo, start, phys,
2040						      len, flags);
2041		if (ret == 1)
2042			ret = 0;
2043	} else {
2044		ret = __generic_block_fiemap(inode, fieinfo, start, len,
2045					     gfs2_block_map);
2046	}
2047
2048	gfs2_glock_dq_uninit(&gh);
2049out:
2050	inode_unlock(inode);
2051	return ret;
2052}
2053
2054const struct inode_operations gfs2_file_iops = {
2055	.permission = gfs2_permission,
2056	.setattr = gfs2_setattr,
2057	.getattr = gfs2_getattr,
2058	.setxattr = gfs2_setxattr,
2059	.getxattr = gfs2_getxattr,
2060	.listxattr = gfs2_listxattr,
2061	.removexattr = gfs2_removexattr,
2062	.fiemap = gfs2_fiemap,
2063	.get_acl = gfs2_get_acl,
2064	.set_acl = gfs2_set_acl,
 
 
 
2065};
2066
2067const struct inode_operations gfs2_dir_iops = {
2068	.create = gfs2_create,
2069	.lookup = gfs2_lookup,
2070	.link = gfs2_link,
2071	.unlink = gfs2_unlink,
2072	.symlink = gfs2_symlink,
2073	.mkdir = gfs2_mkdir,
2074	.rmdir = gfs2_unlink,
2075	.mknod = gfs2_mknod,
2076	.rename2 = gfs2_rename2,
2077	.permission = gfs2_permission,
2078	.setattr = gfs2_setattr,
2079	.getattr = gfs2_getattr,
2080	.setxattr = gfs2_setxattr,
2081	.getxattr = gfs2_getxattr,
2082	.listxattr = gfs2_listxattr,
2083	.removexattr = gfs2_removexattr,
2084	.fiemap = gfs2_fiemap,
2085	.get_acl = gfs2_get_acl,
2086	.set_acl = gfs2_set_acl,
 
2087	.atomic_open = gfs2_atomic_open,
 
 
2088};
2089
2090const struct inode_operations gfs2_symlink_iops = {
2091	.readlink = generic_readlink,
2092	.get_link = gfs2_get_link,
2093	.permission = gfs2_permission,
2094	.setattr = gfs2_setattr,
2095	.getattr = gfs2_getattr,
2096	.setxattr = gfs2_setxattr,
2097	.getxattr = gfs2_getxattr,
2098	.listxattr = gfs2_listxattr,
2099	.removexattr = gfs2_removexattr,
2100	.fiemap = gfs2_fiemap,
2101};
2102
v6.13.7
   1// SPDX-License-Identifier: GPL-2.0-only
   2/*
   3 * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
   4 * Copyright (C) 2004-2011 Red Hat, Inc.  All rights reserved.
 
 
 
 
   5 */
   6
   7#include <linux/slab.h>
   8#include <linux/spinlock.h>
   9#include <linux/completion.h>
  10#include <linux/buffer_head.h>
  11#include <linux/namei.h>
  12#include <linux/mm.h>
  13#include <linux/cred.h>
  14#include <linux/xattr.h>
  15#include <linux/posix_acl.h>
  16#include <linux/gfs2_ondisk.h>
  17#include <linux/crc32.h>
  18#include <linux/iomap.h>
  19#include <linux/security.h>
  20#include <linux/fiemap.h>
  21#include <linux/uaccess.h>
  22
  23#include "gfs2.h"
  24#include "incore.h"
  25#include "acl.h"
  26#include "bmap.h"
  27#include "dir.h"
  28#include "xattr.h"
  29#include "glock.h"
  30#include "inode.h"
  31#include "meta_io.h"
  32#include "quota.h"
  33#include "rgrp.h"
  34#include "trans.h"
  35#include "util.h"
  36#include "super.h"
  37#include "glops.h"
  38
  39static const struct inode_operations gfs2_file_iops;
  40static const struct inode_operations gfs2_dir_iops;
  41static const struct inode_operations gfs2_symlink_iops;
 
  42
  43/**
  44 * gfs2_set_iop - Sets inode operations
  45 * @inode: The inode with correct i_mode filled in
  46 *
  47 * GFS2 lookup code fills in vfs inode contents based on info obtained
  48 * from directory entry inside gfs2_inode_lookup().
  49 */
  50
  51static void gfs2_set_iop(struct inode *inode)
  52{
  53	struct gfs2_sbd *sdp = GFS2_SB(inode);
  54	umode_t mode = inode->i_mode;
  55
  56	if (S_ISREG(mode)) {
  57		inode->i_op = &gfs2_file_iops;
  58		if (gfs2_localflocks(sdp))
  59			inode->i_fop = &gfs2_file_fops_nolock;
  60		else
  61			inode->i_fop = &gfs2_file_fops;
  62	} else if (S_ISDIR(mode)) {
  63		inode->i_op = &gfs2_dir_iops;
  64		if (gfs2_localflocks(sdp))
  65			inode->i_fop = &gfs2_dir_fops_nolock;
  66		else
  67			inode->i_fop = &gfs2_dir_fops;
  68	} else if (S_ISLNK(mode)) {
  69		inode->i_op = &gfs2_symlink_iops;
  70	} else {
  71		inode->i_op = &gfs2_file_iops;
  72		init_special_inode(inode, inode->i_mode, inode->i_rdev);
  73	}
  74}
  75
  76static int iget_test(struct inode *inode, void *opaque)
  77{
  78	u64 no_addr = *(u64 *)opaque;
  79
  80	return GFS2_I(inode)->i_no_addr == no_addr;
  81}
  82
  83static int iget_set(struct inode *inode, void *opaque)
  84{
  85	u64 no_addr = *(u64 *)opaque;
  86
  87	GFS2_I(inode)->i_no_addr = no_addr;
  88	inode->i_ino = no_addr;
  89	return 0;
  90}
  91
  92/**
  93 * gfs2_inode_lookup - Lookup an inode
  94 * @sb: The super block
 
  95 * @type: The type of the inode
  96 * @no_addr: The inode number
  97 * @no_formal_ino: The inode generation number
  98 * @blktype: Requested block type (GFS2_BLKST_DINODE or GFS2_BLKST_UNLINKED;
  99 *           GFS2_BLKST_FREE to indicate not to verify)
 100 *
 101 * If @type is DT_UNKNOWN, the inode type is fetched from disk.
 102 *
 103 * If @blktype is anything other than GFS2_BLKST_FREE (which is used as a
 104 * placeholder because it doesn't otherwise make sense), the on-disk block type
 105 * is verified to be @blktype.
 106 *
 107 * When @no_formal_ino is non-zero, this function will return ERR_PTR(-ESTALE)
 108 * if it detects that @no_formal_ino doesn't match the actual inode generation
 109 * number.  However, it doesn't always know unless @type is DT_UNKNOWN.
 110 *
 111 * Returns: A VFS inode, or an error
 112 */
 113
 114struct inode *gfs2_inode_lookup(struct super_block *sb, unsigned int type,
 115				u64 no_addr, u64 no_formal_ino,
 116				unsigned int blktype)
 117{
 118	struct inode *inode;
 119	struct gfs2_inode *ip;
 120	struct gfs2_holder i_gh;
 121	int error;
 122
 123	gfs2_holder_mark_uninitialized(&i_gh);
 124	inode = iget5_locked(sb, no_addr, iget_test, iget_set, &no_addr);
 
 
 125	if (!inode)
 126		return ERR_PTR(-ENOMEM);
 127
 128	ip = GFS2_I(inode);
 129
 130	if (inode->i_state & I_NEW) {
 131		struct gfs2_sbd *sdp = GFS2_SB(inode);
 132		struct gfs2_glock *io_gl;
 133		int extra_flags = 0;
 134
 135		error = gfs2_glock_get(sdp, no_addr, &gfs2_inode_glops, CREATE,
 136				       &ip->i_gl);
 137		if (unlikely(error))
 138			goto fail;
 
 139
 140		error = gfs2_glock_get(sdp, no_addr, &gfs2_iopen_glops, CREATE,
 141				       &io_gl);
 142		if (unlikely(error))
 143			goto fail;
 144
 145		/*
 146		 * The only caller that sets @blktype to GFS2_BLKST_UNLINKED is
 147		 * delete_work_func().  Make sure not to cancel the delete work
 148		 * from within itself here.
 149		 */
 150		if (blktype == GFS2_BLKST_UNLINKED)
 151			extra_flags |= LM_FLAG_TRY;
 152		else
 153			gfs2_cancel_delete_work(io_gl);
 154		error = gfs2_glock_nq_init(io_gl, LM_ST_SHARED,
 155					   GL_EXACT | GL_NOPID | extra_flags,
 156					   &ip->i_iopen_gh);
 157		gfs2_glock_put(io_gl);
 158		if (unlikely(error))
 159			goto fail;
 160
 161		if (type == DT_UNKNOWN || blktype != GFS2_BLKST_FREE) {
 162			/*
 163			 * The GL_SKIP flag indicates to skip reading the inode
 164			 * block.  We read the inode when instantiating it
 165			 * after possibly checking the block type.
 166			 */
 167			error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE,
 168						   GL_SKIP, &i_gh);
 169			if (error)
 170				goto fail;
 171
 172			error = -ESTALE;
 173			if (no_formal_ino &&
 174			    gfs2_inode_already_deleted(ip->i_gl, no_formal_ino))
 175				goto fail;
 176
 177			if (blktype != GFS2_BLKST_FREE) {
 178				error = gfs2_check_blk_type(sdp, no_addr,
 179							    blktype);
 180				if (error)
 181					goto fail;
 182			}
 183		}
 184
 185		set_bit(GLF_INSTANTIATE_NEEDED, &ip->i_gl->gl_flags);
 186
 187		/* Lowest possible timestamp; will be overwritten in gfs2_dinode_in. */
 188		inode_set_atime(inode,
 189				1LL << (8 * sizeof(inode_get_atime_sec(inode)) - 1),
 190				0);
 191
 192		glock_set_object(ip->i_gl, ip);
 193
 194		if (type == DT_UNKNOWN) {
 195			/* Inode glock must be locked already */
 196			error = gfs2_instantiate(&i_gh);
 197			if (error) {
 198				glock_clear_object(ip->i_gl, ip);
 199				goto fail;
 200			}
 201		} else {
 202			ip->i_no_formal_ino = no_formal_ino;
 203			inode->i_mode = DT2IF(type);
 204		}
 205
 206		if (gfs2_holder_initialized(&i_gh))
 207			gfs2_glock_dq_uninit(&i_gh);
 208		glock_set_object(ip->i_iopen_gh.gh_gl, ip);
 209
 210		gfs2_set_iop(inode);
 211		unlock_new_inode(inode);
 212	}
 213
 214	if (no_formal_ino && ip->i_no_formal_ino &&
 215	    no_formal_ino != ip->i_no_formal_ino) {
 216		iput(inode);
 217		return ERR_PTR(-ESTALE);
 218	}
 219
 220	return inode;
 221
 
 
 
 
 
 
 
 
 
 
 222fail:
 223	if (error == GLR_TRYFAILED)
 224		error = -EAGAIN;
 225	if (gfs2_holder_initialized(&ip->i_iopen_gh))
 226		gfs2_glock_dq_uninit(&ip->i_iopen_gh);
 227	if (gfs2_holder_initialized(&i_gh))
 228		gfs2_glock_dq_uninit(&i_gh);
 229	if (ip->i_gl) {
 230		gfs2_glock_put(ip->i_gl);
 231		ip->i_gl = NULL;
 232	}
 233	iget_failed(inode);
 234	return ERR_PTR(error);
 235}
 236
 237/**
 238 * gfs2_lookup_by_inum - look up an inode by inode number
 239 * @sdp: The super block
 240 * @no_addr: The inode number
 241 * @no_formal_ino: The inode generation number (0 for any)
 242 * @blktype: Requested block type (see gfs2_inode_lookup)
 243 */
 244struct inode *gfs2_lookup_by_inum(struct gfs2_sbd *sdp, u64 no_addr,
 245				  u64 no_formal_ino, unsigned int blktype)
 246{
 247	struct super_block *sb = sdp->sd_vfs;
 248	struct inode *inode;
 
 249	int error;
 250
 251	inode = gfs2_inode_lookup(sb, DT_UNKNOWN, no_addr, no_formal_ino,
 252				  blktype);
 
 
 
 
 
 
 
 
 
 253	if (IS_ERR(inode))
 254		return inode;
 255
 
 256	if (no_formal_ino) {
 
 
 
 
 257		error = -EIO;
 258		if (GFS2_I(inode)->i_diskflags & GFS2_DIF_SYSTEM)
 259			goto fail_iput;
 
 
 260	}
 261	return inode;
 262
 
 
 
 263fail_iput:
 264	iput(inode);
 265	return ERR_PTR(error);
 266}
 267
 268
 269/**
 270 * gfs2_lookup_meta - Look up an inode in a metadata directory
 271 * @dip: The directory
 272 * @name: The name of the inode
 273 */
 274struct inode *gfs2_lookup_meta(struct inode *dip, const char *name)
 275{
 276	struct qstr qstr;
 277	struct inode *inode;
 278
 279	gfs2_str2qstr(&qstr, name);
 280	inode = gfs2_lookupi(dip, &qstr, 1);
 281	if (IS_ERR_OR_NULL(inode))
 282		return inode ? inode : ERR_PTR(-ENOENT);
 283
 284	/*
 285	 * Must not call back into the filesystem when allocating
 286	 * pages in the metadata inode's address space.
 287	 */
 288	mapping_set_gfp_mask(inode->i_mapping, GFP_NOFS);
 289
 290	return inode;
 
 291}
 292
 293
 294/**
 295 * gfs2_lookupi - Look up a filename in a directory and return its inode
 296 * @dir: The inode of the directory containing the inode to look-up
 297 * @name: The name of the inode to look for
 298 * @is_root: If 1, ignore the caller's permissions
 
 299 *
 300 * This can be called via the VFS filldir function when NFS is doing
 301 * a readdirplus and the inode which its intending to stat isn't
 302 * already in cache. In this case we must not take the directory glock
 303 * again, since the readdir call will have already taken that lock.
 304 *
 305 * Returns: errno
 306 */
 307
 308struct inode *gfs2_lookupi(struct inode *dir, const struct qstr *name,
 309			   int is_root)
 310{
 311	struct super_block *sb = dir->i_sb;
 312	struct gfs2_inode *dip = GFS2_I(dir);
 313	struct gfs2_holder d_gh;
 314	int error = 0;
 315	struct inode *inode = NULL;
 
 316
 317	gfs2_holder_mark_uninitialized(&d_gh);
 318	if (!name->len || name->len > GFS2_FNAMESIZE)
 319		return ERR_PTR(-ENAMETOOLONG);
 320
 321	if ((name->len == 1 && memcmp(name->name, ".", 1) == 0) ||
 322	    (name->len == 2 && memcmp(name->name, "..", 2) == 0 &&
 323	     dir == d_inode(sb->s_root))) {
 324		igrab(dir);
 325		return dir;
 326	}
 327
 328	if (gfs2_glock_is_locked_by_me(dip->i_gl) == NULL) {
 329		error = gfs2_glock_nq_init(dip->i_gl, LM_ST_SHARED, 0, &d_gh);
 330		if (error)
 331			return ERR_PTR(error);
 
 332	}
 333
 334	if (!is_root) {
 335		error = gfs2_permission(&nop_mnt_idmap, dir, MAY_EXEC);
 336		if (error)
 337			goto out;
 338	}
 339
 340	inode = gfs2_dir_search(dir, name, false);
 341	if (IS_ERR(inode))
 342		error = PTR_ERR(inode);
 343out:
 344	if (gfs2_holder_initialized(&d_gh))
 345		gfs2_glock_dq_uninit(&d_gh);
 346	if (error == -ENOENT)
 347		return NULL;
 348	return inode ? inode : ERR_PTR(error);
 349}
 350
 351/**
 352 * create_ok - OK to create a new on-disk inode here?
 353 * @dip:  Directory in which dinode is to be created
 354 * @name:  Name of new dinode
 355 * @mode:
 356 *
 357 * Returns: errno
 358 */
 359
 360static int create_ok(struct gfs2_inode *dip, const struct qstr *name,
 361		     umode_t mode)
 362{
 363	int error;
 364
 365	error = gfs2_permission(&nop_mnt_idmap, &dip->i_inode,
 366				MAY_WRITE | MAY_EXEC);
 367	if (error)
 368		return error;
 369
 370	/*  Don't create entries in an unlinked directory  */
 371	if (!dip->i_inode.i_nlink)
 372		return -ENOENT;
 373
 374	if (dip->i_entries == (u32)-1)
 375		return -EFBIG;
 376	if (S_ISDIR(mode) && dip->i_inode.i_nlink == (u32)-1)
 377		return -EMLINK;
 378
 379	return 0;
 380}
 381
 382static void munge_mode_uid_gid(const struct gfs2_inode *dip,
 383			       struct inode *inode)
 384{
 385	if (GFS2_SB(&dip->i_inode)->sd_args.ar_suiddir &&
 386	    (dip->i_inode.i_mode & S_ISUID) &&
 387	    !uid_eq(dip->i_inode.i_uid, GLOBAL_ROOT_UID)) {
 388		if (S_ISDIR(inode->i_mode))
 389			inode->i_mode |= S_ISUID;
 390		else if (!uid_eq(dip->i_inode.i_uid, current_fsuid()))
 391			inode->i_mode &= ~07111;
 392		inode->i_uid = dip->i_inode.i_uid;
 393	} else
 394		inode->i_uid = current_fsuid();
 395
 396	if (dip->i_inode.i_mode & S_ISGID) {
 397		if (S_ISDIR(inode->i_mode))
 398			inode->i_mode |= S_ISGID;
 399		inode->i_gid = dip->i_inode.i_gid;
 400	} else
 401		inode->i_gid = current_fsgid();
 402}
 403
 404static int alloc_dinode(struct gfs2_inode *ip, u32 flags, unsigned *dblocks)
 405{
 406	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
 407	struct gfs2_alloc_parms ap = { .target = *dblocks, .aflags = flags, };
 408	int error;
 409
 410	error = gfs2_quota_lock_check(ip, &ap);
 411	if (error)
 412		goto out;
 413
 414	error = gfs2_inplace_reserve(ip, &ap);
 415	if (error)
 416		goto out_quota;
 417
 418	error = gfs2_trans_begin(sdp, (*dblocks * RES_RG_BIT) + RES_STATFS + RES_QUOTA, 0);
 419	if (error)
 420		goto out_ipreserv;
 421
 422	error = gfs2_alloc_blocks(ip, &ip->i_no_addr, dblocks, 1);
 423	if (error)
 424		goto out_trans_end;
 425
 426	ip->i_no_formal_ino = ip->i_generation;
 427	ip->i_inode.i_ino = ip->i_no_addr;
 428	ip->i_goal = ip->i_no_addr;
 429	if (*dblocks > 1)
 430		ip->i_eattr = ip->i_no_addr + 1;
 431
 432out_trans_end:
 433	gfs2_trans_end(sdp);
 
 434out_ipreserv:
 435	gfs2_inplace_release(ip);
 436out_quota:
 437	gfs2_quota_unlock(ip);
 438out:
 439	return error;
 440}
 441
 442static void gfs2_init_dir(struct buffer_head *dibh,
 443			  const struct gfs2_inode *parent)
 444{
 445	struct gfs2_dinode *di = (struct gfs2_dinode *)dibh->b_data;
 446	struct gfs2_dirent *dent = (struct gfs2_dirent *)(di+1);
 447
 448	gfs2_qstr2dirent(&gfs2_qdot, GFS2_DIRENT_SIZE(gfs2_qdot.len), dent);
 449	dent->de_inum = di->di_num; /* already GFS2 endian */
 450	dent->de_type = cpu_to_be16(DT_DIR);
 451
 452	dent = (struct gfs2_dirent *)((char*)dent + GFS2_DIRENT_SIZE(1));
 453	gfs2_qstr2dirent(&gfs2_qdotdot, dibh->b_size - GFS2_DIRENT_SIZE(1) - sizeof(struct gfs2_dinode), dent);
 454	gfs2_inum_out(parent, dent);
 455	dent->de_type = cpu_to_be16(DT_DIR);
 456	
 457}
 458
 459/**
 460 * gfs2_init_xattr - Initialise an xattr block for a new inode
 461 * @ip: The inode in question
 462 *
 463 * This sets up an empty xattr block for a new inode, ready to
 464 * take any ACLs, LSM xattrs, etc.
 465 */
 466
 467static void gfs2_init_xattr(struct gfs2_inode *ip)
 468{
 469	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
 470	struct buffer_head *bh;
 471	struct gfs2_ea_header *ea;
 472
 473	bh = gfs2_meta_new(ip->i_gl, ip->i_eattr);
 474	gfs2_trans_add_meta(ip->i_gl, bh);
 475	gfs2_metatype_set(bh, GFS2_METATYPE_EA, GFS2_FORMAT_EA);
 476	gfs2_buffer_clear_tail(bh, sizeof(struct gfs2_meta_header));
 477
 478	ea = GFS2_EA_BH2FIRST(bh);
 479	ea->ea_rec_len = cpu_to_be32(sdp->sd_jbsize);
 480	ea->ea_type = GFS2_EATYPE_UNUSED;
 481	ea->ea_flags = GFS2_EAFLAG_LAST;
 482
 483	brelse(bh);
 484}
 485
 486/**
 487 * init_dinode - Fill in a new dinode structure
 488 * @dip: The directory this inode is being created in
 489 * @ip: The inode
 490 * @symname: The symlink destination (if a symlink)
 
 491 *
 492 */
 493
 494static void init_dinode(struct gfs2_inode *dip, struct gfs2_inode *ip,
 495			const char *symname)
 496{
 497	struct gfs2_dinode *di;
 498	struct buffer_head *dibh;
 499
 500	dibh = gfs2_meta_new(ip->i_gl, ip->i_no_addr);
 501	gfs2_trans_add_meta(ip->i_gl, dibh);
 502	di = (struct gfs2_dinode *)dibh->b_data;
 503	gfs2_dinode_out(ip, di);
 504
 505	di->di_major = cpu_to_be32(imajor(&ip->i_inode));
 506	di->di_minor = cpu_to_be32(iminor(&ip->i_inode));
 507	di->__pad1 = 0;
 508	di->__pad2 = 0;
 509	di->__pad3 = 0;
 510	memset(&di->__pad4, 0, sizeof(di->__pad4));
 511	memset(&di->di_reserved, 0, sizeof(di->di_reserved));
 512	gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode));
 513
 514	switch(ip->i_inode.i_mode & S_IFMT) {
 515	case S_IFDIR:
 516		gfs2_init_dir(dibh, dip);
 517		break;
 518	case S_IFLNK:
 519		memcpy(dibh->b_data + sizeof(struct gfs2_dinode), symname, ip->i_inode.i_size);
 520		break;
 521	}
 522
 523	set_buffer_uptodate(dibh);
 524	brelse(dibh);
 525}
 526
 527/**
 528 * gfs2_trans_da_blks - Calculate number of blocks to link inode
 529 * @dip: The directory we are linking into
 530 * @da: The dir add information
 531 * @nr_inodes: The number of inodes involved
 532 *
 533 * This calculate the number of blocks we need to reserve in a
 534 * transaction to link @nr_inodes into a directory. In most cases
 535 * @nr_inodes will be 2 (the directory plus the inode being linked in)
 536 * but in case of rename, 4 may be required.
 537 *
 538 * Returns: Number of blocks
 539 */
 540
 541static unsigned gfs2_trans_da_blks(const struct gfs2_inode *dip,
 542				   const struct gfs2_diradd *da,
 543				   unsigned nr_inodes)
 544{
 545	return da->nr_blocks + gfs2_rg_blocks(dip, da->nr_blocks) +
 546	       (nr_inodes * RES_DINODE) + RES_QUOTA + RES_STATFS;
 547}
 548
 549static int link_dinode(struct gfs2_inode *dip, const struct qstr *name,
 550		       struct gfs2_inode *ip, struct gfs2_diradd *da)
 551{
 552	struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
 553	struct gfs2_alloc_parms ap = { .target = da->nr_blocks, };
 554	int error;
 555
 556	if (da->nr_blocks) {
 557		error = gfs2_quota_lock_check(dip, &ap);
 558		if (error)
 559			goto fail_quota_locks;
 560
 561		error = gfs2_inplace_reserve(dip, &ap);
 562		if (error)
 563			goto fail_quota_locks;
 564
 565		error = gfs2_trans_begin(sdp, gfs2_trans_da_blks(dip, da, 2), 0);
 566		if (error)
 567			goto fail_ipreserv;
 568	} else {
 569		error = gfs2_trans_begin(sdp, RES_LEAF + 2 * RES_DINODE, 0);
 570		if (error)
 571			goto fail_quota_locks;
 572	}
 573
 574	error = gfs2_dir_add(&dip->i_inode, name, ip, da);
 575
 576	gfs2_trans_end(sdp);
 577fail_ipreserv:
 578	gfs2_inplace_release(dip);
 579fail_quota_locks:
 580	gfs2_quota_unlock(dip);
 581	return error;
 582}
 583
 584static int gfs2_initxattrs(struct inode *inode, const struct xattr *xattr_array,
 585		    void *fs_info)
 586{
 587	const struct xattr *xattr;
 588	int err = 0;
 589
 590	for (xattr = xattr_array; xattr->name != NULL; xattr++) {
 591		err = __gfs2_xattr_set(inode, xattr->name, xattr->value,
 592				       xattr->value_len, 0,
 593				       GFS2_EATYPE_SECURITY);
 594		if (err < 0)
 595			break;
 596	}
 597	return err;
 598}
 599
 600/**
 601 * gfs2_create_inode - Create a new inode
 602 * @dir: The parent directory
 603 * @dentry: The new dentry
 604 * @file: If non-NULL, the file which is being opened
 605 * @mode: The permissions on the new inode
 606 * @dev: For device nodes, this is the device number
 607 * @symname: For symlinks, this is the link destination
 608 * @size: The initial size of the inode (ignored for directories)
 609 * @excl: Force fail if inode exists
 610 *
 611 * FIXME: Change to allocate the disk blocks and write them out in the same
 612 * transaction.  That way, we can no longer end up in a situation in which an
 613 * inode is allocated, the node crashes, and the block looks like a valid
 614 * inode.  (With atomic creates in place, we will also no longer need to zero
 615 * the link count and dirty the inode here on failure.)
 616 *
 617 * Returns: 0 on success, or error code
 618 */
 619
 620static int gfs2_create_inode(struct inode *dir, struct dentry *dentry,
 621			     struct file *file,
 622			     umode_t mode, dev_t dev, const char *symname,
 623			     unsigned int size, int excl)
 624{
 625	const struct qstr *name = &dentry->d_name;
 626	struct posix_acl *default_acl, *acl;
 627	struct gfs2_holder d_gh, gh;
 628	struct inode *inode = NULL;
 629	struct gfs2_inode *dip = GFS2_I(dir), *ip;
 630	struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
 631	struct gfs2_glock *io_gl;
 632	int error;
 633	u32 aflags = 0;
 634	unsigned blocks = 1;
 635	struct gfs2_diradd da = { .bh = NULL, .save_loc = 1, };
 636
 637	if (!name->len || name->len > GFS2_FNAMESIZE)
 638		return -ENAMETOOLONG;
 639
 640	error = gfs2_qa_get(dip);
 641	if (error)
 642		return error;
 643
 644	error = gfs2_rindex_update(sdp);
 645	if (error)
 646		goto fail;
 647
 648	error = gfs2_glock_nq_init(dip->i_gl, LM_ST_EXCLUSIVE, 0, &d_gh);
 649	if (error)
 650		goto fail;
 651	gfs2_holder_mark_uninitialized(&gh);
 652
 653	error = create_ok(dip, name, mode);
 654	if (error)
 655		goto fail_gunlock;
 656
 657	inode = gfs2_dir_search(dir, &dentry->d_name, !S_ISREG(mode) || excl);
 658	error = PTR_ERR(inode);
 659	if (!IS_ERR(inode)) {
 660		if (S_ISDIR(inode->i_mode)) {
 661			iput(inode);
 662			inode = ERR_PTR(-EISDIR);
 663			goto fail_gunlock;
 664		}
 665		d_instantiate(dentry, inode);
 666		error = 0;
 667		if (file) {
 668			if (S_ISREG(inode->i_mode))
 669				error = finish_open(file, dentry, gfs2_open_common);
 670			else
 671				error = finish_no_open(file, NULL);
 672		}
 673		gfs2_glock_dq_uninit(&d_gh);
 674		goto fail;
 675	} else if (error != -ENOENT) {
 676		goto fail_gunlock;
 677	}
 678
 679	error = gfs2_diradd_alloc_required(dir, name, &da);
 680	if (error < 0)
 681		goto fail_gunlock;
 682
 683	inode = new_inode(sdp->sd_vfs);
 684	error = -ENOMEM;
 685	if (!inode)
 686		goto fail_gunlock;
 687	ip = GFS2_I(inode);
 688
 689	error = posix_acl_create(dir, &mode, &default_acl, &acl);
 690	if (error)
 691		goto fail_gunlock;
 692
 693	error = gfs2_qa_get(ip);
 
 694	if (error)
 695		goto fail_free_acls;
 696
 697	inode->i_mode = mode;
 698	set_nlink(inode, S_ISDIR(mode) ? 2 : 1);
 699	inode->i_rdev = dev;
 700	inode->i_size = size;
 701	simple_inode_init_ts(inode);
 
 702	munge_mode_uid_gid(dip, inode);
 703	check_and_update_goal(dip);
 704	ip->i_goal = dip->i_goal;
 705	ip->i_diskflags = 0;
 706	ip->i_eattr = 0;
 707	ip->i_height = 0;
 708	ip->i_depth = 0;
 709	ip->i_entries = 0;
 710	ip->i_no_addr = 0; /* Temporarily zero until real addr is assigned */
 711
 712	switch(mode & S_IFMT) {
 713	case S_IFREG:
 714		if ((dip->i_diskflags & GFS2_DIF_INHERIT_JDATA) ||
 715		    gfs2_tune_get(sdp, gt_new_files_jdata))
 716			ip->i_diskflags |= GFS2_DIF_JDATA;
 717		gfs2_set_aops(inode);
 718		break;
 719	case S_IFDIR:
 720		ip->i_diskflags |= (dip->i_diskflags & GFS2_DIF_INHERIT_JDATA);
 721		ip->i_diskflags |= GFS2_DIF_JDATA;
 722		ip->i_entries = 2;
 723		break;
 724	}
 725
 726	/* Force SYSTEM flag on all files and subdirs of a SYSTEM directory */
 727	if (dip->i_diskflags & GFS2_DIF_SYSTEM)
 728		ip->i_diskflags |= GFS2_DIF_SYSTEM;
 729
 730	gfs2_set_inode_flags(inode);
 731
 732	if ((GFS2_I(d_inode(sdp->sd_root_dir)) == dip) ||
 733	    (dip->i_diskflags & GFS2_DIF_TOPDIR))
 734		aflags |= GFS2_AF_ORLOV;
 735
 736	if (default_acl || acl)
 737		blocks++;
 738
 739	error = alloc_dinode(ip, aflags, &blocks);
 740	if (error)
 741		goto fail_free_inode;
 742
 743	gfs2_set_inode_blocks(inode, blocks);
 744
 745	error = gfs2_glock_get(sdp, ip->i_no_addr, &gfs2_inode_glops, CREATE, &ip->i_gl);
 746	if (error)
 747		goto fail_free_inode;
 748
 749	error = gfs2_glock_get(sdp, ip->i_no_addr, &gfs2_iopen_glops, CREATE, &io_gl);
 
 750	if (error)
 751		goto fail_free_inode;
 752	gfs2_cancel_delete_work(io_gl);
 753	io_gl->gl_no_formal_ino = ip->i_no_formal_ino;
 754
 755retry:
 756	error = insert_inode_locked4(inode, ip->i_no_addr, iget_test, &ip->i_no_addr);
 757	if (error == -EBUSY)
 758		goto retry;
 759	if (error)
 760		goto fail_gunlock2;
 761
 762	error = gfs2_glock_nq_init(io_gl, LM_ST_SHARED, GL_EXACT | GL_NOPID,
 763				   &ip->i_iopen_gh);
 
 
 
 
 
 
 764	if (error)
 765		goto fail_gunlock2;
 766
 767	error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, GL_SKIP, &gh);
 768	if (error)
 769		goto fail_gunlock3;
 770
 771	error = gfs2_trans_begin(sdp, blocks, 0);
 772	if (error)
 773		goto fail_gunlock3;
 774
 775	if (blocks > 1)
 776		gfs2_init_xattr(ip);
 777	init_dinode(dip, ip, symname);
 778	gfs2_trans_end(sdp);
 779
 780	glock_set_object(ip->i_gl, ip);
 781	glock_set_object(io_gl, ip);
 782	gfs2_set_iop(inode);
 
 783
 
 
 
 784	if (default_acl) {
 785		error = __gfs2_set_acl(inode, default_acl, ACL_TYPE_DEFAULT);
 786		if (error)
 787			goto fail_gunlock4;
 788		posix_acl_release(default_acl);
 789		default_acl = NULL;
 790	}
 791	if (acl) {
 792		error = __gfs2_set_acl(inode, acl, ACL_TYPE_ACCESS);
 793		if (error)
 794			goto fail_gunlock4;
 795		posix_acl_release(acl);
 796		acl = NULL;
 797	}
 798
 
 
 
 799	error = security_inode_init_security(&ip->i_inode, &dip->i_inode, name,
 800					     &gfs2_initxattrs, NULL);
 801	if (error)
 802		goto fail_gunlock4;
 803
 804	error = link_dinode(dip, name, ip, &da);
 805	if (error)
 806		goto fail_gunlock4;
 807
 808	mark_inode_dirty(inode);
 809	d_instantiate(dentry, inode);
 810	/* After instantiate, errors should result in evict which will destroy
 811	 * both inode and iopen glocks properly. */
 812	if (file) {
 813		file->f_mode |= FMODE_CREATED;
 814		error = finish_open(file, dentry, gfs2_open_common);
 815	}
 816	gfs2_glock_dq_uninit(&d_gh);
 817	gfs2_qa_put(ip);
 818	gfs2_glock_dq_uninit(&gh);
 819	gfs2_glock_put(io_gl);
 820	gfs2_qa_put(dip);
 821	unlock_new_inode(inode);
 822	return error;
 823
 824fail_gunlock4:
 825	glock_clear_object(ip->i_gl, ip);
 826	glock_clear_object(io_gl, ip);
 827fail_gunlock3:
 828	gfs2_glock_dq_uninit(&ip->i_iopen_gh);
 
 829fail_gunlock2:
 830	gfs2_glock_put(io_gl);
 
 
 831fail_free_inode:
 832	if (ip->i_gl) {
 833		gfs2_glock_put(ip->i_gl);
 834		ip->i_gl = NULL;
 835	}
 836	gfs2_rs_deltree(&ip->i_res);
 837	gfs2_qa_put(ip);
 838fail_free_acls:
 839	posix_acl_release(default_acl);
 840	posix_acl_release(acl);
 
 
 841fail_gunlock:
 842	gfs2_dir_no_add(&da);
 843	gfs2_glock_dq_uninit(&d_gh);
 844	if (!IS_ERR_OR_NULL(inode)) {
 845		set_bit(GIF_ALLOC_FAILED, &ip->i_flags);
 846		clear_nlink(inode);
 847		if (ip->i_no_addr)
 848			mark_inode_dirty(inode);
 849		if (inode->i_state & I_NEW)
 850			iget_failed(inode);
 851		else
 852			iput(inode);
 853	}
 854	if (gfs2_holder_initialized(&gh))
 855		gfs2_glock_dq_uninit(&gh);
 856fail:
 857	gfs2_qa_put(dip);
 858	return error;
 859}
 860
 861/**
 862 * gfs2_create - Create a file
 863 * @idmap: idmap of the mount the inode was found from
 864 * @dir: The directory in which to create the file
 865 * @dentry: The dentry of the new file
 866 * @mode: The mode of the new file
 867 * @excl: Force fail if inode exists
 868 *
 869 * Returns: errno
 870 */
 871
 872static int gfs2_create(struct mnt_idmap *idmap, struct inode *dir,
 873		       struct dentry *dentry, umode_t mode, bool excl)
 874{
 875	return gfs2_create_inode(dir, dentry, NULL, S_IFREG | mode, 0, NULL, 0, excl);
 876}
 877
 878/**
 879 * __gfs2_lookup - Look up a filename in a directory and return its inode
 880 * @dir: The directory inode
 881 * @dentry: The dentry of the new inode
 882 * @file: File to be opened
 
 883 *
 884 *
 885 * Returns: errno
 886 */
 887
 888static struct dentry *__gfs2_lookup(struct inode *dir, struct dentry *dentry,
 889				    struct file *file)
 890{
 891	struct inode *inode;
 892	struct dentry *d;
 893	struct gfs2_holder gh;
 894	struct gfs2_glock *gl;
 895	int error;
 896
 897	inode = gfs2_lookupi(dir, &dentry->d_name, 0);
 898	if (inode == NULL) {
 899		d_add(dentry, NULL);
 900		return NULL;
 901	}
 902	if (IS_ERR(inode))
 903		return ERR_CAST(inode);
 904
 905	gl = GFS2_I(inode)->i_gl;
 906	error = gfs2_glock_nq_init(gl, LM_ST_SHARED, LM_FLAG_ANY, &gh);
 907	if (error) {
 908		iput(inode);
 909		return ERR_PTR(error);
 910	}
 911
 912	d = d_splice_alias(inode, dentry);
 913	if (IS_ERR(d)) {
 914		gfs2_glock_dq_uninit(&gh);
 915		return d;
 916	}
 917	if (file && S_ISREG(inode->i_mode))
 918		error = finish_open(file, dentry, gfs2_open_common);
 919
 920	gfs2_glock_dq_uninit(&gh);
 921	if (error) {
 922		dput(d);
 923		return ERR_PTR(error);
 924	}
 925	return d;
 926}
 927
 928static struct dentry *gfs2_lookup(struct inode *dir, struct dentry *dentry,
 929				  unsigned flags)
 930{
 931	return __gfs2_lookup(dir, dentry, NULL);
 932}
 933
 934/**
 935 * gfs2_link - Link to a file
 936 * @old_dentry: The inode to link
 937 * @dir: Add link to this directory
 938 * @dentry: The name of the link
 939 *
 940 * Link the inode in "old_dentry" into the directory "dir" with the
 941 * name in "dentry".
 942 *
 943 * Returns: errno
 944 */
 945
 946static int gfs2_link(struct dentry *old_dentry, struct inode *dir,
 947		     struct dentry *dentry)
 948{
 949	struct gfs2_inode *dip = GFS2_I(dir);
 950	struct gfs2_sbd *sdp = GFS2_SB(dir);
 951	struct inode *inode = d_inode(old_dentry);
 952	struct gfs2_inode *ip = GFS2_I(inode);
 953	struct gfs2_holder d_gh, gh;
 954	struct buffer_head *dibh;
 955	struct gfs2_diradd da = { .bh = NULL, .save_loc = 1, };
 956	int error;
 957
 958	if (S_ISDIR(inode->i_mode))
 959		return -EPERM;
 960
 961	error = gfs2_qa_get(dip);
 962	if (error)
 963		return error;
 964
 965	gfs2_holder_init(dip->i_gl, LM_ST_EXCLUSIVE, 0, &d_gh);
 966	gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);
 967
 968	error = gfs2_glock_nq(&d_gh);
 969	if (error)
 970		goto out_parent;
 971
 972	error = gfs2_glock_nq(&gh);
 973	if (error)
 974		goto out_child;
 975
 976	error = -ENOENT;
 977	if (inode->i_nlink == 0)
 978		goto out_gunlock;
 979
 980	error = gfs2_permission(&nop_mnt_idmap, dir, MAY_WRITE | MAY_EXEC);
 981	if (error)
 982		goto out_gunlock;
 983
 984	error = gfs2_dir_check(dir, &dentry->d_name, NULL);
 985	switch (error) {
 986	case -ENOENT:
 987		break;
 988	case 0:
 989		error = -EEXIST;
 990		goto out_gunlock;
 991	default:
 992		goto out_gunlock;
 993	}
 994
 995	error = -EINVAL;
 996	if (!dip->i_inode.i_nlink)
 997		goto out_gunlock;
 998	error = -EFBIG;
 999	if (dip->i_entries == (u32)-1)
1000		goto out_gunlock;
1001	error = -EPERM;
1002	if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
1003		goto out_gunlock;
 
 
 
1004	error = -EMLINK;
1005	if (ip->i_inode.i_nlink == (u32)-1)
1006		goto out_gunlock;
1007
1008	error = gfs2_diradd_alloc_required(dir, &dentry->d_name, &da);
1009	if (error < 0)
1010		goto out_gunlock;
1011
1012	if (da.nr_blocks) {
1013		struct gfs2_alloc_parms ap = { .target = da.nr_blocks, };
1014		error = gfs2_quota_lock_check(dip, &ap);
1015		if (error)
1016			goto out_gunlock;
1017
1018		error = gfs2_inplace_reserve(dip, &ap);
1019		if (error)
1020			goto out_gunlock_q;
1021
1022		error = gfs2_trans_begin(sdp, gfs2_trans_da_blks(dip, &da, 2), 0);
1023		if (error)
1024			goto out_ipres;
1025	} else {
1026		error = gfs2_trans_begin(sdp, 2 * RES_DINODE + RES_LEAF, 0);
1027		if (error)
1028			goto out_ipres;
1029	}
1030
1031	error = gfs2_meta_inode_buffer(ip, &dibh);
1032	if (error)
1033		goto out_end_trans;
1034
1035	error = gfs2_dir_add(dir, &dentry->d_name, ip, &da);
1036	if (error)
1037		goto out_brelse;
1038
1039	gfs2_trans_add_meta(ip->i_gl, dibh);
1040	inc_nlink(&ip->i_inode);
1041	inode_set_ctime_current(&ip->i_inode);
1042	ihold(inode);
1043	d_instantiate(dentry, inode);
1044	mark_inode_dirty(inode);
1045
1046out_brelse:
1047	brelse(dibh);
1048out_end_trans:
1049	gfs2_trans_end(sdp);
1050out_ipres:
1051	if (da.nr_blocks)
1052		gfs2_inplace_release(dip);
1053out_gunlock_q:
1054	if (da.nr_blocks)
1055		gfs2_quota_unlock(dip);
1056out_gunlock:
1057	gfs2_dir_no_add(&da);
1058	gfs2_glock_dq(&gh);
1059out_child:
1060	gfs2_glock_dq(&d_gh);
1061out_parent:
1062	gfs2_qa_put(dip);
1063	gfs2_holder_uninit(&d_gh);
1064	gfs2_holder_uninit(&gh);
1065	return error;
1066}
1067
1068/*
1069 * gfs2_unlink_ok - check to see that a inode is still in a directory
1070 * @dip: the directory
1071 * @name: the name of the file
1072 * @ip: the inode
1073 *
1074 * Assumes that the lock on (at least) @dip is held.
1075 *
1076 * Returns: 0 if the parent/child relationship is correct, errno if it isn't
1077 */
1078
1079static int gfs2_unlink_ok(struct gfs2_inode *dip, const struct qstr *name,
1080			  const struct gfs2_inode *ip)
1081{
1082	int error;
1083
1084	if (IS_IMMUTABLE(&ip->i_inode) || IS_APPEND(&ip->i_inode))
1085		return -EPERM;
1086
1087	if ((dip->i_inode.i_mode & S_ISVTX) &&
1088	    !uid_eq(dip->i_inode.i_uid, current_fsuid()) &&
1089	    !uid_eq(ip->i_inode.i_uid, current_fsuid()) && !capable(CAP_FOWNER))
1090		return -EPERM;
1091
1092	if (IS_APPEND(&dip->i_inode))
1093		return -EPERM;
1094
1095	error = gfs2_permission(&nop_mnt_idmap, &dip->i_inode,
1096				MAY_WRITE | MAY_EXEC);
1097	if (error)
1098		return error;
1099
1100	return gfs2_dir_check(&dip->i_inode, name, ip);
1101}
1102
1103/**
1104 * gfs2_unlink_inode - Removes an inode from its parent dir and unlinks it
1105 * @dip: The parent directory
1106 * @dentry: The dentry to unlink
 
1107 *
1108 * Called with all the locks and in a transaction. This will only be
1109 * called for a directory after it has been checked to ensure it is empty.
1110 *
1111 * Returns: 0 on success, or an error
1112 */
1113
1114static int gfs2_unlink_inode(struct gfs2_inode *dip,
1115			     const struct dentry *dentry)
1116{
1117	struct inode *inode = d_inode(dentry);
1118	struct gfs2_inode *ip = GFS2_I(inode);
1119	int error;
1120
1121	error = gfs2_dir_del(dip, dentry);
1122	if (error)
1123		return error;
1124
1125	ip->i_entries = 0;
1126	inode_set_ctime_current(inode);
1127	if (S_ISDIR(inode->i_mode))
1128		clear_nlink(inode);
1129	else
1130		drop_nlink(inode);
1131	mark_inode_dirty(inode);
1132	if (inode->i_nlink == 0)
1133		gfs2_unlink_di(inode);
1134	return 0;
1135}
1136
1137
1138/**
1139 * gfs2_unlink - Unlink an inode (this does rmdir as well)
1140 * @dir: The inode of the directory containing the inode to unlink
1141 * @dentry: The file itself
1142 *
1143 * This routine uses the type of the inode as a flag to figure out
1144 * whether this is an unlink or an rmdir.
1145 *
1146 * Returns: errno
1147 */
1148
1149static int gfs2_unlink(struct inode *dir, struct dentry *dentry)
1150{
1151	struct gfs2_inode *dip = GFS2_I(dir);
1152	struct gfs2_sbd *sdp = GFS2_SB(dir);
1153	struct inode *inode = d_inode(dentry);
1154	struct gfs2_inode *ip = GFS2_I(inode);
1155	struct gfs2_holder d_gh, r_gh, gh;
1156	struct gfs2_rgrpd *rgd;
1157	int error;
1158
1159	error = gfs2_rindex_update(sdp);
1160	if (error)
1161		return error;
1162
1163	error = -EROFS;
1164
1165	gfs2_holder_init(dip->i_gl, LM_ST_EXCLUSIVE, 0, &d_gh);
1166	gfs2_holder_init(ip->i_gl,  LM_ST_EXCLUSIVE, 0, &gh);
1167
1168	rgd = gfs2_blk2rgrpd(sdp, ip->i_no_addr, 1);
1169	if (!rgd)
1170		goto out_inodes;
1171
1172	gfs2_holder_init(rgd->rd_gl, LM_ST_EXCLUSIVE, LM_FLAG_NODE_SCOPE, &r_gh);
1173
1174
1175	error = gfs2_glock_nq(&d_gh);
1176	if (error)
1177		goto out_parent;
1178
1179	error = gfs2_glock_nq(&gh);
1180	if (error)
1181		goto out_child;
1182
1183	error = -ENOENT;
1184	if (inode->i_nlink == 0)
1185		goto out_rgrp;
1186
1187	if (S_ISDIR(inode->i_mode)) {
1188		error = -ENOTEMPTY;
1189		if (ip->i_entries > 2 || inode->i_nlink > 2)
1190			goto out_rgrp;
1191	}
1192
1193	error = gfs2_glock_nq(&r_gh); /* rgrp */
1194	if (error)
1195		goto out_rgrp;
1196
1197	error = gfs2_unlink_ok(dip, &dentry->d_name, ip);
1198	if (error)
1199		goto out_gunlock;
1200
1201	error = gfs2_trans_begin(sdp, 2*RES_DINODE + 3*RES_LEAF + RES_RG_BIT, 0);
1202	if (error)
1203		goto out_gunlock;
1204
1205	error = gfs2_unlink_inode(dip, dentry);
 
 
1206	gfs2_trans_end(sdp);
1207
1208out_gunlock:
1209	gfs2_glock_dq(&r_gh);
1210out_rgrp:
1211	gfs2_glock_dq(&gh);
1212out_child:
1213	gfs2_glock_dq(&d_gh);
1214out_parent:
1215	gfs2_holder_uninit(&r_gh);
1216out_inodes:
1217	gfs2_holder_uninit(&gh);
1218	gfs2_holder_uninit(&d_gh);
1219	return error;
1220}
1221
1222/**
1223 * gfs2_symlink - Create a symlink
1224 * @idmap: idmap of the mount the inode was found from
1225 * @dir: The directory to create the symlink in
1226 * @dentry: The dentry to put the symlink in
1227 * @symname: The thing which the link points to
1228 *
1229 * Returns: errno
1230 */
1231
1232static int gfs2_symlink(struct mnt_idmap *idmap, struct inode *dir,
1233			struct dentry *dentry, const char *symname)
1234{
 
1235	unsigned int size;
1236
1237	size = strlen(symname);
1238	if (size >= gfs2_max_stuffed_size(GFS2_I(dir)))
1239		return -ENAMETOOLONG;
1240
1241	return gfs2_create_inode(dir, dentry, NULL, S_IFLNK | S_IRWXUGO, 0, symname, size, 0);
1242}
1243
1244/**
1245 * gfs2_mkdir - Make a directory
1246 * @idmap: idmap of the mount the inode was found from
1247 * @dir: The parent directory of the new one
1248 * @dentry: The dentry of the new directory
1249 * @mode: The mode of the new directory
1250 *
1251 * Returns: errno
1252 */
1253
1254static int gfs2_mkdir(struct mnt_idmap *idmap, struct inode *dir,
1255		      struct dentry *dentry, umode_t mode)
1256{
1257	unsigned dsize = gfs2_max_stuffed_size(GFS2_I(dir));
1258	return gfs2_create_inode(dir, dentry, NULL, S_IFDIR | mode, 0, NULL, dsize, 0);
 
1259}
1260
1261/**
1262 * gfs2_mknod - Make a special file
1263 * @idmap: idmap of the mount the inode was found from
1264 * @dir: The directory in which the special file will reside
1265 * @dentry: The dentry of the special file
1266 * @mode: The mode of the special file
1267 * @dev: The device specification of the special file
1268 *
1269 */
1270
1271static int gfs2_mknod(struct mnt_idmap *idmap, struct inode *dir,
1272		      struct dentry *dentry, umode_t mode, dev_t dev)
1273{
1274	return gfs2_create_inode(dir, dentry, NULL, mode, dev, NULL, 0, 0);
1275}
1276
1277/**
1278 * gfs2_atomic_open - Atomically open a file
1279 * @dir: The directory
1280 * @dentry: The proposed new entry
1281 * @file: The proposed new struct file
1282 * @flags: open flags
1283 * @mode: File mode
 
1284 *
1285 * Returns: error code or 0 for success
1286 */
1287
1288static int gfs2_atomic_open(struct inode *dir, struct dentry *dentry,
1289			    struct file *file, unsigned flags,
1290			    umode_t mode)
1291{
1292	struct dentry *d;
1293	bool excl = !!(flags & O_EXCL);
1294
1295	if (!d_in_lookup(dentry))
1296		goto skip_lookup;
1297
1298	d = __gfs2_lookup(dir, dentry, file);
1299	if (IS_ERR(d))
1300		return PTR_ERR(d);
1301	if (d != NULL)
1302		dentry = d;
1303	if (d_really_is_positive(dentry)) {
1304		if (!(file->f_mode & FMODE_OPENED))
1305			return finish_no_open(file, d);
1306		dput(d);
1307		return excl && (flags & O_CREAT) ? -EEXIST : 0;
1308	}
1309
1310	BUG_ON(d != NULL);
1311
1312skip_lookup:
1313	if (!(flags & O_CREAT))
1314		return -ENOENT;
1315
1316	return gfs2_create_inode(dir, dentry, file, S_IFREG | mode, 0, NULL, 0, excl);
1317}
1318
1319/*
1320 * gfs2_ok_to_move - check if it's ok to move a directory to another directory
1321 * @this: move this
1322 * @to: to here
1323 *
1324 * Follow @to back to the root and make sure we don't encounter @this
1325 * Assumes we already hold the rename lock.
1326 *
1327 * Returns: errno
1328 */
1329
1330static int gfs2_ok_to_move(struct gfs2_inode *this, struct gfs2_inode *to)
1331{
1332	struct inode *dir = &to->i_inode;
1333	struct super_block *sb = dir->i_sb;
1334	struct inode *tmp;
1335	int error = 0;
1336
1337	igrab(dir);
1338
1339	for (;;) {
1340		if (dir == &this->i_inode) {
1341			error = -EINVAL;
1342			break;
1343		}
1344		if (dir == d_inode(sb->s_root)) {
1345			error = 0;
1346			break;
1347		}
1348
1349		tmp = gfs2_lookupi(dir, &gfs2_qdotdot, 1);
1350		if (!tmp) {
1351			error = -ENOENT;
1352			break;
1353		}
1354		if (IS_ERR(tmp)) {
1355			error = PTR_ERR(tmp);
1356			break;
1357		}
1358
1359		iput(dir);
1360		dir = tmp;
1361	}
1362
1363	iput(dir);
1364
1365	return error;
1366}
1367
1368/**
1369 * update_moved_ino - Update an inode that's being moved
1370 * @ip: The inode being moved
1371 * @ndip: The parent directory of the new filename
1372 * @dir_rename: True of ip is a directory
1373 *
1374 * Returns: errno
1375 */
1376
1377static int update_moved_ino(struct gfs2_inode *ip, struct gfs2_inode *ndip,
1378			    int dir_rename)
1379{
 
 
 
1380	if (dir_rename)
1381		return gfs2_dir_mvino(ip, &gfs2_qdotdot, ndip, DT_DIR);
1382
1383	inode_set_ctime_current(&ip->i_inode);
1384	mark_inode_dirty_sync(&ip->i_inode);
 
 
 
 
 
1385	return 0;
1386}
1387
1388
1389/**
1390 * gfs2_rename - Rename a file
1391 * @odir: Parent directory of old file name
1392 * @odentry: The old dentry of the file
1393 * @ndir: Parent directory of new file name
1394 * @ndentry: The new dentry of the file
1395 *
1396 * Returns: errno
1397 */
1398
1399static int gfs2_rename(struct inode *odir, struct dentry *odentry,
1400		       struct inode *ndir, struct dentry *ndentry)
1401{
1402	struct gfs2_inode *odip = GFS2_I(odir);
1403	struct gfs2_inode *ndip = GFS2_I(ndir);
1404	struct gfs2_inode *ip = GFS2_I(d_inode(odentry));
1405	struct gfs2_inode *nip = NULL;
1406	struct gfs2_sbd *sdp = GFS2_SB(odir);
1407	struct gfs2_holder ghs[4], r_gh, rd_gh;
1408	struct gfs2_rgrpd *nrgd;
1409	unsigned int num_gh;
1410	int dir_rename = 0;
1411	struct gfs2_diradd da = { .nr_blocks = 0, .save_loc = 0, };
1412	unsigned int x;
1413	int error;
1414
1415	gfs2_holder_mark_uninitialized(&r_gh);
1416	gfs2_holder_mark_uninitialized(&rd_gh);
1417	if (d_really_is_positive(ndentry)) {
1418		nip = GFS2_I(d_inode(ndentry));
1419		if (ip == nip)
1420			return 0;
1421	}
1422
1423	error = gfs2_rindex_update(sdp);
1424	if (error)
1425		return error;
1426
1427	error = gfs2_qa_get(ndip);
1428	if (error)
1429		return error;
1430
1431	if (odip != ndip) {
1432		error = gfs2_glock_nq_init(sdp->sd_rename_gl, LM_ST_EXCLUSIVE,
1433					   0, &r_gh);
1434		if (error)
1435			goto out;
1436
1437		if (S_ISDIR(ip->i_inode.i_mode)) {
1438			dir_rename = 1;
1439			/* don't move a directory into its subdir */
1440			error = gfs2_ok_to_move(ip, ndip);
1441			if (error)
1442				goto out_gunlock_r;
1443		}
1444	}
1445
1446	num_gh = 1;
1447	gfs2_holder_init(odip->i_gl, LM_ST_EXCLUSIVE, GL_ASYNC, ghs);
1448	if (odip != ndip) {
1449		gfs2_holder_init(ndip->i_gl, LM_ST_EXCLUSIVE,GL_ASYNC,
1450				 ghs + num_gh);
1451		num_gh++;
1452	}
1453	gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, GL_ASYNC, ghs + num_gh);
1454	num_gh++;
1455
1456	if (nip) {
1457		gfs2_holder_init(nip->i_gl, LM_ST_EXCLUSIVE, GL_ASYNC,
1458				 ghs + num_gh);
1459		num_gh++;
 
 
 
 
 
 
 
1460	}
1461
1462	for (x = 0; x < num_gh; x++) {
1463		error = gfs2_glock_nq(ghs + x);
1464		if (error)
1465			goto out_gunlock;
1466	}
1467	error = gfs2_glock_async_wait(num_gh, ghs);
1468	if (error)
1469		goto out_gunlock;
1470
1471	if (nip) {
1472		/* Grab the resource group glock for unlink flag twiddling.
1473		 * This is the case where the target dinode already exists
1474		 * so we unlink before doing the rename.
1475		 */
1476		nrgd = gfs2_blk2rgrpd(sdp, nip->i_no_addr, 1);
1477		if (!nrgd) {
1478			error = -ENOENT;
1479			goto out_gunlock;
1480		}
1481		error = gfs2_glock_nq_init(nrgd->rd_gl, LM_ST_EXCLUSIVE,
1482					   LM_FLAG_NODE_SCOPE, &rd_gh);
1483		if (error)
1484			goto out_gunlock;
1485	}
1486
1487	error = -ENOENT;
1488	if (ip->i_inode.i_nlink == 0)
1489		goto out_gunlock;
1490
1491	/* Check out the old directory */
1492
1493	error = gfs2_unlink_ok(odip, &odentry->d_name, ip);
1494	if (error)
1495		goto out_gunlock;
1496
1497	/* Check out the new directory */
1498
1499	if (nip) {
1500		error = gfs2_unlink_ok(ndip, &ndentry->d_name, nip);
1501		if (error)
1502			goto out_gunlock;
1503
1504		if (nip->i_inode.i_nlink == 0) {
1505			error = -EAGAIN;
1506			goto out_gunlock;
1507		}
1508
1509		if (S_ISDIR(nip->i_inode.i_mode)) {
1510			if (nip->i_entries < 2) {
1511				gfs2_consist_inode(nip);
1512				error = -EIO;
1513				goto out_gunlock;
1514			}
1515			if (nip->i_entries > 2) {
1516				error = -ENOTEMPTY;
1517				goto out_gunlock;
1518			}
1519		}
1520	} else {
1521		error = gfs2_permission(&nop_mnt_idmap, ndir,
1522					MAY_WRITE | MAY_EXEC);
1523		if (error)
1524			goto out_gunlock;
1525
1526		error = gfs2_dir_check(ndir, &ndentry->d_name, NULL);
1527		switch (error) {
1528		case -ENOENT:
1529			error = 0;
1530			break;
1531		case 0:
1532			error = -EEXIST;
1533			goto out_gunlock;
1534		default:
1535			goto out_gunlock;
1536		}
1537
1538		if (odip != ndip) {
1539			if (!ndip->i_inode.i_nlink) {
1540				error = -ENOENT;
1541				goto out_gunlock;
1542			}
1543			if (ndip->i_entries == (u32)-1) {
1544				error = -EFBIG;
1545				goto out_gunlock;
1546			}
1547			if (S_ISDIR(ip->i_inode.i_mode) &&
1548			    ndip->i_inode.i_nlink == (u32)-1) {
1549				error = -EMLINK;
1550				goto out_gunlock;
1551			}
1552		}
1553	}
1554
1555	/* Check out the dir to be renamed */
1556
1557	if (dir_rename) {
1558		error = gfs2_permission(&nop_mnt_idmap, d_inode(odentry),
1559					MAY_WRITE);
1560		if (error)
1561			goto out_gunlock;
1562	}
1563
1564	if (nip == NULL) {
1565		error = gfs2_diradd_alloc_required(ndir, &ndentry->d_name, &da);
1566		if (error)
1567			goto out_gunlock;
1568	}
1569
1570	if (da.nr_blocks) {
1571		struct gfs2_alloc_parms ap = { .target = da.nr_blocks, };
1572		error = gfs2_quota_lock_check(ndip, &ap);
1573		if (error)
1574			goto out_gunlock;
1575
1576		error = gfs2_inplace_reserve(ndip, &ap);
1577		if (error)
1578			goto out_gunlock_q;
1579
1580		error = gfs2_trans_begin(sdp, gfs2_trans_da_blks(ndip, &da, 4) +
1581					 4 * RES_LEAF + 4, 0);
1582		if (error)
1583			goto out_ipreserv;
1584	} else {
1585		error = gfs2_trans_begin(sdp, 4 * RES_DINODE +
1586					 5 * RES_LEAF + 4, 0);
1587		if (error)
1588			goto out_gunlock;
1589	}
1590
1591	/* Remove the target file, if it exists */
1592
1593	if (nip)
1594		error = gfs2_unlink_inode(ndip, ndentry);
1595
1596	error = update_moved_ino(ip, ndip, dir_rename);
1597	if (error)
1598		goto out_end_trans;
1599
1600	error = gfs2_dir_del(odip, odentry);
1601	if (error)
1602		goto out_end_trans;
1603
1604	error = gfs2_dir_add(ndir, &ndentry->d_name, ip, &da);
1605	if (error)
1606		goto out_end_trans;
1607
1608out_end_trans:
1609	gfs2_trans_end(sdp);
1610out_ipreserv:
1611	if (da.nr_blocks)
1612		gfs2_inplace_release(ndip);
1613out_gunlock_q:
1614	if (da.nr_blocks)
1615		gfs2_quota_unlock(ndip);
1616out_gunlock:
1617	gfs2_dir_no_add(&da);
1618	if (gfs2_holder_initialized(&rd_gh))
1619		gfs2_glock_dq_uninit(&rd_gh);
1620
1621	while (x--) {
1622		if (gfs2_holder_queued(ghs + x))
1623			gfs2_glock_dq(ghs + x);
1624		gfs2_holder_uninit(ghs + x);
1625	}
1626out_gunlock_r:
1627	if (gfs2_holder_initialized(&r_gh))
1628		gfs2_glock_dq_uninit(&r_gh);
1629out:
1630	gfs2_qa_put(ndip);
1631	return error;
1632}
1633
1634/**
1635 * gfs2_exchange - exchange two files
1636 * @odir: Parent directory of old file name
1637 * @odentry: The old dentry of the file
1638 * @ndir: Parent directory of new file name
1639 * @ndentry: The new dentry of the file
1640 * @flags: The rename flags
1641 *
1642 * Returns: errno
1643 */
1644
1645static int gfs2_exchange(struct inode *odir, struct dentry *odentry,
1646			 struct inode *ndir, struct dentry *ndentry,
1647			 unsigned int flags)
1648{
1649	struct gfs2_inode *odip = GFS2_I(odir);
1650	struct gfs2_inode *ndip = GFS2_I(ndir);
1651	struct gfs2_inode *oip = GFS2_I(odentry->d_inode);
1652	struct gfs2_inode *nip = GFS2_I(ndentry->d_inode);
1653	struct gfs2_sbd *sdp = GFS2_SB(odir);
1654	struct gfs2_holder ghs[4], r_gh;
1655	unsigned int num_gh;
1656	unsigned int x;
1657	umode_t old_mode = oip->i_inode.i_mode;
1658	umode_t new_mode = nip->i_inode.i_mode;
1659	int error;
1660
1661	gfs2_holder_mark_uninitialized(&r_gh);
1662	error = gfs2_rindex_update(sdp);
1663	if (error)
1664		return error;
1665
1666	if (odip != ndip) {
1667		error = gfs2_glock_nq_init(sdp->sd_rename_gl, LM_ST_EXCLUSIVE,
1668					   0, &r_gh);
1669		if (error)
1670			goto out;
1671
1672		if (S_ISDIR(old_mode)) {
1673			/* don't move a directory into its subdir */
1674			error = gfs2_ok_to_move(oip, ndip);
1675			if (error)
1676				goto out_gunlock_r;
1677		}
1678
1679		if (S_ISDIR(new_mode)) {
1680			/* don't move a directory into its subdir */
1681			error = gfs2_ok_to_move(nip, odip);
1682			if (error)
1683				goto out_gunlock_r;
1684		}
1685	}
1686
1687	num_gh = 1;
1688	gfs2_holder_init(odip->i_gl, LM_ST_EXCLUSIVE, GL_ASYNC, ghs);
1689	if (odip != ndip) {
1690		gfs2_holder_init(ndip->i_gl, LM_ST_EXCLUSIVE, GL_ASYNC,
1691				 ghs + num_gh);
1692		num_gh++;
1693	}
1694	gfs2_holder_init(oip->i_gl, LM_ST_EXCLUSIVE, GL_ASYNC, ghs + num_gh);
1695	num_gh++;
1696
1697	gfs2_holder_init(nip->i_gl, LM_ST_EXCLUSIVE, GL_ASYNC, ghs + num_gh);
1698	num_gh++;
1699
1700	for (x = 0; x < num_gh; x++) {
1701		error = gfs2_glock_nq(ghs + x);
1702		if (error)
1703			goto out_gunlock;
1704	}
1705
1706	error = gfs2_glock_async_wait(num_gh, ghs);
1707	if (error)
1708		goto out_gunlock;
1709
1710	error = -ENOENT;
1711	if (oip->i_inode.i_nlink == 0 || nip->i_inode.i_nlink == 0)
1712		goto out_gunlock;
1713
1714	error = gfs2_unlink_ok(odip, &odentry->d_name, oip);
1715	if (error)
1716		goto out_gunlock;
1717	error = gfs2_unlink_ok(ndip, &ndentry->d_name, nip);
1718	if (error)
1719		goto out_gunlock;
1720
1721	if (S_ISDIR(old_mode)) {
1722		error = gfs2_permission(&nop_mnt_idmap, odentry->d_inode,
1723					MAY_WRITE);
1724		if (error)
1725			goto out_gunlock;
1726	}
1727	if (S_ISDIR(new_mode)) {
1728		error = gfs2_permission(&nop_mnt_idmap, ndentry->d_inode,
1729					MAY_WRITE);
1730		if (error)
1731			goto out_gunlock;
1732	}
1733	error = gfs2_trans_begin(sdp, 4 * RES_DINODE + 4 * RES_LEAF, 0);
1734	if (error)
1735		goto out_gunlock;
1736
1737	error = update_moved_ino(oip, ndip, S_ISDIR(old_mode));
1738	if (error)
1739		goto out_end_trans;
1740
1741	error = update_moved_ino(nip, odip, S_ISDIR(new_mode));
1742	if (error)
1743		goto out_end_trans;
1744
1745	error = gfs2_dir_mvino(ndip, &ndentry->d_name, oip,
1746			       IF2DT(old_mode));
1747	if (error)
1748		goto out_end_trans;
1749
1750	error = gfs2_dir_mvino(odip, &odentry->d_name, nip,
1751			       IF2DT(new_mode));
1752	if (error)
1753		goto out_end_trans;
1754
1755	if (odip != ndip) {
1756		if (S_ISDIR(new_mode) && !S_ISDIR(old_mode)) {
1757			inc_nlink(&odip->i_inode);
1758			drop_nlink(&ndip->i_inode);
1759		} else if (S_ISDIR(old_mode) && !S_ISDIR(new_mode)) {
1760			inc_nlink(&ndip->i_inode);
1761			drop_nlink(&odip->i_inode);
1762		}
1763	}
1764	mark_inode_dirty(&ndip->i_inode);
1765	if (odip != ndip)
1766		mark_inode_dirty(&odip->i_inode);
1767
1768out_end_trans:
1769	gfs2_trans_end(sdp);
1770out_gunlock:
1771	while (x--) {
1772		if (gfs2_holder_queued(ghs + x))
1773			gfs2_glock_dq(ghs + x);
1774		gfs2_holder_uninit(ghs + x);
1775	}
1776out_gunlock_r:
1777	if (gfs2_holder_initialized(&r_gh))
1778		gfs2_glock_dq_uninit(&r_gh);
1779out:
1780	return error;
1781}
1782
1783static int gfs2_rename2(struct mnt_idmap *idmap, struct inode *odir,
1784			struct dentry *odentry, struct inode *ndir,
1785			struct dentry *ndentry, unsigned int flags)
1786{
1787	flags &= ~RENAME_NOREPLACE;
1788
1789	if (flags & ~RENAME_EXCHANGE)
1790		return -EINVAL;
1791
1792	if (flags & RENAME_EXCHANGE)
1793		return gfs2_exchange(odir, odentry, ndir, ndentry, flags);
1794
1795	return gfs2_rename(odir, odentry, ndir, ndentry);
1796}
1797
1798/**
1799 * gfs2_get_link - Follow a symbolic link
1800 * @dentry: The dentry of the link
1801 * @inode: The inode of the link
1802 * @done: destructor for return value
1803 *
1804 * This can handle symlinks of any size.
1805 *
1806 * Returns: 0 on success or error code
1807 */
1808
1809static const char *gfs2_get_link(struct dentry *dentry,
1810				 struct inode *inode,
1811				 struct delayed_call *done)
1812{
1813	struct gfs2_inode *ip = GFS2_I(inode);
1814	struct gfs2_holder i_gh;
1815	struct buffer_head *dibh;
1816	unsigned int size;
1817	char *buf;
1818	int error;
1819
1820	if (!dentry)
1821		return ERR_PTR(-ECHILD);
1822
1823	gfs2_holder_init(ip->i_gl, LM_ST_SHARED, 0, &i_gh);
1824	error = gfs2_glock_nq(&i_gh);
1825	if (error) {
1826		gfs2_holder_uninit(&i_gh);
1827		return ERR_PTR(error);
1828	}
1829
1830	size = (unsigned int)i_size_read(&ip->i_inode);
1831	if (size == 0) {
1832		gfs2_consist_inode(ip);
1833		buf = ERR_PTR(-EIO);
1834		goto out;
1835	}
1836
1837	error = gfs2_meta_inode_buffer(ip, &dibh);
1838	if (error) {
1839		buf = ERR_PTR(error);
1840		goto out;
1841	}
1842
1843	buf = kzalloc(size + 1, GFP_NOFS);
1844	if (!buf)
1845		buf = ERR_PTR(-ENOMEM);
1846	else
1847		memcpy(buf, dibh->b_data + sizeof(struct gfs2_dinode), size);
1848	brelse(dibh);
1849out:
1850	gfs2_glock_dq_uninit(&i_gh);
1851	if (!IS_ERR(buf))
1852		set_delayed_call(done, kfree_link, buf);
1853	return buf;
1854}
1855
1856/**
1857 * gfs2_permission
1858 * @idmap: idmap of the mount the inode was found from
1859 * @inode: The inode
1860 * @mask: The mask to be tested
 
1861 *
1862 * This may be called from the VFS directly, or from within GFS2 with the
1863 * inode locked, so we look to see if the glock is already locked and only
1864 * lock the glock if its not already been done.
1865 *
1866 * Returns: errno
1867 */
1868
1869int gfs2_permission(struct mnt_idmap *idmap, struct inode *inode,
1870		    int mask)
1871{
1872	int may_not_block = mask & MAY_NOT_BLOCK;
1873	struct gfs2_inode *ip;
1874	struct gfs2_holder i_gh;
1875	struct gfs2_glock *gl;
1876	int error;
 
 
1877
1878	gfs2_holder_mark_uninitialized(&i_gh);
1879	ip = GFS2_I(inode);
1880	gl = rcu_dereference_check(ip->i_gl, !may_not_block);
1881	if (unlikely(!gl)) {
1882		/* inode is getting torn down, must be RCU mode */
1883		WARN_ON_ONCE(!may_not_block);
1884		return -ECHILD;
1885        }
1886	if (gfs2_glock_is_locked_by_me(gl) == NULL) {
1887		if (may_not_block)
1888			return -ECHILD;
1889		error = gfs2_glock_nq_init(gl, LM_ST_SHARED, LM_FLAG_ANY, &i_gh);
1890		if (error)
1891			return error;
 
1892	}
1893
1894	if ((mask & MAY_WRITE) && IS_IMMUTABLE(inode))
1895		error = -EPERM;
1896	else
1897		error = generic_permission(&nop_mnt_idmap, inode, mask);
1898	if (gfs2_holder_initialized(&i_gh))
1899		gfs2_glock_dq_uninit(&i_gh);
1900
1901	return error;
1902}
1903
1904static int __gfs2_setattr_simple(struct inode *inode, struct iattr *attr)
1905{
1906	setattr_copy(&nop_mnt_idmap, inode, attr);
1907	mark_inode_dirty(inode);
1908	return 0;
1909}
1910
1911static int gfs2_setattr_simple(struct inode *inode, struct iattr *attr)
 
 
 
 
 
 
 
 
1912{
1913	int error;
1914
1915	if (current->journal_info)
1916		return __gfs2_setattr_simple(inode, attr);
1917
1918	error = gfs2_trans_begin(GFS2_SB(inode), RES_DINODE, 0);
1919	if (error)
1920		return error;
1921
1922	error = __gfs2_setattr_simple(inode, attr);
1923	gfs2_trans_end(GFS2_SB(inode));
1924	return error;
1925}
1926
1927static int setattr_chown(struct inode *inode, struct iattr *attr)
1928{
1929	struct gfs2_inode *ip = GFS2_I(inode);
1930	struct gfs2_sbd *sdp = GFS2_SB(inode);
1931	kuid_t ouid, nuid;
1932	kgid_t ogid, ngid;
1933	int error;
1934	struct gfs2_alloc_parms ap = {};
1935
1936	ouid = inode->i_uid;
1937	ogid = inode->i_gid;
1938	nuid = attr->ia_uid;
1939	ngid = attr->ia_gid;
1940
1941	if (!(attr->ia_valid & ATTR_UID) || uid_eq(ouid, nuid))
1942		ouid = nuid = NO_UID_QUOTA_CHANGE;
1943	if (!(attr->ia_valid & ATTR_GID) || gid_eq(ogid, ngid))
1944		ogid = ngid = NO_GID_QUOTA_CHANGE;
1945	error = gfs2_qa_get(ip);
 
1946	if (error)
1947		return error;
1948
1949	error = gfs2_rindex_update(sdp);
1950	if (error)
1951		goto out;
1952
1953	error = gfs2_quota_lock(ip, nuid, ngid);
1954	if (error)
1955		goto out;
1956
1957	ap.target = gfs2_get_inode_blocks(&ip->i_inode);
1958
1959	if (!uid_eq(ouid, NO_UID_QUOTA_CHANGE) ||
1960	    !gid_eq(ogid, NO_GID_QUOTA_CHANGE)) {
1961		error = gfs2_quota_check(ip, nuid, ngid, &ap);
1962		if (error)
1963			goto out_gunlock_q;
1964	}
1965
1966	error = gfs2_trans_begin(sdp, RES_DINODE + 2 * RES_QUOTA, 0);
1967	if (error)
1968		goto out_gunlock_q;
1969
1970	error = gfs2_setattr_simple(inode, attr);
1971	if (error)
1972		goto out_end_trans;
1973
1974	if (!uid_eq(ouid, NO_UID_QUOTA_CHANGE) ||
1975	    !gid_eq(ogid, NO_GID_QUOTA_CHANGE)) {
1976		gfs2_quota_change(ip, -(s64)ap.target, ouid, ogid);
1977		gfs2_quota_change(ip, ap.target, nuid, ngid);
1978	}
1979
1980out_end_trans:
1981	gfs2_trans_end(sdp);
1982out_gunlock_q:
1983	gfs2_quota_unlock(ip);
1984out:
1985	gfs2_qa_put(ip);
1986	return error;
1987}
1988
1989/**
1990 * gfs2_setattr - Change attributes on an inode
1991 * @idmap: idmap of the mount the inode was found from
1992 * @dentry: The dentry which is changing
1993 * @attr: The structure describing the change
1994 *
1995 * The VFS layer wants to change one or more of an inodes attributes.  Write
1996 * that change out to disk.
1997 *
1998 * Returns: errno
1999 */
2000
2001static int gfs2_setattr(struct mnt_idmap *idmap,
2002			struct dentry *dentry, struct iattr *attr)
2003{
2004	struct inode *inode = d_inode(dentry);
2005	struct gfs2_inode *ip = GFS2_I(inode);
2006	struct gfs2_holder i_gh;
2007	int error;
2008
2009	error = gfs2_qa_get(ip);
2010	if (error)
2011		return error;
2012
2013	error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &i_gh);
2014	if (error)
 
 
 
 
2015		goto out;
2016
2017	error = may_setattr(&nop_mnt_idmap, inode, attr->ia_valid);
2018	if (error)
2019		goto error;
2020
2021	error = setattr_prepare(&nop_mnt_idmap, dentry, attr);
2022	if (error)
2023		goto error;
2024
2025	if (attr->ia_valid & ATTR_SIZE)
2026		error = gfs2_setattr_size(inode, attr->ia_size);
2027	else if (attr->ia_valid & (ATTR_UID | ATTR_GID))
2028		error = setattr_chown(inode, attr);
2029	else {
2030		error = gfs2_setattr_simple(inode, attr);
2031		if (!error && attr->ia_valid & ATTR_MODE)
2032			error = posix_acl_chmod(&nop_mnt_idmap, dentry,
2033						inode->i_mode);
2034	}
2035
2036error:
2037	if (!error)
2038		mark_inode_dirty(inode);
2039	gfs2_glock_dq_uninit(&i_gh);
2040out:
2041	gfs2_qa_put(ip);
2042	return error;
2043}
2044
2045/**
2046 * gfs2_getattr - Read out an inode's attributes
2047 * @idmap: idmap of the mount the inode was found from
2048 * @path: Object to query
2049 * @stat: The inode's stats
2050 * @request_mask: Mask of STATX_xxx flags indicating the caller's interests
2051 * @flags: AT_STATX_xxx setting
2052 *
2053 * This may be called from the VFS directly, or from within GFS2 with the
2054 * inode locked, so we look to see if the glock is already locked and only
2055 * lock the glock if its not already been done. Note that its the NFS
2056 * readdirplus operation which causes this to be called (from filldir)
2057 * with the glock already held.
2058 *
2059 * Returns: errno
2060 */
2061
2062static int gfs2_getattr(struct mnt_idmap *idmap,
2063			const struct path *path, struct kstat *stat,
2064			u32 request_mask, unsigned int flags)
2065{
2066	struct inode *inode = d_inode(path->dentry);
2067	struct gfs2_inode *ip = GFS2_I(inode);
2068	struct gfs2_holder gh;
2069	u32 gfsflags;
2070	int error;
 
2071
2072	gfs2_holder_mark_uninitialized(&gh);
2073	if (gfs2_glock_is_locked_by_me(ip->i_gl) == NULL) {
2074		error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, &gh);
2075		if (error)
2076			return error;
 
2077	}
2078
2079	gfsflags = ip->i_diskflags;
2080	if (gfsflags & GFS2_DIF_APPENDONLY)
2081		stat->attributes |= STATX_ATTR_APPEND;
2082	if (gfsflags & GFS2_DIF_IMMUTABLE)
2083		stat->attributes |= STATX_ATTR_IMMUTABLE;
2084
2085	stat->attributes_mask |= (STATX_ATTR_APPEND |
2086				  STATX_ATTR_COMPRESSED |
2087				  STATX_ATTR_ENCRYPTED |
2088				  STATX_ATTR_IMMUTABLE |
2089				  STATX_ATTR_NODUMP);
2090
2091	generic_fillattr(&nop_mnt_idmap, request_mask, inode, stat);
2092
2093	if (gfs2_holder_initialized(&gh))
2094		gfs2_glock_dq_uninit(&gh);
2095
2096	return 0;
2097}
2098
2099static int gfs2_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
2100		       u64 start, u64 len)
2101{
 
2102	struct gfs2_inode *ip = GFS2_I(inode);
2103	struct gfs2_holder gh;
2104	int ret;
2105
2106	inode_lock_shared(inode);
 
 
 
 
 
 
 
 
 
 
2107
2108	ret = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, 0, &gh);
2109	if (ret)
2110		goto out;
 
 
 
 
2111
2112	ret = iomap_fiemap(inode, fieinfo, start, len, &gfs2_iomap_ops);
2113
2114	gfs2_glock_dq_uninit(&gh);
2115
2116out:
2117	inode_unlock_shared(inode);
 
 
 
 
 
2118	return ret;
2119}
2120
2121loff_t gfs2_seek_data(struct file *file, loff_t offset)
2122{
2123	struct inode *inode = file->f_mapping->host;
2124	struct gfs2_inode *ip = GFS2_I(inode);
2125	struct gfs2_holder gh;
2126	loff_t ret;
2127
2128	inode_lock_shared(inode);
2129	ret = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, 0, &gh);
2130	if (!ret)
2131		ret = iomap_seek_data(inode, offset, &gfs2_iomap_ops);
2132	gfs2_glock_dq_uninit(&gh);
2133	inode_unlock_shared(inode);
2134
2135	if (ret < 0)
2136		return ret;
2137	return vfs_setpos(file, ret, inode->i_sb->s_maxbytes);
2138}
2139
2140loff_t gfs2_seek_hole(struct file *file, loff_t offset)
 
2141{
2142	struct inode *inode = file->f_mapping->host;
2143	struct gfs2_inode *ip = GFS2_I(inode);
2144	struct gfs2_holder gh;
2145	loff_t ret;
2146
2147	inode_lock_shared(inode);
2148	ret = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, 0, &gh);
2149	if (!ret)
2150		ret = iomap_seek_hole(inode, offset, &gfs2_iomap_ops);
2151	gfs2_glock_dq_uninit(&gh);
2152	inode_unlock_shared(inode);
2153
2154	if (ret < 0)
2155		return ret;
2156	return vfs_setpos(file, ret, inode->i_sb->s_maxbytes);
2157}
2158
2159static int gfs2_update_time(struct inode *inode, int flags)
2160{
2161	struct gfs2_inode *ip = GFS2_I(inode);
2162	struct gfs2_glock *gl = ip->i_gl;
2163	struct gfs2_holder *gh;
2164	int error;
2165
2166	gh = gfs2_glock_is_locked_by_me(gl);
2167	if (gh && gl->gl_state != LM_ST_EXCLUSIVE) {
2168		gfs2_glock_dq(gh);
2169		gfs2_holder_reinit(LM_ST_EXCLUSIVE, 0, gh);
2170		error = gfs2_glock_nq(gh);
2171		if (error)
2172			return error;
 
 
 
 
 
 
 
 
 
 
2173	}
2174	generic_update_time(inode, flags);
2175	return 0;
 
 
 
2176}
2177
2178static const struct inode_operations gfs2_file_iops = {
2179	.permission = gfs2_permission,
2180	.setattr = gfs2_setattr,
2181	.getattr = gfs2_getattr,
 
 
2182	.listxattr = gfs2_listxattr,
 
2183	.fiemap = gfs2_fiemap,
2184	.get_inode_acl = gfs2_get_acl,
2185	.set_acl = gfs2_set_acl,
2186	.update_time = gfs2_update_time,
2187	.fileattr_get = gfs2_fileattr_get,
2188	.fileattr_set = gfs2_fileattr_set,
2189};
2190
2191static const struct inode_operations gfs2_dir_iops = {
2192	.create = gfs2_create,
2193	.lookup = gfs2_lookup,
2194	.link = gfs2_link,
2195	.unlink = gfs2_unlink,
2196	.symlink = gfs2_symlink,
2197	.mkdir = gfs2_mkdir,
2198	.rmdir = gfs2_unlink,
2199	.mknod = gfs2_mknod,
2200	.rename = gfs2_rename2,
2201	.permission = gfs2_permission,
2202	.setattr = gfs2_setattr,
2203	.getattr = gfs2_getattr,
 
 
2204	.listxattr = gfs2_listxattr,
 
2205	.fiemap = gfs2_fiemap,
2206	.get_inode_acl = gfs2_get_acl,
2207	.set_acl = gfs2_set_acl,
2208	.update_time = gfs2_update_time,
2209	.atomic_open = gfs2_atomic_open,
2210	.fileattr_get = gfs2_fileattr_get,
2211	.fileattr_set = gfs2_fileattr_set,
2212};
2213
2214static const struct inode_operations gfs2_symlink_iops = {
 
2215	.get_link = gfs2_get_link,
2216	.permission = gfs2_permission,
2217	.setattr = gfs2_setattr,
2218	.getattr = gfs2_getattr,
 
 
2219	.listxattr = gfs2_listxattr,
 
2220	.fiemap = gfs2_fiemap,
2221};
2222