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

#include <linux/sched.h>
#include <linux/slab.h>
#include <linux/spinlock.h>
#include <linux/completion.h>
#include <linux/buffer_head.h>
#include <linux/namei.h>
#include <linux/utsname.h>
#include <linux/mm.h>
#include <linux/xattr.h>
#include <linux/posix_acl.h>
20
#include <linux/gfs2_ondisk.h>
21
#include <linux/crc32.h>
22
#include <linux/lm_interface.h>
D
David Teigland 已提交
23 24 25
#include <asm/uaccess.h>

#include "gfs2.h"
26
#include "incore.h"
D
David Teigland 已提交
27 28 29 30 31 32 33 34 35 36 37 38 39
#include "acl.h"
#include "bmap.h"
#include "dir.h"
#include "eaops.h"
#include "eattr.h"
#include "glock.h"
#include "inode.h"
#include "meta_io.h"
#include "ops_dentry.h"
#include "ops_inode.h"
#include "quota.h"
#include "rgrp.h"
#include "trans.h"
40
#include "util.h"
D
David Teigland 已提交
41 42 43 44 45 46 47 48 49 50 51 52 53

/**
 * gfs2_create - Create a file
 * @dir: The directory in which to create the file
 * @dentry: The dentry of the new file
 * @mode: The mode of the new file
 *
 * Returns: errno
 */

static int gfs2_create(struct inode *dir, struct dentry *dentry,
		       int mode, struct nameidata *nd)
{
54 55
	struct gfs2_inode *dip = GFS2_I(dir);
	struct gfs2_sbd *sdp = GFS2_SB(dir);
D
David Teigland 已提交
56 57 58 59 60 61
	struct gfs2_holder ghs[2];
	struct inode *inode;

	gfs2_holder_init(dip->i_gl, 0, 0, ghs);

	for (;;) {
62 63
		inode = gfs2_createi(ghs, &dentry->d_name, S_IFREG | mode);
		if (!IS_ERR(inode)) {
D
David Teigland 已提交
64 65 66 67 68 69
			gfs2_trans_end(sdp);
			if (dip->i_alloc.al_rgd)
				gfs2_inplace_release(dip);
			gfs2_quota_unlock(dip);
			gfs2_alloc_put(dip);
			gfs2_glock_dq_uninit_m(2, ghs);
70
			mark_inode_dirty(inode);
D
David Teigland 已提交
71
			break;
72
		} else if (PTR_ERR(inode) != -EEXIST ||
D
David Teigland 已提交
73 74
			   (nd->intent.open.flags & O_EXCL)) {
			gfs2_holder_uninit(ghs);
75
			return PTR_ERR(inode);
D
David Teigland 已提交
76 77
		}

78 79 80 81 82 83 84 85 86
		inode = gfs2_lookupi(dir, &dentry->d_name, 0, nd);
		if (inode) {
			if (!IS_ERR(inode)) {
				gfs2_holder_uninit(ghs);
				break;
			} else {
				gfs2_holder_uninit(ghs);
				return PTR_ERR(inode);
			}
D
David Teigland 已提交
87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110
		}
	}

	d_instantiate(dentry, inode);

	return 0;
}

/**
 * gfs2_lookup - Look up a filename in a directory and return its inode
 * @dir: The directory inode
 * @dentry: The dentry of the new inode
 * @nd: passed from Linux VFS, ignored by us
 *
 * Called by the VFS layer. Lock dir and call gfs2_lookupi()
 *
 * Returns: errno
 */

static struct dentry *gfs2_lookup(struct inode *dir, struct dentry *dentry,
				  struct nameidata *nd)
{
	struct inode *inode = NULL;

111
	dentry->d_op = &gfs2_dops;
D
David Teigland 已提交
112

113 114 115
	inode = gfs2_lookupi(dir, &dentry->d_name, 0, nd);
	if (inode && IS_ERR(inode))
		return ERR_PTR(PTR_ERR(inode));
D
David Teigland 已提交
116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138

	if (inode)
		return d_splice_alias(inode, dentry);
	d_add(dentry, inode);

	return NULL;
}

/**
 * gfs2_link - Link to a file
 * @old_dentry: The inode to link
 * @dir: Add link to this directory
 * @dentry: The name of the link
 *
 * Link the inode in "old_dentry" into the directory "dir" with the
 * name in "dentry".
 *
 * Returns: errno
 */

static int gfs2_link(struct dentry *old_dentry, struct inode *dir,
		     struct dentry *dentry)
{
139 140
	struct gfs2_inode *dip = GFS2_I(dir);
	struct gfs2_sbd *sdp = GFS2_SB(dir);
D
David Teigland 已提交
141
	struct inode *inode = old_dentry->d_inode;
142
	struct gfs2_inode *ip = GFS2_I(inode);
D
David Teigland 已提交
143 144 145 146 147 148 149 150 151 152 153 154 155 156
	struct gfs2_holder ghs[2];
	int alloc_required;
	int error;

	if (S_ISDIR(ip->i_di.di_mode))
		return -EPERM;

	gfs2_holder_init(dip->i_gl, LM_ST_EXCLUSIVE, 0, ghs);
	gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + 1);

	error = gfs2_glock_nq_m(2, ghs);
	if (error)
		goto out;

