inode.c 49.5 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
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
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
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
#include "glops.h"

struct gfs2_skip_data {
	u64 no_addr;
	int skipped;
	int non_block;
};

static int iget_test(struct inode *inode, void *opaque)
{
	struct gfs2_inode *ip = GFS2_I(inode);
	struct gfs2_skip_data *data = opaque;

	if (ip->i_no_addr == data->no_addr) {
		if (data->non_block &&
		    inode->i_state & (I_FREEING|I_CLEAR|I_WILL_FREE)) {
			data->skipped = 1;
			return 0;
		}
		return 1;
	}
	return 0;
}

static int iget_set(struct inode *inode, void *opaque)
{
	struct gfs2_inode *ip = GFS2_I(inode);
	struct gfs2_skip_data *data = opaque;

	if (data->skipped)
		return -ENOENT;
	inode->i_ino = (unsigned long)(data->no_addr);
	ip->i_no_addr = data->no_addr;
	return 0;
}

struct inode *gfs2_ilookup(struct super_block *sb, u64 no_addr, int non_block)
{
	unsigned long hash = (unsigned long)no_addr;
	struct gfs2_skip_data data;

	data.no_addr = no_addr;
	data.skipped = 0;
	data.non_block = non_block;
	return ilookup5(sb, hash, iget_test, &data);
}

static struct inode *gfs2_iget(struct super_block *sb, u64 no_addr,
			       int non_block)
{
	struct gfs2_skip_data data;
	unsigned long hash = (unsigned long)no_addr;

	data.no_addr = no_addr;
	data.skipped = 0;
	data.non_block = non_block;
	return iget5_locked(sb, hash, iget_test, iget_set, &data);
}

/**
 * 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
 * @no_addr: The inode number
 * @type: The type of the inode
 * non_block: Can we block on inodes that are being freed?
 *
 * Returns: A VFS inode, or an error
 */

struct inode *gfs2_inode_lookup(struct super_block *sb, unsigned int type,
				u64 no_addr, u64 no_formal_ino, int non_block)
{
	struct inode *inode;
	struct gfs2_inode *ip;
	struct gfs2_glock *io_gl = NULL;
	int error;

	inode = gfs2_iget(sb, no_addr, non_block);
	ip = GFS2_I(inode);

	if (!inode)
152
		return ERR_PTR(-ENOMEM);
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191

	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;

		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))
			goto fail_iopen;

		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);
	}

	return inode;

fail_refresh:
Bob Peterson's avatar
Bob Peterson committed
192
	ip->i_iopen_gh.gh_flags |= GL_NOCACHE;
193
	ip->i_iopen_gh.gh_gl->gl_object = NULL;
194
195
	gfs2_glock_dq_wait(&ip->i_iopen_gh);
	gfs2_holder_uninit(&ip->i_iopen_gh);
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
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
284
285
286
287
288
289
290
291
292
293
294
295
296
297
fail_iopen:
	if (io_gl)
		gfs2_glock_put(io_gl);
fail_put:
	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;
	struct gfs2_holder i_gh;
	struct inode *inode = NULL;
	int error;

	/* Must not read in block until block type is verified */
	error = gfs2_glock_nq_num(sdp, no_addr, &gfs2_inode_glops,
				  LM_ST_EXCLUSIVE, GL_SKIP, &i_gh);
	if (error)
		return ERR_PTR(error);

	error = gfs2_check_blk_type(sdp, no_addr, blktype);
	if (error)
		goto fail;

	inode = gfs2_inode_lookup(sb, DT_UNKNOWN, no_addr, 0, 1);
	if (IS_ERR(inode))
		goto fail;

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

		error = 0;
	}

fail:
	gfs2_glock_dq_uninit(&i_gh);
	return error ? ERR_PTR(error) : inode;
fail_iput:
	iput(inode);
	goto fail;
}


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


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

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

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

	if ((name->len == 1 && memcmp(name->name, ".", 1) == 0) ||
	    (name->len == 2 && memcmp(name->name, "..", 2) == 0 &&
298
	     dir == d_inode(sb->s_root))) {
299
300
301
302
303
304
305
306
307
308
309
310
		igrab(dir);
		return dir;
	}

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

	if (!is_root) {
311
		error = gfs2_permission(dir, MAY_EXEC);
312
313
314
315
		if (error)
			goto out;
	}

