inode.c 31.7 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-2006 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
 */

#include <linux/sched.h>
#include <linux/slab.h>
#include <linux/spinlock.h>
#include <linux/completion.h>
#include <linux/buffer_head.h>
#include <linux/posix_acl.h>
#include <linux/sort.h>
17
#include <linux/gfs2_ondisk.h>
18
#include <linux/crc32.h>
19
#include <linux/lm_interface.h>
20
#include <linux/security.h>
David Teigland's avatar
David Teigland committed
21
22

#include "gfs2.h"
23
#include "incore.h"
David Teigland's avatar
David Teigland committed
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
#include "acl.h"
#include "bmap.h"
#include "dir.h"
#include "eattr.h"
#include "glock.h"
#include "glops.h"
#include "inode.h"
#include "log.h"
#include "meta_io.h"
#include "ops_address.h"
#include "ops_file.h"
#include "ops_inode.h"
#include "quota.h"
#include "rgrp.h"
#include "trans.h"
39
#include "util.h"
David Teigland's avatar
David Teigland committed
40

41
42
43
44
45
struct gfs2_inum_range_host {
	u64 ir_start;
	u64 ir_length;
};

46
47
48
static int iget_test(struct inode *inode, void *opaque)
{
	struct gfs2_inode *ip = GFS2_I(inode);
49
	u64 *no_addr = opaque;
50

51
	if (ip->i_no_addr == *no_addr &&
52
	    inode->i_private != NULL)
53
		return 1;
David Teigland's avatar
David Teigland committed
54

55
56
57
58
	return 0;
}

static int iget_set(struct inode *inode, void *opaque)
David Teigland's avatar
David Teigland committed
59
{
60
	struct gfs2_inode *ip = GFS2_I(inode);
61
	u64 *no_addr = opaque;
David Teigland's avatar
David Teigland committed
62

63
64
	inode->i_ino = (unsigned long)*no_addr;
	ip->i_no_addr = *no_addr;
65
66
	return 0;
}
David Teigland's avatar
David Teigland committed
67

68
struct inode *gfs2_ilookup(struct super_block *sb, u64 no_addr)
69
{
70
71
	unsigned long hash = (unsigned long)no_addr;
	return ilookup5(sb, hash, iget_test, &no_addr);
72
}
David Teigland's avatar
David Teigland committed
73

74
static struct inode *gfs2_iget(struct super_block *sb, u64 no_addr)
75
{
76
77
	unsigned long hash = (unsigned long)no_addr;
	return iget5_locked(sb, hash, iget_test, iget_set, &no_addr);
David Teigland's avatar
David Teigland committed
78
79
80
}

/**
81
82
 * gfs2_inode_lookup - Lookup an inode
 * @sb: The super block
83
 * @no_addr: The inode number
84
 * @type: The type of the inode
David Teigland's avatar
David Teigland committed
85
 *
86
 * Returns: A VFS inode, or an error
David Teigland's avatar
David Teigland committed
87
88
 */

89
struct inode *gfs2_inode_lookup(struct super_block *sb, u64 no_addr, unsigned int type)
David Teigland's avatar
David Teigland committed
90
{
91
	struct inode *inode = gfs2_iget(sb, no_addr);
92
93
94
	struct gfs2_inode *ip = GFS2_I(inode);
	struct gfs2_glock *io_gl;
	int error;
David Teigland's avatar
David Teigland committed
95

96
97
98
	if (!inode)
		return ERR_PTR(-ENOBUFS);

99
100
	if (inode->i_state & I_NEW) {
		struct gfs2_sbd *sdp = GFS2_SB(inode);
101
		umode_t mode;
102
		inode->i_private = ip;
David Teigland's avatar
David Teigland committed
103

104
		error = gfs2_glock_get(sdp, no_addr, &gfs2_inode_glops, CREATE, &ip->i_gl);
105
106
107
		if (unlikely(error))
			goto fail;
		ip->i_gl->gl_object = ip;
David Teigland's avatar
David Teigland committed
108

109
		error = gfs2_glock_get(sdp, no_addr, &gfs2_iopen_glops, CREATE, &io_gl);
110
111
		if (unlikely(error))
			goto fail_put;
David Teigland's avatar
David Teigland committed
112

113
		set_bit(GIF_INVALID, &ip->i_flags);
114
115
116
		error = gfs2_glock_nq_init(io_gl, LM_ST_SHARED, GL_EXACT, &ip->i_iopen_gh);
		if (unlikely(error))
			goto fail_iopen;
David Teigland's avatar
David Teigland committed
117

118
		gfs2_glock_put(io_gl);
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

		/*
		 * We must read the inode in order to work out its type in
		 * this case. Note that this doesn't happen often as we normally
		 * know the type beforehand. This code path only occurs during
		 * unlinked inode recovery (where it is safe to do this glock,
		 * which is not true in the general case).
		 */
		inode->i_mode = mode = DT2IF(type);
		if (type == DT_UNKNOWN) {
			struct gfs2_holder gh;
			error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);
			if (unlikely(error))
				goto fail_glock;
			/* Inode is now uptodate */
			mode = inode->i_mode;
			gfs2_glock_dq_uninit(&gh);
		}

		if (S_ISREG(mode)) {
			inode->i_op = &gfs2_file_iops;
			inode->i_fop = &gfs2_file_fops;
			inode->i_mapping->a_ops = &gfs2_file_aops;
		} else if (S_ISDIR(mode)) {
			inode->i_op = &gfs2_dir_iops;
			inode->i_fop = &gfs2_dir_fops;
		} else if (S_ISLNK(mode)) {
			inode->i_op = &gfs2_symlink_iops;
		} else {
			inode->i_op = &gfs2_dev_iops;
		}

151
152
		unlock_new_inode(inode);
	}
