[linux.git] / fs / gfs2 / ondisk.c

/*
 * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
 * Copyright (C) 2004-2006 Red Hat, Inc.  All rights reserved.
 *
 * This copyrighted material is made available to anyone wishing to use,
 * modify, copy, or redistribute it subject to the terms and conditions
 * of the GNU General Public License version 2.
 */

#include <linux/sched.h>
#include <linux/slab.h>
#include <linux/spinlock.h>
#include <linux/completion.h>
#include <linux/buffer_head.h>

#include "gfs2.h"
#include <linux/gfs2_ondisk.h>

#define pv(struct, member, fmt) printk(KERN_INFO "  "#member" = "fmt"\n", \
				       struct->member);

/*
 * gfs2_xxx_in - read in an xxx struct
 * first arg: the cpu-order structure
 * buf: the disk-order buffer
 *
 * gfs2_xxx_out - write out an xxx struct
 * first arg: the cpu-order structure
 * buf: the disk-order buffer
 *
 * gfs2_xxx_print - print out an xxx struct
 * first arg: the cpu-order structure
 */

void gfs2_inum_in(struct gfs2_inum *no, const void *buf)
{
	const struct gfs2_inum *str = buf;

	no->no_formal_ino = be64_to_cpu(str->no_formal_ino);
	no->no_addr = be64_to_cpu(str->no_addr);
}

void gfs2_inum_out(const struct gfs2_inum *no, void *buf)
{
	struct gfs2_inum *str = buf;

	str->no_formal_ino = cpu_to_be64(no->no_formal_ino);
	str->no_addr = cpu_to_be64(no->no_addr);
}

static void gfs2_inum_print(const struct gfs2_inum *no)
{
	printk(KERN_INFO "  no_formal_ino = %llu\n", (unsigned long long)no->no_formal_ino);
	printk(KERN_INFO "  no_addr = %llu\n", (unsigned long long)no->no_addr);
}

static void gfs2_meta_header_in(struct gfs2_meta_header *mh, const void *buf)
{
	const struct gfs2_meta_header *str = buf;

	mh->mh_magic = be32_to_cpu(str->mh_magic);
	mh->mh_type = be32_to_cpu(str->mh_type);
	mh->mh_format = be32_to_cpu(str->mh_format);
}

static void gfs2_meta_header_out(const struct gfs2_meta_header *mh, void *buf)
{
	struct gfs2_meta_header *str = buf;

	str->mh_magic = cpu_to_be32(mh->mh_magic);
	str->mh_type = cpu_to_be32(mh->mh_type);
	str->mh_format = cpu_to_be32(mh->mh_format);
}

static void gfs2_meta_header_print(const struct gfs2_meta_header *mh)
{
	pv(mh, mh_magic, "0x%.8X");
	pv(mh, mh_type, "%u");
	pv(mh, mh_format, "%u");
}

void gfs2_sb_in(struct gfs2_sb_host *sb, const void *buf)
{
	const struct gfs2_sb *str = buf;

	gfs2_meta_header_in(&sb->sb_header, buf);

	sb->sb_fs_format = be32_to_cpu(str->sb_fs_format);
	sb->sb_multihost_format = be32_to_cpu(str->sb_multihost_format);
	sb->sb_bsize = be32_to_cpu(str->sb_bsize);
	sb->sb_bsize_shift = be32_to_cpu(str->sb_bsize_shift);

	gfs2_inum_in(&sb->sb_master_dir, (char *)&str->sb_master_dir);
	gfs2_inum_in(&sb->sb_root_dir, (char *)&str->sb_root_dir);

	memcpy(sb->sb_lockproto, str->sb_lockproto, GFS2_LOCKNAME_LEN);
	memcpy(sb->sb_locktable, str->sb_locktable, GFS2_LOCKNAME_LEN);
}

void gfs2_rindex_in(struct gfs2_rindex *ri, const void *buf)
{
	const struct gfs2_rindex *str = buf;

	ri->ri_addr = be64_to_cpu(str->ri_addr);
	ri->ri_length = be32_to_cpu(str->ri_length);
	ri->ri_data0 = be64_to_cpu(str->ri_data0);
	ri->ri_data = be32_to_cpu(str->ri_data);
	ri->ri_bitbytes = be32_to_cpu(str->ri_bitbytes);

}

