inode.c 49.1 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
194
195
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
298
299
300
301
302
303
304
305
306
307
308
309
310
	ip->i_iopen_gh.gh_gl->gl_object = NULL;
	gfs2_glock_dq_uninit(&ip->i_iopen_gh);
fail_iopen:
	if (io_gl)
		gfs2_glock_put(io_gl);
fail_put:
	ip->i_gl->gl_object = NULL;
	gfs2_glock_put(ip->i_gl);
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 &&
	     dir == sb->s_root->d_inode)) {
		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;
596
	int error, free_vfs_inode = 0;
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
605
606
607
	error = gfs2_rs_alloc(dip);
	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
653
654
	error = posix_acl_create(dir, &mode, &default_acl, &acl);
	if (error)
		goto fail_free_vfs_inode;

655
656
	ip = GFS2_I(inode);
	error = gfs2_rs_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
688
	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;
	}
	gfs2_set_inode_flags(inode);
689

Steven Whitehouse's avatar
Steven Whitehouse committed
690
691
692
693
	if ((GFS2_I(sdp->sd_root_dir->d_inode) == dip) ||
	    (dip->i_diskflags & GFS2_DIF_TOPDIR))
		aflags |= GFS2_AF_ORLOV;

694
695
696
697
	if (default_acl || acl)
		blocks++;

	error = alloc_dinode(ip, aflags, &blocks);
698
	if (error)
699
		goto fail_free_inode;
700

701
702
	gfs2_set_inode_blocks(inode, blocks);

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

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

712
	error = gfs2_trans_begin(sdp, blocks, 0);
713
	if (error)
714
715
		goto fail_gunlock2;

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

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

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

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

736
737
738
739
740
741
742
743
744
745
	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);
	}

746
	if (error)
747
		goto fail_gunlock3;
748

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

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

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

768
769
770
771
772
773
fail_gunlock3:
	gfs2_glock_dq_uninit(ghs + 1);
	if (ip->i_gl)
		gfs2_glock_put(ip->i_gl);
	goto fail_gunlock;

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

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

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

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

	inode = gfs2_lookupi(dir, &dentry->d_name, 0);
838
839
	if (inode == NULL) {
		d_add(dentry, NULL);
840
		return NULL;
841
	}
842
843
844
845
846
847
848
849
	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);
850
	}
851
852

	d = d_splice_alias(inode, dentry);
853
854
855
856
	if (IS_ERR(d)) {
		gfs2_glock_dq_uninit(&gh);
		return d;
	}
857
858
859
860
	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
861
862
	if (error) {
		dput(d);
863
		return ERR_PTR(error);
Miklos Szeredi's avatar
Miklos Szeredi committed
864
	}
865
866
867
868
869
870
871
	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
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
}

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

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

901
902
903
904
	error = gfs2_rs_alloc(dip);
	if (error)
		return error;

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

908
909
910
911
912
	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
913
	if (error)
914
		goto out_child;
David Teigland's avatar
David Teigland committed
915

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

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

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

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

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

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

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

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

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

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

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

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

1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
/*
 * 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) &&
1029
1030
	    !uid_eq(dip->i_inode.i_uid, current_fsuid()) &&
	    !uid_eq(ip->i_inode.i_uid, current_fsuid()) && !capable(CAP_FOWNER))
1031
1032
1033
1034
1035
		return -EPERM;

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

1142
1143
1144
	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
1145

1146
	error = gfs2_unlink_inode(dip, dentry);
David Teigland's avatar
David Teigland committed
1147

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

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

1183
	return gfs2_create_inode(dir, dentry, NULL, S_IFLNK | S_IRWXUGO, 0, symname, size, 0, NULL);
David Teigland's avatar
David Teigland committed
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
}

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

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

/**
 * 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
1207
 * @dev: The device specification of the special file
David Teigland's avatar
David Teigland committed
1208
1209
1210
 *
 */

Al Viro's avatar
Al Viro committed
1211
static int gfs2_mknod(struct inode *dir, struct dentry *dentry, umode_t mode,
David Teigland's avatar
David Teigland committed
1212
1213
		      dev_t dev)
{
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
	return gfs2_create_inode(dir, dentry, NULL, mode, dev, NULL, 0, 0, NULL);
}

/**
 * gfs2_atomic_open - Atomically open a file
 * @dir: The directory
 * @dentry: The proposed new entry
 * @file: The proposed new struct file
 * @flags: open flags
 * @mode: File mode
 * @opened: Flag to say whether the file has been opened or not
 *
 * Returns: error code or 0 for success
 */

static int gfs2_atomic_open(struct inode *dir, struct dentry *dentry,
1230
1231
			    struct file *file, unsigned flags,
			    umode_t mode, int *opened)
1232
1233
1234
1235
{
	struct dentry *d;
	bool excl = !!(flags & O_EXCL);

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

1239
1240
1241
	d = __gfs2_lookup(dir, dentry, file, opened);
	if (IS_ERR(d))
		return PTR_ERR(d);
Miklos Szeredi's avatar
Miklos Szeredi committed
1242
1243
1244
	if (d != NULL)
		dentry = d;
	if (dentry->d_inode) {
1245
1246
		if (!(*opened & FILE_OPENED))
			return finish_no_open(file, d);
Miklos Szeredi's avatar
Miklos Szeredi committed
1247
		dput(d);
1248
1249
1250
		return 0;
	}

Miklos Szeredi's avatar
Miklos Szeredi committed
1251
	BUG_ON(d != NULL);