157
	error = permission(dir, MAY_WRITE | MAY_EXEC, NULL);
D
David Teigland 已提交
158 159 160
	if (error)
		goto out_gunlock;

161
	error = gfs2_dir_search(dir, &dentry->d_name, NULL, NULL);
D
David Teigland 已提交
162 163 164 165 166 167 168 169 170 171 172 173 174
	switch (error) {
	case -ENOENT:
		break;
	case 0:
		error = -EEXIST;
	default:
		goto out_gunlock;
	}

	error = -EINVAL;
	if (!dip->i_di.di_nlink)
		goto out_gunlock;
	error = -EFBIG;
175
	if (dip->i_di.di_entries == (u32)-1)
D
David Teigland 已提交
176 177 178 179 180 181 182 183
		goto out_gunlock;
	error = -EPERM;
	if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
		goto out_gunlock;
	error = -EINVAL;
	if (!ip->i_di.di_nlink)
		goto out_gunlock;
	error = -EMLINK;
184
	if (ip->i_di.di_nlink == (u32)-1)
D
David Teigland 已提交
185 186
		goto out_gunlock;

187 188
	alloc_required = error = gfs2_diradd_alloc_required(dir, &dentry->d_name);
	if (error < 0)
D
David Teigland 已提交
189
		goto out_gunlock;
190
	error = 0;
D
David Teigland 已提交
191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209

	if (alloc_required) {
		struct gfs2_alloc *al = gfs2_alloc_get(dip);

		error = gfs2_quota_lock(dip, NO_QUOTA_CHANGE, NO_QUOTA_CHANGE);
		if (error)
			goto out_alloc;

		error = gfs2_quota_check(dip, dip->i_di.di_uid,
					 dip->i_di.di_gid);
		if (error)
			goto out_gunlock_q;

		al->al_requested = sdp->sd_max_dirres;

		error = gfs2_inplace_reserve(dip);
		if (error)
			goto out_gunlock_q;

210
		error = gfs2_trans_begin(sdp, sdp->sd_max_dirres +
D
David Teigland 已提交
211 212 213 214 215 216 217 218 219 220 221
					 al->al_rgd->rd_ri.ri_length +
					 2 * RES_DINODE + RES_STATFS +
					 RES_QUOTA, 0);
		if (error)
			goto out_ipres;
	} else {
		error = gfs2_trans_begin(sdp, 2 * RES_DINODE + RES_LEAF, 0);
		if (error)
			goto out_ipres;
	}

222
	error = gfs2_dir_add(dir, &dentry->d_name, &ip->i_num,
D
David Teigland 已提交
223 224 225 226 227 228
			     IF2DT(ip->i_di.di_mode));
	if (error)
		goto out_end_trans;

	error = gfs2_change_nlink(ip, +1);

229
out_end_trans:
D
David Teigland 已提交
230
	gfs2_trans_end(sdp);
231
out_ipres:
D
David Teigland 已提交
232 233
	if (alloc_required)
		gfs2_inplace_release(dip);
234
out_gunlock_q:
D
David Teigland 已提交
235 236
	if (alloc_required)
		gfs2_quota_unlock(dip);
237
out_alloc:
D
David Teigland 已提交
238 239
	if (alloc_required)
		gfs2_alloc_put(dip);
240
out_gunlock:
D
David Teigland 已提交
241
	gfs2_glock_dq_m(2, ghs);
242
out:
D
David Teigland 已提交
243 244 245
	gfs2_holder_uninit(ghs);
	gfs2_holder_uninit(ghs + 1);
	if (!error) {
246
		atomic_inc(&inode->i_count);
D
David Teigland 已提交
247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264
		d_instantiate(dentry, inode);
		mark_inode_dirty(inode);
	}
	return error;
}

/**
 * gfs2_unlink - Unlink a file
 * @dir: The inode of the directory containing the file to unlink
 * @dentry: The file itself
 *
 * Unlink a file.  Call gfs2_unlinki()
 *
 * Returns: errno
 */

static int gfs2_unlink(struct inode *dir, struct dentry *dentry)
{
265 266 267
	struct gfs2_inode *dip = GFS2_I(dir);
	struct gfs2_sbd *sdp = GFS2_SB(dir);
	struct gfs2_inode *ip = GFS2_I(dentry->d_inode);
D
David Teigland 已提交
268 269 270 271 272 273 274 275 276 277 278 279 280 281
	struct gfs2_holder ghs[2];
	int error;

	gfs2_holder_init(dip->i_gl, LM_ST_EXCLUSIVE, 0, ghs);
	gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + 1);

	error = gfs2_glock_nq_m(2, ghs);
	if (error)
		goto out;

	error = gfs2_unlink_ok(dip, &dentry->d_name, ip);
	if (error)
		goto out_gunlock;

282
	error = gfs2_trans_begin(sdp, 2*RES_DINODE + RES_LEAF + RES_RG_BIT, 0);
D
David Teigland 已提交
283 284 285
	if (error)
		goto out_gunlock;

286 287 288
	error = gfs2_dir_del(dip, &dentry->d_name);
        if (error)
                goto out_end_trans;