void gfs2_rindex_print(const struct gfs2_rindex *ri)
{
	printk(KERN_INFO "  ri_addr = %llu\n", (unsigned long long)ri->ri_addr);
	pv(ri, ri_length, "%u");

	printk(KERN_INFO "  ri_data0 = %llu\n", (unsigned long long)ri->ri_data0);
	pv(ri, ri_data, "%u");

	pv(ri, ri_bitbytes, "%u");
}

void gfs2_rgrp_in(struct gfs2_rgrp_host *rg, const void *buf)
{
	const struct gfs2_rgrp *str = buf;

	gfs2_meta_header_in(&rg->rg_header, buf);
	rg->rg_flags = be32_to_cpu(str->rg_flags);
	rg->rg_free = be32_to_cpu(str->rg_free);
	rg->rg_dinodes = be32_to_cpu(str->rg_dinodes);
	rg->rg_igeneration = be64_to_cpu(str->rg_igeneration);
}

void gfs2_rgrp_out(const struct gfs2_rgrp_host *rg, void *buf)
{
	struct gfs2_rgrp *str = buf;

	gfs2_meta_header_out(&rg->rg_header, buf);
	str->rg_flags = cpu_to_be32(rg->rg_flags);
	str->rg_free = cpu_to_be32(rg->rg_free);
	str->rg_dinodes = cpu_to_be32(rg->rg_dinodes);
	str->__pad = cpu_to_be32(0);
	str->rg_igeneration = cpu_to_be64(rg->rg_igeneration);
	memset(&str->rg_reserved, 0, sizeof(str->rg_reserved));
}

void gfs2_quota_in(struct gfs2_quota *qu, const void *buf)
{
	const struct gfs2_quota *str = buf;

	qu->qu_limit = be64_to_cpu(str->qu_limit);
	qu->qu_warn = be64_to_cpu(str->qu_warn);
	qu->qu_value = be64_to_cpu(str->qu_value);
}

void gfs2_dinode_in(struct gfs2_dinode_host *di, const void *buf)
{
	const struct gfs2_dinode *str = buf;

	gfs2_meta_header_in(&di->di_header, buf);
	gfs2_inum_in(&di->di_num, &str->di_num);

	di->di_mode = be32_to_cpu(str->di_mode);
	di->di_uid = be32_to_cpu(str->di_uid);
	di->di_gid = be32_to_cpu(str->di_gid);
	di->di_nlink = be32_to_cpu(str->di_nlink);
	di->di_size = be64_to_cpu(str->di_size);
	di->di_blocks = be64_to_cpu(str->di_blocks);
	di->di_atime = be64_to_cpu(str->di_atime);
	di->di_mtime = be64_to_cpu(str->di_mtime);
	di->di_ctime = be64_to_cpu(str->di_ctime);
	di->di_major = be32_to_cpu(str->di_major);
	di->di_minor = be32_to_cpu(str->di_minor);

	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);
	di->di_payload_format = be32_to_cpu(str->di_payload_format);
	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);

}

void gfs2_dinode_out(const struct gfs2_dinode_host *di, void *buf)
{
	struct gfs2_dinode *str = buf;

	gfs2_meta_header_out(&di->di_header, buf);
	gfs2_inum_out(&di->di_num, (char *)&str->di_num);

	str->di_mode = cpu_to_be32(di->di_mode);
	str->di_uid = cpu_to_be32(di->di_uid);
	str->di_gid = cpu_to_be32(di->di_gid);
	str->di_nlink = cpu_to_be32(di->di_nlink);
	str->di_size = cpu_to_be64(di->di_size);
	str->di_blocks = cpu_to_be64(di->di_blocks);
	str->di_atime = cpu_to_be64(di->di_atime);
	str->di_mtime = cpu_to_be64(di->di_mtime);
	str->di_ctime = cpu_to_be64(di->di_ctime);
	str->di_major = cpu_to_be32(di->di_major);
	str->di_minor = cpu_to_be32(di->di_minor);

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

	str->di_flags = cpu_to_be32(di->di_flags);
	str->di_payload_format = cpu_to_be32(di->di_payload_format);
	str->di_height = cpu_to_be16(di->di_height);

	str->di_depth = cpu_to_be16(di->di_depth);
	str->di_entries = cpu_to_be32(di->di_entries);

	str->di_eattr = cpu_to_be64(di->di_eattr);

}