David Teigland's avatar
David Teigland committed
153
154

	return inode;
155
156
fail_glock:
	gfs2_glock_dq(&ip->i_iopen_gh);
157
158
159
160
161
162
163
164
fail_iopen:
	gfs2_glock_put(io_gl);
fail_put:
	ip->i_gl->gl_object = NULL;
	gfs2_glock_put(ip->i_gl);
fail:
	iput(inode);
	return ERR_PTR(error);
David Teigland's avatar
David Teigland committed
165
166
}

167
static int gfs2_dinode_in(struct gfs2_inode *ip, const void *buf)
168
169
170
171
{
	struct gfs2_dinode_host *di = &ip->i_di;
	const struct gfs2_dinode *str = buf;

172
	if (ip->i_no_addr != be64_to_cpu(str->di_num.no_addr)) {
173
174
175
176
		if (gfs2_consist_inode(ip))
			gfs2_dinode_print(ip);
		return -EIO;
	}
177
	ip->i_no_formal_ino = be64_to_cpu(str->di_num.no_formal_ino);
178
	ip->i_inode.i_mode = be32_to_cpu(str->di_mode);
179
	ip->i_inode.i_rdev = 0;
180
	switch (ip->i_inode.i_mode & S_IFMT) {
181
182
183
184
185
186
187
	case S_IFBLK:
	case S_IFCHR:
		ip->i_inode.i_rdev = MKDEV(be32_to_cpu(str->di_major),
					   be32_to_cpu(str->di_minor));
		break;
	};

188
189
	ip->i_inode.i_uid = be32_to_cpu(str->di_uid);
	ip->i_inode.i_gid = be32_to_cpu(str->di_gid);
190
191
192
193
194
195
	/*
	 * We will need to review setting the nlink count here in the
	 * light of the forthcoming ro bind mount work. This is a reminder
	 * to do that.
	 */
	ip->i_inode.i_nlink = be32_to_cpu(str->di_nlink);
196
	di->di_size = be64_to_cpu(str->di_size);
197
	i_size_write(&ip->i_inode, di->di_size);
198
	di->di_blocks = be64_to_cpu(str->di_blocks);
199
	gfs2_set_inode_blocks(&ip->i_inode);
200
	ip->i_inode.i_atime.tv_sec = be64_to_cpu(str->di_atime);
201
	ip->i_inode.i_atime.tv_nsec = be32_to_cpu(str->di_atime_nsec);
202
	ip->i_inode.i_mtime.tv_sec = be64_to_cpu(str->di_mtime);
203
	ip->i_inode.i_mtime.tv_nsec = be32_to_cpu(str->di_mtime_nsec);
204
	ip->i_inode.i_ctime.tv_sec = be64_to_cpu(str->di_ctime);
205
	ip->i_inode.i_ctime.tv_nsec = be32_to_cpu(str->di_ctime_nsec);
206
207
208
209
210
211

	di->di_goal_meta = be64_to_cpu(str->di_goal_meta);
	di->di_goal_data = be64_to_cpu(str->di_goal_data);
	di->di_generation = be64_to_cpu(str->di_generation);

	di->di_flags = be32_to_cpu(str->di_flags);
212
	gfs2_set_inode_flags(&ip->i_inode);
213
214
215
216
217
218
	di->di_height = be16_to_cpu(str->di_height);

	di->di_depth = be16_to_cpu(str->di_depth);
	di->di_entries = be32_to_cpu(str->di_entries);

	di->di_eattr = be64_to_cpu(str->di_eattr);
219
	return 0;
220
221
}

David Teigland's avatar
David Teigland committed
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
/**
 * gfs2_inode_refresh - Refresh the incore copy of the dinode
 * @ip: The GFS2 inode
 *
 * Returns: errno
 */

int gfs2_inode_refresh(struct gfs2_inode *ip)
{
	struct buffer_head *dibh;
	int error;

	error = gfs2_meta_inode_buffer(ip, &dibh);
	if (error)
		return error;

238
	if (gfs2_metatype_check(GFS2_SB(&ip->i_inode), dibh, GFS2_METATYPE_DI)) {
David Teigland's avatar
David Teigland committed
239
240
241
242
		brelse(dibh);
		return -EIO;
	}

243
	error = gfs2_dinode_in(ip, dibh->b_data);
David Teigland's avatar
David Teigland committed
244
	brelse(dibh);
245
	clear_bit(GIF_INVALID, &ip->i_flags);
David Teigland's avatar
David Teigland committed
246

247
	return error;
David Teigland's avatar
David Teigland committed
248
249
}

250
int gfs2_dinode_dealloc(struct gfs2_inode *ip)
David Teigland's avatar
David Teigland committed
251
{
252
	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
David Teigland's avatar
David Teigland committed
253
254
255
256
257
258
	struct gfs2_alloc *al;
	struct gfs2_rgrpd *rgd;
	int error;

	if (ip->i_di.di_blocks != 1) {
		if (gfs2_consist_inode(ip))
259
			gfs2_dinode_print(ip);
David Teigland's avatar
David Teigland committed
260
261
262
263
264
265
266
267
268
269
270
271
272
		return -EIO;
	}

	al = gfs2_alloc_get(ip);

	error = gfs2_quota_hold(ip, NO_QUOTA_CHANGE, NO_QUOTA_CHANGE);
	if (error)
		goto out;

	error = gfs2_rindex_hold(sdp, &al->al_ri_gh);
	if (error)
		goto out_qs;

273
	rgd = gfs2_blk2rgrpd(sdp, ip->i_no_addr);
David Teigland's avatar
David Teigland committed
274
275
276
277
278
279
280
281
282
283
284
	if (!rgd) {
		gfs2_consist_inode(ip);
		error = -EIO;
		goto out_rindex_relse;
	}

	error = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_EXCLUSIVE, 0,
				   &al->al_rgd_gh);
	if (error)
		goto out_rindex_relse;