D
David Teigland 已提交
289

290
	error = gfs2_change_nlink(ip, -1);
D
David Teigland 已提交
291

292 293 294
out_end_trans:
	gfs2_trans_end(sdp);
out_gunlock:
D
David Teigland 已提交
295
	gfs2_glock_dq_m(2, ghs);
296
out:
D
David Teigland 已提交
297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313
	gfs2_holder_uninit(ghs);
	gfs2_holder_uninit(ghs + 1);
	return error;
}

/**
 * gfs2_symlink - Create a symlink
 * @dir: The directory to create the symlink in
 * @dentry: The dentry to put the symlink in
 * @symname: The thing which the link points to
 *
 * Returns: errno
 */

static int gfs2_symlink(struct inode *dir, struct dentry *dentry,
			const char *symname)
{
314 315
	struct gfs2_inode *dip = GFS2_I(dir), *ip;
	struct gfs2_sbd *sdp = GFS2_SB(dir);
D
David Teigland 已提交
316 317 318 319 320 321 322 323 324 325 326 327 328
	struct gfs2_holder ghs[2];
	struct inode *inode;
	struct buffer_head *dibh;
	int size;
	int error;

	/* Must be stuffed with a null terminator for gfs2_follow_link() */
	size = strlen(symname);
	if (size > sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode) - 1)
		return -ENAMETOOLONG;

	gfs2_holder_init(dip->i_gl, 0, 0, ghs);

329 330
	inode = gfs2_createi(ghs, &dentry->d_name, S_IFLNK | S_IRWXUGO);
	if (IS_ERR(inode)) {
D
David Teigland 已提交
331
		gfs2_holder_uninit(ghs);
332
		return PTR_ERR(inode);
D
David Teigland 已提交
333 334
	}

335
	ip = ghs[1].gh_gl->gl_object;
D
David Teigland 已提交
336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372

	ip->i_di.di_size = size;

	error = gfs2_meta_inode_buffer(ip, &dibh);

	if (!gfs2_assert_withdraw(sdp, !error)) {
		gfs2_dinode_out(&ip->i_di, dibh->b_data);
		memcpy(dibh->b_data + sizeof(struct gfs2_dinode), symname,
		       size);
		brelse(dibh);
	}

	gfs2_trans_end(sdp);
	if (dip->i_alloc.al_rgd)
		gfs2_inplace_release(dip);
	gfs2_quota_unlock(dip);
	gfs2_alloc_put(dip);

	gfs2_glock_dq_uninit_m(2, ghs);

	d_instantiate(dentry, inode);
	mark_inode_dirty(inode);

	return 0;
}

/**
 * gfs2_mkdir - Make a directory
 * @dir: The parent directory of the new one
 * @dentry: The dentry of the new directory
 * @mode: The mode of the new directory
 *
 * Returns: errno
 */

static int gfs2_mkdir(struct inode *dir, struct dentry *dentry, int mode)
{
373 374
	struct gfs2_inode *dip = GFS2_I(dir), *ip;
	struct gfs2_sbd *sdp = GFS2_SB(dir);
D
David Teigland 已提交
375 376 377 378 379 380 381
	struct gfs2_holder ghs[2];
	struct inode *inode;
	struct buffer_head *dibh;
	int error;

	gfs2_holder_init(dip->i_gl, 0, 0, ghs);

382 383
	inode = gfs2_createi(ghs, &dentry->d_name, S_IFDIR | mode);
	if (IS_ERR(inode)) {
D
David Teigland 已提交
384
		gfs2_holder_uninit(ghs);
385
		return PTR_ERR(inode);
D
David Teigland 已提交
386 387
	}

388
	ip = ghs[1].gh_gl->gl_object;
D
David Teigland 已提交
389 390 391 392 393 394 395 396 397 398 399

	ip->i_di.di_nlink = 2;
	ip->i_di.di_size = sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode);
	ip->i_di.di_flags |= GFS2_DIF_JDATA;
	ip->i_di.di_payload_format = GFS2_FORMAT_DE;
	ip->i_di.di_entries = 2;

	error = gfs2_meta_inode_buffer(ip, &dibh);

	if (!gfs2_assert_withdraw(sdp, !error)) {
		struct gfs2_dinode *di = (struct gfs2_dinode *)dibh->b_data;
400
		struct gfs2_dirent *dent = (struct gfs2_dirent *)(di+1);
401
		struct qstr str;
D
David Teigland 已提交
402

403
		gfs2_str2qstr(&str, ".");
404 405
		gfs2_trans_add_bh(ip->i_gl, dibh, 1);
		gfs2_qstr2dirent(&str, GFS2_DIRENT_SIZE(str.len), dent);
D
David Teigland 已提交
406 407 408 409
		dent->de_inum = di->di_num; /* already GFS2 endian */
		dent->de_type = DT_DIR;
		di->di_entries = cpu_to_be32(1);

410
		gfs2_str2qstr(&str, "..");
411 412
		dent = (struct gfs2_dirent *)((char*)dent + GFS2_DIRENT_SIZE(1));
		gfs2_qstr2dirent(&str, dibh->b_size - GFS2_DIRENT_SIZE(1) - sizeof(struct gfs2_dinode), dent);
D
David Teigland 已提交
413

414
		gfs2_inum_out(&dip->i_num, &dent->de_inum);
D
David Teigland 已提交
415 416
		dent->de_type = DT_DIR;

417
		gfs2_dinode_out(&ip->i_di, di);
D
David Teigland 已提交
418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450

		brelse(dibh);
	}

	error = gfs2_change_nlink(dip, +1);
	gfs2_assert_withdraw(sdp, !error); /* dip already pinned */

	gfs2_trans_end(sdp);
	if (dip->i_alloc.al_rgd)
		gfs2_inplace_release(dip);
	gfs2_quota_unlock(dip);
	gfs2_alloc_put(dip);

	gfs2_glock_dq_uninit_m(2, ghs);

	d_instantiate(dentry, inode);
	mark_inode_dirty(inode);

	return 0;
}

