inode.c 28.6 KB
Newer Older
D
David Teigland 已提交
1 2
/*
 * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
B
Bob Peterson 已提交
3
 * Copyright (C) 2004-2008 Red Hat, Inc.  All rights reserved.
D
David Teigland 已提交
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.
D
David Teigland 已提交
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/security.h>
20
#include <linux/time.h>
D
David Teigland 已提交
21 22

#include "gfs2.h"
23
#include "incore.h"
D
David Teigland 已提交
24 25 26 27 28 29 30 31 32 33 34 35
#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 "quota.h"
#include "rgrp.h"
#include "trans.h"
36
#include "util.h"
D
David Teigland 已提交
37

38 39 40 41 42
struct gfs2_inum_range_host {
	u64 ir_start;
	u64 ir_length;
};

43 44 45
static int iget_test(struct inode *inode, void *opaque)
{
	struct gfs2_inode *ip = GFS2_I(inode);
46
	u64 *no_addr = opaque;
47

48
	if (ip->i_no_addr == *no_addr && test_bit(GIF_USER, &ip->i_flags))
49
		return 1;
D
David Teigland 已提交
50

51 52 53 54
	return 0;
}

static int iget_set(struct inode *inode, void *opaque)
D
David Teigland 已提交
55
{
56
	struct gfs2_inode *ip = GFS2_I(inode);
57
	u64 *no_addr = opaque;
D
David Teigland 已提交
58

59 60
	inode->i_ino = (unsigned long)*no_addr;
	ip->i_no_addr = *no_addr;
61
	set_bit(GIF_USER, &ip->i_flags);
62 63
	return 0;
}
D
David Teigland 已提交
64

65
struct inode *gfs2_ilookup(struct super_block *sb, u64 no_addr)
66
{
67 68
	unsigned long hash = (unsigned long)no_addr;
	return ilookup5(sb, hash, iget_test, &no_addr);
69
}
D
David Teigland 已提交
70

71
static struct inode *gfs2_iget(struct super_block *sb, u64 no_addr)
72
{
73 74
	unsigned long hash = (unsigned long)no_addr;
	return iget5_locked(sb, hash, iget_test, iget_set, &no_addr);
D
David Teigland 已提交
75 76
}

77 78 79 80 81 82 83 84 85 86
struct gfs2_skip_data {
	u64	no_addr;
	int	skipped;
};

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

87
	if (ip->i_no_addr == data->no_addr && test_bit(GIF_USER, &ip->i_flags)){
88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105
		if (inode->i_state & (I_FREEING|I_CLEAR|I_WILL_FREE)){
			data->skipped = 1;
			return 0;
		}
		return 1;
	}
	return 0;
}

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

	if (data->skipped)
		return 1;
	inode->i_ino = (unsigned long)(data->no_addr);
	ip->i_no_addr = data->no_addr;
106
	set_bit(GIF_USER, &ip->i_flags);
107 108 109 110 111 112 113 114 115 116 117 118 119 120
	return 0;
}

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

	data.no_addr = no_addr;
	data.skipped = 0;
	return iget5_locked(sb, hash, iget_skip_test, iget_skip_set, &data);
}

121 122 123 124 125 126 127 128 129 130 131 132
/**
 * GFS2 lookup code fills in vfs inode contents based on info obtained
 * from directory entry inside gfs2_inode_lookup(). This has caused issues
 * with NFS code path since its get_dentry routine doesn't have the relevant
 * directory entry when gfs2_inode_lookup() is invoked. Part of the code
 * segment inside gfs2_inode_lookup code needs to get moved around.
 *
 * Clean up I_LOCK and I_NEW as well.
 **/

void gfs2_set_iop(struct inode *inode)
{
133
	struct gfs2_sbd *sdp = GFS2_SB(inode);
134 135 136 137
	umode_t mode = inode->i_mode;

	if (S_ISREG(mode)) {
		inode->i_op = &gfs2_file_iops;
138
		if (gfs2_localflocks(sdp))
139
			inode->i_fop = &gfs2_file_fops_nolock;
140
		else
141
			inode->i_fop = &gfs2_file_fops;
142 143
	} else if (S_ISDIR(mode)) {
		inode->i_op = &gfs2_dir_iops;
144
		if (gfs2_localflocks(sdp))
145
			inode->i_fop = &gfs2_dir_fops_nolock;
146
		else
147
			inode->i_fop = &gfs2_dir_fops;
148 149 150
	} else if (S_ISLNK(mode)) {
		inode->i_op = &gfs2_symlink_iops;
	} else {
D
Denis Cheng 已提交
151
		inode->i_op = &gfs2_file_iops;
D
Denis Cheng 已提交
152
		init_special_inode(inode, inode->i_mode, inode->i_rdev);
153 154 155 156 157
	}

	unlock_new_inode(inode);
}

D
David Teigland 已提交
158
/**
159 160
 * gfs2_inode_lookup - Lookup an inode
 * @sb: The super block
161
 * @no_addr: The inode number
162
 * @type: The type of the inode
163
 * @skip_freeing: set this not return an inode if it is currently being freed.
D
David Teigland 已提交
164
 *
165
 * Returns: A VFS inode, or an error
D
David Teigland 已提交
166 167
 */

168
struct inode *gfs2_inode_lookup(struct super_block *sb,
169 170
				unsigned int type,
				u64 no_addr,
171
				u64 no_formal_ino, int skip_freeing)