void gfs2_dinode_print(const struct gfs2_dinode_host *di)
{
	gfs2_meta_header_print(&di->di_header);
	gfs2_inum_print(&di->di_num);

	pv(di, di_mode, "0%o");
	pv(di, di_uid, "%u");
	pv(di, di_gid, "%u");
	pv(di, di_nlink, "%u");
	printk(KERN_INFO "  di_size = %llu\n", (unsigned long long)di->di_size);
	printk(KERN_INFO "  di_blocks = %llu\n", (unsigned long long)di->di_blocks);
	printk(KERN_INFO "  di_atime = %lld\n", (long long)di->di_atime);
	printk(KERN_INFO "  di_mtime = %lld\n", (long long)di->di_mtime);
	printk(KERN_INFO "  di_ctime = %lld\n", (long long)di->di_ctime);
	pv(di, di_major, "%u");
	pv(di, di_minor, "%u");

	printk(KERN_INFO "  di_goal_meta = %llu\n", (unsigned long long)di->di_goal_meta);
	printk(KERN_INFO "  di_goal_data = %llu\n", (unsigned long long)di->di_goal_data);

	pv(di, di_flags, "0x%.8X");
	pv(di, di_payload_format, "%u");
	pv(di, di_height, "%u");

	pv(di, di_depth, "%u");
	pv(di, di_entries, "%u");

	printk(KERN_INFO "  di_eattr = %llu\n", (unsigned long long)di->di_eattr);
}

void gfs2_log_header_in(struct gfs2_log_header *lh, const void *buf)
{
	const struct gfs2_log_header *str = buf;

	gfs2_meta_header_in(&lh->lh_header, buf);
	lh->lh_sequence = be64_to_cpu(str->lh_sequence);
	lh->lh_flags = be32_to_cpu(str->lh_flags);
	lh->lh_tail = be32_to_cpu(str->lh_tail);
	lh->lh_blkno = be32_to_cpu(str->lh_blkno);
	lh->lh_hash = be32_to_cpu(str->lh_hash);
}

void gfs2_inum_range_in(struct gfs2_inum_range *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);
}

void gfs2_inum_range_out(const struct gfs2_inum_range *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);
}

void gfs2_statfs_change_in(struct gfs2_statfs_change *sc, const void *buf)
{
	const struct gfs2_statfs_change *str = buf;

	sc->sc_total = be64_to_cpu(str->sc_total);
	sc->sc_free = be64_to_cpu(str->sc_free);
	sc->sc_dinodes = be64_to_cpu(str->sc_dinodes);
}

void gfs2_statfs_change_out(const struct gfs2_statfs_change *sc, void *buf)
{
	struct gfs2_statfs_change *str = buf;

	str->sc_total = cpu_to_be64(sc->sc_total);
	str->sc_free = cpu_to_be64(sc->sc_free);
	str->sc_dinodes = cpu_to_be64(sc->sc_dinodes);
}

void gfs2_quota_change_in(struct gfs2_quota_change *qc, const void *buf)
{
	const struct gfs2_quota_change *str = buf;

	qc->qc_change = be64_to_cpu(str->qc_change);
	qc->qc_flags = be32_to_cpu(str->qc_flags);
	qc->qc_id = be32_to_cpu(str->qc_id);
}
Commit	Line	Data
b3b94faa DT	1	/*
b3b94faa DT	2	* Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
3a8a9a10	3	* Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved.
b3b94faa DT	4	*
	5	* This copyrighted material is made available to anyone wishing to use,
	6	* modify, copy, or redistribute it subject to the terms and conditions
e9fc2aa0	7	* of the GNU General Public License version 2.
b3b94faa DT	8	*/
	9
	10	#include <linux/sched.h>
	11	#include <linux/slab.h>
	12	#include <linux/spinlock.h>
	13	#include <linux/completion.h>
	14	#include <linux/buffer_head.h>