/**
 * gfs2_rmdir - Remove a directory
 * @dir: The parent directory of the directory to be removed
 * @dentry: The dentry of the directory to remove
 *
 * Remove a directory. Call gfs2_rmdiri()
 *
 * Returns: errno
 */

static int gfs2_rmdir(struct inode *dir, struct dentry *dentry)
{
451 452 453
	struct gfs2_inode *dip = GFS2_I(dir);
	struct gfs2_sbd *sdp = GFS2_SB(dir);
	struct gfs2_inode *ip = GFS2_I(dentry->d_inode);
D
David Teigland 已提交
454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478
	struct gfs2_holder ghs[2];
	int error;

	gfs2_holder_init(dip->i_gl, LM_ST_EXCLUSIVE, 0, ghs);
	gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + 1);

	error = gfs2_glock_nq_m(2, ghs);
	if (error)
		goto out;

	error = gfs2_unlink_ok(dip, &dentry->d_name, ip);
	if (error)
		goto out_gunlock;

	if (ip->i_di.di_entries < 2) {
		if (gfs2_consist_inode(ip))
			gfs2_dinode_print(&ip->i_di);
		error = -EIO;
		goto out_gunlock;
	}
	if (ip->i_di.di_entries > 2) {
		error = -ENOTEMPTY;
		goto out_gunlock;
	}

479
	error = gfs2_trans_begin(sdp, 2 * RES_DINODE + 3 * RES_LEAF + RES_RG_BIT, 0);
D
David Teigland 已提交
480 481 482
	if (error)
		goto out_gunlock;

483
	error = gfs2_rmdiri(dip, &dentry->d_name, ip);
D
David Teigland 已提交
484 485 486

	gfs2_trans_end(sdp);

487
out_gunlock:
D
David Teigland 已提交
488
	gfs2_glock_dq_m(2, ghs);
489
out:
D
David Teigland 已提交
490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506
	gfs2_holder_uninit(ghs);
	gfs2_holder_uninit(ghs + 1);
	return error;
}

/**
 * gfs2_mknod - Make a special file
 * @dir: The directory in which the special file will reside
 * @dentry: The dentry of the special file
 * @mode: The mode of the special file
 * @rdev: The device specification of the special file
 *
 */

static int gfs2_mknod(struct inode *dir, struct dentry *dentry, int mode,
		      dev_t dev)
{
507 508
	struct gfs2_inode *dip = GFS2_I(dir), *ip;
	struct gfs2_sbd *sdp = GFS2_SB(dir);
D
David Teigland 已提交
509 510 511
	struct gfs2_holder ghs[2];
	struct inode *inode;
	struct buffer_head *dibh;
512
	u32 major = 0, minor = 0;
D
David Teigland 已提交
513 514 515 516 517 518 519 520 521 522 523 524
	int error;

	switch (mode & S_IFMT) {
	case S_IFBLK:
	case S_IFCHR:
		major = MAJOR(dev);
		minor = MINOR(dev);
		break;
	case S_IFIFO:
	case S_IFSOCK:
		break;
	default:
525
		return -EOPNOTSUPP;
D
David Teigland 已提交
526 527 528 529
	};

	gfs2_holder_init(dip->i_gl, 0, 0, ghs);

530 531
	inode = gfs2_createi(ghs, &dentry->d_name, mode);
	if (IS_ERR(inode)) {
D
David Teigland 已提交
532
		gfs2_holder_uninit(ghs);
533
		return PTR_ERR(inode);
D
David Teigland 已提交
534 535
	}

536
	ip = ghs[1].gh_gl->gl_object;
D
David Teigland 已提交
537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574

	ip->i_di.di_major = major;
	ip->i_di.di_minor = minor;

	error = gfs2_meta_inode_buffer(ip, &dibh);

	if (!gfs2_assert_withdraw(sdp, !error)) {
		gfs2_dinode_out(&ip->i_di, dibh->b_data);
		brelse(dibh);
	}

	gfs2_trans_end(sdp);
	if (dip->i_alloc.al_rgd)
		gfs2_inplace_release(dip);
	gfs2_quota_unlock(dip);
	gfs2_alloc_put(dip);

	gfs2_glock_dq_uninit_m(2, ghs);

	d_instantiate(dentry, inode);
	mark_inode_dirty(inode);

	return 0;
}