D
David Teigland 已提交
172
{
173 174
	struct inode *inode;
	struct gfs2_inode *ip;
175 176
	struct gfs2_glock *io_gl;
	int error;
D
David Teigland 已提交
177

178 179 180 181 182 183
	if (skip_freeing)
		inode = gfs2_iget_skip(sb, no_addr);
	else
		inode = gfs2_iget(sb, no_addr);
	ip = GFS2_I(inode);

S
Steven Whitehouse 已提交
184 185 186
	if (!inode)
		return ERR_PTR(-ENOBUFS);

187 188
	if (inode->i_state & I_NEW) {
		struct gfs2_sbd *sdp = GFS2_SB(inode);
189
		ip->i_no_formal_ino = no_formal_ino;
D
David Teigland 已提交
190

191
		error = gfs2_glock_get(sdp, no_addr, &gfs2_inode_glops, CREATE, &ip->i_gl);
192 193 194
		if (unlikely(error))
			goto fail;
		ip->i_gl->gl_object = ip;
D
David Teigland 已提交
195

196
		error = gfs2_glock_get(sdp, no_addr, &gfs2_iopen_glops, CREATE, &io_gl);
197 198
		if (unlikely(error))
			goto fail_put;
D
David Teigland 已提交
199

200
		set_bit(GIF_INVALID, &ip->i_flags);
201 202 203
		error = gfs2_glock_nq_init(io_gl, LM_ST_SHARED, GL_EXACT, &ip->i_iopen_gh);
		if (unlikely(error))
			goto fail_iopen;
A
Abhijith Das 已提交
204
		ip->i_iopen_gh.gh_gl->gl_object = ip;
D
David Teigland 已提交
205

206
		gfs2_glock_put(io_gl);
207

208 209 210 211 212
		if ((type == DT_UNKNOWN) && (no_formal_ino == 0))
			goto gfs2_nfsbypass;

		inode->i_mode = DT2IF(type);

213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228
		/*
		 * 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).
		 */
		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 */
			gfs2_glock_dq_uninit(&gh);
		}

229
		gfs2_set_iop(inode);
230
	}
D
David Teigland 已提交
231

232
gfs2_nfsbypass:
D
David Teigland 已提交
233
	return inode;
234 235
fail_glock:
	gfs2_glock_dq(&ip->i_iopen_gh);
236 237 238 239 240 241
fail_iopen:
	gfs2_glock_put(io_gl);
fail_put:
	ip->i_gl->gl_object = NULL;
	gfs2_glock_put(ip->i_gl);
fail:
D
David Howells 已提交
242
	iget_failed(inode);
243
	return ERR_PTR(error);
D
David Teigland 已提交
244 245
}