285
	error = gfs2_trans_begin(sdp, RES_RG_BIT + RES_STATFS + RES_QUOTA, 1);
David Teigland's avatar
David Teigland committed
286
287
288
289
290
291
292
293
294
295
	if (error)
		goto out_rg_gunlock;

	gfs2_trans_add_gl(ip->i_gl);

	gfs2_free_di(rgd, ip);

	gfs2_trans_end(sdp);
	clear_bit(GLF_STICKY, &ip->i_gl->gl_flags);

296
out_rg_gunlock:
David Teigland's avatar
David Teigland committed
297
	gfs2_glock_dq_uninit(&al->al_rgd_gh);
298
out_rindex_relse:
David Teigland's avatar
David Teigland committed
299
	gfs2_glock_dq_uninit(&al->al_ri_gh);
300
out_qs:
David Teigland's avatar
David Teigland committed
301
	gfs2_quota_unhold(ip);
302
out:
303
	gfs2_alloc_put(ip);
David Teigland's avatar
David Teigland committed
304
305
306
307
	return error;
}

/**
308
 * gfs2_change_nlink - Change nlink count on inode
David Teigland's avatar
David Teigland committed
309
310
311
312
313
 * @ip: The GFS2 inode
 * @diff: The change in the nlink count required
 *
 * Returns: errno
 */
314
int gfs2_change_nlink(struct gfs2_inode *ip, int diff)
David Teigland's avatar
David Teigland committed
315
316
{
	struct buffer_head *dibh;
317
	u32 nlink;
David Teigland's avatar
David Teigland committed
318
319
	int error;

320
321
	BUG_ON(diff != 1 && diff != -1);
	nlink = ip->i_inode.i_nlink + diff;
David Teigland's avatar
David Teigland committed
322
323
324

	/* If we are reducing the nlink count, but the new value ends up being
	   bigger than the old one, we must have underflowed. */
325
	if (diff < 0 && nlink > ip->i_inode.i_nlink) {
David Teigland's avatar
David Teigland committed
326
		if (gfs2_consist_inode(ip))
327
			gfs2_dinode_print(ip);
David Teigland's avatar
David Teigland committed
328
329
330
331
332
333
334
		return -EIO;
	}

	error = gfs2_meta_inode_buffer(ip, &dibh);
	if (error)
		return error;

335
336
337
338
339
	if (diff > 0)
		inc_nlink(&ip->i_inode);
	else
		drop_nlink(&ip->i_inode);

340
	ip->i_inode.i_ctime = CURRENT_TIME;
David Teigland's avatar
David Teigland committed
341

342
	gfs2_trans_add_bh(ip->i_gl, dibh, 1);
343
	gfs2_dinode_out(ip, dibh->b_data);
David Teigland's avatar
David Teigland committed
344
	brelse(dibh);
345
	mark_inode_dirty(&ip->i_inode);
David Teigland's avatar
David Teigland committed
346

347
	if (ip->i_inode.i_nlink == 0)
Russell Cattelan's avatar
Russell Cattelan committed
348
		gfs2_unlink_di(&ip->i_inode); /* mark inode unlinked */
349

350
351
352
	return error;
}