316
	inode = gfs2_dir_search(dir, name, false);
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
	if (IS_ERR(inode))
		error = PTR_ERR(inode);
out:
	if (unlock)
		gfs2_glock_dq_uninit(&d_gh);
	if (error == -ENOENT)
		return NULL;
	return inode ? inode : ERR_PTR(error);
}

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

static int create_ok(struct gfs2_inode *dip, const struct qstr *name,
Al Viro's avatar
Al Viro committed
337
		     umode_t mode)
338
339
340
{
	int error;

341
	error = gfs2_permission(&dip->i_inode, MAY_WRITE | MAY_EXEC);
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
	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;
}

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

	if (dip->i_inode.i_mode & S_ISGID) {
372
373
374
		if (S_ISDIR(inode->i_mode))
			inode->i_mode |= S_ISGID;
		inode->i_gid = dip->i_inode.i_gid;
375
	} else
376
		inode->i_gid = current_fsgid();
377
378
}

379
static int alloc_dinode(struct gfs2_inode *ip, u32 flags, unsigned *dblocks)
380
{
381
	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
382
	struct gfs2_alloc_parms ap = { .target = *dblocks, .aflags = flags, };
383
384
	int error;

385
	error = gfs2_quota_lock_check(ip, &ap);
386
387
388
	if (error)
		goto out;

389
	error = gfs2_inplace_reserve(ip, &ap);
390
391
392
	if (error)
		goto out_quota;

393
	error = gfs2_trans_begin(sdp, (*dblocks * RES_RG_BIT) + RES_STATFS + RES_QUOTA, 0);
394
395
396
	if (error)
		goto out_ipreserv;

397
	error = gfs2_alloc_blocks(ip, &ip->i_no_addr, dblocks, 1, &ip->i_generation);
398
399
400
	ip->i_no_formal_ino = ip->i_generation;
	ip->i_inode.i_ino = ip->i_no_addr;
	ip->i_goal = ip->i_no_addr;
401
402
403
404

	gfs2_trans_end(sdp);

out_ipreserv:
405
	gfs2_inplace_release(ip);
406
407
out_quota:
	gfs2_quota_unlock(ip);
408
409
410
411
out:
	return error;
}

412
413
static void gfs2_init_dir(struct buffer_head *dibh,
			  const struct gfs2_inode *parent)
Steven Whitehouse's avatar
Steven Whitehouse committed
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
{
	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);
	
}

429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
/**
 * 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);
}

456
457
/**
 * init_dinode - Fill in a new dinode structure
458
 * @dip: The directory this inode is being created in
459
 * @ip: The inode
460
461
 * @symname: The symlink destination (if a symlink)
 * @bhp: The buffer head (returned to caller)
462
463
464
 *
 */

465
static void init_dinode(struct gfs2_inode *dip, struct gfs2_inode *ip,
466
			const char *symname)
467
468
469
470
{
	struct gfs2_dinode *di;
	struct buffer_head *dibh;

471
	dibh = gfs2_meta_new(ip->i_gl, ip->i_no_addr);
472
	gfs2_trans_add_meta(ip->i_gl, dibh);
473
	di = (struct gfs2_dinode *)dibh->b_data;
474
	gfs2_dinode_out(ip, di);
475

476
477
	di->di_major = cpu_to_be32(MAJOR(ip->i_inode.i_rdev));
	di->di_minor = cpu_to_be32(MINOR(ip->i_inode.i_rdev));
478
479
480
481
482
	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));
483
	gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode));
484

485
	switch(ip->i_inode.i_mode & S_IFMT) {
486
	case S_IFDIR:
Steven Whitehouse's avatar
Steven Whitehouse committed
487
		gfs2_init_dir(dibh, dip);
488
489
		break;
	case S_IFLNK:
490
		memcpy(dibh->b_data + sizeof(struct gfs2_dinode), symname, ip->i_inode.i_size);
491
		break;
Steven Whitehouse's avatar
Steven Whitehouse committed
492
493
	}

494
	set_buffer_uptodate(dibh);
495
	brelse(dibh);
496
497
}