b3b94faa DT	15
	16	#include "gfs2.h"
	17	#include <linux/gfs2_ondisk.h>
	18
568f4c96 SW	19	#define pv(struct, member, fmt) printk(KERN_INFO " "#member" = "fmt"\n", \
568f4c96 SW	20	struct->member);
b3b94faa DT	21
	22	/*
	23	* gfs2_xxx_in - read in an xxx struct
	24	* first arg: the cpu-order structure
	25	* buf: the disk-order buffer
	26	*
	27	* gfs2_xxx_out - write out an xxx struct
	28	* first arg: the cpu-order structure
	29	* buf: the disk-order buffer
	30	*
	31	* gfs2_xxx_print - print out an xxx struct
	32	* first arg: the cpu-order structure
	33	*/
	34
38c60ef2	35	void gfs2_inum_in(struct gfs2_inum no, const void buf)
b3b94faa	36	{
38c60ef2	37	const struct gfs2_inum *str = buf;
b3b94faa DT	38
	39	no->no_formal_ino = be64_to_cpu(str->no_formal_ino);
	40	no->no_addr = be64_to_cpu(str->no_addr);
	41	}
	42
38c60ef2	43	void gfs2_inum_out(const struct gfs2_inum no, void buf)
b3b94faa	44	{
38c60ef2	45	struct gfs2_inum *str = buf;
b3b94faa DT	46
	47	str->no_formal_ino = cpu_to_be64(no->no_formal_ino);
	48	str->no_addr = cpu_to_be64(no->no_addr);
	49	}
	50
38c60ef2	51	static void gfs2_inum_print(const struct gfs2_inum *no)
b3b94faa	52	{
382066da SW	53	printk(KERN_INFO " no_formal_ino = %llu\n", (unsigned long long)no->no_formal_ino);
382066da SW	54	printk(KERN_INFO " no_addr = %llu\n", (unsigned long long)no->no_addr);
b3b94faa DT	55	}
b3b94faa DT	56
38c60ef2	57	static void gfs2_meta_header_in(struct gfs2_meta_header mh, const void buf)
b3b94faa	58	{
38c60ef2	59	const struct gfs2_meta_header *str = buf;
b3b94faa DT	60
b3b94faa DT	61	mh->mh_magic = be32_to_cpu(str->mh_magic);
e3167ded SW	62	mh->mh_type = be32_to_cpu(str->mh_type);
e3167ded SW	63	mh->mh_format = be32_to_cpu(str->mh_format);
b3b94faa DT	64	}
b3b94faa DT	65
38c60ef2	66	static void gfs2_meta_header_out(const struct gfs2_meta_header mh, void buf)
b3b94faa	67	{
38c60ef2	68	struct gfs2_meta_header *str = buf;
b3b94faa DT	69
b3b94faa DT	70	str->mh_magic = cpu_to_be32(mh->mh_magic);
e3167ded SW	71	str->mh_type = cpu_to_be32(mh->mh_type);
e3167ded SW	72	str->mh_format = cpu_to_be32(mh->mh_format);
b3b94faa DT	73	}
b3b94faa DT	74
38c60ef2	75	static void gfs2_meta_header_print(const struct gfs2_meta_header *mh)
b3b94faa DT	76	{
	77	pv(mh, mh_magic, "0x%.8X");
	78	pv(mh, mh_type, "%u");
	79	pv(mh, mh_format, "%u");
	80	}
	81
