inode.c 48.2 KB
Newer Older
David Teigland's avatar
David Teigland committed
1
2
/*
 * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
3
 * Copyright (C) 2004-2011 Red Hat, Inc.  All rights reserved.
David Teigland's avatar
David Teigland committed
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.
David Teigland's avatar
David Teigland committed
8
9
10
11
12
13
14
15
16
17
 */

#include <linux/slab.h>
#include <linux/spinlock.h>
#include <linux/completion.h>
#include <linux/buffer_head.h>
#include <linux/namei.h>
#include <linux/mm.h>
#include <linux/xattr.h>
#include <linux/posix_acl.h>
18
#include <linux/gfs2_ondisk.h>
19
#include <linux/crc32.h>
20
#include <linux/fiemap.h>
21
#include <linux/security.h>
David Teigland's avatar
David Teigland committed
22
23
24
#include <asm/uaccess.h>

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

40
static int iget_test(struct inode *inode, void *opaque)
41
{
42
43
44
45
46
47
48
49
50
51
52
53
54
55
	u64 no_addr = *(u64 *)opaque;

	return GFS2_I(inode)->i_no_addr == no_addr;
}

static int iget_set(struct inode *inode, void *opaque)
{
	u64 no_addr = *(u64 *)opaque;

	GFS2_I(inode)->i_no_addr = no_addr;
	inode->i_ino = no_addr;
	return 0;
}

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

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

/**
 * gfs2_set_iop - Sets inode operations
 * @inode: The inode with correct i_mode filled in
 *
 * GFS2 lookup code fills in vfs inode contents based on info obtained
 * from directory entry inside gfs2_inode_lookup().
 */

static void gfs2_set_iop(struct inode *inode)
{
	struct gfs2_sbd *sdp = GFS2_SB(inode);
	umode_t mode = inode->i_mode;

	if (S_ISREG(mode)) {
		inode->i_op = &gfs2_file_iops;
		if (gfs2_localflocks(sdp))
			inode->i_fop = &gfs2_file_fops_nolock;
		else
			inode->i_fop = &gfs2_file_fops;
	} else if (S_ISDIR(mode)) {
		inode->i_op = &gfs2_dir_iops;
		if (gfs2_localflocks(sdp))
			inode->i_fop = &gfs2_dir_fops_nolock;
		else
			inode->i_fop = &gfs2_dir_fops;
	} else if (S_ISLNK(mode)) {
		inode->i_op = &gfs2_symlink_iops;
	} else {
		inode->i_op = &gfs2_file_iops;
		init_special_inode(inode, inode->i_mode, inode->i_rdev);
	}
}

/**
 * gfs2_inode_lookup - Lookup an inode
 * @sb: The super block
 * @type: The type of the inode
108
109
110
111
112
113
114
115
116
117
 * @no_addr: The inode number
 * @no_formal_ino: The inode generation number
 * @blktype: Requested block type (GFS2_BLKST_DINODE or GFS2_BLKST_UNLINKED;
 *           GFS2_BLKST_FREE do indicate not to verify)
 *
 * If @type is DT_UNKNOWN, the inode type is fetched from disk.
 *
 * If @blktype is anything other than GFS2_BLKST_FREE (which is used as a
 * placeholder because it doesn't otherwise make sense), the on-disk block type
 * is verified to be @blktype.
118
119
120
121
122
 *
 * Returns: A VFS inode, or an error
 */

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

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

137
138
	ip = GFS2_I(inode);

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

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

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

152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
		if (type == DT_UNKNOWN || blktype != GFS2_BLKST_FREE) {
			/*
			 * The GL_SKIP flag indicates to skip reading the inode
			 * block.  We read the inode with gfs2_inode_refresh
			 * after possibly checking the block type.
			 */
			error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE,
						   GL_SKIP, &i_gh);
			if (error)
				goto fail_put;

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