498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
/**
 * 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;
}

520
static int link_dinode(struct gfs2_inode *dip, const struct qstr *name,
521
		       struct gfs2_inode *ip, struct gfs2_diradd *da)
522
523
{
	struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
524
	struct gfs2_alloc_parms ap = { .target = da->nr_blocks, };
525
526
	int error;

527
	if (da->nr_blocks) {
528
		error = gfs2_quota_lock_check(dip, &ap);
529
530
531
		if (error)
			goto fail_quota_locks;

532
		error = gfs2_inplace_reserve(dip, &ap);
533
534
535
		if (error)
			goto fail_quota_locks;

536
		error = gfs2_trans_begin(sdp, gfs2_trans_da_blks(dip, da, 2), 0);
537
538
539
540
541
542
543
544
		if (error)
			goto fail_ipreserv;
	} else {
		error = gfs2_trans_begin(sdp, RES_LEAF + 2 * RES_DINODE, 0);
		if (error)
			goto fail_quota_locks;
	}

545
	error = gfs2_dir_add(&dip->i_inode, name, ip, da);
546
547
548

	gfs2_trans_end(sdp);
fail_ipreserv:
549
	gfs2_inplace_release(dip);
550
551
552
553
554
fail_quota_locks:
	gfs2_quota_unlock(dip);
	return error;
}

555
static int gfs2_initxattrs(struct inode *inode, const struct xattr *xattr_array,
556
		    void *fs_info)
557
{
558
559
560
561
562
563
564
565
566
	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;
567
568
569
	}
	return err;
}
David Teigland's avatar
David Teigland committed
570

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

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

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

604
	error = gfs2_rsqa_alloc(dip);
605
606
607
	if (error)
		return error;

608
609
610
611
	error = gfs2_rindex_update(sdp);
	if (error)
		return error;

612
	error = gfs2_glock_nq_init(dip->i_gl, LM_ST_EXCLUSIVE, 0, ghs);
613
614
615
616
	if (error)
		goto fail;

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

642
	error = gfs2_diradd_alloc_required(dir, name, &da);
643
644
645
	if (error < 0)
		goto fail_gunlock;

646
	inode = new_inode(sdp->sd_vfs);
647
648
649
650
	error = -ENOMEM;
	if (!inode)
		goto fail_gunlock;

651
652
	error = posix_acl_create(dir, &mode, &default_acl, &acl);
	if (error)
653
		goto fail_gunlock;
654

655
	ip = GFS2_I(inode);
656
	error = gfs2_rsqa_alloc(ip);
657
	if (error)
658
		goto fail_free_acls;
659
660

	inode->i_mode = mode;
661
	set_nlink(inode, S_ISDIR(mode) ? 2 : 1);
662
663
	inode->i_rdev = dev;
	inode->i_size = size;
664
	inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
665
	gfs2_set_inode_blocks(inode, 1);
666
	munge_mode_uid_gid(dip, inode);
667
	check_and_update_goal(dip);
668
	ip->i_goal = dip->i_goal;
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
	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;
	}
688
689
690
691
692

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

693
	gfs2_set_inode_flags(inode);
694

695
	if ((GFS2_I(d_inode(sdp->sd_root_dir)) == dip) ||
Steven Whitehouse's avatar
Steven Whitehouse committed
696
697
698
	    (dip->i_diskflags & GFS2_DIF_TOPDIR))
		aflags |= GFS2_AF_ORLOV;

699
700
701
702
	if (default_acl || acl)
		blocks++;

	error = alloc_dinode(ip, aflags, &blocks);
703
	if (error)
704
		goto fail_free_inode;
705

706
707
	gfs2_set_inode_blocks(inode, blocks);

708
	error = gfs2_glock_get(sdp, ip->i_no_addr, &gfs2_inode_glops, CREATE, &ip->i_gl);
709
	if (error)
710
		goto fail_free_inode;
711

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

717
	error = gfs2_trans_begin(sdp, blocks, 0);
718
	if (error)
719
720
		goto fail_gunlock2;

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

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

732
733
	BUG_ON(test_and_set_bit(GLF_INODE_CREATING, &io_gl->gl_flags));

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

738
739
740
741
742
	ip->i_iopen_gh.gh_gl->gl_object = ip;
	gfs2_glock_put(io_gl);
	gfs2_set_iop(inode);
	insert_inode_hash(inode);

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

756
	if (error)
757
		goto fail_gunlock3;
758

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

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

768
	mark_inode_dirty(inode);
769
	d_instantiate(dentry, inode);
Miklos Szeredi's avatar
Miklos Szeredi committed
770
771
	if (file) {
		*opened |= FILE_CREATED;
772
		error = finish_open(file, dentry, gfs2_open_common, opened);
Miklos Szeredi's avatar
Miklos Szeredi committed
773
	}
774
775
	gfs2_glock_dq_uninit(ghs);
	gfs2_glock_dq_uninit(ghs + 1);
776
	clear_bit(GLF_INODE_CREATING, &io_gl->gl_flags);
777
	return error;
778

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

David Teigland's avatar
David Teigland committed
810
811
812
813
814
815
816
817
818
819
/**
 * 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
820
		       umode_t mode, bool excl)
David Teigland's avatar
David Teigland committed
821
{
822
	return gfs2_create_inode(dir, dentry, NULL, S_IFREG | mode, 0, NULL, 0, excl, NULL);
David Teigland's avatar
David Teigland committed
823
824
825
}

/**
826
 * __gfs2_lookup - Look up a filename in a directory and return its inode
David Teigland's avatar
David Teigland committed
827
828
 * @dir: The directory inode
 * @dentry: The dentry of the new inode
829
830
 * @file: File to be opened
 * @opened: atomic_open flags
David Teigland's avatar
David Teigland committed
831
832
833
834
835
 *
 *
 * Returns: errno
 */

