2 * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
3 * Copyright (C) 2004-2005 Red Hat, Inc. All rights reserved.
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.
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>
15 #include <asm/semaphore.h>
18 #include <linux/gfs2_ondisk.h>
20 #define pv(struct, member, fmt) printk(KERN_INFO " "#member" = "fmt"\n", \
22 #define pa(struct, member, count) print_array(#member, struct->member, count);
25 * print_array - Print out an array of bytes
26 * @title: what to print before the array
28 * @count: the number of bytes
32 static void print_array(char *title
, char *buf
, int count
)
36 printk(KERN_INFO
" %s =\n" KERN_INFO
, title
);
37 for (x
= 0; x
< count
; x
++) {
38 printk("%.2X ", (unsigned char)buf
[x
]);
40 printk("\n" KERN_INFO
);
48 * gfs2_xxx_in - read in an xxx struct
49 * first arg: the cpu-order structure
50 * buf: the disk-order buffer
52 * gfs2_xxx_out - write out an xxx struct
53 * first arg: the cpu-order structure
54 * buf: the disk-order buffer
56 * gfs2_xxx_print - print out an xxx struct
57 * first arg: the cpu-order structure
60 void gfs2_inum_in(struct gfs2_inum
*no
, char *buf
)
62 struct gfs2_inum
*str
= (struct gfs2_inum
*)buf
;
64 no
->no_formal_ino
= be64_to_cpu(str
->no_formal_ino
);
65 no
->no_addr
= be64_to_cpu(str
->no_addr
);
68 void gfs2_inum_out(const struct gfs2_inum
*no
, char *buf
)
70 struct gfs2_inum
*str
= (struct gfs2_inum
*)buf
;
72 str
->no_formal_ino
= cpu_to_be64(no
->no_formal_ino
);
73 str
->no_addr
= cpu_to_be64(no
->no_addr
);
76 static void gfs2_inum_print(struct gfs2_inum
*no
)
78 pv(no
, no_formal_ino
, "%llu");
79 pv(no
, no_addr
, "%llu");
82 static void gfs2_meta_header_in(struct gfs2_meta_header
*mh
, char *buf
)
84 struct gfs2_meta_header
*str
= (struct gfs2_meta_header
*)buf
;
86 mh
->mh_magic
= be32_to_cpu(str
->mh_magic
);
87 mh
->mh_type
= be32_to_cpu(str
->mh_type
);
88 mh
->mh_format
= be32_to_cpu(str
->mh_format
);
91 static void gfs2_meta_header_out(struct gfs2_meta_header
*mh
, char *buf
)
93 struct gfs2_meta_header
*str
= (struct gfs2_meta_header
*)buf
;
95 str
->mh_magic
= cpu_to_be32(mh
->mh_magic
);
96 str
->mh_type
= cpu_to_be32(mh
->mh_type
);
97 str
->mh_format
= cpu_to_be32(mh
->mh_format
);
100 static void gfs2_meta_header_print(struct gfs2_meta_header
*mh
)
102 pv(mh
, mh_magic
, "0x%.8X");
103 pv(mh
, mh_type
, "%u");
104 pv(mh
, mh_format
, "%u");
107 void gfs2_sb_in(struct gfs2_sb
*sb
, char *buf
)
109 struct gfs2_sb
*str
= (struct gfs2_sb
*)buf
;
111 gfs2_meta_header_in(&sb
->sb_header
, buf
);
113 sb
->sb_fs_format
= be32_to_cpu(str
->sb_fs_format
);
114 sb
->sb_multihost_format
= be32_to_cpu(str
->sb_multihost_format
);
115 sb
->sb_bsize
= be32_to_cpu(str
->sb_bsize
);
116 sb
->sb_bsize_shift
= be32_to_cpu(str
->sb_bsize_shift
);
118 gfs2_inum_in(&sb
->sb_master_dir
, (char *)&str
->sb_master_dir
);
119 gfs2_inum_in(&sb
->sb_root_dir
, (char *)&str
->sb_root_dir
);
121 memcpy(sb
->sb_lockproto
, str
->sb_lockproto
, GFS2_LOCKNAME_LEN
);
122 memcpy(sb
->sb_locktable
, str
->sb_locktable
, GFS2_LOCKNAME_LEN
);
126 void gfs2_sb_print(struct gfs2_sb
*sb
)
128 gfs2_meta_header_print(&sb
->sb_header
);
130 pv(sb
, sb_fs_format
, "%u");
131 pv(sb
, sb_multihost_format
, "%u");
133 pv(sb
, sb_bsize
, "%u");
134 pv(sb
, sb_bsize_shift
, "%u");
136 gfs2_inum_print(&sb
->sb_master_dir
);
138 pv(sb
, sb_lockproto
, "%s");
139 pv(sb
, sb_locktable
, "%s");
143 void gfs2_rindex_in(struct gfs2_rindex
*ri
, char *buf
)
145 struct gfs2_rindex
*str
= (struct gfs2_rindex
*)buf
;
147 ri
->ri_addr
= be64_to_cpu(str
->ri_addr
);
148 ri
->ri_length
= be32_to_cpu(str
->ri_length
);
149 ri
->ri_data0
= be64_to_cpu(str
->ri_data0
);
150 ri
->ri_data
= be32_to_cpu(str
->ri_data
);
151 ri
->ri_bitbytes
= be32_to_cpu(str
->ri_bitbytes
);
156 void gfs2_rindex_out(struct gfs2_rindex
*ri
, char *buf
)
158 struct gfs2_rindex
*str
= (struct gfs2_rindex
*)buf
;
160 str
->ri_addr
= cpu_to_be64(ri
->ri_addr
);
161 str
->ri_length
= cpu_to_be32(ri
->ri_length
);
164 str
->ri_data0
= cpu_to_be64(ri
->ri_data0
);
165 str
->ri_data
= cpu_to_be32(ri
->ri_data
);
166 str
->ri_bitbytes
= cpu_to_be32(ri
->ri_bitbytes
);
167 memset(str
->ri_reserved
, 0, sizeof(str
->ri_reserved
));
172 void gfs2_rindex_print(struct gfs2_rindex
*ri
)
174 pv(ri
, ri_addr
, "%llu");
175 pv(ri
, ri_length
, "%u");
177 pv(ri
, ri_data0
, "%llu");
178 pv(ri
, ri_data
, "%u");
180 pv(ri
, ri_bitbytes
, "%u");
183 void gfs2_rgrp_in(struct gfs2_rgrp
*rg
, char *buf
)
185 struct gfs2_rgrp
*str
= (struct gfs2_rgrp
*)buf
;
187 gfs2_meta_header_in(&rg
->rg_header
, buf
);
188 rg
->rg_flags
= be32_to_cpu(str
->rg_flags
);
189 rg
->rg_free
= be32_to_cpu(str
->rg_free
);
190 rg
->rg_dinodes
= be32_to_cpu(str
->rg_dinodes
);
193 void gfs2_rgrp_out(struct gfs2_rgrp
*rg
, char *buf
)
195 struct gfs2_rgrp
*str
= (struct gfs2_rgrp
*)buf
;
197 gfs2_meta_header_out(&rg
->rg_header
, buf
);
198 str
->rg_flags
= cpu_to_be32(rg
->rg_flags
);
199 str
->rg_free
= cpu_to_be32(rg
->rg_free
);
200 str
->rg_dinodes
= cpu_to_be32(rg
->rg_dinodes
);
202 memset(&str
->rg_reserved
, 0, sizeof(str
->rg_reserved
));
206 void gfs2_rgrp_print(struct gfs2_rgrp
*rg
)
208 gfs2_meta_header_print(&rg
->rg_header
);
209 pv(rg
, rg_flags
, "%u");
210 pv(rg
, rg_free
, "%u");
211 pv(rg
, rg_dinodes
, "%u");
213 pa(rg
, rg_reserved
, 36);
217 void gfs2_quota_in(struct gfs2_quota
*qu
, char *buf
)
219 struct gfs2_quota
*str
= (struct gfs2_quota
*)buf
;
221 qu
->qu_limit
= be64_to_cpu(str
->qu_limit
);
222 qu
->qu_warn
= be64_to_cpu(str
->qu_warn
);
223 qu
->qu_value
= be64_to_cpu(str
->qu_value
);
228 void gfs2_quota_out(struct gfs2_quota
*qu
, char *buf
)
230 struct gfs2_quota
*str
= (struct gfs2_quota
*)buf
;
232 str
->qu_limit
= cpu_to_be64(qu
->qu_limit
);
233 str
->qu_warn
= cpu_to_be64(qu
->qu_warn
);
234 str
->qu_value
= cpu_to_be64(qu
->qu_value
);
237 void gfs2_quota_print(struct gfs2_quota
*qu
)
239 pv(qu
, qu_limit
, "%llu");
240 pv(qu
, qu_warn
, "%llu");
241 pv(qu
, qu_value
, "%lld");
246 void gfs2_dinode_in(struct gfs2_dinode
*di
, char *buf
)
248 struct gfs2_dinode
*str
= (struct gfs2_dinode
*)buf
;
250 gfs2_meta_header_in(&di
->di_header
, buf
);
251 gfs2_inum_in(&di
->di_num
, (char *)&str
->di_num
);
253 di
->di_mode
= be32_to_cpu(str
->di_mode
);
254 di
->di_uid
= be32_to_cpu(str
->di_uid
);
255 di
->di_gid
= be32_to_cpu(str
->di_gid
);
256 di
->di_nlink
= be32_to_cpu(str
->di_nlink
);
257 di
->di_size
= be64_to_cpu(str
->di_size
);
258 di
->di_blocks
= be64_to_cpu(str
->di_blocks
);
259 di
->di_atime
= be64_to_cpu(str
->di_atime
);
260 di
->di_mtime
= be64_to_cpu(str
->di_mtime
);
261 di
->di_ctime
= be64_to_cpu(str
->di_ctime
);
262 di
->di_major
= be32_to_cpu(str
->di_major
);
263 di
->di_minor
= be32_to_cpu(str
->di_minor
);
265 di
->di_goal_meta
= be64_to_cpu(str
->di_goal_meta
);
266 di
->di_goal_data
= be64_to_cpu(str
->di_goal_data
);
268 di
->di_flags
= be32_to_cpu(str
->di_flags
);
269 di
->di_payload_format
= be32_to_cpu(str
->di_payload_format
);
270 di
->di_height
= be16_to_cpu(str
->di_height
);
272 di
->di_depth
= be16_to_cpu(str
->di_depth
);
273 di
->di_entries
= be32_to_cpu(str
->di_entries
);
275 di
->di_eattr
= be64_to_cpu(str
->di_eattr
);
279 void gfs2_dinode_out(struct gfs2_dinode
*di
, char *buf
)
281 struct gfs2_dinode
*str
= (struct gfs2_dinode
*)buf
;
283 gfs2_meta_header_out(&di
->di_header
, buf
);
284 gfs2_inum_out(&di
->di_num
, (char *)&str
->di_num
);
286 str
->di_mode
= cpu_to_be32(di
->di_mode
);
287 str
->di_uid
= cpu_to_be32(di
->di_uid
);
288 str
->di_gid
= cpu_to_be32(di
->di_gid
);
289 str
->di_nlink
= cpu_to_be32(di
->di_nlink
);
290 str
->di_size
= cpu_to_be64(di
->di_size
);
291 str
->di_blocks
= cpu_to_be64(di
->di_blocks
);
292 str
->di_atime
= cpu_to_be64(di
->di_atime
);
293 str
->di_mtime
= cpu_to_be64(di
->di_mtime
);
294 str
->di_ctime
= cpu_to_be64(di
->di_ctime
);
295 str
->di_major
= cpu_to_be32(di
->di_major
);
296 str
->di_minor
= cpu_to_be32(di
->di_minor
);
298 str
->di_goal_meta
= cpu_to_be64(di
->di_goal_meta
);
299 str
->di_goal_data
= cpu_to_be64(di
->di_goal_data
);
301 str
->di_flags
= cpu_to_be32(di
->di_flags
);
302 str
->di_payload_format
= cpu_to_be32(di
->di_payload_format
);
303 str
->di_height
= cpu_to_be16(di
->di_height
);
305 str
->di_depth
= cpu_to_be16(di
->di_depth
);
306 str
->di_entries
= cpu_to_be32(di
->di_entries
);
308 str
->di_eattr
= cpu_to_be64(di
->di_eattr
);
312 void gfs2_dinode_print(struct gfs2_dinode
*di
)
314 gfs2_meta_header_print(&di
->di_header
);
315 gfs2_inum_print(&di
->di_num
);
317 pv(di
, di_mode
, "0%o");
318 pv(di
, di_uid
, "%u");
319 pv(di
, di_gid
, "%u");
320 pv(di
, di_nlink
, "%u");
321 pv(di
, di_size
, "%llu");
322 pv(di
, di_blocks
, "%llu");
323 pv(di
, di_atime
, "%lld");
324 pv(di
, di_mtime
, "%lld");
325 pv(di
, di_ctime
, "%lld");
326 pv(di
, di_major
, "%u");
327 pv(di
, di_minor
, "%u");
329 pv(di
, di_goal_meta
, "%llu");
330 pv(di
, di_goal_data
, "%llu");
332 pv(di
, di_flags
, "0x%.8X");
333 pv(di
, di_payload_format
, "%u");
334 pv(di
, di_height
, "%u");
336 pv(di
, di_depth
, "%u");
337 pv(di
, di_entries
, "%u");
339 pv(di
, di_eattr
, "%llu");
344 void gfs2_dirent_print(struct gfs2_dirent
*de
, char *name
)
346 char buf
[GFS2_FNAMESIZE
+ 1];
348 gfs2_inum_print(&de
->de_inum
);
349 pv(de
, de_hash
, "0x%.8X");
350 pv(de
, de_rec_len
, "%u");
351 pv(de
, de_name_len
, "%u");
352 pv(de
, de_type
, "%u");
354 memset(buf
, 0, GFS2_FNAMESIZE
+ 1);
355 memcpy(buf
, name
, de
->de_name_len
);
356 printk(KERN_INFO
" name = %s\n", buf
);
359 void gfs2_leaf_print(struct gfs2_leaf
*lf
)
361 gfs2_meta_header_print(&lf
->lf_header
);
362 pv(lf
, lf_depth
, "%u");
363 pv(lf
, lf_entries
, "%u");
364 pv(lf
, lf_dirent_format
, "%u");
365 pv(lf
, lf_next
, "%llu");
367 pa(lf
, lf_reserved
, 32);
370 void gfs2_ea_header_in(struct gfs2_ea_header
*ea
, char *buf
)
372 struct gfs2_ea_header
*str
= (struct gfs2_ea_header
*)buf
;
374 ea
->ea_rec_len
= be32_to_cpu(str
->ea_rec_len
);
375 ea
->ea_data_len
= be32_to_cpu(str
->ea_data_len
);
376 ea
->ea_name_len
= str
->ea_name_len
;
377 ea
->ea_type
= str
->ea_type
;
378 ea
->ea_flags
= str
->ea_flags
;
379 ea
->ea_num_ptrs
= str
->ea_num_ptrs
;
382 void gfs2_ea_header_out(struct gfs2_ea_header
*ea
, char *buf
)
384 struct gfs2_ea_header
*str
= (struct gfs2_ea_header
*)buf
;
386 str
->ea_rec_len
= cpu_to_be32(ea
->ea_rec_len
);
387 str
->ea_data_len
= cpu_to_be32(ea
->ea_data_len
);
388 str
->ea_name_len
= ea
->ea_name_len
;
389 str
->ea_type
= ea
->ea_type
;
390 str
->ea_flags
= ea
->ea_flags
;
391 str
->ea_num_ptrs
= ea
->ea_num_ptrs
;
395 void gfs2_ea_header_print(struct gfs2_ea_header
*ea
, char *name
)
397 char buf
[GFS2_EA_MAX_NAME_LEN
+ 1];
399 pv(ea
, ea_rec_len
, "%u");
400 pv(ea
, ea_data_len
, "%u");
401 pv(ea
, ea_name_len
, "%u");
402 pv(ea
, ea_type
, "%u");
403 pv(ea
, ea_flags
, "%u");
404 pv(ea
, ea_num_ptrs
, "%u");
406 memset(buf
, 0, GFS2_EA_MAX_NAME_LEN
+ 1);
407 memcpy(buf
, name
, ea
->ea_name_len
);
408 printk(KERN_INFO
" name = %s\n", buf
);
413 void gfs2_log_header_in(struct gfs2_log_header
*lh
, char *buf
)
415 struct gfs2_log_header
*str
= (struct gfs2_log_header
*)buf
;
417 gfs2_meta_header_in(&lh
->lh_header
, buf
);
418 lh
->lh_sequence
= be64_to_cpu(str
->lh_sequence
);
419 lh
->lh_flags
= be32_to_cpu(str
->lh_flags
);
420 lh
->lh_tail
= be32_to_cpu(str
->lh_tail
);
421 lh
->lh_blkno
= be32_to_cpu(str
->lh_blkno
);
422 lh
->lh_hash
= be32_to_cpu(str
->lh_hash
);
427 void gfs2_log_header_print(struct gfs2_log_header
*lh
)
429 gfs2_meta_header_print(&lh
->lh_header
);
430 pv(lh
, lh_sequence
, "%llu");
431 pv(lh
, lh_flags
, "0x%.8X");
432 pv(lh
, lh_tail
, "%u");
433 pv(lh
, lh_blkno
, "%u");
434 pv(lh
, lh_hash
, "0x%.8X");
437 void gfs2_log_descriptor_print(struct gfs2_log_descriptor
*ld
)
439 gfs2_meta_header_print(&ld
->ld_header
);
440 pv(ld
, ld_type
, "%u");
441 pv(ld
, ld_length
, "%u");
442 pv(ld
, ld_data1
, "%u");
443 pv(ld
, ld_data2
, "%u");
445 pa(ld
, ld_reserved
, 32);
450 void gfs2_inum_range_in(struct gfs2_inum_range
*ir
, char *buf
)
452 struct gfs2_inum_range
*str
= (struct gfs2_inum_range
*)buf
;
454 ir
->ir_start
= be64_to_cpu(str
->ir_start
);
455 ir
->ir_length
= be64_to_cpu(str
->ir_length
);
458 void gfs2_inum_range_out(struct gfs2_inum_range
*ir
, char *buf
)
460 struct gfs2_inum_range
*str
= (struct gfs2_inum_range
*)buf
;
462 str
->ir_start
= cpu_to_be64(ir
->ir_start
);
463 str
->ir_length
= cpu_to_be64(ir
->ir_length
);
467 void gfs2_inum_range_print(struct gfs2_inum_range
*ir
)
469 pv(ir
, ir_start
, "%llu");
470 pv(ir
, ir_length
, "%llu");
474 void gfs2_statfs_change_in(struct gfs2_statfs_change
*sc
, char *buf
)
476 struct gfs2_statfs_change
*str
= (struct gfs2_statfs_change
*)buf
;
478 sc
->sc_total
= be64_to_cpu(str
->sc_total
);
479 sc
->sc_free
= be64_to_cpu(str
->sc_free
);
480 sc
->sc_dinodes
= be64_to_cpu(str
->sc_dinodes
);
483 void gfs2_statfs_change_out(struct gfs2_statfs_change
*sc
, char *buf
)
485 struct gfs2_statfs_change
*str
= (struct gfs2_statfs_change
*)buf
;
487 str
->sc_total
= cpu_to_be64(sc
->sc_total
);
488 str
->sc_free
= cpu_to_be64(sc
->sc_free
);
489 str
->sc_dinodes
= cpu_to_be64(sc
->sc_dinodes
);
493 void gfs2_statfs_change_print(struct gfs2_statfs_change
*sc
)
495 pv(sc
, sc_total
, "%lld");
496 pv(sc
, sc_free
, "%lld");
497 pv(sc
, sc_dinodes
, "%lld");
501 void gfs2_unlinked_tag_in(struct gfs2_unlinked_tag
*ut
, char *buf
)
503 struct gfs2_unlinked_tag
*str
= (struct gfs2_unlinked_tag
*)buf
;
505 gfs2_inum_in(&ut
->ut_inum
, buf
);
506 ut
->ut_flags
= be32_to_cpu(str
->ut_flags
);
509 void gfs2_unlinked_tag_out(struct gfs2_unlinked_tag
*ut
, char *buf
)
511 struct gfs2_unlinked_tag
*str
= (struct gfs2_unlinked_tag
*)buf
;
513 gfs2_inum_out(&ut
->ut_inum
, buf
);
514 str
->ut_flags
= cpu_to_be32(ut
->ut_flags
);
520 void gfs2_unlinked_tag_print(struct gfs2_unlinked_tag
*ut
)
522 gfs2_inum_print(&ut
->ut_inum
);
523 pv(ut
, ut_flags
, "%u");
528 void gfs2_quota_change_in(struct gfs2_quota_change
*qc
, char *buf
)
530 struct gfs2_quota_change
*str
= (struct gfs2_quota_change
*)buf
;
532 qc
->qc_change
= be64_to_cpu(str
->qc_change
);
533 qc
->qc_flags
= be32_to_cpu(str
->qc_flags
);
534 qc
->qc_id
= be32_to_cpu(str
->qc_id
);
539 void gfs2_quota_change_print(struct gfs2_quota_change
*qc
)
541 pv(qc
, qc_change
, "%lld");
542 pv(qc
, qc_flags
, "0x%.8X");