353
354
355
struct inode *gfs2_lookup_simple(struct inode *dip, const char *name)
{
	struct qstr qstr;
356
	struct inode *inode;
357
	gfs2_str2qstr(&qstr, name);
358
359
360
361
362
363
364
365
366
367
	inode = gfs2_lookupi(dip, &qstr, 1, NULL);
	/* 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;
368
369
370
}


David Teigland's avatar
David Teigland committed
371
372
373
374
375
376
377
/**
 * 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
 *
378
379
380
381
 * 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.
David Teigland's avatar
David Teigland committed
382
383
384
385
 *
 * Returns: errno
 */

386
387
struct inode *gfs2_lookupi(struct inode *dir, const struct qstr *name,
			   int is_root, struct nameidata *nd)
David Teigland's avatar
David Teigland committed
388
{
Steven Whitehouse's avatar
Steven Whitehouse committed
389
	struct super_block *sb = dir->i_sb;
390
	struct gfs2_inode *dip = GFS2_I(dir);
David Teigland's avatar
David Teigland committed
391
	struct gfs2_holder d_gh;
392
	int error = 0;
393
	struct inode *inode = NULL;
394
	int unlock = 0;
David Teigland's avatar
David Teigland committed
395
396

	if (!name->len || name->len > GFS2_FNAMESIZE)
397
		return ERR_PTR(-ENAMETOOLONG);
David Teigland's avatar
David Teigland committed
398

399
400
401
	if ((name->len == 1 && memcmp(name->name, ".", 1) == 0) ||
	    (name->len == 2 && memcmp(name->name, "..", 2) == 0 &&
	     dir == sb->s_root->d_inode)) {
402
403
		igrab(dir);
		return dir;
David Teigland's avatar
David Teigland committed
404
405
	}

406
407
408
409
410
411
	if (gfs2_glock_is_locked_by_me(dip->i_gl) == 0) {
		error = gfs2_glock_nq_init(dip->i_gl, LM_ST_SHARED, 0, &d_gh);
		if (error)
			return ERR_PTR(error);
		unlock = 1;
	}
David Teigland's avatar
David Teigland committed
412
413

	if (!is_root) {
414
		error = permission(dir, MAY_EXEC, NULL);
David Teigland's avatar
David Teigland committed
415
416
417
418
		if (error)
			goto out;
	}

419
420
421
	inode = gfs2_dir_search(dir, name);
	if (IS_ERR(inode))
		error = PTR_ERR(inode);
422
out:
423
424
	if (unlock)
		gfs2_glock_dq_uninit(&d_gh);
425
426
	if (error == -ENOENT)
		return NULL;
427
	return inode ? inode : ERR_PTR(error);
David Teigland's avatar
David Teigland committed
428
429
}

430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
static void gfs2_inum_range_in(struct gfs2_inum_range_host *ir, const void *buf)
{
	const struct gfs2_inum_range *str = buf;

	ir->ir_start = be64_to_cpu(str->ir_start);
	ir->ir_length = be64_to_cpu(str->ir_length);
}

static void gfs2_inum_range_out(const struct gfs2_inum_range_host *ir, void *buf)
{
	struct gfs2_inum_range *str = buf;

	str->ir_start = cpu_to_be64(ir->ir_start);
	str->ir_length = cpu_to_be64(ir->ir_length);
}

446
static int pick_formal_ino_1(struct gfs2_sbd *sdp, u64 *formal_ino)
David Teigland's avatar
David Teigland committed
447
{
448
	struct gfs2_inode *ip = GFS2_I(sdp->sd_ir_inode);
David Teigland's avatar
David Teigland committed
449
	struct buffer_head *bh;
450
	struct gfs2_inum_range_host ir;
David Teigland's avatar
David Teigland committed
451
452
453
454
455
	int error;

	error = gfs2_trans_begin(sdp, RES_DINODE, 0);
	if (error)
		return error;
456
	mutex_lock(&sdp->sd_inum_mutex);
David Teigland's avatar
David Teigland committed
457
458
459

	error = gfs2_meta_inode_buffer(ip, &bh);
	if (error) {
460
		mutex_unlock(&sdp->sd_inum_mutex);
David Teigland's avatar
David Teigland committed
461
462
463
464
465
466
467
468
469
		gfs2_trans_end(sdp);
		return error;
	}

	gfs2_inum_range_in(&ir, bh->b_data + sizeof(struct gfs2_dinode));

	if (ir.ir_length) {
		*formal_ino = ir.ir_start++;
		ir.ir_length--;
470
		gfs2_trans_add_bh(ip->i_gl, bh, 1);
David Teigland's avatar
David Teigland committed
471
472
473
		gfs2_inum_range_out(&ir,
				    bh->b_data + sizeof(struct gfs2_dinode));
		brelse(bh);
474
		mutex_unlock(&sdp->sd_inum_mutex);
David Teigland's avatar
David Teigland committed
475
476
477
478
479
480
		gfs2_trans_end(sdp);
		return 0;
	}

	brelse(bh);

481
	mutex_unlock(&sdp->sd_inum_mutex);
David Teigland's avatar
David Teigland committed
482
483
484
485
486
	gfs2_trans_end(sdp);

	return 1;
}

487
static int pick_formal_ino_2(struct gfs2_sbd *sdp, u64 *formal_ino)
David Teigland's avatar
David Teigland committed
488
{
489
490
	struct gfs2_inode *ip = GFS2_I(sdp->sd_ir_inode);
	struct gfs2_inode *m_ip = GFS2_I(sdp->sd_inum_inode);
David Teigland's avatar
David Teigland committed
491
492
	struct gfs2_holder gh;
	struct buffer_head *bh;
493
	struct gfs2_inum_range_host ir;
David Teigland's avatar
David Teigland committed
494
495
496
497
498
499
500
501
502
	int error;

	error = gfs2_glock_nq_init(m_ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);
	if (error)
		return error;

	error = gfs2_trans_begin(sdp, 2 * RES_DINODE, 0);
	if (error)
		goto out;
503
	mutex_lock(&sdp->sd_inum_mutex);
David Teigland's avatar
David Teigland committed
504
505
506
507

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

David Teigland's avatar
David Teigland committed
509
510
511
512
	gfs2_inum_range_in(&ir, bh->b_data + sizeof(struct gfs2_dinode));

	if (!ir.ir_length) {
		struct buffer_head *m_bh;
513
		u64 x, y;
514
		__be64 z;
David Teigland's avatar
David Teigland committed
515
516
517
518
519

		error = gfs2_meta_inode_buffer(m_ip, &m_bh);
		if (error)
			goto out_brelse;

520
521
		z = *(__be64 *)(m_bh->b_data + sizeof(struct gfs2_dinode));
		x = y = be64_to_cpu(z);
David Teigland's avatar
David Teigland committed
522
523
524
525
526
		ir.ir_start = x;
		ir.ir_length = GFS2_INUM_QUANTUM;
		x += GFS2_INUM_QUANTUM;
		if (x < y)
			gfs2_consist_inode(m_ip);
527
		z = cpu_to_be64(x);
528
		gfs2_trans_add_bh(m_ip->i_gl, m_bh, 1);
529
		*(__be64 *)(m_bh->b_data + sizeof(struct gfs2_dinode)) = z;
David Teigland's avatar
David Teigland committed
530
531
532
533
534
535
536

		brelse(m_bh);
	}

	*formal_ino = ir.ir_start++;
	ir.ir_length--;

537
	gfs2_trans_add_bh(ip->i_gl, bh, 1);
David Teigland's avatar
David Teigland committed
538
539
	gfs2_inum_range_out(&ir, bh->b_data + sizeof(struct gfs2_dinode));

540
out_brelse:
David Teigland's avatar
David Teigland committed
541
	brelse(bh);
542
out_end_trans:
543
	mutex_unlock(&sdp->sd_inum_mutex);
David Teigland's avatar
David Teigland committed
544
	gfs2_trans_end(sdp);
545
out:
David Teigland's avatar
David Teigland committed
546
547
548
549
	gfs2_glock_dq_uninit(&gh);
	return error;
}

550
static int pick_formal_ino(struct gfs2_sbd *sdp, u64 *inum)
David Teigland's avatar
David Teigland committed
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
{
	int error;

	error = pick_formal_ino_1(sdp, inum);
	if (error <= 0)
		return error;

	error = pick_formal_ino_2(sdp, inum);

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

572
static int create_ok(struct gfs2_inode *dip, const struct qstr *name,
David Teigland's avatar
David Teigland committed
573
574
575
576
		     unsigned int mode)
{
	int error;

577
	error = permission(&dip->i_inode, MAY_WRITE | MAY_EXEC, NULL);
David Teigland's avatar
David Teigland committed
578
579
580
581
	if (error)
		return error;

	/*  Don't create entries in an unlinked directory  */
582
	if (!dip->i_inode.i_nlink)
David Teigland's avatar
David Teigland committed
583
584
		return -EPERM;

585
	error = gfs2_dir_check(&dip->i_inode, name, NULL);
David Teigland's avatar
David Teigland committed
586
587
588
589
590
591
592
593
594
595
	switch (error) {
	case -ENOENT:
		error = 0;
		break;
	case 0:
		return -EEXIST;
	default:
		return error;
	}

596
	if (dip->i_di.di_entries == (u32)-1)
David Teigland's avatar
David Teigland committed
597
		return -EFBIG;
598
	if (S_ISDIR(mode) && dip->i_inode.i_nlink == (u32)-1)
David Teigland's avatar
David Teigland committed
599
600
601
602
603
604
605
606
		return -EMLINK;

	return 0;
}

static void munge_mode_uid_gid(struct gfs2_inode *dip, unsigned int *mode,
			       unsigned int *uid, unsigned int *gid)
{
607
	if (GFS2_SB(&dip->i_inode)->sd_args.ar_suiddir &&
608
	    (dip->i_inode.i_mode & S_ISUID) && dip->i_inode.i_uid) {
David Teigland's avatar
David Teigland committed
609
610
		if (S_ISDIR(*mode))
			*mode |= S_ISUID;
611
		else if (dip->i_inode.i_uid != current->fsuid)
David Teigland's avatar
David Teigland committed
612
			*mode &= ~07111;
613
		*uid = dip->i_inode.i_uid;
David Teigland's avatar
David Teigland committed
614
615
616
	} else
		*uid = current->fsuid;

617
	if (dip->i_inode.i_mode & S_ISGID) {
David Teigland's avatar
David Teigland committed
618
619
		if (S_ISDIR(*mode))
			*mode |= S_ISGID;
620
		*gid = dip->i_inode.i_gid;
David Teigland's avatar
David Teigland committed
621
622
623
624
	} else
		*gid = current->fsgid;
}

625
static int alloc_dinode(struct gfs2_inode *dip, u64 *no_addr, u64 *generation)
David Teigland's avatar
David Teigland committed
626
{
627
	struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
David Teigland's avatar
David Teigland committed
628
629
630
631
632
633
634
635
636
	int error;

	gfs2_alloc_get(dip);

	dip->i_alloc.al_requested = RES_DINODE;
	error = gfs2_inplace_reserve(dip);
	if (error)
		goto out;

637
	error = gfs2_trans_begin(sdp, RES_RG_BIT + RES_STATFS, 0);
David Teigland's avatar
David Teigland committed
638
639
640
	if (error)
		goto out_ipreserv;

641
	*no_addr = gfs2_alloc_di(dip, generation);
David Teigland's avatar
David Teigland committed
642
643
644

	gfs2_trans_end(sdp);

645
out_ipreserv:
David Teigland's avatar
David Teigland committed
646
	gfs2_inplace_release(dip);
647
out:
David Teigland's avatar
David Teigland committed
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
	gfs2_alloc_put(dip);
	return error;
}

/**
 * init_dinode - Fill in a new dinode structure
 * @dip: the directory this inode is being created in
 * @gl: The glock covering the new inode
 * @inum: the inode number
 * @mode: the file permissions
 * @uid:
 * @gid:
 *
 */

static void init_dinode(struct gfs2_inode *dip, struct gfs2_glock *gl,
Al Viro's avatar
Al Viro committed
664
			const struct gfs2_inum_host *inum, unsigned int mode,
665
			unsigned int uid, unsigned int gid,
666
			const u64 *generation, dev_t dev)
David Teigland's avatar
David Teigland committed
667
{
668
	struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
669
	struct gfs2_dinode *di;
David Teigland's avatar
David Teigland committed
670
	struct buffer_head *dibh;
671
	struct timespec tv = CURRENT_TIME;
David Teigland's avatar
David Teigland committed
672
673

	dibh = gfs2_meta_new(gl, inum->no_addr);
674
	gfs2_trans_add_bh(gl, dibh, 1);
David Teigland's avatar
David Teigland committed
675
676
	gfs2_metatype_set(dibh, GFS2_METATYPE_DI, GFS2_FORMAT_DI);
	gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode));
677
678
	di = (struct gfs2_dinode *)dibh->b_data;

679
680
	di->di_num.no_formal_ino = cpu_to_be64(inum->no_formal_ino);
	di->di_num.no_addr = cpu_to_be64(inum->no_addr);
681
682
683
	di->di_mode = cpu_to_be32(mode);
	di->di_uid = cpu_to_be32(uid);
	di->di_gid = cpu_to_be32(gid);
684
685
	di->di_nlink = 0;
	di->di_size = 0;
686
	di->di_blocks = cpu_to_be64(1);
687
	di->di_atime = di->di_mtime = di->di_ctime = cpu_to_be64(tv.tv_sec);
688
689
	di->di_major = cpu_to_be32(MAJOR(dev));
	di->di_minor = cpu_to_be32(MINOR(dev));
690
	di->di_goal_meta = di->di_goal_data = cpu_to_be64(inum->no_addr);
691
	di->di_generation = cpu_to_be64(*generation);
692
	di->di_flags = 0;
David Teigland's avatar
David Teigland committed
693
694
695
696