836
837
static struct dentry *__gfs2_lookup(struct inode *dir, struct dentry *dentry,
				    struct file *file, int *opened)
David Teigland's avatar
David Teigland committed
838
{
839
840
841
842
843
844
845
	struct inode *inode;
	struct dentry *d;
	struct gfs2_holder gh;
	struct gfs2_glock *gl;
	int error;

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

	d = d_splice_alias(inode, dentry);
861
862
863
864
	if (IS_ERR(d)) {
		gfs2_glock_dq_uninit(&gh);
		return d;
	}
865
866
867
868
	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
869
870
	if (error) {
		dput(d);
871
		return ERR_PTR(error);
Miklos Szeredi's avatar
Miklos Szeredi committed
872
	}
873
874
875
876
877
878
879
	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
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
}

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

906
	if (S_ISDIR(inode->i_mode))
David Teigland's avatar
David Teigland committed
907
908
		return -EPERM;

909
	error = gfs2_rsqa_alloc(dip);
910
911
912
	if (error)
		return error;

David Teigland's avatar
David Teigland committed
913
914
915
	gfs2_holder_init(dip->i_gl, LM_ST_EXCLUSIVE, 0, ghs);
	gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + 1);

916
917
918
919
920
	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
921
	if (error)
922
		goto out_child;
David Teigland's avatar
David Teigland committed
923

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

928
	error = gfs2_permission(dir, MAY_WRITE | MAY_EXEC);
David Teigland's avatar
David Teigland committed
929
930
931
	if (error)
		goto out_gunlock;

932
	error = gfs2_dir_check(dir, &dentry->d_name, NULL);
David Teigland's avatar
David Teigland committed
933
934
935
936
937
938
939
940
941
942
	switch (error) {
	case -ENOENT:
		break;
	case 0:
		error = -EEXIST;
	default:
		goto out_gunlock;
	}

	error = -EINVAL;
943
	if (!dip->i_inode.i_nlink)
David Teigland's avatar
David Teigland committed
944
945
		goto out_gunlock;
	error = -EFBIG;
946
	if (dip->i_entries == (u32)-1)
David Teigland's avatar
David Teigland committed
947
948
949
950
951
		goto out_gunlock;
	error = -EPERM;
	if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
		goto out_gunlock;
	error = -EINVAL;
952
	if (!ip->i_inode.i_nlink)
David Teigland's avatar
David Teigland committed
953
954
		goto out_gunlock;
	error = -EMLINK;
955
	if (ip->i_inode.i_nlink == (u32)-1)
David Teigland's avatar
David Teigland committed
956
957
		goto out_gunlock;

958
	error = gfs2_diradd_alloc_required(dir, &dentry->d_name, &da);
959
	if (error < 0)
David Teigland's avatar
David Teigland committed
960
961
		goto out_gunlock;