246
static int gfs2_dinode_in(struct gfs2_inode *ip, const void *buf)
247 248
{
	const struct gfs2_dinode *str = buf;
249
	struct timespec atime;
250
	u16 height, depth;
251

252 253
	if (unlikely(ip->i_no_addr != be64_to_cpu(str->di_num.no_addr)))
		goto corrupt;
254
	ip->i_no_formal_ino = be64_to_cpu(str->di_num.no_formal_ino);
255
	ip->i_inode.i_mode = be32_to_cpu(str->di_mode);
256
	ip->i_inode.i_rdev = 0;
257
	switch (ip->i_inode.i_mode & S_IFMT) {
258 259 260 261 262 263 264
	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;
	};

265 266
	ip->i_inode.i_uid = be32_to_cpu(str->di_uid);
	ip->i_inode.i_gid = be32_to_cpu(str->di_gid);
267 268 269 270 271 272
	/*
	 * 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);
273 274
	ip->i_disksize = be64_to_cpu(str->di_size);
	i_size_write(&ip->i_inode, ip->i_disksize);
275
	gfs2_set_inode_blocks(&ip->i_inode, be64_to_cpu(str->di_blocks));
276 277 278 279
	atime.tv_sec = be64_to_cpu(str->di_atime);
	atime.tv_nsec = be32_to_cpu(str->di_atime_nsec);
	if (timespec_compare(&ip->i_inode.i_atime, &atime) < 0)
		ip->i_inode.i_atime = atime;
280
	ip->i_inode.i_mtime.tv_sec = be64_to_cpu(str->di_mtime);
281
	ip->i_inode.i_mtime.tv_nsec = be32_to_cpu(str->di_mtime_nsec);
282
	ip->i_inode.i_ctime.tv_sec = be64_to_cpu(str->di_ctime);
283
	ip->i_inode.i_ctime.tv_nsec = be32_to_cpu(str->di_ctime_nsec);
284

285
	ip->i_goal = be64_to_cpu(str->di_goal_meta);
286
	ip->i_generation = be64_to_cpu(str->di_generation);
287

288
	ip->i_diskflags = be32_to_cpu(str->di_flags);
289
	gfs2_set_inode_flags(&ip->i_inode);
290 291 292 293
	height = be16_to_cpu(str->di_height);
	if (unlikely(height > GFS2_MAX_META_HEIGHT))
		goto corrupt;
	ip->i_height = (u8)height;
294

295 296 297 298
	depth = be16_to_cpu(str->di_depth);
	if (unlikely(depth > GFS2_DIR_MAX_DEPTH))
		goto corrupt;
	ip->i_depth = (u8)depth;
299
	ip->i_entries = be32_to_cpu(str->di_entries);
300

301
	ip->i_eattr = be64_to_cpu(str->di_eattr);
302 303 304
	if (S_ISREG(ip->i_inode.i_mode))
		gfs2_set_aops(&ip->i_inode);

305
	return 0;
306 307 308 309
corrupt:
	if (gfs2_consist_inode(ip))
		gfs2_dinode_print(ip);
	return -EIO;
310 311
}

D
David Teigland 已提交
312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327
/**
 * 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;

328
	if (gfs2_metatype_check(GFS2_SB(&ip->i_inode), dibh, GFS2_METATYPE_DI)) {
D
David Teigland 已提交
329 330 331 332
		brelse(dibh);
		return -EIO;
	}

333
	error = gfs2_dinode_in(ip, dibh->b_data);
D
David Teigland 已提交
334
	brelse(dibh);
335
	clear_bit(GIF_INVALID, &ip->i_flags);
D
David Teigland 已提交
336

337
	return error;
D
David Teigland 已提交
338 339
}

340
int gfs2_dinode_dealloc(struct gfs2_inode *ip)
D
David Teigland 已提交
341
{
342
	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
D
David Teigland 已提交
343 344 345 346
	struct gfs2_alloc *al;
	struct gfs2_rgrpd *rgd;
	int error;

347
	if (gfs2_get_inode_blocks(&ip->i_inode) != 1) {
D
David Teigland 已提交
348
		if (gfs2_consist_inode(ip))
349
			gfs2_dinode_print(ip);
D
David Teigland 已提交
350 351 352 353
		return -EIO;
	}

	al = gfs2_alloc_get(ip);
354 355
	if (!al)
		return -ENOMEM;
D
David Teigland 已提交
356 357 358 359 360 361 362 363 364

	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;

365
	rgd = gfs2_blk2rgrpd(sdp, ip->i_no_addr);
D
David Teigland 已提交
366 367 368 369 370 371 372 373 374 375 376
	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;

377
	error = gfs2_trans_begin(sdp, RES_RG_BIT + RES_STATFS + RES_QUOTA, 1);
D
David Teigland 已提交
378 379 380
	if (error)
		goto out_rg_gunlock;

381 382
	set_bit(GLF_DIRTY, &ip->i_gl->gl_flags);
	set_bit(GLF_LFLUSH, &ip->i_gl->gl_flags);
D
David Teigland 已提交
383 384 385 386 387

	gfs2_free_di(rgd, ip);

	gfs2_trans_end(sdp);

388
out_rg_gunlock:
D
David Teigland 已提交
389
	gfs2_glock_dq_uninit(&al->al_rgd_gh);
390
out_rindex_relse:
D
David Teigland 已提交
391
	gfs2_glock_dq_uninit(&al->al_ri_gh);
392
out_qs:
D
David Teigland 已提交
393
	gfs2_quota_unhold(ip);
394
out:
395
	gfs2_alloc_put(ip);
D
David Teigland 已提交
396 397 398 399
	return error;
}

/**
S
S. Wendy Cheng 已提交
400
 * gfs2_change_nlink - Change nlink count on inode
D
David Teigland 已提交
401 402 403 404 405
 * @ip: The GFS2 inode
 * @diff: The change in the nlink count required
 *
 * Returns: errno
 */
S
S. Wendy Cheng 已提交
406
int gfs2_change_nlink(struct gfs2_inode *ip, int diff)
D
David Teigland 已提交
407 408
{
	struct buffer_head *dibh;
409
	u32 nlink;
D
David Teigland 已提交
410 411
	int error;

412 413
	BUG_ON(diff != 1 && diff != -1);
	nlink = ip->i_inode.i_nlink + diff;
D
David Teigland 已提交
414 415 416

	/* If we are reducing the nlink count, but the new value ends up being
	   bigger than the old one, we must have underflowed. */
417
	if (diff < 0 && nlink > ip->i_inode.i_nlink) {
D
David Teigland 已提交
418
		if (gfs2_consist_inode(ip))
419
			gfs2_dinode_print(ip);
D
David Teigland 已提交
420 421 422 423 424 425 426
		return -EIO;
	}

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

427 428 429 430 431
	if (diff > 0)
		inc_nlink(&ip->i_inode);
	else
		drop_nlink(&ip->i_inode);

432
	ip->i_inode.i_ctime = CURRENT_TIME;
D
David Teigland 已提交
433

434
	gfs2_trans_add_bh(ip->i_gl, dibh, 1);
435
	gfs2_dinode_out(ip, dibh->b_data);
D
David Teigland 已提交
436
	brelse(dibh);
437
	mark_inode_dirty(&ip->i_inode);
D
David Teigland 已提交
438

S
S. Wendy Cheng 已提交
439
	if (ip->i_inode.i_nlink == 0)
R
Russell Cattelan 已提交
440
		gfs2_unlink_di(&ip->i_inode); /* mark inode unlinked */
S
S. Wendy Cheng 已提交
441

442 443 444
	return error;
}

445 446 447
struct inode *gfs2_lookup_simple(struct inode *dip, const char *name)
{
	struct qstr qstr;
448
	struct inode *inode;
449
	gfs2_str2qstr(&qstr, name);
450
	inode = gfs2_lookupi(dip, &qstr, 1);
451 452 453 454 455 456 457 458 459
	/* 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;
460 461 462
}


D
David Teigland 已提交
463 464 465 466 467 468 469
/**
 * 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
 *
470 471 472 473
 * 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.
D
David Teigland 已提交
474 475 476 477
 *
 * Returns: errno
 */

478
struct inode *gfs2_lookupi(struct inode *dir, const struct qstr *name,
479
			   int is_root)
D
David Teigland 已提交
480
{
S
Steven Whitehouse 已提交
481
	struct super_block *sb = dir->i_sb;
482
	struct gfs2_inode *dip = GFS2_I(dir);
D
David Teigland 已提交
483
	struct gfs2_holder d_gh;
484
	int error = 0;
485
	struct inode *inode = NULL;
486
	int unlock = 0;
D
David Teigland 已提交
487 488

	if (!name->len || name->len > GFS2_FNAMESIZE)
489
		return ERR_PTR(-ENAMETOOLONG);
D
David Teigland 已提交
490

491 492 493
	if ((name->len == 1 && memcmp(name->name, ".", 1) == 0) ||
	    (name->len == 2 && memcmp(name->name, "..", 2) == 0 &&
	     dir == sb->s_root->d_inode)) {
494 495
		igrab(dir);
		return dir;
D
David Teigland 已提交
496 497
	}

498
	if (gfs2_glock_is_locked_by_me(dip->i_gl) == NULL) {
499 500 501 502 503
		error = gfs2_glock_nq_init(dip->i_gl, LM_ST_SHARED, 0, &d_gh);
		if (error)
			return ERR_PTR(error);
		unlock = 1;
	}
D
David Teigland 已提交
504 505

	if (!is_root) {
M
Miklos Szeredi 已提交
506
		error = gfs2_permission(dir, MAY_EXEC);
D
David Teigland 已提交
507 508 509 510
		if (error)
			goto out;
	}

511 512 513
	inode = gfs2_dir_search(dir, name);
	if (IS_ERR(inode))
		error = PTR_ERR(inode);
514
out:
515 516
	if (unlock)
		gfs2_glock_dq_uninit(&d_gh);
517 518
	if (error == -ENOENT)
		return NULL;
519
	return inode ? inode : ERR_PTR(error);
D
David Teigland 已提交
520 521
}

522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537
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);
}