	if (S_ISREG(mode)) {
		if ((dip->i_di.di_flags & GFS2_DIF_INHERIT_JDATA) ||
		    gfs2_tune_get(sdp, gt_new_files_jdata))
697
			di->di_flags |= cpu_to_be32(GFS2_DIF_JDATA);
David Teigland's avatar
David Teigland committed
698
699
		if ((dip->i_di.di_flags & GFS2_DIF_INHERIT_DIRECTIO) ||
		    gfs2_tune_get(sdp, gt_new_files_directio))
700
			di->di_flags |= cpu_to_be32(GFS2_DIF_DIRECTIO);
David Teigland's avatar
David Teigland committed
701
	} else if (S_ISDIR(mode)) {
702
703
704
705
		di->di_flags |= cpu_to_be32(dip->i_di.di_flags &
					    GFS2_DIF_INHERIT_DIRECTIO);
		di->di_flags |= cpu_to_be32(dip->i_di.di_flags &
					    GFS2_DIF_INHERIT_JDATA);
David Teigland's avatar
David Teigland committed
706
707
	}

708
	di->__pad1 = 0;
709
	di->di_payload_format = cpu_to_be32(S_ISDIR(mode) ? GFS2_FORMAT_DE : 0);
710
	di->di_height = 0;
711
712
	di->__pad2 = 0;
	di->__pad3 = 0;
713
714
	di->di_depth = 0;
	di->di_entries = 0;
715
	memset(&di->__pad4, 0, sizeof(di->__pad4));
716
	di->di_eattr = 0;
717
718
719
	di->di_atime_nsec = cpu_to_be32(tv.tv_nsec);
	di->di_mtime_nsec = cpu_to_be32(tv.tv_nsec);
	di->di_ctime_nsec = cpu_to_be32(tv.tv_nsec);
720
721
	memset(&di->di_reserved, 0, sizeof(di->di_reserved));

David Teigland's avatar
David Teigland committed
722
723
724
725
	brelse(dibh);
}