/**
 * gfs2_rename - Rename a file
 * @odir: Parent directory of old file name
 * @odentry: The old dentry of the file
 * @ndir: Parent directory of new file name
 * @ndentry: The new dentry of the file
 *
 * Returns: errno
 */

static int gfs2_rename(struct inode *odir, struct dentry *odentry,
		       struct inode *ndir, struct dentry *ndentry)
{
575 576 577
	struct gfs2_inode *odip = GFS2_I(odir);
	struct gfs2_inode *ndip = GFS2_I(ndir);
	struct gfs2_inode *ip = GFS2_I(odentry->d_inode);
D
David Teigland 已提交
578
	struct gfs2_inode *nip = NULL;
579
	struct gfs2_sbd *sdp = GFS2_SB(odir);
D
David Teigland 已提交
580 581 582 583 584 585 586 587
	struct gfs2_holder ghs[4], r_gh;
	unsigned int num_gh;
	int dir_rename = 0;
	int alloc_required;
	unsigned int x;
	int error;

	if (ndentry->d_inode) {
588
		nip = GFS2_I(ndentry->d_inode);
D
David Teigland 已提交
589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608
		if (ip == nip)
			return 0;
	}

	/* Make sure we aren't trying to move a dirctory into it's subdir */

	if (S_ISDIR(ip->i_di.di_mode) && odip != ndip) {
		dir_rename = 1;

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

		error = gfs2_ok_to_move(ip, ndip);
		if (error)
			goto out_gunlock_r;
	}

609
	num_gh = 1;
D
David Teigland 已提交
610
	gfs2_holder_init(odip->i_gl, LM_ST_EXCLUSIVE, 0, ghs);
611 612 613 614 615 616
	if (odip != ndip) {
		gfs2_holder_init(ndip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + num_gh);
		num_gh++;
	}
	gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + num_gh);
	num_gh++;
D
David Teigland 已提交
617

618 619 620 621
	if (nip) {
		gfs2_holder_init(nip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + num_gh);
		num_gh++;
	}
D
David Teigland 已提交
622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652

	error = gfs2_glock_nq_m(num_gh, ghs);
	if (error)
		goto out_uninit;

	/* Check out the old directory */

	error = gfs2_unlink_ok(odip, &odentry->d_name, ip);
	if (error)
		goto out_gunlock;

	/* Check out the new directory */

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

		if (S_ISDIR(nip->i_di.di_mode)) {
			if (nip->i_di.di_entries < 2) {
				if (gfs2_consist_inode(nip))
					gfs2_dinode_print(&nip->i_di);
				error = -EIO;
				goto out_gunlock;
			}
			if (nip->i_di.di_entries > 2) {
				error = -ENOTEMPTY;
				goto out_gunlock;
			}
		}
	} else {
653
		error = permission(ndir, MAY_WRITE | MAY_EXEC, NULL);
D
David Teigland 已提交
654 655 656
		if (error)
			goto out_gunlock;

657
		error = gfs2_dir_search(ndir, &ndentry->d_name, NULL, NULL);
D
David Teigland 已提交
658 659 660 661 662 663 664 665 666 667 668 669 670 671 672
		switch (error) {
		case -ENOENT:
			error = 0;
			break;
		case 0:
			error = -EEXIST;
		default:
			goto out_gunlock;
		};

		if (odip != ndip) {
			if (!ndip->i_di.di_nlink) {
				error = -EINVAL;
				goto out_gunlock;
			}
673
			if (ndip->i_di.di_entries == (u32)-1) {
D
David Teigland 已提交
674 675 676 677
				error = -EFBIG;
				goto out_gunlock;
			}
			if (S_ISDIR(ip->i_di.di_mode) &&
678
			    ndip->i_di.di_nlink == (u32)-1) {
D
David Teigland 已提交
679 680 681 682 683 684 685 686 687
				error = -EMLINK;
				goto out_gunlock;
			}
		}
	}

	/* Check out the dir to be renamed */

	if (dir_rename) {
688
		error = permission(odentry->d_inode, MAY_WRITE, NULL);
D
David Teigland 已提交
689 690 691 692
		if (error)
			goto out_gunlock;
	}

693 694
	alloc_required = error = gfs2_diradd_alloc_required(ndir, &ndentry->d_name);
	if (error < 0)
D
David Teigland 已提交
695
		goto out_gunlock;
696
	error = 0;