538
static int pick_formal_ino_1(struct gfs2_sbd *sdp, u64 *formal_ino)
D
David Teigland 已提交
539
{
540
	struct gfs2_inode *ip = GFS2_I(sdp->sd_ir_inode);
D
David Teigland 已提交
541
	struct buffer_head *bh;
542
	struct gfs2_inum_range_host ir;
D
David Teigland 已提交
543 544 545 546 547
	int error;

	error = gfs2_trans_begin(sdp, RES_DINODE, 0);
	if (error)
		return error;
548
	mutex_lock(&sdp->sd_inum_mutex);
D
David Teigland 已提交
549 550 551

	error = gfs2_meta_inode_buffer(ip, &bh);
	if (error) {
552
		mutex_unlock(&sdp->sd_inum_mutex);
D
David Teigland 已提交
553 554 555 556 557 558 559 560 561
		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--;
562
		gfs2_trans_add_bh(ip->i_gl, bh, 1);
D
David Teigland 已提交
563 564 565
		gfs2_inum_range_out(&ir,
				    bh->b_data + sizeof(struct gfs2_dinode));
		brelse(bh);
566
		mutex_unlock(&sdp->sd_inum_mutex);
D
David Teigland 已提交
567 568 569 570 571 572
		gfs2_trans_end(sdp);
		return 0;
	}

	brelse(bh);

573
	mutex_unlock(&sdp->sd_inum_mutex);
D
David Teigland 已提交
574 575 576 577 578
	gfs2_trans_end(sdp);

	return 1;
}

579
static int pick_formal_ino_2(struct gfs2_sbd *sdp, u64 *formal_ino)
D
David Teigland 已提交
580
{
581 582
	struct gfs2_inode *ip = GFS2_I(sdp->sd_ir_inode);
	struct gfs2_inode *m_ip = GFS2_I(sdp->sd_inum_inode);
D
David Teigland 已提交
583 584
	struct gfs2_holder gh;
	struct buffer_head *bh;
585
	struct gfs2_inum_range_host ir;
D
David Teigland 已提交
586 587 588 589 590 591 592 593 594
	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;
595
	mutex_lock(&sdp->sd_inum_mutex);
D
David Teigland 已提交
596 597 598 599

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

D
David Teigland 已提交
601 602 603 604
	gfs2_inum_range_in(&ir, bh->b_data + sizeof(struct gfs2_dinode));

	if (!ir.ir_length) {
		struct buffer_head *m_bh;
605
		u64 x, y;
A
Al Viro 已提交
606
		__be64 z;
D
David Teigland 已提交
607 608 609 610 611

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

A
Al Viro 已提交
612 613
		z = *(__be64 *)(m_bh->b_data + sizeof(struct gfs2_dinode));
		x = y = be64_to_cpu(z);
D
David Teigland 已提交
614 615 616 617 618
		ir.ir_start = x;
		ir.ir_length = GFS2_INUM_QUANTUM;
		x += GFS2_INUM_QUANTUM;
		if (x < y)
			gfs2_consist_inode(m_ip);
A
Al Viro 已提交
619
		z = cpu_to_be64(x);
620
		gfs2_trans_add_bh(m_ip->i_gl, m_bh, 1);
A
Al Viro 已提交
621
		*(__be64 *)(m_bh->b_data + sizeof(struct gfs2_dinode)) = z;
D
David Teigland 已提交
622 623 624 625 626 627 628

		brelse(m_bh);
	}

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

629
	gfs2_trans_add_bh(ip->i_gl, bh, 1);
D
David Teigland 已提交
630 631
	gfs2_inum_range_out(&ir, bh->b_data + sizeof(struct gfs2_dinode));

632
out_brelse:
D
David Teigland 已提交
633
	brelse(bh);
634
out_end_trans:
635
	mutex_unlock(&sdp->sd_inum_mutex);
D
David Teigland 已提交
636
	gfs2_trans_end(sdp);
637
out:
D
David Teigland 已提交
638 639 640 641
	gfs2_glock_dq_uninit(&gh);
	return error;
}