static int make_dinode(struct gfs2_inode *dip, struct gfs2_glock *gl,
Al Viro's avatar
Al Viro committed
726
		       unsigned int mode, const struct gfs2_inum_host *inum,
727
		       const u64 *generation, dev_t dev)
David Teigland's avatar
David Teigland committed
728
{
729
	struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
David Teigland's avatar
David Teigland committed
730
731
732
733
734
735
736
737
738
739
740
741
742
743
	unsigned int uid, gid;
	int error;

	munge_mode_uid_gid(dip, &mode, &uid, &gid);
	gfs2_alloc_get(dip);

	error = gfs2_quota_lock(dip, uid, gid);
	if (error)
		goto out;

	error = gfs2_quota_check(dip, uid, gid);
	if (error)
		goto out_quota;

744
	error = gfs2_trans_begin(sdp, RES_DINODE + RES_QUOTA, 0);
David Teigland's avatar
David Teigland committed
745
746
747
	if (error)
		goto out_quota;

748
	init_dinode(dip, gl, inum, mode, uid, gid, generation, dev);
David Teigland's avatar
David Teigland committed
749
750
751
	gfs2_quota_change(dip, +1, uid, gid);
	gfs2_trans_end(sdp);

752
out_quota:
David Teigland's avatar
David Teigland committed
753
	gfs2_quota_unlock(dip);
754
out:
David Teigland's avatar
David Teigland committed
755
756
757
758
	gfs2_alloc_put(dip);
	return error;
}

759
760
static int link_dinode(struct gfs2_inode *dip, const struct qstr *name,
		       struct gfs2_inode *ip)