f50dfaf7	82	void gfs2_sb_in(struct gfs2_sb_host sb, const void buf)
b3b94faa	83	{
38c60ef2	84	const struct gfs2_sb *str = buf;
b3b94faa DT	85
	86	gfs2_meta_header_in(&sb->sb_header, buf);
	87
	88	sb->sb_fs_format = be32_to_cpu(str->sb_fs_format);
	89	sb->sb_multihost_format = be32_to_cpu(str->sb_multihost_format);
	90	sb->sb_bsize = be32_to_cpu(str->sb_bsize);
	91	sb->sb_bsize_shift = be32_to_cpu(str->sb_bsize_shift);
	92
	93	gfs2_inum_in(&sb->sb_master_dir, (char *)&str->sb_master_dir);
	94	gfs2_inum_in(&sb->sb_root_dir, (char *)&str->sb_root_dir);
	95
	96	memcpy(sb->sb_lockproto, str->sb_lockproto, GFS2_LOCKNAME_LEN);
	97	memcpy(sb->sb_locktable, str->sb_locktable, GFS2_LOCKNAME_LEN);
	98	}
	99
38c60ef2	100	void gfs2_rindex_in(struct gfs2_rindex ri, const void buf)
b3b94faa	101	{
38c60ef2	102	const struct gfs2_rindex *str = buf;
b3b94faa DT	103
	104	ri->ri_addr = be64_to_cpu(str->ri_addr);
	105	ri->ri_length = be32_to_cpu(str->ri_length);
	106	ri->ri_data0 = be64_to_cpu(str->ri_data0);
	107	ri->ri_data = be32_to_cpu(str->ri_data);
	108	ri->ri_bitbytes = be32_to_cpu(str->ri_bitbytes);
	109
	110	}
	111
38c60ef2	112	void gfs2_rindex_print(const struct gfs2_rindex *ri)
b3b94faa	113	{
382066da	114	printk(KERN_INFO " ri_addr = %llu\n", (unsigned long long)ri->ri_addr);
b3b94faa DT	115	pv(ri, ri_length, "%u");
b3b94faa DT	116
382066da	117	printk(KERN_INFO " ri_data0 = %llu\n", (unsigned long long)ri->ri_data0);
b3b94faa DT	118	pv(ri, ri_data, "%u");
	119
	120	pv(ri, ri_bitbytes, "%u");
	121	}
	122
68826664	123	void gfs2_rgrp_in(struct gfs2_rgrp_host rg, const void buf)
b3b94faa	124	{
38c60ef2	125	const struct gfs2_rgrp *str = buf;
b3b94faa DT	126
	127	gfs2_meta_header_in(&rg->rg_header, buf);
	128	rg->rg_flags = be32_to_cpu(str->rg_flags);
	129	rg->rg_free = be32_to_cpu(str->rg_free);
	130	rg->rg_dinodes = be32_to_cpu(str->rg_dinodes);
4340fe62	131	rg->rg_igeneration = be64_to_cpu(str->rg_igeneration);
b3b94faa DT	132	}
b3b94faa DT	133
68826664	134	void gfs2_rgrp_out(const struct gfs2_rgrp_host rg, void buf)
b3b94faa	135	{
38c60ef2	136	struct gfs2_rgrp *str = buf;
b3b94faa DT	137
	138	gfs2_meta_header_out(&rg->rg_header, buf);
	139	str->rg_flags = cpu_to_be32(rg->rg_flags);
	140	str->rg_free = cpu_to_be32(rg->rg_free);
	141	str->rg_dinodes = cpu_to_be32(rg->rg_dinodes);
4340fe62 SW	142	str->__pad = cpu_to_be32(0);
4340fe62 SW	143	str->rg_igeneration = cpu_to_be64(rg->rg_igeneration);
b3b94faa DT	144	memset(&str->rg_reserved, 0, sizeof(str->rg_reserved));
	145	}
	146
38c60ef2	147	void gfs2_quota_in(struct gfs2_quota qu, const void buf)
b3b94faa	148	{
38c60ef2	149	const struct gfs2_quota *str = buf;
b3b94faa DT	150
	151	qu->qu_limit = be64_to_cpu(str->qu_limit);
	152	qu->qu_warn = be64_to_cpu(str->qu_warn);
	153	qu->qu_value = be64_to_cpu(str->qu_value);
	154	}
	155