642
static int pick_formal_ino(struct gfs2_sbd *sdp, u64 *inum)
D
David Teigland 已提交
643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663
{
	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
 */

664
static int create_ok(struct gfs2_inode *dip, const struct qstr *name,
D
David Teigland 已提交
665 666 667 668
		     unsigned int mode)
{
	int error;

M
Miklos Szeredi 已提交
669
	error = gfs2_permission(&dip->i_inode, MAY_WRITE | MAY_EXEC);
D
David Teigland 已提交
670 671 672 673
	if (error)
		return error;

	/*  Don't create entries in an unlinked directory  */
674
	if (!dip->i_inode.i_nlink)
D
David Teigland 已提交
675 676
		return -EPERM;

677
	error = gfs2_dir_check(&dip->i_inode, name, NULL);
D
David Teigland 已提交
678 679 680 681 682 683 684 685 686 687
	switch (error) {
	case -ENOENT:
		error = 0;
		break;
	case 0:
		return -EEXIST;
	default:
		return error;
	}

688
	if (dip->i_entries == (u32)-1)
D
David Teigland 已提交
689
		return -EFBIG;
690
	if (S_ISDIR(mode) && dip->i_inode.i_nlink == (u32)-1)
D
David Teigland 已提交
691 692 693 694 695 696 697 698
		return -EMLINK;

	return 0;
}

static void munge_mode_uid_gid(struct gfs2_inode *dip, unsigned int *mode,
			       unsigned int *uid, unsigned int *gid)
{
699
	if (GFS2_SB(&dip->i_inode)->sd_args.ar_suiddir &&
700
	    (dip->i_inode.i_mode & S_ISUID) && dip->i_inode.i_uid) {
D
David Teigland 已提交
701 702
		if (S_ISDIR(*mode))
			*mode |= S_ISUID;
703
		else if (dip->i_inode.i_uid != current_fsuid())
D
David Teigland 已提交
704
			*mode &= ~07111;
705
		*uid = dip->i_inode.i_uid;
D
David Teigland 已提交
706
	} else
707
		*uid = current_fsuid();
D
David Teigland 已提交
708

709
	if (dip->i_inode.i_mode & S_ISGID) {
D
David Teigland 已提交
710 711
		if (S_ISDIR(*mode))
			*mode |= S_ISGID;
712
		*gid = dip->i_inode.i_gid;
D
David Teigland 已提交
713
	} else
714
		*gid = current_fsgid();
D
David Teigland 已提交
715 716
}

717
static int alloc_dinode(struct gfs2_inode *dip, u64 *no_addr, u64 *generation)
D
David Teigland 已提交
718
{
719
	struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
D
David Teigland 已提交
720 721
	int error;

722 723
	if (gfs2_alloc_get(dip) == NULL)
		return -ENOMEM;
D
David Teigland 已提交
724

725
	dip->i_alloc->al_requested = RES_DINODE;
D
David Teigland 已提交
726 727 728 729
	error = gfs2_inplace_reserve(dip);
	if (error)
		goto out;

730
	error = gfs2_trans_begin(sdp, RES_RG_BIT + RES_STATFS, 0);
D
David Teigland 已提交
731 732 733
	if (error)
		goto out_ipreserv;

734
	*no_addr = gfs2_alloc_di(dip, generation);
D
David Teigland 已提交
735 736 737

	gfs2_trans_end(sdp);

S
Steven Whitehouse 已提交
738
out_ipreserv:
D
David Teigland 已提交
739
	gfs2_inplace_release(dip);
S
Steven Whitehouse 已提交
740
out:
D
David Teigland 已提交
741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756
	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,
A
Al Viro 已提交
757
			const struct gfs2_inum_host *inum, unsigned int mode,
S
Steven Whitehouse 已提交
758
			unsigned int uid, unsigned int gid,
759
			const u64 *generation, dev_t dev, struct buffer_head **bhp)
D
David Teigland 已提交
760
{
761
	struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
762
	struct gfs2_dinode *di;
D
David Teigland 已提交
763
	struct buffer_head *dibh;
764
	struct timespec tv = CURRENT_TIME;
D
David Teigland 已提交
765 766

	dibh = gfs2_meta_new(gl, inum->no_addr);
767
	gfs2_trans_add_bh(gl, dibh, 1);
D
David Teigland 已提交
768 769
	gfs2_metatype_set(dibh, GFS2_METATYPE_DI, GFS2_FORMAT_DI);
	gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode));
770 771
	di = (struct gfs2_dinode *)dibh->b_data;

772 773
	di->di_num.no_formal_ino = cpu_to_be64(inum->no_formal_ino);
	di->di_num.no_addr = cpu_to_be64(inum->no_addr);
774 775 776
	di->di_mode = cpu_to_be32(mode);
	di->di_uid = cpu_to_be32(uid);
	di->di_gid = cpu_to_be32(gid);
777 778
	di->di_nlink = 0;
	di->di_size = 0;
779
	di->di_blocks = cpu_to_be64(1);
780
	di->di_atime = di->di_mtime = di->di_ctime = cpu_to_be64(tv.tv_sec);