171
172
173
		set_bit(GIF_INVALID, &ip->i_flags);
		error = gfs2_glock_nq_init(io_gl, LM_ST_SHARED, GL_EXACT, &ip->i_iopen_gh);
		if (unlikely(error))
174
			goto fail_put;
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192

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

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

		gfs2_set_iop(inode);
		unlock_new_inode(inode);
	}

193
	if (gfs2_holder_initialized(&i_gh))
194
		gfs2_glock_dq_uninit(&i_gh);
195
196
197
	return inode;

fail_refresh:
Bob Peterson's avatar
Bob Peterson committed
198
	ip->i_iopen_gh.gh_flags |= GL_NOCACHE;
199
	ip->i_iopen_gh.gh_gl->gl_object = NULL;
200
201
	gfs2_glock_dq_wait(&ip->i_iopen_gh);
	gfs2_holder_uninit(&ip->i_iopen_gh);
202
fail_put:
203
204
	if (io_gl)
		gfs2_glock_put(io_gl);
205
	if (gfs2_holder_initialized(&i_gh))
206
		gfs2_glock_dq_uninit(&i_gh);
207
208
209
210
211
212
213
214
215
216
	ip->i_gl->gl_object = NULL;
fail:
	iget_failed(inode);
	return ERR_PTR(error);
}

struct inode *gfs2_lookup_by_inum(struct gfs2_sbd *sdp, u64 no_addr,
				  u64 *no_formal_ino, unsigned int blktype)
{
	struct super_block *sb = sdp->sd_vfs;
217
	struct inode *inode;
218
219
	int error;

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

	/* Two extra checks for NFS only */
	if (no_formal_ino) {
		error = -ESTALE;
		if (GFS2_I(inode)->i_no_formal_ino != *no_formal_ino)
			goto fail_iput;

		error = -EIO;
		if (GFS2_I(inode)->i_diskflags & GFS2_DIF_SYSTEM)
			goto fail_iput;
	}
234
	return inode;
235
236
237

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


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


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

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

284
	gfs2_holder_mark_uninitialized(&d_gh);
285
286
287
288
289
	if (!name->len || name->len > GFS2_FNAMESIZE)
		return ERR_PTR(-ENAMETOOLONG);

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

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

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

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

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

static int create_ok(struct gfs2_inode *dip, const struct qstr *name,
Al Viro's avatar
Al Viro committed
328
		     umode_t mode)
329
330
331
{
	int error;

332
	error = gfs2_permission(&dip->i_inode, MAY_WRITE | MAY_EXEC);
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
	if (error)
		return error;

	/*  Don't create entries in an unlinked directory  */
	if (!dip->i_inode.i_nlink)
		return -ENOENT;

	if (dip->i_entries == (u32)-1)
		return -EFBIG;
	if (S_ISDIR(mode) && dip->i_inode.i_nlink == (u32)-1)
		return -EMLINK;

	return 0;
}

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

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

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

376
	error = gfs2_quota_lock_check(ip, &ap);
377
378
379
	if (error)
		goto out;

380
	error = gfs2_inplace_reserve(ip, &ap);
381
382
383
	if (error)
		goto out_quota;

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

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

	gfs2_trans_end(sdp);

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

403
404
static void gfs2_init_dir(struct buffer_head *dibh,
			  const struct gfs2_inode *parent)
Steven Whitehouse's avatar
Steven Whitehouse committed
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
{
	struct gfs2_dinode *di = (struct gfs2_dinode *)dibh->b_data;
	struct gfs2_dirent *dent = (struct gfs2_dirent *)(di+1);

	gfs2_qstr2dirent(&gfs2_qdot, GFS2_DIRENT_SIZE(gfs2_qdot.len), dent);
	dent->de_inum = di->di_num; /* already GFS2 endian */
	dent->de_type = cpu_to_be16(DT_DIR);

	dent = (struct gfs2_dirent *)((char*)dent + GFS2_DIRENT_SIZE(1));
	gfs2_qstr2dirent(&gfs2_qdotdot, dibh->b_size - GFS2_DIRENT_SIZE(1) - sizeof(struct gfs2_dinode), dent);
	gfs2_inum_out(parent, dent);
	dent->de_type = cpu_to_be16(DT_DIR);
	
}

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
/**
 * gfs2_init_xattr - Initialise an xattr block for a new inode
 * @ip: The inode in question
 *
 * This sets up an empty xattr block for a new inode, ready to
 * take any ACLs, LSM xattrs, etc.
 */

static void gfs2_init_xattr(struct gfs2_inode *ip)
{
	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
	struct buffer_head *bh;
	struct gfs2_ea_header *ea;

	bh = gfs2_meta_new(ip->i_gl, ip->i_eattr);
	gfs2_trans_add_meta(ip->i_gl, bh);
	gfs2_metatype_set(bh, GFS2_METATYPE_EA, GFS2_FORMAT_EA);
	gfs2_buffer_clear_tail(bh, sizeof(struct gfs2_meta_header));

	ea = GFS2_EA_BH2FIRST(bh);
	ea->ea_rec_len = cpu_to_be32(sdp->sd_jbsize);
	ea->ea_type = GFS2_EATYPE_UNUSED;
	ea->ea_flags = GFS2_EAFLAG_LAST;

	brelse(bh);
}

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

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

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

467
468
	di->di_major = cpu_to_be32(MAJOR(ip->i_inode.i_rdev));
	di->di_minor = cpu_to_be32(MINOR(ip->i_inode.i_rdev));
469
470
471
472
473
	di->__pad1 = 0;
	di->__pad2 = 0;
	di->__pad3 = 0;
	memset(&di->__pad4, 0, sizeof(di->__pad4));
	memset(&di->di_reserved, 0, sizeof(di->di_reserved));
474
	gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode));