3ca68df6	156	void gfs2_dinode_in(struct gfs2_dinode_host di, const void buf)
b3b94faa	157	{
38c60ef2	158	const struct gfs2_dinode *str = buf;
b3b94faa DT	159
b3b94faa DT	160	gfs2_meta_header_in(&di->di_header, buf);
38c60ef2	161	gfs2_inum_in(&di->di_num, &str->di_num);
b3b94faa DT	162
	163	di->di_mode = be32_to_cpu(str->di_mode);
	164	di->di_uid = be32_to_cpu(str->di_uid);
	165	di->di_gid = be32_to_cpu(str->di_gid);
	166	di->di_nlink = be32_to_cpu(str->di_nlink);
	167	di->di_size = be64_to_cpu(str->di_size);
	168	di->di_blocks = be64_to_cpu(str->di_blocks);
	169	di->di_atime = be64_to_cpu(str->di_atime);
	170	di->di_mtime = be64_to_cpu(str->di_mtime);
	171	di->di_ctime = be64_to_cpu(str->di_ctime);
	172	di->di_major = be32_to_cpu(str->di_major);
	173	di->di_minor = be32_to_cpu(str->di_minor);
	174
	175	di->di_goal_meta = be64_to_cpu(str->di_goal_meta);
	176	di->di_goal_data = be64_to_cpu(str->di_goal_data);
4340fe62	177	di->di_generation = be64_to_cpu(str->di_generation);
b3b94faa DT	178
	179	di->di_flags = be32_to_cpu(str->di_flags);
	180	di->di_payload_format = be32_to_cpu(str->di_payload_format);
	181	di->di_height = be16_to_cpu(str->di_height);
	182
	183	di->di_depth = be16_to_cpu(str->di_depth);
	184	di->di_entries = be32_to_cpu(str->di_entries);
	185
	186	di->di_eattr = be64_to_cpu(str->di_eattr);
	187
	188	}
	189
3ca68df6	190	void gfs2_dinode_out(const struct gfs2_dinode_host di, void buf)
b3b94faa	191	{
38c60ef2	192	struct gfs2_dinode *str = buf;
b3b94faa DT	193
	194	gfs2_meta_header_out(&di->di_header, buf);
	195	gfs2_inum_out(&di->di_num, (char *)&str->di_num);
	196
	197	str->di_mode = cpu_to_be32(di->di_mode);
	198	str->di_uid = cpu_to_be32(di->di_uid);
	199	str->di_gid = cpu_to_be32(di->di_gid);
	200	str->di_nlink = cpu_to_be32(di->di_nlink);
	201	str->di_size = cpu_to_be64(di->di_size);
	202	str->di_blocks = cpu_to_be64(di->di_blocks);
	203	str->di_atime = cpu_to_be64(di->di_atime);
	204	str->di_mtime = cpu_to_be64(di->di_mtime);
	205	str->di_ctime = cpu_to_be64(di->di_ctime);
	206	str->di_major = cpu_to_be32(di->di_major);
	207	str->di_minor = cpu_to_be32(di->di_minor);
	208
	209	str->di_goal_meta = cpu_to_be64(di->di_goal_meta);
	210	str->di_goal_data = cpu_to_be64(di->di_goal_data);
4340fe62	211	str->di_generation = cpu_to_be64(di->di_generation);
b3b94faa DT	212
	213	str->di_flags = cpu_to_be32(di->di_flags);
	214	str->di_payload_format = cpu_to_be32(di->di_payload_format);
	215	str->di_height = cpu_to_be16(di->di_height);
	216
	217	str->di_depth = cpu_to_be16(di->di_depth);
	218	str->di_entries = cpu_to_be32(di->di_entries);
	219
	220	str->di_eattr = cpu_to_be64(di->di_eattr);
	221
	222	}
	223
