Commit | Line | Data |
---|---|---|
b3b94faa DT |
1 | /* |
2 | * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved. | |
3 | * Copyright (C) 2004-2005 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 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> | |
15 | #include <asm/semaphore.h> | |
16 | ||
17 | #include "gfs2.h" | |
18 | #include <linux/gfs2_ondisk.h> | |
19 | ||
d92a8d48 | 20 | #define pv(struct, member, fmt) printk(KERN_INFO " "#member" = "fmt"\n", struct->member); |
b3b94faa DT |
21 | #define pa(struct, member, count) print_array(#member, struct->member, count); |
22 | ||
23 | /** | |
24 | * print_array - Print out an array of bytes | |
25 | * @title: what to print before the array | |
26 | * @buf: the array | |
27 | * @count: the number of bytes | |
28 | * | |
29 | */ | |
30 | ||
31 | static void print_array(char *title, char *buf, int count) | |
32 | { | |
33 | int x; | |
34 | ||
d92a8d48 | 35 | printk(KERN_INFO " %s =\n" KERN_INFO, title); |
b3b94faa DT |
36 | for (x = 0; x < count; x++) { |
37 | printk("%.2X ", (unsigned char)buf[x]); | |
38 | if (x % 16 == 15) | |
d92a8d48 | 39 | printk("\n" KERN_INFO); |
b3b94faa DT |
40 | } |
41 | if (x % 16) | |
42 | printk("\n"); | |
43 | } | |
44 | ||
45 | /* | |
46 | * gfs2_xxx_in - read in an xxx struct | |
47 | * first arg: the cpu-order structure | |
48 | * buf: the disk-order buffer | |
49 | * | |
50 | * gfs2_xxx_out - write out an xxx struct | |
51 | * first arg: the cpu-order structure | |
52 | * buf: the disk-order buffer | |
53 | * | |
54 | * gfs2_xxx_print - print out an xxx struct | |
55 | * first arg: the cpu-order structure | |
56 | */ | |
57 | ||
58 | void gfs2_inum_in(struct gfs2_inum *no, char *buf) | |
59 | { | |
60 | struct gfs2_inum *str = (struct gfs2_inum *)buf; | |
61 | ||
62 | no->no_formal_ino = be64_to_cpu(str->no_formal_ino); | |
63 | no->no_addr = be64_to_cpu(str->no_addr); | |
64 | } | |
65 | ||
66 | void gfs2_inum_out(struct gfs2_inum *no, char *buf) | |
67 | { | |
68 | struct gfs2_inum *str = (struct gfs2_inum *)buf; | |
69 | ||
70 | str->no_formal_ino = cpu_to_be64(no->no_formal_ino); | |
71 | str->no_addr = cpu_to_be64(no->no_addr); | |
72 | } | |
73 | ||
74 | void gfs2_inum_print(struct gfs2_inum *no) | |
75 | { | |
76 | pv(no, no_formal_ino, "%llu"); | |
77 | pv(no, no_addr, "%llu"); | |
78 | } | |
79 | ||
b96ca4fa | 80 | static void gfs2_meta_header_in(struct gfs2_meta_header *mh, char *buf) |
b3b94faa DT |
81 | { |
82 | struct gfs2_meta_header *str = (struct gfs2_meta_header *)buf; | |
83 | ||
84 | mh->mh_magic = be32_to_cpu(str->mh_magic); | |
85 | mh->mh_type = be16_to_cpu(str->mh_type); | |
86 | mh->mh_format = be16_to_cpu(str->mh_format); | |
87 | } | |
88 | ||
b96ca4fa | 89 | static void gfs2_meta_header_out(struct gfs2_meta_header *mh, char *buf) |
b3b94faa DT |
90 | { |
91 | struct gfs2_meta_header *str = (struct gfs2_meta_header *)buf; | |
92 | ||
93 | str->mh_magic = cpu_to_be32(mh->mh_magic); | |
94 | str->mh_type = cpu_to_be16(mh->mh_type); | |
95 | str->mh_format = cpu_to_be16(mh->mh_format); | |
96 | } | |
97 | ||
98 | void gfs2_meta_header_print(struct gfs2_meta_header *mh) | |
99 | { | |
100 | pv(mh, mh_magic, "0x%.8X"); | |
101 | pv(mh, mh_type, "%u"); | |
102 | pv(mh, mh_format, "%u"); | |
103 | } | |
104 | ||
105 | void gfs2_sb_in(struct gfs2_sb *sb, char *buf) | |
106 | { | |
107 | struct gfs2_sb *str = (struct gfs2_sb *)buf; | |
108 | ||
109 | gfs2_meta_header_in(&sb->sb_header, buf); | |
110 | ||
111 | sb->sb_fs_format = be32_to_cpu(str->sb_fs_format); | |
112 | sb->sb_multihost_format = be32_to_cpu(str->sb_multihost_format); | |
113 | sb->sb_bsize = be32_to_cpu(str->sb_bsize); | |
114 | sb->sb_bsize_shift = be32_to_cpu(str->sb_bsize_shift); | |
115 | ||
116 | gfs2_inum_in(&sb->sb_master_dir, (char *)&str->sb_master_dir); | |
117 | gfs2_inum_in(&sb->sb_root_dir, (char *)&str->sb_root_dir); | |
118 | ||
119 | memcpy(sb->sb_lockproto, str->sb_lockproto, GFS2_LOCKNAME_LEN); | |
120 | memcpy(sb->sb_locktable, str->sb_locktable, GFS2_LOCKNAME_LEN); | |
121 | } | |
122 | ||
b3b94faa DT |
123 | void gfs2_sb_print(struct gfs2_sb *sb) |
124 | { | |
125 | gfs2_meta_header_print(&sb->sb_header); | |
126 | ||
127 | pv(sb, sb_fs_format, "%u"); | |
128 | pv(sb, sb_multihost_format, "%u"); | |
129 | ||
130 | pv(sb, sb_bsize, "%u"); | |
131 | pv(sb, sb_bsize_shift, "%u"); | |
132 | ||
133 | gfs2_inum_print(&sb->sb_master_dir); | |
134 | ||
135 | pv(sb, sb_lockproto, "%s"); | |
136 | pv(sb, sb_locktable, "%s"); | |
137 | } | |
138 | ||
139 | void gfs2_rindex_in(struct gfs2_rindex *ri, char *buf) | |
140 | { | |
141 | struct gfs2_rindex *str = (struct gfs2_rindex *)buf; | |
142 | ||
143 | ri->ri_addr = be64_to_cpu(str->ri_addr); | |
144 | ri->ri_length = be32_to_cpu(str->ri_length); | |
145 | ri->ri_data0 = be64_to_cpu(str->ri_data0); | |
146 | ri->ri_data = be32_to_cpu(str->ri_data); | |
147 | ri->ri_bitbytes = be32_to_cpu(str->ri_bitbytes); | |
148 | ||
149 | } | |
150 | ||
151 | void gfs2_rindex_out(struct gfs2_rindex *ri, char *buf) | |
152 | { | |
153 | struct gfs2_rindex *str = (struct gfs2_rindex *)buf; | |
154 | ||
155 | str->ri_addr = cpu_to_be64(ri->ri_addr); | |
156 | str->ri_length = cpu_to_be32(ri->ri_length); | |
157 | str->__pad = 0; | |
158 | ||
159 | str->ri_data0 = cpu_to_be64(ri->ri_data0); | |
160 | str->ri_data = cpu_to_be32(ri->ri_data); | |
161 | str->ri_bitbytes = cpu_to_be32(ri->ri_bitbytes); | |
162 | memset(str->ri_reserved, 0, sizeof(str->ri_reserved)); | |
163 | } | |
164 | ||
165 | void gfs2_rindex_print(struct gfs2_rindex *ri) | |
166 | { | |
167 | pv(ri, ri_addr, "%llu"); | |
168 | pv(ri, ri_length, "%u"); | |
169 | ||
170 | pv(ri, ri_data0, "%llu"); | |
171 | pv(ri, ri_data, "%u"); | |
172 | ||
173 | pv(ri, ri_bitbytes, "%u"); | |
174 | } | |
175 | ||
176 | void gfs2_rgrp_in(struct gfs2_rgrp *rg, char *buf) | |
177 | { | |
178 | struct gfs2_rgrp *str = (struct gfs2_rgrp *)buf; | |
179 | ||
180 | gfs2_meta_header_in(&rg->rg_header, buf); | |
181 | rg->rg_flags = be32_to_cpu(str->rg_flags); | |
182 | rg->rg_free = be32_to_cpu(str->rg_free); | |
183 | rg->rg_dinodes = be32_to_cpu(str->rg_dinodes); | |
184 | } | |
185 | ||
186 | void gfs2_rgrp_out(struct gfs2_rgrp *rg, char *buf) | |
187 | { | |
188 | struct gfs2_rgrp *str = (struct gfs2_rgrp *)buf; | |
189 | ||
190 | gfs2_meta_header_out(&rg->rg_header, buf); | |
191 | str->rg_flags = cpu_to_be32(rg->rg_flags); | |
192 | str->rg_free = cpu_to_be32(rg->rg_free); | |
193 | str->rg_dinodes = cpu_to_be32(rg->rg_dinodes); | |
194 | ||
195 | memset(&str->rg_reserved, 0, sizeof(str->rg_reserved)); | |
196 | } | |
197 | ||
198 | void gfs2_rgrp_print(struct gfs2_rgrp *rg) | |
199 | { | |
200 | gfs2_meta_header_print(&rg->rg_header); | |
201 | pv(rg, rg_flags, "%u"); | |
202 | pv(rg, rg_free, "%u"); | |
203 | pv(rg, rg_dinodes, "%u"); | |
204 | ||
205 | pa(rg, rg_reserved, 36); | |
206 | } | |
207 | ||
208 | void gfs2_quota_in(struct gfs2_quota *qu, char *buf) | |
209 | { | |
210 | struct gfs2_quota *str = (struct gfs2_quota *)buf; | |
211 | ||
212 | qu->qu_limit = be64_to_cpu(str->qu_limit); | |
213 | qu->qu_warn = be64_to_cpu(str->qu_warn); | |
214 | qu->qu_value = be64_to_cpu(str->qu_value); | |
215 | } | |
216 | ||
217 | void gfs2_quota_out(struct gfs2_quota *qu, char *buf) | |
218 | { | |
219 | struct gfs2_quota *str = (struct gfs2_quota *)buf; | |
220 | ||
221 | str->qu_limit = cpu_to_be64(qu->qu_limit); | |
222 | str->qu_warn = cpu_to_be64(qu->qu_warn); | |
223 | str->qu_value = cpu_to_be64(qu->qu_value); | |
224 | } | |
225 | ||
226 | void gfs2_quota_print(struct gfs2_quota *qu) | |
227 | { | |
228 | pv(qu, qu_limit, "%llu"); | |
229 | pv(qu, qu_warn, "%llu"); | |
230 | pv(qu, qu_value, "%lld"); | |
231 | } | |
232 | ||
233 | void gfs2_dinode_in(struct gfs2_dinode *di, char *buf) | |
234 | { | |
235 | struct gfs2_dinode *str = (struct gfs2_dinode *)buf; | |
236 | ||
237 | gfs2_meta_header_in(&di->di_header, buf); | |
238 | gfs2_inum_in(&di->di_num, (char *)&str->di_num); | |
239 | ||
240 | di->di_mode = be32_to_cpu(str->di_mode); | |
241 | di->di_uid = be32_to_cpu(str->di_uid); | |
242 | di->di_gid = be32_to_cpu(str->di_gid); | |
243 | di->di_nlink = be32_to_cpu(str->di_nlink); | |
244 | di->di_size = be64_to_cpu(str->di_size); | |
245 | di->di_blocks = be64_to_cpu(str->di_blocks); | |
246 | di->di_atime = be64_to_cpu(str->di_atime); | |
247 | di->di_mtime = be64_to_cpu(str->di_mtime); | |
248 | di->di_ctime = be64_to_cpu(str->di_ctime); | |
249 | di->di_major = be32_to_cpu(str->di_major); | |
250 | di->di_minor = be32_to_cpu(str->di_minor); | |
251 | ||
252 | di->di_goal_meta = be64_to_cpu(str->di_goal_meta); | |
253 | di->di_goal_data = be64_to_cpu(str->di_goal_data); | |
254 | ||
255 | di->di_flags = be32_to_cpu(str->di_flags); | |
256 | di->di_payload_format = be32_to_cpu(str->di_payload_format); | |
257 | di->di_height = be16_to_cpu(str->di_height); | |
258 | ||
259 | di->di_depth = be16_to_cpu(str->di_depth); | |
260 | di->di_entries = be32_to_cpu(str->di_entries); | |
261 | ||
262 | di->di_eattr = be64_to_cpu(str->di_eattr); | |
263 | ||
264 | } | |
265 | ||
266 | void gfs2_dinode_out(struct gfs2_dinode *di, char *buf) | |
267 | { | |
268 | struct gfs2_dinode *str = (struct gfs2_dinode *)buf; | |
269 | ||
270 | gfs2_meta_header_out(&di->di_header, buf); | |
271 | gfs2_inum_out(&di->di_num, (char *)&str->di_num); | |
272 | ||
273 | str->di_mode = cpu_to_be32(di->di_mode); | |
274 | str->di_uid = cpu_to_be32(di->di_uid); | |
275 | str->di_gid = cpu_to_be32(di->di_gid); | |
276 | str->di_nlink = cpu_to_be32(di->di_nlink); | |
277 | str->di_size = cpu_to_be64(di->di_size); | |
278 | str->di_blocks = cpu_to_be64(di->di_blocks); | |
279 | str->di_atime = cpu_to_be64(di->di_atime); | |
280 | str->di_mtime = cpu_to_be64(di->di_mtime); | |
281 | str->di_ctime = cpu_to_be64(di->di_ctime); | |
282 | str->di_major = cpu_to_be32(di->di_major); | |
283 | str->di_minor = cpu_to_be32(di->di_minor); | |
284 | ||
285 | str->di_goal_meta = cpu_to_be64(di->di_goal_meta); | |
286 | str->di_goal_data = cpu_to_be64(di->di_goal_data); | |
287 | ||
288 | str->di_flags = cpu_to_be32(di->di_flags); | |
289 | str->di_payload_format = cpu_to_be32(di->di_payload_format); | |
290 | str->di_height = cpu_to_be16(di->di_height); | |
291 | ||
292 | str->di_depth = cpu_to_be16(di->di_depth); | |
293 | str->di_entries = cpu_to_be32(di->di_entries); | |
294 | ||
295 | str->di_eattr = cpu_to_be64(di->di_eattr); | |
296 | ||
297 | } | |
298 | ||
299 | void gfs2_dinode_print(struct gfs2_dinode *di) | |
300 | { | |
301 | gfs2_meta_header_print(&di->di_header); | |
302 | gfs2_inum_print(&di->di_num); | |
303 | ||
304 | pv(di, di_mode, "0%o"); | |
305 | pv(di, di_uid, "%u"); | |
306 | pv(di, di_gid, "%u"); | |
307 | pv(di, di_nlink, "%u"); | |
308 | pv(di, di_size, "%llu"); | |
309 | pv(di, di_blocks, "%llu"); | |
310 | pv(di, di_atime, "%lld"); | |
311 | pv(di, di_mtime, "%lld"); | |
312 | pv(di, di_ctime, "%lld"); | |
313 | pv(di, di_major, "%u"); | |
314 | pv(di, di_minor, "%u"); | |
315 | ||
316 | pv(di, di_goal_meta, "%llu"); | |
317 | pv(di, di_goal_data, "%llu"); | |
318 | ||
319 | pv(di, di_flags, "0x%.8X"); | |
320 | pv(di, di_payload_format, "%u"); | |
321 | pv(di, di_height, "%u"); | |
322 | ||
323 | pv(di, di_depth, "%u"); | |
324 | pv(di, di_entries, "%u"); | |
325 | ||
326 | pv(di, di_eattr, "%llu"); | |
327 | } | |
328 | ||
b3b94faa DT |
329 | void gfs2_dirent_print(struct gfs2_dirent *de, char *name) |
330 | { | |
331 | char buf[GFS2_FNAMESIZE + 1]; | |
332 | ||
333 | gfs2_inum_print(&de->de_inum); | |
334 | pv(de, de_hash, "0x%.8X"); | |
335 | pv(de, de_rec_len, "%u"); | |
336 | pv(de, de_name_len, "%u"); | |
337 | pv(de, de_type, "%u"); | |
338 | ||
339 | memset(buf, 0, GFS2_FNAMESIZE + 1); | |
340 | memcpy(buf, name, de->de_name_len); | |
d92a8d48 | 341 | printk(KERN_INFO " name = %s\n", buf); |
b3b94faa DT |
342 | } |
343 | ||
344 | void gfs2_leaf_in(struct gfs2_leaf *lf, char *buf) | |
345 | { | |
346 | struct gfs2_leaf *str = (struct gfs2_leaf *)buf; | |
347 | ||
348 | gfs2_meta_header_in(&lf->lf_header, buf); | |
349 | lf->lf_depth = be16_to_cpu(str->lf_depth); | |
350 | lf->lf_entries = be16_to_cpu(str->lf_entries); | |
351 | lf->lf_dirent_format = be32_to_cpu(str->lf_dirent_format); | |
352 | lf->lf_next = be64_to_cpu(str->lf_next); | |
353 | } | |
354 | ||
b3b94faa DT |
355 | void gfs2_leaf_print(struct gfs2_leaf *lf) |
356 | { | |
357 | gfs2_meta_header_print(&lf->lf_header); | |
358 | pv(lf, lf_depth, "%u"); | |
359 | pv(lf, lf_entries, "%u"); | |
360 | pv(lf, lf_dirent_format, "%u"); | |
361 | pv(lf, lf_next, "%llu"); | |
362 | ||
363 | pa(lf, lf_reserved, 32); | |
364 | } | |
365 | ||
366 | void gfs2_ea_header_in(struct gfs2_ea_header *ea, char *buf) | |
367 | { | |
368 | struct gfs2_ea_header *str = (struct gfs2_ea_header *)buf; | |
369 | ||
370 | ea->ea_rec_len = be32_to_cpu(str->ea_rec_len); | |
371 | ea->ea_data_len = be32_to_cpu(str->ea_data_len); | |
372 | ea->ea_name_len = str->ea_name_len; | |
373 | ea->ea_type = str->ea_type; | |
374 | ea->ea_flags = str->ea_flags; | |
375 | ea->ea_num_ptrs = str->ea_num_ptrs; | |
376 | } | |
377 | ||
378 | void gfs2_ea_header_out(struct gfs2_ea_header *ea, char *buf) | |
379 | { | |
380 | struct gfs2_ea_header *str = (struct gfs2_ea_header *)buf; | |
381 | ||
382 | str->ea_rec_len = cpu_to_be32(ea->ea_rec_len); | |
383 | str->ea_data_len = cpu_to_be32(ea->ea_data_len); | |
384 | str->ea_name_len = ea->ea_name_len; | |
385 | str->ea_type = ea->ea_type; | |
386 | str->ea_flags = ea->ea_flags; | |
387 | str->ea_num_ptrs = ea->ea_num_ptrs; | |
388 | str->__pad = 0; | |
389 | } | |
390 | ||
391 | void gfs2_ea_header_print(struct gfs2_ea_header *ea, char *name) | |
392 | { | |
393 | char buf[GFS2_EA_MAX_NAME_LEN + 1]; | |
394 | ||
395 | pv(ea, ea_rec_len, "%u"); | |
396 | pv(ea, ea_data_len, "%u"); | |
397 | pv(ea, ea_name_len, "%u"); | |
398 | pv(ea, ea_type, "%u"); | |
399 | pv(ea, ea_flags, "%u"); | |
400 | pv(ea, ea_num_ptrs, "%u"); | |
401 | ||
402 | memset(buf, 0, GFS2_EA_MAX_NAME_LEN + 1); | |
403 | memcpy(buf, name, ea->ea_name_len); | |
d92a8d48 | 404 | printk(KERN_INFO " name = %s\n", buf); |
b3b94faa DT |
405 | } |
406 | ||
407 | void gfs2_log_header_in(struct gfs2_log_header *lh, char *buf) | |
408 | { | |
409 | struct gfs2_log_header *str = (struct gfs2_log_header *)buf; | |
410 | ||
411 | gfs2_meta_header_in(&lh->lh_header, buf); | |
412 | lh->lh_sequence = be64_to_cpu(str->lh_sequence); | |
413 | lh->lh_flags = be32_to_cpu(str->lh_flags); | |
414 | lh->lh_tail = be32_to_cpu(str->lh_tail); | |
415 | lh->lh_blkno = be32_to_cpu(str->lh_blkno); | |
416 | lh->lh_hash = be32_to_cpu(str->lh_hash); | |
417 | } | |
418 | ||
419 | void gfs2_log_header_print(struct gfs2_log_header *lh) | |
420 | { | |
421 | gfs2_meta_header_print(&lh->lh_header); | |
422 | pv(lh, lh_sequence, "%llu"); | |
423 | pv(lh, lh_flags, "0x%.8X"); | |
424 | pv(lh, lh_tail, "%u"); | |
425 | pv(lh, lh_blkno, "%u"); | |
426 | pv(lh, lh_hash, "0x%.8X"); | |
427 | } | |
428 | ||
429 | void gfs2_log_descriptor_print(struct gfs2_log_descriptor *ld) | |
430 | { | |
431 | gfs2_meta_header_print(&ld->ld_header); | |
432 | pv(ld, ld_type, "%u"); | |
433 | pv(ld, ld_length, "%u"); | |
434 | pv(ld, ld_data1, "%u"); | |
435 | pv(ld, ld_data2, "%u"); | |
436 | ||
437 | pa(ld, ld_reserved, 32); | |
438 | } | |
439 | ||
440 | void gfs2_inum_range_in(struct gfs2_inum_range *ir, char *buf) | |
441 | { | |
442 | struct gfs2_inum_range *str = (struct gfs2_inum_range *)buf; | |
443 | ||
444 | ir->ir_start = be64_to_cpu(str->ir_start); | |
445 | ir->ir_length = be64_to_cpu(str->ir_length); | |
446 | } | |
447 | ||
448 | void gfs2_inum_range_out(struct gfs2_inum_range *ir, char *buf) | |
449 | { | |
450 | struct gfs2_inum_range *str = (struct gfs2_inum_range *)buf; | |
451 | ||
452 | str->ir_start = cpu_to_be64(ir->ir_start); | |
453 | str->ir_length = cpu_to_be64(ir->ir_length); | |
454 | } | |
455 | ||
456 | void gfs2_inum_range_print(struct gfs2_inum_range *ir) | |
457 | { | |
458 | pv(ir, ir_start, "%llu"); | |
459 | pv(ir, ir_length, "%llu"); | |
460 | } | |
461 | ||
462 | void gfs2_statfs_change_in(struct gfs2_statfs_change *sc, char *buf) | |
463 | { | |
464 | struct gfs2_statfs_change *str = (struct gfs2_statfs_change *)buf; | |
465 | ||
466 | sc->sc_total = be64_to_cpu(str->sc_total); | |
467 | sc->sc_free = be64_to_cpu(str->sc_free); | |
468 | sc->sc_dinodes = be64_to_cpu(str->sc_dinodes); | |
469 | } | |
470 | ||
471 | void gfs2_statfs_change_out(struct gfs2_statfs_change *sc, char *buf) | |
472 | { | |
473 | struct gfs2_statfs_change *str = (struct gfs2_statfs_change *)buf; | |
474 | ||
475 | str->sc_total = cpu_to_be64(sc->sc_total); | |
476 | str->sc_free = cpu_to_be64(sc->sc_free); | |
477 | str->sc_dinodes = cpu_to_be64(sc->sc_dinodes); | |
478 | } | |
479 | ||
480 | void gfs2_statfs_change_print(struct gfs2_statfs_change *sc) | |
481 | { | |
482 | pv(sc, sc_total, "%lld"); | |
483 | pv(sc, sc_free, "%lld"); | |
484 | pv(sc, sc_dinodes, "%lld"); | |
485 | } | |
486 | ||
487 | void gfs2_unlinked_tag_in(struct gfs2_unlinked_tag *ut, char *buf) | |
488 | { | |
489 | struct gfs2_unlinked_tag *str = (struct gfs2_unlinked_tag *)buf; | |
490 | ||
491 | gfs2_inum_in(&ut->ut_inum, buf); | |
492 | ut->ut_flags = be32_to_cpu(str->ut_flags); | |
493 | } | |
494 | ||
495 | void gfs2_unlinked_tag_out(struct gfs2_unlinked_tag *ut, char *buf) | |
496 | { | |
497 | struct gfs2_unlinked_tag *str = (struct gfs2_unlinked_tag *)buf; | |
498 | ||
499 | gfs2_inum_out(&ut->ut_inum, buf); | |
500 | str->ut_flags = cpu_to_be32(ut->ut_flags); | |
501 | str->__pad = 0; | |
502 | } | |
503 | ||
504 | void gfs2_unlinked_tag_print(struct gfs2_unlinked_tag *ut) | |
505 | { | |
506 | gfs2_inum_print(&ut->ut_inum); | |
507 | pv(ut, ut_flags, "%u"); | |
508 | } | |
509 | ||
510 | void gfs2_quota_change_in(struct gfs2_quota_change *qc, char *buf) | |
511 | { | |
512 | struct gfs2_quota_change *str = (struct gfs2_quota_change *)buf; | |
513 | ||
514 | qc->qc_change = be64_to_cpu(str->qc_change); | |
515 | qc->qc_flags = be32_to_cpu(str->qc_flags); | |
516 | qc->qc_id = be32_to_cpu(str->qc_id); | |
517 | } | |
518 | ||
b3b94faa DT |
519 | void gfs2_quota_change_print(struct gfs2_quota_change *qc) |
520 | { | |
521 | pv(qc, qc_change, "%lld"); | |
522 | pv(qc, qc_flags, "0x%.8X"); | |
523 | pv(qc, qc_id, "%u"); | |
524 | } | |
525 | ||
526 | ||
527 |