David Teigland's avatar
David Teigland committed
761
{
762
	struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
David Teigland's avatar
David Teigland committed
763
764
765
766
767
768
769
770
771
772
773
	struct gfs2_alloc *al;
	int alloc_required;
	struct buffer_head *dibh;
	int error;

	al = gfs2_alloc_get(dip);

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

774
	error = alloc_required = gfs2_diradd_alloc_required(&dip->i_inode, name);
775
776
	if (alloc_required < 0)
		goto fail;
David Teigland's avatar
David Teigland committed
777
	if (alloc_required) {
778
		error = gfs2_quota_check(dip, dip->i_inode.i_uid, dip->i_inode.i_gid);
David Teigland's avatar
David Teigland committed
779
780
781
782
783
784
785
786
787
		if (error)
			goto fail_quota_locks;

		al->al_requested = sdp->sd_max_dirres;

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

788
		error = gfs2_trans_begin(sdp, sdp->sd_max_dirres +
789
					 al->al_rgd->rd_length +
790
					 2 * RES_DINODE +
David Teigland's avatar
David Teigland committed
791
792
793
794
					 RES_STATFS + RES_QUOTA, 0);
		if (error)
			goto fail_ipreserv;
	} else {
795
		error = gfs2_trans_begin(sdp, RES_LEAF + 2 * RES_DINODE, 0);
David Teigland's avatar
David Teigland committed
796
797
798
799
		if (error)
			goto fail_quota_locks;
	}

800
	error = gfs2_dir_add(&dip->i_inode, name, ip, IF2DT(ip->i_inode.i_mode));
David Teigland's avatar
David Teigland committed
801
802
803
804
805
806
	if (error)
		goto fail_end_trans;

	error = gfs2_meta_inode_buffer(ip, &dibh);
	if (error)
		goto fail_end_trans;
807
	ip->i_inode.i_nlink = 1;
808
	gfs2_trans_add_bh(ip->i_gl, dibh, 1);
809
	gfs2_dinode_out(ip, dibh->b_data);
David Teigland's avatar
David Teigland committed
810
811
812
	brelse(dibh);
	return 0;

813
fail_end_trans:
David Teigland's avatar
David Teigland committed
814
815
	gfs2_trans_end(sdp);

816
fail_ipreserv:
David Teigland's avatar
David Teigland committed
817
818
819
	if (dip->i_alloc.al_rgd)
		gfs2_inplace_release(dip);

820
fail_quota_locks:
David Teigland's avatar
David Teigland committed
821
822
	gfs2_quota_unlock(dip);

823
fail:
David Teigland's avatar
David Teigland committed
824
825
826
827
	gfs2_alloc_put(dip);
	return error;
}

828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
static int gfs2_security_init(struct gfs2_inode *dip, struct gfs2_inode *ip)
{
	int err;
	size_t len;
	void *value;
	char *name;
	struct gfs2_ea_request er;

	err = security_inode_init_security(&ip->i_inode, &dip->i_inode,
					   &name, &value, &len);

	if (err) {
		if (err == -EOPNOTSUPP)
			return 0;
		return err;
	}

	memset(&er, 0, sizeof(struct gfs2_ea_request));

	er.er_type = GFS2_EATYPE_SECURITY;
	er.er_name = name;
	er.er_data = value;
	er.er_name_len = strlen(name);
	er.er_data_len = len;

	err = gfs2_ea_set_i(ip, &er);

	kfree(value);
	kfree(name);

	return err;
}

David Teigland's avatar
David Teigland committed
861
862
863
864
865
866
867
868
869
/**
 * gfs2_createi - Create a new inode
 * @ghs: An array of two holders
 * @name: The name of the new file
 * @mode: the permissions on the new inode
 *
 * @ghs[0] is an initialized holder for the directory
 * @ghs[1] is the holder for the inode lock
 *
870
 * If the return value is not NULL, the glocks on both the directory and the new
David Teigland's avatar
David Teigland committed
871
872
873
 * file are held.  A transaction has been started and an inplace reservation
 * is held, as well.
 *
874
 * Returns: An inode
David Teigland's avatar
David Teigland committed
875
876
 */

877
struct inode *gfs2_createi(struct gfs2_holder *ghs, const struct qstr *name,
878
			   unsigned int mode, dev_t dev)
David Teigland's avatar
David Teigland committed
879
{
880
	struct inode *inode = NULL;
881
	struct gfs2_inode *dip = ghs->gh_gl->gl_object;
882
883
	struct inode *dir = &dip->i_inode;
	struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
884
	struct gfs2_inum_host inum = { .no_addr = 0, .no_formal_ino = 0 };
David Teigland's avatar
David Teigland committed
885
	int error;
886
	u64 generation;
David Teigland's avatar
David Teigland committed
887
888

	if (!name->len || name->len > GFS2_FNAMESIZE)
889
		return ERR_PTR(-ENAMETOOLONG);
David Teigland's avatar
David Teigland committed
890
891
892
893
894
895
896
897
898
899

	gfs2_holder_reinit(LM_ST_EXCLUSIVE, 0, ghs);
	error = gfs2_glock_nq(ghs);
	if (error)
		goto fail;

	error = create_ok(dip, name, mode);
	if (error)
		goto fail_gunlock;

900
	error = pick_formal_ino(sdp, &inum.no_formal_ino);
David Teigland's avatar
David Teigland committed
901
902
903
	if (error)
		goto fail_gunlock;

904
	error = alloc_dinode(dip, &inum.no_addr, &generation);
David Teigland's avatar
David Teigland committed
905
906
907
	if (error)
		goto fail_gunlock;

908
909
910
911
	error = gfs2_glock_nq_num(sdp, inum.no_addr, &gfs2_inode_glops,
				  LM_ST_EXCLUSIVE, GL_SKIP, ghs + 1);
	if (error)
		goto fail_gunlock;
David Teigland's avatar
David Teigland committed
912

913
	error = make_dinode(dip, ghs[1].gh_gl, mode, &inum, &generation, dev);
David Teigland's avatar
David Teigland committed
914
915
916
	if (error)
		goto fail_gunlock2;

917
	inode = gfs2_inode_lookup(dir->i_sb, inum.no_addr, IF2DT(mode));
918
	if (IS_ERR(inode))
David Teigland's avatar
David Teigland committed
919
920
		goto fail_gunlock2;

921
	error = gfs2_inode_refresh(GFS2_I(inode));
David Teigland's avatar
David Teigland committed
922
	if (error)
923
		goto fail_gunlock2;
David Teigland's avatar
David Teigland committed
924

925
	error = gfs2_acl_create(dip, GFS2_I(inode));
David Teigland's avatar
David Teigland committed
926
	if (error)
927
		goto fail_gunlock2;
David Teigland's avatar
David Teigland committed
928

929
930
	error = gfs2_security_init(dip, GFS2_I(inode));
	if (error)
931
		goto fail_gunlock2;
932

933
	error = link_dinode(dip, name, GFS2_I(inode));
David Teigland's avatar
David Teigland committed
934
	if (error)
935
		goto fail_gunlock2;
David Teigland's avatar
David Teigland committed
936

937
938
939
	if (!inode)
		return ERR_PTR(-ENOMEM);
	return inode;
David Teigland's avatar
David Teigland committed
940

941
fail_gunlock2:
David Teigland's avatar
David Teigland committed
942
	gfs2_glock_dq_uninit(ghs + 1);
943
944
	if (inode)
		iput(inode);
945
fail_gunlock:
David Teigland's avatar
David Teigland committed
946
	gfs2_glock_dq(ghs);
947
fail:
948
	return ERR_PTR(error);
David Teigland's avatar
David Teigland committed
949
950
951
952
953
954
955
956
957
958
959
960
961
}

