inode.c 49.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
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
	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 &&
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;
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
	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
653
654
	error = posix_acl_create(dir, &mode, &default_acl, &acl);
	if (error)
		goto fail_free_vfs_inode;

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
	error = gfs2_glock_nq_init(io_gl, LM_ST_SHARED, GL_EXACT, &ip->i_iopen_gh);
733
734
	if (error)
		goto fail_gunlock2;
735

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

741
742
743
744
745
746
747
748
749
750
	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);
	}

751
	if (error)
752
		goto fail_gunlock3;
753

754
755
	error = security_inode_init_security(&ip->i_inode, &dip->i_inode, name,
					     &gfs2_initxattrs, NULL);
756
	if (error)
757
		goto fail_gunlock3;
758

759
	error = link_dinode(dip, name, ip, &da);
760
	if (error)
761
		goto fail_gunlock3;
762

763
	mark_inode_dirty(inode);
764
	d_instantiate(dentry, inode);
Miklos Szeredi's avatar
Miklos Szeredi committed
765
766
	if (file) {
		*opened |= FILE_CREATED;
767
		error = finish_open(file, dentry, gfs2_open_common, opened);
Miklos Szeredi's avatar
Miklos Szeredi committed
768
	}
769
770
	gfs2_glock_dq_uninit(ghs);
	gfs2_glock_dq_uninit(ghs + 1);
771
	return error;
772

773
774
775
776
777
778
fail_gunlock3:
	gfs2_glock_dq_uninit(ghs + 1);
	if (ip->i_gl)
		gfs2_glock_put(ip->i_gl);
	goto fail_gunlock;

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

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

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

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

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

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

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

903
	if (S_ISDIR(inode->i_mode))
David Teigland's avatar
David Teigland committed
904
905
		return -EPERM;

906
	error = gfs2_rsqa_alloc(dip);
907
908
909
	if (error)
		return error;

David Teigland's avatar
David Teigland committed
910
911
912
	gfs2_holder_init(dip->i_gl, LM_ST_EXCLUSIVE, 0, ghs);
	gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + 1);

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

921
922
923
924
	error = -ENOENT;
	if (inode->i_nlink == 0)
		goto out_gunlock;

925
	error = gfs2_permission(dir, MAY_WRITE | MAY_EXEC);
David Teigland's avatar
David Teigland committed
926
927
928
	if (error)
		goto out_gunlock;

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

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

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

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

965
		error = gfs2_inplace_reserve(dip, &ap);
David Teigland's avatar
David Teigland committed
966
967
968
		if (error)
			goto out_gunlock_q;

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

978
	error = gfs2_meta_inode_buffer(ip, &dibh);
David Teigland's avatar
David Teigland committed
979
980
981
	if (error)
		goto out_end_trans;

982
	error = gfs2_dir_add(dir, &dentry->d_name, ip, &da);
983
984
985
	if (error)
		goto out_brelse;

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

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

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

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

1041
	error = gfs2_permission(&dip->i_inode, MAY_WRITE | MAY_EXEC);
1042
1043
1044
	if (error)
		return error;

1045
	return gfs2_dir_check(&dip->i_inode, name, ip);
1046
1047
}

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

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

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

	error = -EROFS;
David Teigland's avatar
David Teigland committed
1110
1111

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

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

Russell Cattelan's avatar
Russell Cattelan committed
1118
1119
1120
	gfs2_holder_init(rgd->rd_gl, LM_ST_EXCLUSIVE, 0, ghs + 2);


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

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

1129
	error = -ENOENT;
1130
	if (inode->i_nlink == 0)
1131
1132
		goto out_rgrp;

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

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

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

1147
1148
1149
	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
1150

1151
	error = gfs2_unlink_inode(dip, dentry);
David Teigland's avatar
David Teigland committed
1152

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

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

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

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

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

/**
 * 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
1212
 * @dev: The device specification of the special file
David Teigland's avatar
David Teigland committed
1213
1214
1215
 *
 */

Al Viro's avatar
Al Viro committed
1216
static int gfs2_mknod(struct inode *dir, struct dentry *dentry, umode_t mode,
David Teigland's avatar
David Teigland committed
1217
1218
		      dev_t dev)
{
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
	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,
1235
1236
			    struct file *file, unsigned flags,
			    umode_t mode, int *opened)
<