475

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

485
	set_buffer_uptodate(dibh);
486
	brelse(dibh);
487
488
}

489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
/**
 * gfs2_trans_da_blocks - Calculate number of blocks to link inode
 * @dip: The directory we are linking into
 * @da: The dir add information
 * @nr_inodes: The number of inodes involved
 *
 * This calculate the number of blocks we need to reserve in a
 * transaction to link @nr_inodes into a directory. In most cases
 * @nr_inodes will be 2 (the directory plus the inode being linked in)
 * but in case of rename, 4 may be required.
 *
 * Returns: Number of blocks
 */

static unsigned gfs2_trans_da_blks(const struct gfs2_inode *dip,
				   const struct gfs2_diradd *da,
				   unsigned nr_inodes)
{
	return da->nr_blocks + gfs2_rg_blocks(dip, da->nr_blocks) +
	       (nr_inodes * RES_DINODE) + RES_QUOTA + RES_STATFS;
}

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

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

523
		error = gfs2_inplace_reserve(dip, &ap);
524
525
526
		if (error)
			goto fail_quota_locks;

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

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

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

546
static int gfs2_initxattrs(struct inode *inode, const struct xattr *xattr_array,
547
		    void *fs_info)
548
{
549
550
551
552
553
554
555
556
557
	const struct xattr *xattr;
	int err = 0;

	for (xattr = xattr_array; xattr->name != NULL; xattr++) {
		err = __gfs2_xattr_set(inode, xattr->name, xattr->value,
				       xattr->value_len, 0,
				       GFS2_EATYPE_SECURITY);
		if (err < 0)
			break;
558
559
560
	}
	return err;
}
David Teigland's avatar
David Teigland committed
561

562
/**
563
564
565
 * gfs2_create_inode - Create a new inode
 * @dir: The parent directory
 * @dentry: The new dentry
566
 * @file: If non-NULL, the file which is being opened
567
568
569
570
 * @mode: The permissions on the new inode
 * @dev: For device nodes, this is the device number
 * @symname: For symlinks, this is the link destination
 * @size: The initial size of the inode (ignored for directories)
571
 *
572
 * Returns: 0 on success, or error code
573
574
 */

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

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