962
963
	if (da.nr_blocks) {
		struct gfs2_alloc_parms ap = { .target = da.nr_blocks, };
964
		error = gfs2_quota_lock_check(dip, &ap);
David Teigland's avatar
David Teigland committed
965
		if (error)
966
			goto out_gunlock;
David Teigland's avatar
David Teigland committed
967

968
		error = gfs2_inplace_reserve(dip, &ap);
David Teigland's avatar
David Teigland committed
969
970
971
		if (error)
			goto out_gunlock_q;

972
		error = gfs2_trans_begin(sdp, gfs2_trans_da_blks(dip, &da, 2), 0);
David Teigland's avatar
David Teigland committed
973
974
975
976
977
978
979
980
		if (error)
			goto out_ipres;
	} else {
		error = gfs2_trans_begin(sdp, 2 * RES_DINODE + RES_LEAF, 0);
		if (error)
			goto out_ipres;
	}

981
	error = gfs2_meta_inode_buffer(ip, &dibh);
David Teigland's avatar
David Teigland committed
982
983
984
	if (error)
		goto out_end_trans;

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

989
	gfs2_trans_add_meta(ip->i_gl, dibh);
990
991
	inc_nlink(&ip->i_inode);
	ip->i_inode.i_ctime = CURRENT_TIME;
Steven Whitehouse's avatar
Steven Whitehouse committed
992
993
994
	ihold(inode);
	d_instantiate(dentry, inode);
	mark_inode_dirty(inode);
David Teigland's avatar
David Teigland committed
995

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

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

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

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

1048
	return gfs2_dir_check(&dip->i_inode, name, ip);
1049
1050
}

David Teigland's avatar
David Teigland committed
1051
/**
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
 * 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,
1064
			     const struct dentry *dentry)
1065
{
1066
	struct inode *inode = d_inode(dentry);
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
	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
1090
1091
 * @dentry: The file itself
 *
1092
1093
 * 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
1094
1095
1096
1097
1098
1099
 *
 * Returns: errno
 */

static int gfs2_unlink(struct inode *dir, struct dentry *dentry)
{
1100
1101
	struct gfs2_inode *dip = GFS2_I(dir);
	struct gfs2_sbd *sdp = GFS2_SB(dir);
1102
	struct inode *inode = d_inode(dentry);
1103
	struct gfs2_inode *ip = GFS2_I(inode);
Russell Cattelan's avatar
Russell Cattelan committed
1104
1105
	struct gfs2_holder ghs[3];
	struct gfs2_rgrpd *rgd;
1106
1107
1108
1109
1110
1111
1112
	int error;

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

	error = -EROFS;
David Teigland's avatar
David Teigland committed
1113
1114

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

Steven Whitehouse's avatar
Steven Whitehouse committed
1117
	rgd = gfs2_blk2rgrpd(sdp, ip->i_no_addr, 1);
1118
	if (!rgd)
1119
		goto out_inodes;
1120

Russell Cattelan's avatar
Russell Cattelan committed
1121
1122
1123
	gfs2_holder_init(rgd->rd_gl, LM_ST_EXCLUSIVE, 0, ghs + 2);


1124
	error = gfs2_glock_nq(ghs); /* parent */
David Teigland's avatar
David Teigland committed
1125
	if (error)
1126
1127
1128
1129
1130
1131
		goto out_parent;

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

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

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

1142
1143
1144
	error = gfs2_glock_nq(ghs + 2); /* rgrp */
	if (error)
		goto out_rgrp;
David Teigland's avatar
David Teigland committed
1145
1146
1147

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

1150
1151
1152
	error = gfs2_trans_begin(sdp, 2*RES_DINODE + 3*RES_LEAF + RES_RG_BIT, 0);
	if (error)
		goto out_end_trans;
David Teigland's avatar
David Teigland committed
1153

1154
	error = gfs2_unlink_inode(dip, dentry);
David Teigland's avatar
David Teigland committed
1155

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

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

1191
	return gfs2_create_inode(dir, dentry, NULL, S_IFLNK | S_IRWXUGO, 0, symname, size, 0, NULL);
David Teigland's avatar
David Teigland committed
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
}

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

1203
static int gfs2_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
David Teigland's avatar
David Teigland committed
1204
{
1205
1206
	struct gfs2_sbd *sdp = GFS2_SB(dir);
	unsigned dsize = sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode);
1207
	return gfs2_create_inode(dir, dentry, NULL, S_IFDIR | mode, 0, NULL, dsize, 0, NULL);
David Teigland's avatar
David Teigland committed
1208
1209
1210
1211
1212
1213
1214
}

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