781 782
	di->di_major = cpu_to_be32(MAJOR(dev));
	di->di_minor = cpu_to_be32(MINOR(dev));
783
	di->di_goal_meta = di->di_goal_data = cpu_to_be64(inum->no_addr);
S
Steven Whitehouse 已提交
784
	di->di_generation = cpu_to_be64(*generation);
785
	di->di_flags = 0;
D
David Teigland 已提交
786 787

	if (S_ISREG(mode)) {
788
		if ((dip->i_diskflags & GFS2_DIF_INHERIT_JDATA) ||
D
David Teigland 已提交
789
		    gfs2_tune_get(sdp, gt_new_files_jdata))
790
			di->di_flags |= cpu_to_be32(GFS2_DIF_JDATA);
D
David Teigland 已提交
791
	} else if (S_ISDIR(mode)) {
792
		di->di_flags |= cpu_to_be32(dip->i_diskflags &
793
					    GFS2_DIF_INHERIT_JDATA);
D
David Teigland 已提交
794 795
	}

796
	di->__pad1 = 0;
797
	di->di_payload_format = cpu_to_be32(S_ISDIR(mode) ? GFS2_FORMAT_DE : 0);
798
	di->di_height = 0;
799 800
	di->__pad2 = 0;
	di->__pad3 = 0;
801 802
	di->di_depth = 0;
	di->di_entries = 0;
803
	memset(&di->__pad4, 0, sizeof(di->__pad4));
804
	di->di_eattr = 0;
805 806 807
	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);
808
	memset(&di->di_reserved, 0, sizeof(di->di_reserved));
809 810
	
	set_buffer_uptodate(dibh);
811

812
	*bhp = dibh;
D
David Teigland 已提交
813 814 815
}

static int make_dinode(struct gfs2_inode *dip, struct gfs2_glock *gl,
A
Al Viro 已提交
816
		       unsigned int mode, const struct gfs2_inum_host *inum,
817
		       const u64 *generation, dev_t dev, struct buffer_head **bhp)
D
David Teigland 已提交
818
{
819
	struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
D
David Teigland 已提交
820 821 822 823
	unsigned int uid, gid;
	int error;

	munge_mode_uid_gid(dip, &mode, &uid, &gid);
824 825
	if (!gfs2_alloc_get(dip))
		return -ENOMEM;
D
David Teigland 已提交
826 827 828 829 830 831 832 833 834

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

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

835
	error = gfs2_trans_begin(sdp, RES_DINODE + RES_QUOTA, 0);
D
David Teigland 已提交
836 837 838
	if (error)
		goto out_quota;

839
	init_dinode(dip, gl, inum, mode, uid, gid, generation, dev, bhp);
D
David Teigland 已提交
840 841 842
	gfs2_quota_change(dip, +1, uid, gid);
	gfs2_trans_end(sdp);

843
out_quota:
D
David Teigland 已提交
844
	gfs2_quota_unlock(dip);
845
out:
D
David Teigland 已提交
846 847 848 849
	gfs2_alloc_put(dip);
	return error;
}

850 851
static int link_dinode(struct gfs2_inode *dip, const struct qstr *name,
		       struct gfs2_inode *ip)
D
David Teigland 已提交
852
{
853
	struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
D
David Teigland 已提交
854 855 856 857 858 859
	struct gfs2_alloc *al;
	int alloc_required;
	struct buffer_head *dibh;
	int error;

	al = gfs2_alloc_get(dip);
860 861
	if (!al)
		return -ENOMEM;
D
David Teigland 已提交
862 863 864 865 866

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

867
	error = alloc_required = gfs2_diradd_alloc_required(&dip->i_inode, name);
868
	if (alloc_required < 0)
B
Bob Peterson 已提交
869
		goto fail_quota_locks;
D
David Teigland 已提交
870
	if (alloc_required) {
871
		error = gfs2_quota_check(dip, dip->i_inode.i_uid, dip->i_inode.i_gid);
D
David Teigland 已提交
872 873 874 875 876 877 878 879 880
		if (error)
			goto fail_quota_locks;

		al->al_requested = sdp->sd_max_dirres;

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

881
		error = gfs2_trans_begin(sdp, sdp->sd_max_dirres +
882
					 al->al_rgd->rd_length +
883
					 2 * RES_DINODE +
D
David Teigland 已提交
884 885 886 887
					 RES_STATFS + RES_QUOTA, 0);
		if (error)
			goto fail_ipreserv;
	} else {
888
		error = gfs2_trans_begin(sdp, RES_LEAF + 2 * RES_DINODE, 0);
D
David Teigland 已提交
889 890 891 892
		if (error)
			goto fail_quota_locks;
	}

893
	error = gfs2_dir_add(&dip->i_inode, name, ip, IF2DT(ip->i_inode.i_mode));
D
David Teigland 已提交
894 895 896 897 898 899
	if (error)
		goto fail_end_trans;

	error = gfs2_meta_inode_buffer(ip, &dibh);
	if (error)
		goto fail_end_trans;
900
	ip->i_inode.i_nlink = 1;
901
	gfs2_trans_add_bh(ip->i_gl, dibh, 1);
902
	gfs2_dinode_out(ip, dibh->b_data);
D
David Teigland 已提交
903 904 905
	brelse(dibh);
	return 0;

906
fail_end_trans:
D
David Teigland 已提交
907 908
	gfs2_trans_end(sdp);

909
fail_ipreserv:
910
	if (dip->i_alloc->al_rgd)
D
David Teigland 已提交
911 912
		gfs2_inplace_release(dip);

913
fail_quota_locks:
D
David Teigland 已提交
914 915
	gfs2_quota_unlock(dip);

916
fail:
D
David Teigland 已提交
917 918 919 920
	gfs2_alloc_put(dip);
	return error;
}