D
David Teigland 已提交
697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715

	if (alloc_required) {
		struct gfs2_alloc *al = gfs2_alloc_get(ndip);

		error = gfs2_quota_lock(ndip, NO_QUOTA_CHANGE, NO_QUOTA_CHANGE);
		if (error)
			goto out_alloc;

		error = gfs2_quota_check(ndip, ndip->i_di.di_uid,
					 ndip->i_di.di_gid);
		if (error)
			goto out_gunlock_q;

		al->al_requested = sdp->sd_max_dirres;

		error = gfs2_inplace_reserve(ndip);
		if (error)
			goto out_gunlock_q;

716
		error = gfs2_trans_begin(sdp, sdp->sd_max_dirres +
D
David Teigland 已提交
717 718
					 al->al_rgd->rd_ri.ri_length +
					 4 * RES_DINODE + 4 * RES_LEAF +
719
					 RES_STATFS + RES_QUOTA, 0);
D
David Teigland 已提交
720 721 722 723
		if (error)
			goto out_ipreserv;
	} else {
		error = gfs2_trans_begin(sdp, 4 * RES_DINODE +
724
					 5 * RES_LEAF, 0);
D
David Teigland 已提交
725 726 727 728 729 730 731 732
		if (error)
			goto out_gunlock;
	}

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

	if (nip) {
		if (S_ISDIR(nip->i_di.di_mode))
733 734 735 736 737 738 739
			error = gfs2_rmdiri(ndip, &ndentry->d_name, nip);
		else {
			error = gfs2_dir_del(ndip, &ndentry->d_name);
			if (error)
				goto out_end_trans;
			error = gfs2_change_nlink(nip, -1);
		}
D
David Teigland 已提交
740 741 742 743 744 745
		if (error)
			goto out_end_trans;
	}

	if (dir_rename) {
		struct qstr name;
746
		gfs2_str2qstr(&name, "..");
D
David Teigland 已提交
747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763

		error = gfs2_change_nlink(ndip, +1);
		if (error)
			goto out_end_trans;
		error = gfs2_change_nlink(odip, -1);
		if (error)
			goto out_end_trans;

		error = gfs2_dir_mvino(ip, &name, &ndip->i_num, DT_DIR);
		if (error)
			goto out_end_trans;
	} else {
		struct buffer_head *dibh;
		error = gfs2_meta_inode_buffer(ip, &dibh);
		if (error)
			goto out_end_trans;
		ip->i_di.di_ctime = get_seconds();
764
		gfs2_trans_add_bh(ip->i_gl, dibh, 1);
D
David Teigland 已提交
765 766 767 768 769 770 771 772
		gfs2_dinode_out(&ip->i_di, dibh->b_data);
		brelse(dibh);
	}

	error = gfs2_dir_del(odip, &odentry->d_name);
	if (error)
		goto out_end_trans;

773
	error = gfs2_dir_add(ndir, &ndentry->d_name, &ip->i_num,
D
David Teigland 已提交
774 775 776 777
			     IF2DT(ip->i_di.di_mode));
	if (error)
		goto out_end_trans;

778
out_end_trans:
D
David Teigland 已提交
779
	gfs2_trans_end(sdp);
780
out_ipreserv:
D
David Teigland 已提交
781 782
	if (alloc_required)
		gfs2_inplace_release(ndip);
783
out_gunlock_q:
D
David Teigland 已提交
784 785
	if (alloc_required)
		gfs2_quota_unlock(ndip);
786
out_alloc:
D
David Teigland 已提交
787 788
	if (alloc_required)
		gfs2_alloc_put(ndip);
789
out_gunlock:
D
David Teigland 已提交
790
	gfs2_glock_dq_m(num_gh, ghs);
791
out_uninit:
D
David Teigland 已提交
792 793
	for (x = 0; x < num_gh; x++)
		gfs2_holder_uninit(ghs + x);
794
out_gunlock_r:
D
David Teigland 已提交
795 796
	if (dir_rename)
		gfs2_glock_dq_uninit(&r_gh);
797
out:
D
David Teigland 已提交
798 799 800 801 802 803 804 805 806 807 808 809 810 811 812
	return error;
}

/**
 * gfs2_readlink - Read the value of a symlink
 * @dentry: the symlink
 * @buf: the buffer to read the symlink data into
 * @size: the size of the buffer
 *
 * Returns: errno
 */

static int gfs2_readlink(struct dentry *dentry, char __user *user_buf,
			 int user_size)
{
813
	struct gfs2_inode *ip = GFS2_I(dentry->d_inode);
D
David Teigland 已提交
814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848
	char array[GFS2_FAST_NAME_SIZE], *buf = array;
	unsigned int len = GFS2_FAST_NAME_SIZE;
	int error;

	error = gfs2_readlinki(ip, &buf, &len);
	if (error)
		return error;

	if (user_size > len - 1)
		user_size = len - 1;

	if (copy_to_user(user_buf, buf, user_size))
		error = -EFAULT;
	else
		error = user_size;

	if (buf != array)
		kfree(buf);

	return error;
}

/**
 * gfs2_follow_link - Follow a symbolic link
 * @dentry: The dentry of the link
 * @nd: Data that we pass to vfs_follow_link()
 *
 * This can handle symlinks of any size. It is optimised for symlinks
 * under GFS2_FAST_NAME_SIZE.
 *
 * Returns: 0 on success or error code
 */

static void *gfs2_follow_link(struct dentry *dentry, struct nameidata *nd)
{
849
	struct gfs2_inode *ip = GFS2_I(dentry->d_inode);
D
David Teigland 已提交
850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874
	char array[GFS2_FAST_NAME_SIZE], *buf = array;
	unsigned int len = GFS2_FAST_NAME_SIZE;
	int error;

	error = gfs2_readlinki(ip, &buf, &len);
	if (!error) {
		error = vfs_follow_link(nd, buf);
		if (buf != array)
			kfree(buf);
	}

	return ERR_PTR(error);
}