595
	error = gfs2_rsqa_alloc(dip);
596
597
598
	if (error)
		return error;

599
600
601
602
	error = gfs2_rindex_update(sdp);
	if (error)
		return error;

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

	error = create_ok(dip, name, mode);
608
609
610
611
612
613
	if (error)
		goto fail_gunlock;

	inode = gfs2_dir_search(dir, &dentry->d_name, !S_ISREG(mode) || excl);
	error = PTR_ERR(inode);
	if (!IS_ERR(inode)) {
614
615
616
617
618
		if (S_ISDIR(inode->i_mode)) {
			iput(inode);
			inode = ERR_PTR(-EISDIR);
			goto fail_gunlock;
		}
619
		d_instantiate(dentry, inode);
620
		error = 0;
621
		if (file) {
622
			if (S_ISREG(inode->i_mode))
Miklos Szeredi's avatar
Miklos Szeredi committed
623
				error = finish_open(file, dentry, gfs2_open_common, opened);
624
625
			else
				error = finish_no_open(file, NULL);
626
		}
Steven Whitehouse's avatar
Steven Whitehouse committed
627
		gfs2_glock_dq_uninit(ghs);
628
		return error;
629
	} else if (error != -ENOENT) {
630
		goto fail_gunlock;
631
	}
632

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

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

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

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

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

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

	/* Force SYSTEM flag on all files and subdirs of a SYSTEM directory */
	if (dip->i_diskflags & GFS2_DIF_SYSTEM)
		ip->i_diskflags |= GFS2_DIF_SYSTEM;

684
	gfs2_set_inode_flags(inode);
685

686
	if ((GFS2_I(d_inode(sdp->sd_root_dir)) == dip) ||
Steven Whitehouse's avatar
Steven Whitehouse committed
687
688
689
	    (dip->i_diskflags & GFS2_DIF_TOPDIR))
		aflags |= GFS2_AF_ORLOV;

690
691
692
693
	if (default_acl || acl)
		blocks++;

	error = alloc_dinode(ip, aflags, &blocks);
694
	if (error)
695
		goto fail_free_inode;
696

697
698
	gfs2_set_inode_blocks(inode, blocks);

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

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

708
	error = gfs2_trans_begin(sdp, blocks, 0);
709
	if (error)
710
711
		goto fail_gunlock2;

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

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

723
724
	BUG_ON(test_and_set_bit(GLF_INODE_CREATING, &io_gl->gl_flags));

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

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

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

747
	if (error)
748
		goto fail_gunlock3;
749

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

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

759
	mark_inode_dirty(inode);
760
	d_instantiate(dentry, inode);
Miklos Szeredi's avatar
Miklos Szeredi committed
761
762
	if (file) {
		*opened |= FILE_CREATED;
763
		error = finish_open(file, dentry, gfs2_open_common, opened);
Miklos Szeredi's avatar
Miklos Szeredi committed
764
	}
765
766
	gfs2_glock_dq_uninit(ghs);
	gfs2_glock_dq_uninit(ghs + 1);
767
	clear_bit(GLF_INODE_CREATING, &io_gl->gl_flags);
768
	return error;
769

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

David Teigland's avatar
David Teigland committed
801
802
803
804
805
806
807
808
809
810
/**
 * gfs2_create - Create a file
 * @dir: The directory in which to create the file
 * @dentry: The dentry of the new file
 * @mode: The mode of the new file
 *
 * Returns: errno
 */

static int gfs2_create(struct inode *dir, struct dentry *dentry,
Al Viro's avatar
Al Viro committed
811
		       umode_t mode, bool excl)
David Teigland's avatar
David Teigland committed
812
{
813
	return gfs2_create_inode(dir, dentry, NULL, S_IFREG | mode, 0, NULL, 0, excl, NULL);
David Teigland's avatar
David Teigland committed
814
815
816
}

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

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

	inode = gfs2_lookupi(dir, &dentry->d_name, 0);