921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953
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;
}

D
David Teigland 已提交
954 955 956 957 958 959 960 961 962
/**
 * 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
 *
963
 * If the return value is not NULL, the glocks on both the directory and the new
D
David Teigland 已提交
964 965 966
 * file are held.  A transaction has been started and an inplace reservation
 * is held, as well.
 *
967
 * Returns: An inode
D
David Teigland 已提交
968 969
 */

970
struct inode *gfs2_createi(struct gfs2_holder *ghs, const struct qstr *name,
971
			   unsigned int mode, dev_t dev)
D
David Teigland 已提交
972
{
973
	struct inode *inode = NULL;
974
	struct gfs2_inode *dip = ghs->gh_gl->gl_object;
975 976
	struct inode *dir = &dip->i_inode;
	struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
977
	struct gfs2_inum_host inum = { .no_addr = 0, .no_formal_ino = 0 };
D
David Teigland 已提交
978
	int error;
S
Steven Whitehouse 已提交
979
	u64 generation;
980
	struct buffer_head *bh = NULL;
D
David Teigland 已提交
981 982

	if (!name->len || name->len > GFS2_FNAMESIZE)
983
		return ERR_PTR(-ENAMETOOLONG);
D
David Teigland 已提交
984 985 986 987 988 989 990 991 992 993

	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;

994
	error = pick_formal_ino(sdp, &inum.no_formal_ino);
D
David Teigland 已提交
995 996 997
	if (error)
		goto fail_gunlock;

998
	error = alloc_dinode(dip, &inum.no_addr, &generation);
D
David Teigland 已提交
999 1000 1001
	if (error)
		goto fail_gunlock;

1002 1003 1004 1005
	error = gfs2_glock_nq_num(sdp, inum.no_addr, &gfs2_inode_glops,
				  LM_ST_EXCLUSIVE, GL_SKIP, ghs + 1);
	if (error)
		goto fail_gunlock;
D
David Teigland 已提交
1006

1007
	error = make_dinode(dip, ghs[1].gh_gl, mode, &inum, &generation, dev, &bh);
D
David Teigland 已提交
1008 1009 1010
	if (error)
		goto fail_gunlock2;

1011 1012
	inode = gfs2_inode_lookup(dir->i_sb, IF2DT(mode),
					inum.no_addr,
1013
					inum.no_formal_ino, 0);
1014
	if (IS_ERR(inode))
D
David Teigland 已提交
1015 1016
		goto fail_gunlock2;

1017
	error = gfs2_inode_refresh(GFS2_I(inode));
D
David Teigland 已提交
1018
	if (error)
1019
		goto fail_gunlock2;
D
David Teigland 已提交
1020

1021
	error = gfs2_acl_create(dip, GFS2_I(inode));
D
David Teigland 已提交
1022
	if (error)
1023
		goto fail_gunlock2;
D
David Teigland 已提交
1024

1025 1026
	error = gfs2_security_init(dip, GFS2_I(inode));
	if (error)
1027
		goto fail_gunlock2;
1028

1029
	error = link_dinode(dip, name, GFS2_I(inode));
D
David Teigland 已提交
1030
	if (error)
1031
		goto fail_gunlock2;
D
David Teigland 已提交
1032

1033 1034
	if (bh)
		brelse(bh);
1035
	return inode;
D
David Teigland 已提交
1036

1037
fail_gunlock2:
D
David Teigland 已提交
1038
	gfs2_glock_dq_uninit(ghs + 1);
1039
	if (inode && !IS_ERR(inode))
1040
		iput(inode);
1041
fail_gunlock:
D
David Teigland 已提交
1042
	gfs2_glock_dq(ghs);
1043
fail:
1044 1045
	if (bh)
		brelse(bh);
1046
	return ERR_PTR(error);
D
David Teigland 已提交
1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060
}


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

1061
int gfs2_unlink_ok(struct gfs2_inode *dip, const struct qstr *name,
1062
		   const struct gfs2_inode *ip)
D
David Teigland 已提交
1063 1064 1065
{
	int error;

1066
	if (IS_IMMUTABLE(&ip->i_inode) || IS_APPEND(&ip->i_inode))
D
David Teigland 已提交
1067 1068
		return -EPERM;

1069
	if ((dip->i_inode.i_mode & S_ISVTX) &&
1070 1071
	    dip->i_inode.i_uid != current_fsuid() &&
	    ip->i_inode.i_uid != current_fsuid() && !capable(CAP_FOWNER))
D
David Teigland 已提交
1072 1073
		return -EPERM;

1074
	if (IS_APPEND(&dip->i_inode))
D
David Teigland 已提交
1075 1076
		return -EPERM;

M
Miklos Szeredi 已提交
1077
	error = gfs2_permission(&dip->i_inode, MAY_WRITE | MAY_EXEC);
D
David Teigland 已提交
1078 1079 1080
	if (error)
		return error;

1081
	error = gfs2_dir_check(&dip->i_inode, name, ip);
D
David Teigland 已提交
1082 1083 1084 1085 1086 1087
	if (error)
		return error;

	return 0;
}

