1/*
2 * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
3 * Copyright (C) 2004-2006 Red Hat, Inc.  All rights reserved.
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 version 2.
8 */
9
10#include <linux/slab.h>
11#include <linux/spinlock.h>
12#include <linux/completion.h>
13#include <linux/buffer_head.h>
14
15#include "gfs2.h"
16#include <linux/gfs2_ondisk.h>
17#include <linux/lm_interface.h>
18#include "incore.h"
19
20#define pv(struct, member, fmt) printk(KERN_INFO "  "#member" = "fmt"\n", \
21				       struct->member);
22
23
24void gfs2_inum_in(struct gfs2_inum_host *no, const void *buf)
25{
26	const struct gfs2_inum *str = buf;
27
28	no->no_formal_ino = be64_to_cpu(str->no_formal_ino);
29	no->no_addr = be64_to_cpu(str->no_addr);
30}
31
32void gfs2_inum_out(const struct gfs2_inum_host *no, void *buf)
33{
34	struct gfs2_inum *str = buf;
35
36	str->no_formal_ino = cpu_to_be64(no->no_formal_ino);
37	str->no_addr = cpu_to_be64(no->no_addr);
38}
39
40static void gfs2_inum_print(const struct gfs2_inum_host *no)
41{
42	printk(KERN_INFO "  no_formal_ino = %llu\n", (unsigned long long)no->no_formal_ino);
43	printk(KERN_INFO "  no_addr = %llu\n", (unsigned long long)no->no_addr);
44}
45
46static void gfs2_meta_header_in(struct gfs2_meta_header_host *mh, const void *buf)
47{
48	const struct gfs2_meta_header *str = buf;
49
50	mh->mh_magic = be32_to_cpu(str->mh_magic);
51	mh->mh_type = be32_to_cpu(str->mh_type);
52	mh->mh_format = be32_to_cpu(str->mh_format);
53}
54
55void gfs2_sb_in(struct gfs2_sb_host *sb, const void *buf)
56{
57	const struct gfs2_sb *str = buf;
58
59	gfs2_meta_header_in(&sb->sb_header, buf);
60
61	sb->sb_fs_format = be32_to_cpu(str->sb_fs_format);
62	sb->sb_multihost_format = be32_to_cpu(str->sb_multihost_format);
63	sb->sb_bsize = be32_to_cpu(str->sb_bsize);
64	sb->sb_bsize_shift = be32_to_cpu(str->sb_bsize_shift);
65
66	gfs2_inum_in(&sb->sb_master_dir, (char *)&str->sb_master_dir);
67	gfs2_inum_in(&sb->sb_root_dir, (char *)&str->sb_root_dir);
68
69	memcpy(sb->sb_lockproto, str->sb_lockproto, GFS2_LOCKNAME_LEN);
70	memcpy(sb->sb_locktable, str->sb_locktable, GFS2_LOCKNAME_LEN);
71}
72
73void gfs2_rindex_in(struct gfs2_rindex_host *ri, const void *buf)
74{
75	const struct gfs2_rindex *str = buf;
76
77	ri->ri_addr = be64_to_cpu(str->ri_addr);
78	ri->ri_length = be32_to_cpu(str->ri_length);
79	ri->ri_data0 = be64_to_cpu(str->ri_data0);
80	ri->ri_data = be32_to_cpu(str->ri_data);
81	ri->ri_bitbytes = be32_to_cpu(str->ri_bitbytes);
82
83}
84
85void gfs2_rindex_print(const struct gfs2_rindex_host *ri)
86{
87	printk(KERN_INFO "  ri_addr = %llu\n", (unsigned long long)ri->ri_addr);
88	pv(ri, ri_length, "%u");
89
90	printk(KERN_INFO "  ri_data0 = %llu\n", (unsigned long long)ri->ri_data0);
91	pv(ri, ri_data, "%u");
92
93	pv(ri, ri_bitbytes, "%u");
94}
95
96void gfs2_rgrp_in(struct gfs2_rgrp_host *rg, const void *buf)
97{
98	const struct gfs2_rgrp *str = buf;
99
100	rg->rg_flags = be32_to_cpu(str->rg_flags);
101	rg->rg_free = be32_to_cpu(str->rg_free);
102	rg->rg_dinodes = be32_to_cpu(str->rg_dinodes);
103	rg->rg_igeneration = be64_to_cpu(str->rg_igeneration);
104}
105
106void gfs2_rgrp_out(const struct gfs2_rgrp_host *rg, void *buf)
107{
108	struct gfs2_rgrp *str = buf;
109
110	str->rg_flags = cpu_to_be32(rg->rg_flags);
111	str->rg_free = cpu_to_be32(rg->rg_free);
112	str->rg_dinodes = cpu_to_be32(rg->rg_dinodes);
113	str->__pad = cpu_to_be32(0);
114	str->rg_igeneration = cpu_to_be64(rg->rg_igeneration);
115	memset(&str->rg_reserved, 0, sizeof(str->rg_reserved));
116}
117
118void gfs2_quota_in(struct gfs2_quota_host *qu, const void *buf)
119{
120	const struct gfs2_quota *str = buf;
121
122	qu->qu_limit = be64_to_cpu(str->qu_limit);
123	qu->qu_warn = be64_to_cpu(str->qu_warn);
124	qu->qu_value = be64_to_cpu(str->qu_value);
125}
126
127void gfs2_dinode_out(const struct gfs2_inode *ip, void *buf)
128{
129	const struct gfs2_dinode_host *di = &ip->i_di;
130	struct gfs2_dinode *str = buf;
131
132	str->di_header.mh_magic = cpu_to_be32(GFS2_MAGIC);
133	str->di_header.mh_type = cpu_to_be32(GFS2_METATYPE_DI);
134	str->di_header.__pad0 = 0;
135	str->di_header.mh_format = cpu_to_be32(GFS2_FORMAT_DI);
136	str->di_header.__pad1 = 0;
137
138	gfs2_inum_out(&ip->i_num, &str->di_num);
139
140	str->di_mode = cpu_to_be32(ip->i_inode.i_mode);
141	str->di_uid = cpu_to_be32(ip->i_inode.i_uid);
142	str->di_gid = cpu_to_be32(ip->i_inode.i_gid);
143	str->di_nlink = cpu_to_be32(ip->i_inode.i_nlink);
144	str->di_size = cpu_to_be64(di->di_size);
145	str->di_blocks = cpu_to_be64(di->di_blocks);
146	str->di_atime = cpu_to_be64(ip->i_inode.i_atime.tv_sec);
147	str->di_mtime = cpu_to_be64(ip->i_inode.i_mtime.tv_sec);
148	str->di_ctime = cpu_to_be64(ip->i_inode.i_ctime.tv_sec);
149
150	str->di_goal_meta = cpu_to_be64(di->di_goal_meta);
151	str->di_goal_data = cpu_to_be64(di->di_goal_data);
152	str->di_generation = cpu_to_be64(di->di_generation);
153
154	str->di_flags = cpu_to_be32(di->di_flags);
155	str->di_height = cpu_to_be16(di->di_height);
156	str->di_payload_format = cpu_to_be32(S_ISDIR(ip->i_inode.i_mode) &&
157					     !(ip->i_di.di_flags & GFS2_DIF_EXHASH) ?
158					     GFS2_FORMAT_DE : 0);
159	str->di_depth = cpu_to_be16(di->di_depth);
160	str->di_entries = cpu_to_be32(di->di_entries);
161
162	str->di_eattr = cpu_to_be64(di->di_eattr);
163}
164
165void gfs2_dinode_print(const struct gfs2_inode *ip)
166{
167	const struct gfs2_dinode_host *di = &ip->i_di;
168
169	gfs2_inum_print(&ip->i_num);
170
171	printk(KERN_INFO "  di_size = %llu\n", (unsigned long long)di->di_size);
172	printk(KERN_INFO "  di_blocks = %llu\n", (unsigned long long)di->di_blocks);
173	printk(KERN_INFO "  di_goal_meta = %llu\n", (unsigned long long)di->di_goal_meta);
174	printk(KERN_INFO "  di_goal_data = %llu\n", (unsigned long long)di->di_goal_data);
175
176	pv(di, di_flags, "0x%.8X");
177	pv(di, di_height, "%u");
178
179	pv(di, di_depth, "%u");
180	pv(di, di_entries, "%u");
181
182	printk(KERN_INFO "  di_eattr = %llu\n", (unsigned long long)di->di_eattr);
183}
184
185void gfs2_log_header_in(struct gfs2_log_header_host *lh, const void *buf)
186{
187	const struct gfs2_log_header *str = buf;
188
189	gfs2_meta_header_in(&lh->lh_header, buf);
190	lh->lh_sequence = be64_to_cpu(str->lh_sequence);
191	lh->lh_flags = be32_to_cpu(str->lh_flags);
192	lh->lh_tail = be32_to_cpu(str->lh_tail);
193	lh->lh_blkno = be32_to_cpu(str->lh_blkno);
194	lh->lh_hash = be32_to_cpu(str->lh_hash);
195}
196
197void gfs2_inum_range_in(struct gfs2_inum_range_host *ir, const void *buf)
198{
199	const struct gfs2_inum_range *str = buf;
200
201	ir->ir_start = be64_to_cpu(str->ir_start);
202	ir->ir_length = be64_to_cpu(str->ir_length);
203}
204
205void gfs2_inum_range_out(const struct gfs2_inum_range_host *ir, void *buf)
206{
207	struct gfs2_inum_range *str = buf;
208
209	str->ir_start = cpu_to_be64(ir->ir_start);
210	str->ir_length = cpu_to_be64(ir->ir_length);
211}
212
213void gfs2_statfs_change_in(struct gfs2_statfs_change_host *sc, const void *buf)
214{
215	const struct gfs2_statfs_change *str = buf;
216
217	sc->sc_total = be64_to_cpu(str->sc_total);
218	sc->sc_free = be64_to_cpu(str->sc_free);
219	sc->sc_dinodes = be64_to_cpu(str->sc_dinodes);
220}
221
222void gfs2_statfs_change_out(const struct gfs2_statfs_change_host *sc, void *buf)
223{
224	struct gfs2_statfs_change *str = buf;
225
226	str->sc_total = cpu_to_be64(sc->sc_total);
227	str->sc_free = cpu_to_be64(sc->sc_free);
228	str->sc_dinodes = cpu_to_be64(sc->sc_dinodes);
229}
230
231void gfs2_quota_change_in(struct gfs2_quota_change_host *qc, const void *buf)
232{
233	const struct gfs2_quota_change *str = buf;
234
235	qc->qc_change = be64_to_cpu(str->qc_change);
236	qc->qc_flags = be32_to_cpu(str->qc_flags);
237	qc->qc_id = be32_to_cpu(str->qc_id);
238}
239