[deliverable/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 v.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, char *buf)
{
	struct gfs2_inum *str = (struct gfs2_inum *)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, char *buf)
{
	struct gfs2_inum *str = (struct gfs2_inum *)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(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, char *buf)
{
	struct gfs2_meta_header *str = (struct gfs2_meta_header *)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(struct gfs2_meta_header *mh, char *buf)
{
	struct gfs2_meta_header *str = (struct gfs2_meta_header *)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(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 *sb, char *buf)
{
	struct gfs2_sb *str = (struct gfs2_sb *)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, char *buf)
{
	struct gfs2_rindex *str = (struct gfs2_rindex *)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(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 *rg, char *buf)
{
	struct gfs2_rgrp *str = (struct gfs2_rgrp *)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);
}

void gfs2_rgrp_out(struct gfs2_rgrp *rg, char *buf)
{
	struct gfs2_rgrp *str = (struct gfs2_rgrp *)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);

	memset(&str->rg_reserved, 0, sizeof(str->rg_reserved));
}

void gfs2_quota_in(struct gfs2_quota *qu, char *buf)
{
	struct gfs2_quota *str = (struct gfs2_quota *)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 *di, char *buf)
{
	struct gfs2_dinode *str = (struct gfs2_dinode *)buf;

	gfs2_meta_header_in(&di->di_header, buf);
	gfs2_inum_in(&di->di_num, (char *)&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_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(struct gfs2_dinode *di, char *buf)
{
	struct gfs2_dinode *str = (struct gfs2_dinode *)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_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(struct gfs2_dinode *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, char *buf)
{
	struct gfs2_log_header *str = (struct gfs2_log_header *)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, char *buf)
{
	struct gfs2_inum_range *str = (struct gfs2_inum_range *)buf;

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

void gfs2_inum_range_out(struct gfs2_inum_range *ir, char *buf)
{
	struct gfs2_inum_range *str = (struct gfs2_inum_range *)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, char *buf)
{
	struct gfs2_statfs_change *str = (struct gfs2_statfs_change *)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(struct gfs2_statfs_change *sc, char *buf)
{
	struct gfs2_statfs_change *str = (struct gfs2_statfs_change *)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, char *buf)
{
	struct gfs2_quota_change *str = (struct gfs2_quota_change *)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
	7	* of the GNU General Public License v.2.
	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
	35	void gfs2_inum_in(struct gfs2_inum no, char buf)
	36	{
	37	struct gfs2_inum str = (struct gfs2_inum )buf;
	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
c752666c	43	void gfs2_inum_out(const struct gfs2_inum no, char buf)
b3b94faa DT	44	{
	45	struct gfs2_inum str = (struct gfs2_inum )buf;
	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
08bc2dbc	51	static void gfs2_inum_print(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
b96ca4fa	57	static void gfs2_meta_header_in(struct gfs2_meta_header mh, char buf)
b3b94faa DT	58	{
	59	struct gfs2_meta_header str = (struct gfs2_meta_header )buf;
	60
	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
b96ca4fa	66	static void gfs2_meta_header_out(struct gfs2_meta_header mh, char buf)
b3b94faa DT	67	{
	68	struct gfs2_meta_header str = (struct gfs2_meta_header )buf;
	69
	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
08bc2dbc	75	static void gfs2_meta_header_print(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
	82	void gfs2_sb_in(struct gfs2_sb sb, char buf)
	83	{
	84	struct gfs2_sb str = (struct gfs2_sb )buf;
	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
b3b94faa DT	100	void gfs2_rindex_in(struct gfs2_rindex ri, char buf)
	101	{
	102	struct gfs2_rindex str = (struct gfs2_rindex )buf;
	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
b3b94faa DT	112	void gfs2_rindex_print(struct gfs2_rindex *ri)
b3b94faa DT	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
	123	void gfs2_rgrp_in(struct gfs2_rgrp rg, char buf)
	124	{
	125	struct gfs2_rgrp str = (struct gfs2_rgrp )buf;
	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);
	131	}
	132
	133	void gfs2_rgrp_out(struct gfs2_rgrp rg, char buf)
	134	{
	135	struct gfs2_rgrp str = (struct gfs2_rgrp )buf;
	136
	137	gfs2_meta_header_out(&rg->rg_header, buf);
	138	str->rg_flags = cpu_to_be32(rg->rg_flags);
	139	str->rg_free = cpu_to_be32(rg->rg_free);
	140	str->rg_dinodes = cpu_to_be32(rg->rg_dinodes);
	141
	142	memset(&str->rg_reserved, 0, sizeof(str->rg_reserved));
	143	}
	144
b3b94faa DT	145	void gfs2_quota_in(struct gfs2_quota qu, char buf)
	146	{
	147	struct gfs2_quota str = (struct gfs2_quota )buf;
	148
	149	qu->qu_limit = be64_to_cpu(str->qu_limit);
	150	qu->qu_warn = be64_to_cpu(str->qu_warn);
	151	qu->qu_value = be64_to_cpu(str->qu_value);
	152	}
	153
b3b94faa DT	154	void gfs2_dinode_in(struct gfs2_dinode di, char buf)
	155	{
	156	struct gfs2_dinode str = (struct gfs2_dinode )buf;
	157
	158	gfs2_meta_header_in(&di->di_header, buf);
	159	gfs2_inum_in(&di->di_num, (char *)&str->di_num);
	160
	161	di->di_mode = be32_to_cpu(str->di_mode);
	162	di->di_uid = be32_to_cpu(str->di_uid);
	163	di->di_gid = be32_to_cpu(str->di_gid);
	164	di->di_nlink = be32_to_cpu(str->di_nlink);
	165	di->di_size = be64_to_cpu(str->di_size);
	166	di->di_blocks = be64_to_cpu(str->di_blocks);
	167	di->di_atime = be64_to_cpu(str->di_atime);
	168	di->di_mtime = be64_to_cpu(str->di_mtime);
	169	di->di_ctime = be64_to_cpu(str->di_ctime);
	170	di->di_major = be32_to_cpu(str->di_major);
	171	di->di_minor = be32_to_cpu(str->di_minor);
	172
	173	di->di_goal_meta = be64_to_cpu(str->di_goal_meta);
	174	di->di_goal_data = be64_to_cpu(str->di_goal_data);
	175
	176	di->di_flags = be32_to_cpu(str->di_flags);
	177	di->di_payload_format = be32_to_cpu(str->di_payload_format);
	178	di->di_height = be16_to_cpu(str->di_height);
	179
	180	di->di_depth = be16_to_cpu(str->di_depth);
	181	di->di_entries = be32_to_cpu(str->di_entries);
	182
	183	di->di_eattr = be64_to_cpu(str->di_eattr);
	184
	185	}
	186
	187	void gfs2_dinode_out(struct gfs2_dinode di, char buf)
	188	{
	189	struct gfs2_dinode str = (struct gfs2_dinode )buf;
	190
	191	gfs2_meta_header_out(&di->di_header, buf);
	192	gfs2_inum_out(&di->di_num, (char *)&str->di_num);
	193
	194	str->di_mode = cpu_to_be32(di->di_mode);
	195	str->di_uid = cpu_to_be32(di->di_uid);
	196	str->di_gid = cpu_to_be32(di->di_gid);
	197	str->di_nlink = cpu_to_be32(di->di_nlink);
	198	str->di_size = cpu_to_be64(di->di_size);
	199	str->di_blocks = cpu_to_be64(di->di_blocks);
	200	str->di_atime = cpu_to_be64(di->di_atime);
	201	str->di_mtime = cpu_to_be64(di->di_mtime);
	202	str->di_ctime = cpu_to_be64(di->di_ctime);
	203	str->di_major = cpu_to_be32(di->di_major);
	204	str->di_minor = cpu_to_be32(di->di_minor);
	205
	206	str->di_goal_meta = cpu_to_be64(di->di_goal_meta);
	207	str->di_goal_data = cpu_to_be64(di->di_goal_data);
	208
	209	str->di_flags = cpu_to_be32(di->di_flags);
	210	str->di_payload_format = cpu_to_be32(di->di_payload_format);
	211	str->di_height = cpu_to_be16(di->di_height);
	212
	213	str->di_depth = cpu_to_be16(di->di_depth);
	214	str->di_entries = cpu_to_be32(di->di_entries);
	215
	216	str->di_eattr = cpu_to_be64(di->di_eattr);
	217
218	}
219
220	void gfs2_dinode_print(struct gfs2_dinode *di)
221	{
222	gfs2_meta_header_print(&di->di_header);
223	gfs2_inum_print(&di->di_num);
224
225	pv(di, di_mode, "0%o");
226	pv(di, di_uid, "%u");
227	pv(di, di_gid, "%u");
228	pv(di, di_nlink, "%u");
382066da SW	229	printk(KERN_INFO " di_size = %llu\n", (unsigned long long)di->di_size);
	230	printk(KERN_INFO " di_blocks = %llu\n", (unsigned long long)di->di_blocks);
	231	printk(KERN_INFO " di_atime = %lld\n", (long long)di->di_atime);
	232	printk(KERN_INFO " di_mtime = %lld\n", (long long)di->di_mtime);
	233	printk(KERN_INFO " di_ctime = %lld\n", (long long)di->di_ctime);
b3b94faa DT	234	pv(di, di_major, "%u");
	235	pv(di, di_minor, "%u");
	236
382066da SW	237	printk(KERN_INFO " di_goal_meta = %llu\n", (unsigned long long)di->di_goal_meta);
382066da SW	238	printk(KERN_INFO " di_goal_data = %llu\n", (unsigned long long)di->di_goal_data);
b3b94faa DT	239
	240	pv(di, di_flags, "0x%.8X");
	241	pv(di, di_payload_format, "%u");
	242	pv(di, di_height, "%u");
	243
	244	pv(di, di_depth, "%u");
	245	pv(di, di_entries, "%u");
	246
382066da	247	printk(KERN_INFO " di_eattr = %llu\n", (unsigned long long)di->di_eattr);
b3b94faa DT	248	}
b3b94faa DT	249
b3b94faa DT	250	void gfs2_log_header_in(struct gfs2_log_header lh, char buf)
	251	{
	252	struct gfs2_log_header str = (struct gfs2_log_header )buf;
	253
	254	gfs2_meta_header_in(&lh->lh_header, buf);
	255	lh->lh_sequence = be64_to_cpu(str->lh_sequence);
	256	lh->lh_flags = be32_to_cpu(str->lh_flags);
	257	lh->lh_tail = be32_to_cpu(str->lh_tail);
	258	lh->lh_blkno = be32_to_cpu(str->lh_blkno);
	259	lh->lh_hash = be32_to_cpu(str->lh_hash);
	260	}
	261
b3b94faa DT	262	void gfs2_inum_range_in(struct gfs2_inum_range ir, char buf)
	263	{
	264	struct gfs2_inum_range str = (struct gfs2_inum_range )buf;
	265
	266	ir->ir_start = be64_to_cpu(str->ir_start);
	267	ir->ir_length = be64_to_cpu(str->ir_length);
	268	}
	269
	270	void gfs2_inum_range_out(struct gfs2_inum_range ir, char buf)
	271	{
	272	struct gfs2_inum_range str = (struct gfs2_inum_range )buf;
	273
	274	str->ir_start = cpu_to_be64(ir->ir_start);
	275	str->ir_length = cpu_to_be64(ir->ir_length);
	276	}
	277
b3b94faa DT	278	void gfs2_statfs_change_in(struct gfs2_statfs_change sc, char buf)
	279	{
	280	struct gfs2_statfs_change str = (struct gfs2_statfs_change )buf;
	281
	282	sc->sc_total = be64_to_cpu(str->sc_total);
	283	sc->sc_free = be64_to_cpu(str->sc_free);
	284	sc->sc_dinodes = be64_to_cpu(str->sc_dinodes);
	285	}
	286
	287	void gfs2_statfs_change_out(struct gfs2_statfs_change sc, char buf)
	288	{
	289	struct gfs2_statfs_change str = (struct gfs2_statfs_change )buf;
	290
	291	str->sc_total = cpu_to_be64(sc->sc_total);
	292	str->sc_free = cpu_to_be64(sc->sc_free);
	293	str->sc_dinodes = cpu_to_be64(sc->sc_dinodes);
	294	}
	295
b3b94faa DT	296	void gfs2_quota_change_in(struct gfs2_quota_change qc, char buf)
	297	{
	298	struct gfs2_quota_change str = (struct gfs2_quota_change )buf;
	299
	300	qc->qc_change = be64_to_cpu(str->qc_change);
	301	qc->qc_flags = be32_to_cpu(str->qc_flags);
	302	qc->qc_id = be32_to_cpu(str->qc_id);
	303	}
	304