3ca68df6	224	void gfs2_dinode_print(const struct gfs2_dinode_host *di)
b3b94faa DT	225	{
	226	gfs2_meta_header_print(&di->di_header);
	227	gfs2_inum_print(&di->di_num);
	228
	229	pv(di, di_mode, "0%o");
	230	pv(di, di_uid, "%u");
	231	pv(di, di_gid, "%u");
	232	pv(di, di_nlink, "%u");
382066da SW	233	printk(KERN_INFO " di_size = %llu\n", (unsigned long long)di->di_size);
	234	printk(KERN_INFO " di_blocks = %llu\n", (unsigned long long)di->di_blocks);
	235	printk(KERN_INFO " di_atime = %lld\n", (long long)di->di_atime);
	236	printk(KERN_INFO " di_mtime = %lld\n", (long long)di->di_mtime);
	237	printk(KERN_INFO " di_ctime = %lld\n", (long long)di->di_ctime);
b3b94faa DT	238	pv(di, di_major, "%u");
	239	pv(di, di_minor, "%u");
	240
382066da SW	241	printk(KERN_INFO " di_goal_meta = %llu\n", (unsigned long long)di->di_goal_meta);
382066da SW	242	printk(KERN_INFO " di_goal_data = %llu\n", (unsigned long long)di->di_goal_data);
b3b94faa DT	243
	244	pv(di, di_flags, "0x%.8X");
	245	pv(di, di_payload_format, "%u");
	246	pv(di, di_height, "%u");
	247
	248	pv(di, di_depth, "%u");
	249	pv(di, di_entries, "%u");
	250
382066da	251	printk(KERN_INFO " di_eattr = %llu\n", (unsigned long long)di->di_eattr);
b3b94faa DT	252	}
b3b94faa DT	253
38c60ef2	254	void gfs2_log_header_in(struct gfs2_log_header lh, const void buf)
b3b94faa	255	{
38c60ef2	256	const struct gfs2_log_header *str = buf;
b3b94faa DT	257
	258	gfs2_meta_header_in(&lh->lh_header, buf);
	259	lh->lh_sequence = be64_to_cpu(str->lh_sequence);
	260	lh->lh_flags = be32_to_cpu(str->lh_flags);
	261	lh->lh_tail = be32_to_cpu(str->lh_tail);
	262	lh->lh_blkno = be32_to_cpu(str->lh_blkno);
	263	lh->lh_hash = be32_to_cpu(str->lh_hash);
	264	}
	265
38c60ef2	266	void gfs2_inum_range_in(struct gfs2_inum_range ir, const void buf)
b3b94faa	267	{
38c60ef2	268	const struct gfs2_inum_range *str = buf;
b3b94faa DT	269
	270	ir->ir_start = be64_to_cpu(str->ir_start);
	271	ir->ir_length = be64_to_cpu(str->ir_length);
	272	}
	273
38c60ef2	274	void gfs2_inum_range_out(const struct gfs2_inum_range ir, void buf)
b3b94faa	275	{
38c60ef2	276	struct gfs2_inum_range *str = buf;
b3b94faa DT	277
	278	str->ir_start = cpu_to_be64(ir->ir_start);
	279	str->ir_length = cpu_to_be64(ir->ir_length);
	280	}
	281
38c60ef2	282	void gfs2_statfs_change_in(struct gfs2_statfs_change sc, const void buf)
b3b94faa	283	{
38c60ef2	284	const struct gfs2_statfs_change *str = buf;
b3b94faa DT	285
	286	sc->sc_total = be64_to_cpu(str->sc_total);
	287	sc->sc_free = be64_to_cpu(str->sc_free);
	288	sc->sc_dinodes = be64_to_cpu(str->sc_dinodes);
	289	}
	290
38c60ef2	291	void gfs2_statfs_change_out(const struct gfs2_statfs_change sc, void buf)
b3b94faa	292	{
38c60ef2	293	struct gfs2_statfs_change *str = buf;
b3b94faa DT	294
	295	str->sc_total = cpu_to_be64(sc->sc_total);
	296	str->sc_free = cpu_to_be64(sc->sc_free);
	297	str->sc_dinodes = cpu_to_be64(sc->sc_dinodes);
	298	}
	299
38c60ef2	300	void gfs2_quota_change_in(struct gfs2_quota_change qc, const void buf)
b3b94faa	301	{
38c60ef2	302	const struct gfs2_quota_change *str = buf;
b3b94faa DT	303
	304	qc->qc_change = be64_to_cpu(str->qc_change);
	305	qc->qc_flags = be32_to_cpu(str->qc_flags);
	306	qc->qc_id = be32_to_cpu(str->qc_id);
	307	}
	308