837
838
	if (inode == NULL) {
		d_add(dentry, NULL);
839
		return NULL;
840
	}
841
842
843
844
845
846
847
848
	if (IS_ERR(inode))
		return ERR_CAST(inode);

	gl = GFS2_I(inode)->i_gl;
	error = gfs2_glock_nq_init(gl, LM_ST_SHARED, LM_FLAG_ANY, &gh);
	if (error) {
		iput(inode);
		return ERR_PTR(error);
849
	}
850
851

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

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

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

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

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

900
	error = gfs2_rsqa_alloc(dip);
901
902
903
	if (error)
		return error;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
/*
 * gfs2_unlink_ok - check to see that a inode is still in a directory
 * @dip: the directory
 * @name: the name of the file
 * @ip: the inode
 *
 * Assumes that the lock on (at least) @dip is held.
 *
 * Returns: 0 if the parent/child relationship is correct, errno if it isn't
 */

static int gfs2_unlink_ok(struct gfs2_inode *dip, const struct qstr *name,
			  const struct gfs2_inode *ip)
{
	int error;

	if (IS_IMMUTABLE(&ip->i_inode) || IS_APPEND(&ip->i_inode))
		return -EPERM;

	if ((dip->i_inode.i_mode & S_ISVTX) &&
1028
1029
	    !uid_eq(dip->i_inode.i_uid, current_fsuid()) &&
	    !uid_eq(ip->i_inode.i_uid, current_fsuid()) && !capable(CAP_FOWNER))
1030
1031
1032
1033
1034
		return -EPERM;

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

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

1039
	return gfs2_dir_check(&dip->i_inode, name, ip);
1040
1041
}

David Teigland's avatar
David Teigland committed
1042
/**
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
 * gfs2_unlink_inode - Removes an inode from its parent dir and unlinks it
 * @dip: The parent directory
 * @name: The name of the entry in the parent directory
 * @inode: The inode to be removed
 *
 * Called with all the locks and in a transaction. This will only be
 * called for a directory after it has been checked to ensure it is empty.
 *
 * Returns: 0 on success, or an error
 */

static int gfs2_unlink_inode(struct gfs2_inode *dip,
1055
			     const struct dentry *dentry)
1056
{
1057
	struct inode *inode = d_inode(dentry);
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
	struct gfs2_inode *ip = GFS2_I(inode);
	int error;

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

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


/**
 * gfs2_unlink - Unlink an inode (this does rmdir as well)
 * @dir: The inode of the directory containing the inode to unlink
David Teigland's avatar
David Teigland committed
1081
1082
 * @dentry: The file itself
 *
1083
1084
 * This routine uses the type of the inode as a flag to figure out
 * whether this is an unlink or an rmdir.
David Teigland's avatar
David Teigland committed
1085
1086
1087
1088
1089
1090
 *
 * Returns: errno
 */

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

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

	error = -EROFS;
David Teigland's avatar
David Teigland committed
1104
1105

	gfs2_holder_init(dip->i_gl, LM_ST_EXCLUSIVE, 0, ghs);
Russell Cattelan's avatar
Russell Cattelan committed
1106
	gfs2_holder_init(ip->i_gl,  LM_ST_EXCLUSIVE, 0, ghs + 1);
David Teigland's avatar
David Teigland committed
1107

Steven Whitehouse's avatar
Steven Whitehouse committed
1108
	rgd = gfs2_blk2rgrpd(sdp, ip->i_no_addr, 1);
1109
	if (!rgd)
1110
		goto out_inodes;
1111

Russell Cattelan's avatar
Russell Cattelan committed
1112
1113
1114
	gfs2_holder_init(rgd->rd_gl, LM_ST_EXCLUSIVE, 0, ghs + 2);


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

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

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

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

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

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