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 | ||
568f4c96 SW |
20 | #define pv(struct, member, fmt) printk(KERN_INFO " "#member" = "fmt"\n", \ |
21 | struct->member); | |
b3b94faa DT |
22 | #define pa(struct, member, count) print_array(#member, struct->member, count); |
23 | ||
24 | /** | |
25 | * print_array - Print out an array of bytes | |
26 | * @title: what to print before the array | |
27 | * @buf: the array | |
28 | * @count: the number of bytes | |
29 | * | |
30 | */ | |
08bc2dbc | 31 | #if 0 |
b3b94faa DT |
32 | static void print_array(char *title, char *buf, int count) |
33 | { | |
34 | int x; | |
35 | ||
d92a8d48 | 36 | printk(KERN_INFO " %s =\n" KERN_INFO, title); |
b3b94faa DT |
37 | for (x = 0; x < count; x++) { |
38 | printk("%.2X ", (unsigned char)buf[x]); | |
39 | if (x % 16 == 15) | |
d92a8d48 | 40 | printk("\n" KERN_INFO); |
b3b94faa DT |
41 | } |
42 | if (x % 16) | |
43 | printk("\n"); | |
44 | } | |
08bc2dbc | 45 | #endif /* 0 */ |
b3b94faa DT |
46 | |
47 | /* | |
48 | * gfs2_xxx_in - read in an xxx struct | |
49 | * first arg: the cpu-order structure | |
50 | * buf: the disk-order buffer | |
51 | * | |
52 | * gfs2_xxx_out - write out an xxx struct | |
53 | * first arg: the cpu-order structure | |
54 | * buf: the disk-order buffer | |
55 | * | |
56 | * gfs2_xxx_print - print out an xxx struct | |
57 | * first arg: the cpu-order structure | |
58 | */ | |
59 | ||
60 | void gfs2_inum_in(struct gfs2_inum *no, char *buf) | |
61 | { | |
62 | struct gfs2_inum *str = (struct gfs2_inum *)buf; | |
63 | ||
64 | no->no_formal_ino = be64_to_cpu(str->no_formal_ino); | |
65 | no->no_addr = be64_to_cpu(str->no_addr); | |
66 | } | |
67 | ||
c752666c | 68 | void gfs2_inum_out(const struct gfs2_inum *no, char *buf) |
b3b94faa DT |
69 | { |
70 | struct gfs2_inum *str = (struct gfs2_inum *)buf; | |
71 | ||
72 | str->no_formal_ino = cpu_to_be64(no->no_formal_ino); | |
73 | str->no_addr = cpu_to_be64(no->no_addr); | |
74 | } | |
75 | ||
08bc2dbc | 76 | static void gfs2_inum_print(struct gfs2_inum *no) |
b3b94faa DT |
77 | { |
78 | pv(no, no_formal_ino, "%llu"); | |
79 | pv(no, no_addr, "%llu"); | |
80 | } | |
81 | ||
b96ca4fa | 82 | static void gfs2_meta_header_in(struct gfs2_meta_header *mh, char *buf) |
b3b94faa DT |
83 | { |
84 | struct gfs2_meta_header *str = (struct gfs2_meta_header *)buf; | |
85 | ||
86 | mh->mh_magic = be32_to_cpu(str->mh_magic); | |
e3167ded SW |
87 | mh->mh_type = be32_to_cpu(str->mh_type); |
88 | mh->mh_format = be32_to_cpu(str->mh_format); | |
b3b94faa DT |
89 | } |
90 | ||
b96ca4fa | 91 | static void gfs2_meta_header_out(struct gfs2_meta_header *mh, char *buf) |
b3b94faa DT |
92 | { |
93 | struct gfs2_meta_header *str = (struct gfs2_meta_header *)buf; | |
94 | ||
95 | str->mh_magic = cpu_to_be32(mh->mh_magic); | |
e3167ded SW |
96 | str->mh_type = cpu_to_be32(mh->mh_type); |
97 | str->mh_format = cpu_to_be32(mh->mh_format); | |
b3b94faa DT |
98 | } |
99 | ||
08bc2dbc | 100 | static void gfs2_meta_header_print(struct gfs2_meta_header *mh) |
b3b94faa DT |
101 | { |
102 | pv(mh, mh_magic, "0x%.8X"); | |
103 | pv(mh, mh_type, "%u"); | |
104 | pv(mh, mh_format, "%u"); | |
105 | } | |
106 | ||
107 | void gfs2_sb_in(struct gfs2_sb *sb, char *buf) | |
108 | { | |
109 | struct gfs2_sb *str = (struct gfs2_sb *)buf; | |
110 | ||
111 | gfs2_meta_header_in(&sb->sb_header, buf); | |
112 | ||
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); | |
117 | ||
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); | |
120 | ||
121 | memcpy(sb->sb_lockproto, str->sb_lockproto, GFS2_LOCKNAME_LEN); | |
122 | memcpy(sb->sb_locktable, str->sb_locktable, GFS2_LOCKNAME_LEN); | |
123 | } | |
124 | ||
08bc2dbc | 125 | #if 0 |
b3b94faa DT |
126 | void gfs2_sb_print(struct gfs2_sb *sb) |
127 | { | |
128 | gfs2_meta_header_print(&sb->sb_header); | |
129 | ||
130 | pv(sb, sb_fs_format, "%u"); | |
131 | pv(sb, sb_multihost_format, "%u"); | |
132 | ||
133 | pv(sb, sb_bsize, "%u"); | |
134 | pv(sb, sb_bsize_shift, "%u"); | |
135 | ||
136 | gfs2_inum_print(&sb->sb_master_dir); | |
137 | ||
138 | pv(sb, sb_lockproto, "%s"); | |
139 | pv(sb, sb_locktable, "%s"); | |
140 | } | |
08bc2dbc | 141 | #endif /* 0 */ |
b3b94faa DT |
142 | |
143 | void gfs2_rindex_in(struct gfs2_rindex *ri, char *buf) | |
144 | { | |
145 | struct gfs2_rindex *str = (struct gfs2_rindex *)buf; | |
146 | ||
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); | |
152 | ||
153 | } | |
154 | ||
08bc2dbc | 155 | #if 0 |
b3b94faa DT |
156 | void gfs2_rindex_out(struct gfs2_rindex *ri, char *buf) |
157 | { | |
158 | struct gfs2_rindex *str = (struct gfs2_rindex *)buf; | |
159 | ||
160 | str->ri_addr = cpu_to_be64(ri->ri_addr); | |
161 | str->ri_length = cpu_to_be32(ri->ri_length); | |
162 | str->__pad = 0; | |
163 | ||
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)); | |
168 | } | |
169 | ||
08bc2dbc AB |
170 | #endif /* 0 */ |
171 | ||
b3b94faa DT |
172 | void gfs2_rindex_print(struct gfs2_rindex *ri) |
173 | { | |
174 | pv(ri, ri_addr, "%llu"); | |
175 | pv(ri, ri_length, "%u"); | |
176 | ||
177 | pv(ri, ri_data0, "%llu"); | |
178 | pv(ri, ri_data, "%u"); | |
179 | ||
180 | pv(ri, ri_bitbytes, "%u"); | |
181 | } | |
182 | ||
183 | void gfs2_rgrp_in(struct gfs2_rgrp *rg, char *buf) | |
184 | { | |
185 | struct gfs2_rgrp *str = (struct gfs2_rgrp *)buf; | |
186 | ||
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); | |
191 | } | |
192 | ||
193 | void gfs2_rgrp_out(struct gfs2_rgrp *rg, char *buf) | |
194 | { | |
195 | struct gfs2_rgrp *str = (struct gfs2_rgrp *)buf; | |
196 | ||
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); | |
201 | ||
202 | memset(&str->rg_reserved, 0, sizeof(str->rg_reserved)); | |
203 | } | |
204 | ||
08bc2dbc | 205 | #if 0 |
b3b94faa DT |
206 | void gfs2_rgrp_print(struct gfs2_rgrp *rg) |
207 | { | |
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"); | |
212 | ||
213 | pa(rg, rg_reserved, 36); | |
214 | } | |
08bc2dbc | 215 | #endif /* 0 */ |
b3b94faa DT |
216 | |
217 | void gfs2_quota_in(struct gfs2_quota *qu, char *buf) | |
218 | { | |
219 | struct gfs2_quota *str = (struct gfs2_quota *)buf; | |
220 | ||
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); | |
224 | } | |
225 | ||
08bc2dbc AB |
226 | #if 0 |
227 | ||
b3b94faa DT |
228 | void gfs2_quota_out(struct gfs2_quota *qu, char *buf) |
229 | { | |
230 | struct gfs2_quota *str = (struct gfs2_quota *)buf; | |
231 | ||
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); | |
235 | } | |
236 | ||
237 | void gfs2_quota_print(struct gfs2_quota *qu) | |
238 | { | |
239 | pv(qu, qu_limit, "%llu"); | |
240 | pv(qu, qu_warn, "%llu"); | |
241 | pv(qu, qu_value, "%lld"); | |
242 | } | |
243 | ||
08bc2dbc AB |
244 | #endif /* 0 */ |
245 | ||
b3b94faa DT |
246 | void gfs2_dinode_in(struct gfs2_dinode *di, char *buf) |
247 | { | |
248 | struct gfs2_dinode *str = (struct gfs2_dinode *)buf; | |
249 | ||
250 | gfs2_meta_header_in(&di->di_header, buf); | |
251 | gfs2_inum_in(&di->di_num, (char *)&str->di_num); | |
252 | ||
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); | |
264 | ||
265 | di->di_goal_meta = be64_to_cpu(str->di_goal_meta); | |
266 | di->di_goal_data = be64_to_cpu(str->di_goal_data); | |
267 | ||
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); | |
271 | ||
272 | di->di_depth = be16_to_cpu(str->di_depth); | |
273 | di->di_entries = be32_to_cpu(str->di_entries); | |
274 | ||
275 | di->di_eattr = be64_to_cpu(str->di_eattr); | |
276 | ||
277 | } | |
278 | ||
279 | void gfs2_dinode_out(struct gfs2_dinode *di, char *buf) | |
280 | { | |
281 | struct gfs2_dinode *str = (struct gfs2_dinode *)buf; | |
282 | ||
283 | gfs2_meta_header_out(&di->di_header, buf); | |
284 | gfs2_inum_out(&di->di_num, (char *)&str->di_num); | |
285 | ||
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); | |
297 | ||
298 | str->di_goal_meta = cpu_to_be64(di->di_goal_meta); | |
299 | str->di_goal_data = cpu_to_be64(di->di_goal_data); | |
300 | ||
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); | |
304 | ||
305 | str->di_depth = cpu_to_be16(di->di_depth); | |
306 | str->di_entries = cpu_to_be32(di->di_entries); | |
307 | ||
308 | str->di_eattr = cpu_to_be64(di->di_eattr); | |
309 | ||
310 | } | |
311 | ||
312 | void gfs2_dinode_print(struct gfs2_dinode *di) | |
313 | { | |
314 | gfs2_meta_header_print(&di->di_header); | |
315 | gfs2_inum_print(&di->di_num); | |
316 | ||
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"); | |
328 | ||
329 | pv(di, di_goal_meta, "%llu"); | |
330 | pv(di, di_goal_data, "%llu"); | |
331 | ||
332 | pv(di, di_flags, "0x%.8X"); | |
333 | pv(di, di_payload_format, "%u"); | |
334 | pv(di, di_height, "%u"); | |
335 | ||
336 | pv(di, di_depth, "%u"); | |
337 | pv(di, di_entries, "%u"); | |
338 | ||
339 | pv(di, di_eattr, "%llu"); | |
340 | } | |
341 | ||
08bc2dbc AB |
342 | #if 0 |
343 | ||
b3b94faa DT |
344 | void gfs2_dirent_print(struct gfs2_dirent *de, char *name) |
345 | { | |
346 | char buf[GFS2_FNAMESIZE + 1]; | |
347 | ||
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"); | |
353 | ||
354 | memset(buf, 0, GFS2_FNAMESIZE + 1); | |
355 | memcpy(buf, name, de->de_name_len); | |
d92a8d48 | 356 | printk(KERN_INFO " name = %s\n", buf); |
b3b94faa DT |
357 | } |
358 | ||
b3b94faa DT |
359 | void gfs2_leaf_print(struct gfs2_leaf *lf) |
360 | { | |
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"); | |
366 | ||
367 | pa(lf, lf_reserved, 32); | |
368 | } | |
369 | ||
370 | void gfs2_ea_header_in(struct gfs2_ea_header *ea, char *buf) | |
371 | { | |
372 | struct gfs2_ea_header *str = (struct gfs2_ea_header *)buf; | |
373 | ||
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; | |
380 | } | |
381 | ||
382 | void gfs2_ea_header_out(struct gfs2_ea_header *ea, char *buf) | |
383 | { | |
384 | struct gfs2_ea_header *str = (struct gfs2_ea_header *)buf; | |
385 | ||
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; | |
392 | str->__pad = 0; | |
393 | } | |
394 | ||
395 | void gfs2_ea_header_print(struct gfs2_ea_header *ea, char *name) | |
396 | { | |
397 | char buf[GFS2_EA_MAX_NAME_LEN + 1]; | |
398 | ||
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"); | |
405 | ||
406 | memset(buf, 0, GFS2_EA_MAX_NAME_LEN + 1); | |
407 | memcpy(buf, name, ea->ea_name_len); | |
d92a8d48 | 408 | printk(KERN_INFO " name = %s\n", buf); |
b3b94faa DT |
409 | } |
410 | ||
08bc2dbc AB |
411 | #endif /* 0 */ |
412 | ||
b3b94faa DT |
413 | void gfs2_log_header_in(struct gfs2_log_header *lh, char *buf) |
414 | { | |
415 | struct gfs2_log_header *str = (struct gfs2_log_header *)buf; | |
416 | ||
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); | |
423 | } | |
424 | ||
08bc2dbc AB |
425 | #if 0 |
426 | ||
b3b94faa DT |
427 | void gfs2_log_header_print(struct gfs2_log_header *lh) |
428 | { | |
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"); | |
435 | } | |
436 | ||
437 | void gfs2_log_descriptor_print(struct gfs2_log_descriptor *ld) | |
438 | { | |
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"); | |
444 | ||
445 | pa(ld, ld_reserved, 32); | |
446 | } | |
447 | ||
08bc2dbc AB |
448 | #endif /* 0 */ |
449 | ||
b3b94faa DT |
450 | void gfs2_inum_range_in(struct gfs2_inum_range *ir, char *buf) |
451 | { | |
452 | struct gfs2_inum_range *str = (struct gfs2_inum_range *)buf; | |
453 | ||
454 | ir->ir_start = be64_to_cpu(str->ir_start); | |
455 | ir->ir_length = be64_to_cpu(str->ir_length); | |
456 | } | |
457 | ||
458 | void gfs2_inum_range_out(struct gfs2_inum_range *ir, char *buf) | |
459 | { | |
460 | struct gfs2_inum_range *str = (struct gfs2_inum_range *)buf; | |
461 | ||
462 | str->ir_start = cpu_to_be64(ir->ir_start); | |
463 | str->ir_length = cpu_to_be64(ir->ir_length); | |
464 | } | |
465 | ||
08bc2dbc | 466 | #if 0 |
b3b94faa DT |
467 | void gfs2_inum_range_print(struct gfs2_inum_range *ir) |
468 | { | |
469 | pv(ir, ir_start, "%llu"); | |
470 | pv(ir, ir_length, "%llu"); | |
471 | } | |
08bc2dbc | 472 | #endif /* 0 */ |
b3b94faa DT |
473 | |
474 | void gfs2_statfs_change_in(struct gfs2_statfs_change *sc, char *buf) | |
475 | { | |
476 | struct gfs2_statfs_change *str = (struct gfs2_statfs_change *)buf; | |
477 | ||
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); | |
481 | } | |
482 | ||
483 | void gfs2_statfs_change_out(struct gfs2_statfs_change *sc, char *buf) | |
484 | { | |
485 | struct gfs2_statfs_change *str = (struct gfs2_statfs_change *)buf; | |
486 | ||
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); | |
490 | } | |
491 | ||
08bc2dbc | 492 | #if 0 |
b3b94faa DT |
493 | void gfs2_statfs_change_print(struct gfs2_statfs_change *sc) |
494 | { | |
495 | pv(sc, sc_total, "%lld"); | |
496 | pv(sc, sc_free, "%lld"); | |
497 | pv(sc, sc_dinodes, "%lld"); | |
498 | } | |
08bc2dbc | 499 | #endif /* 0 */ |
b3b94faa DT |
500 | |
501 | void gfs2_unlinked_tag_in(struct gfs2_unlinked_tag *ut, char *buf) | |
502 | { | |
503 | struct gfs2_unlinked_tag *str = (struct gfs2_unlinked_tag *)buf; | |
504 | ||
505 | gfs2_inum_in(&ut->ut_inum, buf); | |
506 | ut->ut_flags = be32_to_cpu(str->ut_flags); | |
507 | } | |
508 | ||
509 | void gfs2_unlinked_tag_out(struct gfs2_unlinked_tag *ut, char *buf) | |
510 | { | |
511 | struct gfs2_unlinked_tag *str = (struct gfs2_unlinked_tag *)buf; | |
512 | ||
513 | gfs2_inum_out(&ut->ut_inum, buf); | |
514 | str->ut_flags = cpu_to_be32(ut->ut_flags); | |
515 | str->__pad = 0; | |
516 | } | |
517 | ||
08bc2dbc AB |
518 | #if 0 |
519 | ||
b3b94faa DT |
520 | void gfs2_unlinked_tag_print(struct gfs2_unlinked_tag *ut) |
521 | { | |
522 | gfs2_inum_print(&ut->ut_inum); | |
523 | pv(ut, ut_flags, "%u"); | |
524 | } | |
525 | ||
08bc2dbc AB |
526 | #endif /* 0 */ |
527 | ||
b3b94faa DT |
528 | void gfs2_quota_change_in(struct gfs2_quota_change *qc, char *buf) |
529 | { | |
530 | struct gfs2_quota_change *str = (struct gfs2_quota_change *)buf; | |
531 | ||
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); | |
535 | } | |
536 | ||
08bc2dbc AB |
537 | #if 0 |
538 | ||
b3b94faa DT |
539 | void gfs2_quota_change_print(struct gfs2_quota_change *qc) |
540 | { | |
541 | pv(qc, qc_change, "%lld"); | |
542 | pv(qc, qc_flags, "0x%.8X"); | |
543 | pv(qc, qc_id, "%u"); | |
544 | } | |
545 | ||
08bc2dbc | 546 | #endif /* 0 */ |
b3b94faa | 547 |