/**
 * gfs2_rmdiri - Remove a directory
 * @dip: The parent directory of the directory to be removed
 * @name: The name of the directory to be removed
 * @ip: The GFS2 inode of the directory to be removed
 *
 * Assumes Glocks on dip and ip are held
 *
 * Returns: errno
 */

962
963
int gfs2_rmdiri(struct gfs2_inode *dip, const struct qstr *name,
		struct gfs2_inode *ip)
David Teigland's avatar
David Teigland committed
964
965
966
967
968
969
{
	struct qstr dotname;
	int error;

	if (ip->i_di.di_entries != 2) {
		if (gfs2_consist_inode(ip))
970
			gfs2_dinode_print(ip);
David Teigland's avatar
David Teigland committed
971
972
973
974
975
976
977
978
979
980
981
		return -EIO;
	}

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

	error = gfs2_change_nlink(dip, -1);
	if (error)
		return error;

982
	gfs2_str2qstr(&dotname, ".");
David Teigland's avatar
David Teigland committed
983
984
985
986
	error = gfs2_dir_del(ip, &dotname);
	if (error)
		return error;

987
	gfs2_str2qstr(&dotname, "..");
David Teigland's avatar
David Teigland committed
988
989
990
991
	error = gfs2_dir_del(ip, &dotname);
	if (error)
		return error;

992
993
994
995
996
997
	/* It looks odd, but it really should be done twice */
	error = gfs2_change_nlink(ip, -1);
	if (error)
		return error;

	error = gfs2_change_nlink(ip, -1);
David Teigland's avatar
David Teigland committed
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
	if (error)
		return error;

	return error;
}

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

1015
int gfs2_unlink_ok(struct gfs2_inode *dip, const struct qstr *name,
1016
		   const struct gfs2_inode *ip)
David Teigland's avatar
David Teigland committed
1017
1018
1019
{
	int error;

1020
	if (IS_IMMUTABLE(&ip->i_inode) || IS_APPEND(&ip->i_inode))
David Teigland's avatar
David Teigland committed
1021
1022
		return -EPERM;

1023
	if ((dip->i_inode.i_mode & S_ISVTX) &&
1024
1025
	    dip->i_inode.i_uid != current->fsuid &&
	    ip->i_inode.i_uid != current->fsuid && !capable(CAP_FOWNER))
David Teigland's avatar
David Teigland committed
1026
1027
		return -EPERM;

1028
	if (IS_APPEND(&dip->i_inode))
David Teigland's avatar
David Teigland committed
1029
1030
		return -EPERM;

1031
	error = permission(&dip->i_inode, MAY_WRITE | MAY_EXEC, NULL);
David Teigland's avatar
David Teigland committed
1032
1033
1034
	if (error)
		return error;

1035
	error = gfs2_dir_check(&dip->i_inode, name, ip);
David Teigland's avatar
David Teigland committed
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
	if (error)
		return error;

	return 0;
}

/*
 * gfs2_ok_to_move - check if it's ok to move a directory to another directory
 * @this: move this
 * @to: to here
 *
 * Follow @to back to the root and make sure we don't encounter @this
 * Assumes we already hold the rename lock.
 *
 * Returns: errno
 */

int gfs2_ok_to_move(struct gfs2_inode *this, struct gfs2_inode *to)
{
1055
	struct inode *dir = &to->i_inode;
Steven Whitehouse's avatar
Steven Whitehouse committed
1056
	struct super_block *sb = dir->i_sb;
1057
	struct inode *tmp;
David Teigland's avatar
David Teigland committed
1058
1059
1060
	struct qstr dotdot;
	int error = 0;

1061
	gfs2_str2qstr(&dotdot, "..");
David Teigland's avatar
David Teigland committed
1062

1063
	igrab(dir);
David Teigland's avatar
David Teigland committed
1064
1065

	for (;;) {
1066
		if (dir == &this->i_inode) {
David Teigland's avatar
David Teigland committed
1067
1068
1069
			error = -EINVAL;
			break;
		}
Steven Whitehouse's avatar
Steven Whitehouse committed
1070
		if (dir == sb->s_root->d_inode) {
David Teigland's avatar
David Teigland committed
1071
1072
1073
1074
			error = 0;
			break;
		}

1075
1076
1077
		tmp = gfs2_lookupi(dir, &dotdot, 1, NULL);
		if (IS_ERR(tmp)) {
			error = PTR_ERR(tmp);
David Teigland's avatar