1088
static int __gfs2_setattr_simple(struct gfs2_inode *ip, struct iattr *attr)
D
David Teigland 已提交
1089 1090 1091 1092 1093 1094
{
	struct buffer_head *dibh;
	int error;

	error = gfs2_meta_inode_buffer(ip, &dibh);
	if (!error) {
1095 1096
		error = inode_setattr(&ip->i_inode, attr);
		gfs2_assert_warn(GFS2_SB(&ip->i_inode), !error);
1097
		gfs2_trans_add_bh(ip->i_gl, dibh, 1);
1098
		gfs2_dinode_out(ip, dibh->b_data);
D
David Teigland 已提交
1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117
		brelse(dibh);
	}
	return error;
}

/**
 * gfs2_setattr_simple -
 * @ip:
 * @attr:
 *
 * Called with a reference on the vnode.
 *
 * Returns: errno
 */

int gfs2_setattr_simple(struct gfs2_inode *ip, struct iattr *attr)
{
	int error;

1118
	if (current->journal_info)
D
David Teigland 已提交
1119 1120
		return __gfs2_setattr_simple(ip, attr);

1121
	error = gfs2_trans_begin(GFS2_SB(&ip->i_inode), RES_DINODE, 0);
D
David Teigland 已提交
1122 1123 1124 1125
	if (error)
		return error;

	error = __gfs2_setattr_simple(ip, attr);
1126
	gfs2_trans_end(GFS2_SB(&ip->i_inode));
D
David Teigland 已提交
1127 1128 1129
	return error;
}

1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144
void gfs2_dinode_out(const struct gfs2_inode *ip, void *buf)
{
	struct gfs2_dinode *str = buf;

	str->di_header.mh_magic = cpu_to_be32(GFS2_MAGIC);
	str->di_header.mh_type = cpu_to_be32(GFS2_METATYPE_DI);
	str->di_header.__pad0 = 0;
	str->di_header.mh_format = cpu_to_be32(GFS2_FORMAT_DI);
	str->di_header.__pad1 = 0;
	str->di_num.no_addr = cpu_to_be64(ip->i_no_addr);
	str->di_num.no_formal_ino = cpu_to_be64(ip->i_no_formal_ino);
	str->di_mode = cpu_to_be32(ip->i_inode.i_mode);
	str->di_uid = cpu_to_be32(ip->i_inode.i_uid);
	str->di_gid = cpu_to_be32(ip->i_inode.i_gid);
	str->di_nlink = cpu_to_be32(ip->i_inode.i_nlink);
1145
	str->di_size = cpu_to_be64(ip->i_disksize);
1146
	str->di_blocks = cpu_to_be64(gfs2_get_inode_blocks(&ip->i_inode));
1147 1148 1149 1150
	str->di_atime = cpu_to_be64(ip->i_inode.i_atime.tv_sec);
	str->di_mtime = cpu_to_be64(ip->i_inode.i_mtime.tv_sec);
	str->di_ctime = cpu_to_be64(ip->i_inode.i_ctime.tv_sec);

1151 1152
	str->di_goal_meta = cpu_to_be64(ip->i_goal);
	str->di_goal_data = cpu_to_be64(ip->i_goal);
1153
	str->di_generation = cpu_to_be64(ip->i_generation);
1154

1155
	str->di_flags = cpu_to_be32(ip->i_diskflags);
1156
	str->di_height = cpu_to_be16(ip->i_height);
1157
	str->di_payload_format = cpu_to_be32(S_ISDIR(ip->i_inode.i_mode) &&
1158
					     !(ip->i_diskflags & GFS2_DIF_EXHASH) ?
1159
					     GFS2_FORMAT_DE : 0);
1160
	str->di_depth = cpu_to_be16(ip->i_depth);
1161
	str->di_entries = cpu_to_be32(ip->i_entries);
1162

1163
	str->di_eattr = cpu_to_be64(ip->i_eattr);
1164 1165 1166
	str->di_atime_nsec = cpu_to_be32(ip->i_inode.i_atime.tv_nsec);
	str->di_mtime_nsec = cpu_to_be32(ip->i_inode.i_mtime.tv_nsec);
	str->di_ctime_nsec = cpu_to_be32(ip->i_inode.i_ctime.tv_nsec);
1167 1168 1169 1170 1171 1172 1173 1174
}

void gfs2_dinode_print(const struct gfs2_inode *ip)
{
	printk(KERN_INFO "  no_formal_ino = %llu\n",
	       (unsigned long long)ip->i_no_formal_ino);
	printk(KERN_INFO "  no_addr = %llu\n",
	       (unsigned long long)ip->i_no_addr);
1175 1176
	printk(KERN_INFO "  i_disksize = %llu\n",
	       (unsigned long long)ip->i_disksize);
1177 1178
	printk(KERN_INFO "  blocks = %llu\n",
	       (unsigned long long)gfs2_get_inode_blocks(&ip->i_inode));
1179 1180
	printk(KERN_INFO "  i_goal = %llu\n",
	       (unsigned long long)ip->i_goal);
1181
	printk(KERN_INFO "  i_diskflags = 0x%.8X\n", ip->i_diskflags);
B
Bob Peterson 已提交
1182
	printk(KERN_INFO "  i_height = %u\n", ip->i_height);
1183
	printk(KERN_INFO "  i_depth = %u\n", ip->i_depth);
1184
	printk(KERN_INFO "  i_entries = %u\n", ip->i_entries);
1185 1186
	printk(KERN_INFO "  i_eattr = %llu\n",
	       (unsigned long long)ip->i_eattr);
1187 1188
}