/**
 * gfs2_permission -
 * @inode:
 * @mask:
 * @nd: passed from Linux VFS, ignored by us
 *
 * Returns: errno
 */

static int gfs2_permission(struct inode *inode, int mask, struct nameidata *nd)
{
875
	struct gfs2_inode *ip = GFS2_I(inode);
D
David Teigland 已提交
876 877 878 879 880 881
	struct gfs2_holder i_gh;
	int error;

	if (ip->i_vn == ip->i_gl->gl_vn)
		return generic_permission(inode, mask, gfs2_check_acl);

882
	error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, &i_gh);
D
David Teigland 已提交
883 884 885 886 887 888 889 890 891 892
	if (!error) {
		error = generic_permission(inode, mask, gfs2_check_acl_locked);
		gfs2_glock_dq_uninit(&i_gh);
	}

	return error;
}

static int setattr_size(struct inode *inode, struct iattr *attr)
{
893
	struct gfs2_inode *ip = GFS2_I(inode);
D
David Teigland 已提交
894 895 896 897 898 899 900 901
	int error;

	if (attr->ia_size != ip->i_di.di_size) {
		error = vmtruncate(inode, attr->ia_size);
		if (error)
			return error;
	}

902
	error = gfs2_truncatei(ip, attr->ia_size);
D
David Teigland 已提交
903 904 905 906 907 908 909 910
	if (error)
		return error;

	return error;
}

static int setattr_chown(struct inode *inode, struct iattr *attr)
{
911 912
	struct gfs2_inode *ip = GFS2_I(inode);
	struct gfs2_sbd *sdp = GFS2_SB(inode);
D
David Teigland 已提交
913
	struct buffer_head *dibh;
914
	u32 ouid, ogid, nuid, ngid;
D
David Teigland 已提交
915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950
	int error;

	ouid = ip->i_di.di_uid;
	ogid = ip->i_di.di_gid;
	nuid = attr->ia_uid;
	ngid = attr->ia_gid;

	if (!(attr->ia_valid & ATTR_UID) || ouid == nuid)
		ouid = nuid = NO_QUOTA_CHANGE;
	if (!(attr->ia_valid & ATTR_GID) || ogid == ngid)
		ogid = ngid = NO_QUOTA_CHANGE;

	gfs2_alloc_get(ip);

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

	if (ouid != NO_QUOTA_CHANGE || ogid != NO_QUOTA_CHANGE) {
		error = gfs2_quota_check(ip, nuid, ngid);
		if (error)
			goto out_gunlock_q;
	}

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

	error = gfs2_meta_inode_buffer(ip, &dibh);
	if (error)
		goto out_end_trans;

	error = inode_setattr(inode, attr);
	gfs2_assert_warn(sdp, !error);
	gfs2_inode_attr_out(ip);

951
	gfs2_trans_add_bh(ip->i_gl, dibh, 1);
D
David Teigland 已提交
952 953 954 955
	gfs2_dinode_out(&ip->i_di, dibh->b_data);
	brelse(dibh);

	if (ouid != NO_QUOTA_CHANGE || ogid != NO_QUOTA_CHANGE) {
956 957
		gfs2_quota_change(ip, -ip->i_di.di_blocks, ouid, ogid);
		gfs2_quota_change(ip, ip->i_di.di_blocks, nuid, ngid);
D
David Teigland 已提交
958 959
	}

960
out_end_trans:
D
David Teigland 已提交
961
	gfs2_trans_end(sdp);
962
out_gunlock_q:
D
David Teigland 已提交
963
	gfs2_quota_unlock(ip);
964
out_alloc:
D
David Teigland 已提交
965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982
	gfs2_alloc_put(ip);
	return error;
}

/**
 * gfs2_setattr - Change attributes on an inode
 * @dentry: The dentry which is changing
 * @attr: The structure describing the change
 *
 * The VFS layer wants to change one or more of an inodes attributes.  Write
 * that change out to disk.
 *
 * Returns: errno
 */

static int gfs2_setattr(struct dentry *dentry, struct iattr *attr)
{
	struct inode *inode = dentry->d_inode;
983
	struct gfs2_inode *ip = GFS2_I(inode);
D
David Teigland 已提交
984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007
	struct gfs2_holder i_gh;
	int error;

	error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &i_gh);
	if (error)
		return error;

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

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

	if (attr->ia_valid & ATTR_SIZE)
		error = setattr_size(inode, attr);
	else if (attr->ia_valid & (ATTR_UID | ATTR_GID))
		error = setattr_chown(inode, attr);
	else if ((attr->ia_valid & ATTR_MODE) && IS_POSIXACL(inode))
		error = gfs2_acl_chmod(ip, attr);
	else
		error = gfs2_setattr_simple(ip, attr);

1008
out:
D
David Teigland 已提交
1009 1010 1011 1012 1013 1014 1015 1016
	gfs2_glock_dq_uninit(&i_gh);
	if (!error)
		mark_inode_dirty(inode);
	return error;
}

/**
 * gfs2_getattr - Read out an inode's attributes
1017
 * @mnt: The vfsmount the inode is being accessed from
D
David Teigland 已提交
1018 1019 1020 1021 1022 1023 1024 1025 1026 1027
 * @dentry: The dentry to stat
 * @stat: The inode's stats
 *
 * Returns: errno
 */

static int gfs2_getattr(struct vfsmount *mnt, struct dentry *dentry,
			struct kstat *stat)
{
	struct inode *inode = dentry->d_inode;
1028
	struct gfs2_inode *ip = GFS2_I(inode);
D
David Teigland 已提交
1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043
	struct gfs2_holder gh;
	int error;

	error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, &gh);
	if (!error) {
		generic_fillattr(inode, stat);
		gfs2_glock_dq_uninit(&gh);
	}

	return error;
}

static int gfs2_setxattr(struct dentry *dentry, const char *name,
			 const void *data, size_t size, int flags)
{
1044
	struct inode *inode = dentry->d_inode;
D
David Teigland 已提交
1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055
	struct gfs2_ea_request er;

	memset(&er, 0, sizeof(struct gfs2_ea_request));
	er.er_type = gfs2_ea_name2type(name, &er.er_name);
	if (er.er_type == GFS2_EATYPE_UNUSED)
		return -EOPNOTSUPP;
	er.er_data = (char *)data;
	er.er_name_len = strlen(er.er_name);
	er.er_data_len = size;
	er.er_flags = flags;

1056
	gfs2_assert_warn(GFS2_SB(inode), !(er.er_flags & GFS2_ERF_MODE));
D
David Teigland 已提交
1057

1058
	return gfs2_ea_set(GFS2_I(inode), &er);
D
David Teigland 已提交
1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073
}

static ssize_t gfs2_getxattr(struct dentry *dentry, const char *name,
			     void *data, size_t size)
{
	struct gfs2_ea_request er;

	memset(&er, 0, sizeof(struct gfs2_ea_request));
	er.er_type = gfs2_ea_name2type(name, &er.er_name);
	if (er.er_type == GFS2_EATYPE_UNUSED)
		return -EOPNOTSUPP;
	er.er_data = data;
	er.er_name_len = strlen(er.er_name);
	er.er_data_len = size;

1074
	return gfs2_ea_get(GFS2_I(dentry->d_inode), &er);
D
David Teigland 已提交
1075 1076 1077 1078 1079 1080 1081 1082 1083 1084
}

static ssize_t gfs2_listxattr(struct dentry *dentry, char *buffer, size_t size)
{
	struct gfs2_ea_request er;

	memset(&er, 0, sizeof(struct gfs2_ea_request));
	er.er_data = (size) ? buffer : NULL;
	er.er_data_len = size;

1085
	return gfs2_ea_list(GFS2_I(dentry->d_inode), &er);
D
David Teigland 已提交
1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097
}

static int gfs2_removexattr(struct dentry *dentry, const char *name)
{
	struct gfs2_ea_request er;

	memset(&er, 0, sizeof(struct gfs2_ea_request));
	er.er_type = gfs2_ea_name2type(name, &er.er_name);
	if (er.er_type == GFS2_EATYPE_UNUSED)
		return -EOPNOTSUPP;
	er.er_name_len = strlen(er.er_name);

1098
	return gfs2_ea_remove(GFS2_I(dentry->d_inode), &er);
D
David Teigland 已提交
1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151
}

struct inode_operations gfs2_file_iops = {
	.permission = gfs2_permission,
	.setattr = gfs2_setattr,
	.getattr = gfs2_getattr,
	.setxattr = gfs2_setxattr,
	.getxattr = gfs2_getxattr,
	.listxattr = gfs2_listxattr,
	.removexattr = gfs2_removexattr,
};

struct inode_operations gfs2_dev_iops = {
	.permission = gfs2_permission,
	.setattr = gfs2_setattr,
	.getattr = gfs2_getattr,
	.setxattr = gfs2_setxattr,
	.getxattr = gfs2_getxattr,
	.listxattr = gfs2_listxattr,
	.removexattr = gfs2_removexattr,
};

struct inode_operations gfs2_dir_iops = {
	.create = gfs2_create,
	.lookup = gfs2_lookup,
	.link = gfs2_link,
	.unlink = gfs2_unlink,
	.symlink = gfs2_symlink,
	.mkdir = gfs2_mkdir,
	.rmdir = gfs2_rmdir,
	.mknod = gfs2_mknod,
	.rename = gfs2_rename,
	.permission = gfs2_permission,
	.setattr = gfs2_setattr,
	.getattr = gfs2_getattr,
	.setxattr = gfs2_setxattr,
	.getxattr = gfs2_getxattr,
	.listxattr = gfs2_listxattr,
	.removexattr = gfs2_removexattr,
};

struct inode_operations gfs2_symlink_iops = {
	.readlink = gfs2_readlink,
	.follow_link = gfs2_follow_link,
	.permission = gfs2_permission,
	.setattr = gfs2_setattr,
	.getattr = gfs2_getattr,
	.setxattr = gfs2_setxattr,
	.getxattr = gfs2_getxattr,
	.listxattr = gfs2_listxattr,
	.removexattr = gfs2_removexattr,
};