#include "clusterautoconfig.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <inttypes.h>
#include <ctype.h>
#include <linux/types.h>
#include "libgfs2.h"
#ifdef GFS2_HAS_UUID
#include <uuid.h>
#endif
#define pv(struct, member, fmt, fmt2) do { \
print_it(" "#member, fmt, fmt2, struct->member); \
} while (FALSE);
#define pv2(struct, member, fmt, fmt2) do { \
print_it(" ", fmt, fmt2, struct->member); \
} while (FALSE);
#define CPIN_08(s1, s2, member, count) {memcpy((s1->member), (s2->member), (count));}
#define CPOUT_08(s1, s2, member, count) {memcpy((s2->member), (s1->member), (count));}
#define CPIN_16(s1, s2, member) {(s1->member) = be16_to_cpu((s2->member));}
#define CPOUT_16(s1, s2, member) {(s2->member) = cpu_to_be16((s1->member));}
#define CPIN_32(s1, s2, member) {(s1->member) = be32_to_cpu((s2->member));}
#define CPOUT_32(s1, s2, member) {(s2->member) = cpu_to_be32((s1->member));}
#define CPIN_64(s1, s2, member) {(s1->member) = be64_to_cpu((s2->member));}
#define CPOUT_64(s1, s2, member) {(s2->member) = cpu_to_be64((s1->member));}
/*
* gfs2_xxx_in - read in an xxx struct
* first arg: the cpu-order structure
* buf: the disk-order block data
*
* gfs2_xxx_out - write out an xxx struct
* first arg: the cpu-order structure
* buf: the disk-order block data
*
* 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;
CPIN_64(no, str, no_formal_ino);
CPIN_64(no, str, no_addr);
}
void gfs2_inum_out(const struct gfs2_inum *no, char *buf)
{
struct gfs2_inum *str = (struct gfs2_inum *)buf;
CPOUT_64(no, str, no_formal_ino);
CPOUT_64(no, str, no_addr);
}
void gfs2_inum_print(const struct gfs2_inum *no)
{
pv(no, no_formal_ino, "%llu", "0x%llx");
pv(no, no_addr, "%llu", "0x%llx");
}
void gfs2_meta_header_in(struct gfs2_meta_header *mh, char *buf)
{
struct gfs2_meta_header *str = (struct gfs2_meta_header *)buf;
CPIN_32(mh, str, mh_magic);
CPIN_32(mh, str, mh_type);
CPIN_32(mh, str, mh_format);
}
void gfs2_meta_header_out(const struct gfs2_meta_header *mh, char *buf)
{
struct gfs2_meta_header *str = (struct gfs2_meta_header *)buf;
CPOUT_32(mh, str, mh_magic);
CPOUT_32(mh, str, mh_type);
CPOUT_32(mh, str, mh_format);
str->__pad0 = 0;
str->__pad1 = 0;
}
void gfs2_meta_header_print(const struct gfs2_meta_header *mh)
{
pv(mh, mh_magic, "0x%08X", NULL);
pv(mh, mh_type, "%u", "0x%x");
pv(mh, mh_format, "%u", "0x%x");
}
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);
CPIN_32(sb, str, sb_fs_format);
CPIN_32(sb, str, sb_multihost_format);
CPIN_32(sb, str, __pad0); /* gfs sb_flags */
CPIN_32(sb, str, sb_bsize);
CPIN_32(sb, str, sb_bsize_shift);
CPIN_32(sb, str, __pad1); /* gfs sb_seg_size */
gfs2_inum_in(&sb->sb_master_dir, (char *)&str->sb_master_dir);
gfs2_inum_in(&sb->sb_root_dir, (char *)&str->sb_root_dir);
CPIN_08(sb, str, sb_lockproto, GFS2_LOCKNAME_LEN);
CPIN_08(sb, str, sb_locktable, GFS2_LOCKNAME_LEN);
gfs2_inum_in(&sb->__pad2, (char *)&str->__pad2); /* gfs rindex */
gfs2_inum_in(&sb->__pad3, (char *)&str->__pad3); /* gfs quota */
gfs2_inum_in(&sb->__pad4, (char *)&str->__pad4); /* gfs license */
#ifdef GFS2_HAS_UUID
CPIN_08(sb, str, sb_uuid, sizeof(sb->sb_uuid));
#endif
}
void gfs2_sb_out(const struct gfs2_sb *sb, char *buf)
{
struct gfs2_sb *str = (struct gfs2_sb *)buf;
gfs2_meta_header_out(&sb->sb_header, buf);
CPOUT_32(sb, str, sb_fs_format);
CPOUT_32(sb, str, sb_multihost_format);
CPOUT_32(sb, str, __pad0); /* gfs sb_flags */
CPOUT_32(sb, str, sb_bsize);
CPOUT_32(sb, str, sb_bsize_shift);
CPOUT_32(sb, str, __pad1); /* gfs sb_seg_size */
gfs2_inum_out(&sb->sb_master_dir, (char *)&str->sb_master_dir);
gfs2_inum_out(&sb->sb_root_dir, (char *)&str->sb_root_dir);
CPOUT_08(sb, str, sb_lockproto, GFS2_LOCKNAME_LEN);
CPOUT_08(sb, str, sb_locktable, GFS2_LOCKNAME_LEN);
gfs2_inum_out(&sb->__pad2, (char *)&str->__pad2); /* gfs rindex */
gfs2_inum_out(&sb->__pad3, (char *)&str->__pad3); /* gfs quota */
gfs2_inum_out(&sb->__pad4, (char *)&str->__pad4); /* gfs license */
#ifdef GFS2_HAS_UUID
memcpy(str->sb_uuid, sb->sb_uuid, 16);
#endif
}
void gfs2_sb_print(const struct gfs2_sb *sb)
{
gfs2_meta_header_print(&sb->sb_header);
pv(sb, sb_fs_format, "%u", "0x%x");
pv(sb, sb_multihost_format, "%u", "0x%x");
pv(sb, sb_bsize, "%u", "0x%x");
pv(sb, sb_bsize_shift, "%u", "0x%x");
gfs2_inum_print(&sb->sb_master_dir);
gfs2_inum_print(&sb->sb_root_dir);
pv(sb, sb_lockproto, "%s", NULL);
pv(sb, sb_locktable, "%s", NULL);
#ifdef GFS2_HAS_UUID
{
char readable_uuid[36+1];
uuid_unparse(sb->sb_uuid, readable_uuid);
print_it(" uuid", "%36s", NULL, readable_uuid);
}
#endif
}
void gfs2_rindex_in(struct gfs2_rindex *ri, char *buf)
{
struct gfs2_rindex *str = (struct gfs2_rindex *)buf;
CPIN_64(ri, str, ri_addr);
CPIN_32(ri, str, ri_length);
CPIN_32(ri, str, __pad);
CPIN_64(ri, str, ri_data0);
CPIN_32(ri, str, ri_data);
CPIN_32(ri, str, ri_bitbytes);
CPIN_08(ri, str, ri_reserved, sizeof(ri->ri_reserved));
}
void gfs2_rindex_out(const struct gfs2_rindex *ri, char *buf)
{
struct gfs2_rindex *str = (struct gfs2_rindex *)buf;
CPOUT_64(ri, str, ri_addr);
CPOUT_32(ri, str, ri_length);
str->__pad = 0;
CPOUT_64(ri, str, ri_data0);
CPOUT_32(ri, str, ri_data);
CPOUT_32(ri, str, ri_bitbytes);
CPOUT_08(ri, str, ri_reserved, sizeof(ri->ri_reserved));
}
void gfs2_rindex_print(const struct gfs2_rindex *ri)
{
pv(ri, ri_addr, "%llu", "0x%llx");
pv(ri, ri_length, "%u", "0x%x");
pv(ri, ri_data0, "%llu", "0x%llx");
pv(ri, ri_data, "%u", "0x%x");
pv(ri, ri_bitbytes, "%u", "0x%x");
}
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);
CPIN_32(rg, str, rg_flags);
CPIN_32(rg, str, rg_free);
CPIN_32(rg, str, rg_dinodes);
#ifdef GFS2_HAS_RG_SKIP
CPIN_32(rg, str, rg_skip);
#else
CPIN_32(rg, str, __pad);
#endif
CPIN_64(rg, str, rg_igeneration);
#ifdef GFS2_HAS_RG_RI_FIELDS
CPIN_64(rg, str, rg_data0);
CPIN_32(rg, str, rg_data);
CPIN_32(rg, str, rg_bitbytes);
CPIN_32(rg, str, rg_crc);
#endif
CPIN_08(rg, str, rg_reserved, sizeof(rg->rg_reserved));
}
void gfs2_rgrp_out(const struct gfs2_rgrp *rg, char *buf)
{
struct gfs2_rgrp *str = (struct gfs2_rgrp *)buf;
gfs2_meta_header_out(&rg->rg_header, buf);
CPOUT_32(rg, str, rg_flags);
CPOUT_32(rg, str, rg_free);
CPOUT_32(rg, str, rg_dinodes);
#ifdef GFS2_HAS_RG_SKIP
CPOUT_32(rg, str, rg_skip);
#else
CPOUT_32(rg, str, __pad);
#endif
CPOUT_64(rg, str, rg_igeneration);
#ifdef GFS2_HAS_RG_RI_FIELDS
CPOUT_64(rg, str, rg_data0);
CPOUT_32(rg, str, rg_data);
CPOUT_32(rg, str, rg_bitbytes);
CPOUT_08(rg, str, rg_reserved, sizeof(rg->rg_reserved));
lgfs2_rgrp_crc_set(buf);
#else
CPOUT_08(rg, str, rg_reserved, sizeof(rg->rg_reserved));
#endif
}
void gfs2_rgrp_print(const struct gfs2_rgrp *rg)
{
gfs2_meta_header_print(&rg->rg_header);
pv(rg, rg_flags, "%u", "0x%x");
pv(rg, rg_free, "%u", "0x%x");
pv(rg, rg_dinodes, "%u", "0x%x");
#ifdef GFS2_HAS_RG_SKIP
pv(rg, rg_skip, "%u", "0x%x");
#else
pv(rg, __pad, "%u", "0x%x");
#endif
pv(rg, rg_igeneration, "%llu", "0x%llx");
#ifdef GFS2_HAS_RG_RI_FIELDS
pv(rg, rg_data0, "%llu", "0x%llx");
pv(rg, rg_data, "%u", "0x%x");
pv(rg, rg_bitbytes, "%u", "0x%x");
pv(rg, rg_crc, "%u", "0x%x");
#endif
}
void gfs2_quota_in(struct gfs2_quota *qu, char *buf)
{
struct gfs2_quota *str = (struct gfs2_quota *)buf;
CPIN_64(qu, str, qu_limit);
CPIN_64(qu, str, qu_warn);
CPIN_64(qu, str, qu_value);
CPIN_08(qu, str, qu_reserved, sizeof(qu->qu_reserved));
}
void gfs2_quota_out(struct gfs2_quota *qu, char *buf)
{
struct gfs2_quota *str = (struct gfs2_quota *)buf;
CPOUT_64(qu, str, qu_limit);
CPOUT_64(qu, str, qu_warn);
CPOUT_64(qu, str, qu_value);
memset(qu->qu_reserved, 0, sizeof(qu->qu_reserved));
}
void gfs2_quota_print(const struct gfs2_quota *qu)
{
pv(qu, qu_limit, "%llu", "0x%llx");
pv(qu, qu_warn, "%llu", "0x%llx");
pv(qu, qu_value, "%lld", "0x%llx");
}
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);
CPIN_32(di, str, di_mode);
CPIN_32(di, str, di_uid);
CPIN_32(di, str, di_gid);
CPIN_32(di, str, di_nlink);
CPIN_64(di, str, di_size);
CPIN_64(di, str, di_blocks);
CPIN_64(di, str, di_atime);
CPIN_64(di, str, di_mtime);
CPIN_64(di, str, di_ctime);
CPIN_32(di, str, di_major);
CPIN_32(di, str, di_minor);
CPIN_64(di, str, di_goal_meta);
CPIN_64(di, str, di_goal_data);
CPIN_32(di, str, di_flags);
CPIN_32(di, str, di_payload_format);
CPIN_16(di, str, __pad1);
CPIN_16(di, str, di_height);
CPIN_16(di, str, di_depth);
CPIN_32(di, str, di_entries);
CPIN_64(di, str, di_eattr);
CPIN_08(di, str, di_reserved, 32);
}
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);
CPOUT_32(di, str, di_mode);
CPOUT_32(di, str, di_uid);
CPOUT_32(di, str, di_gid);
CPOUT_32(di, str, di_nlink);
CPOUT_64(di, str, di_size);
CPOUT_64(di, str, di_blocks);
CPOUT_64(di, str, di_atime);
CPOUT_64(di, str, di_mtime);
CPOUT_64(di, str, di_ctime);
CPOUT_32(di, str, di_major);
CPOUT_32(di, str, di_minor);
CPOUT_64(di, str, di_goal_meta);
CPOUT_64(di, str, di_goal_data);
CPOUT_32(di, str, di_flags);
CPOUT_32(di, str, di_payload_format);
CPOUT_16(di, str, __pad1);
CPOUT_16(di, str, di_height);
CPOUT_16(di, str, di_depth);
CPOUT_32(di, str, di_entries);
CPOUT_64(di, str, di_eattr);
CPOUT_08(di, str, di_reserved, 32);
}
void gfs2_dinode_print(const struct gfs2_dinode *di)
{
gfs2_meta_header_print(&di->di_header);
gfs2_inum_print(&di->di_num);
pv(di, di_mode, "0%o", NULL);
pv(di, di_uid, "%u", "0x%x");
pv(di, di_gid, "%u", "0x%x");
pv(di, di_nlink, "%u", "0x%x");
pv(di, di_size, "%llu", "0x%llx");
pv(di, di_blocks, "%llu", "0x%llx");
pv(di, di_atime, "%lld", "0x%llx");
pv(di, di_mtime, "%lld", "0x%llx");
pv(di, di_ctime, "%lld", "0x%llx");
pv(di, di_major, "%u", "0x%llx");
pv(di, di_minor, "%u", "0x%llx");
pv(di, di_goal_meta, "%llu", "0x%llx");
pv(di, di_goal_data, "%llu", "0x%llx");
pv(di, di_flags, "0x%.8X", NULL);
pv(di, di_payload_format, "%u", "0x%x");
pv(di, di_height, "%u", "0x%x");
pv(di, di_depth, "%u", "0x%x");
pv(di, di_entries, "%u", "0x%x");
pv(di, di_eattr, "%llu", "0x%llx");
}
void gfs2_dirent_in(struct gfs2_dirent *de, char *buf)
{
struct gfs2_dirent *str = (struct gfs2_dirent *)buf;
gfs2_inum_in(&de->de_inum, buf);
CPIN_32(de, str, de_hash);
CPIN_16(de, str, de_rec_len);
CPIN_16(de, str, de_name_len);
CPIN_16(de, str, de_type);
#ifdef GFS2_HAS_DE_RAHEAD
CPIN_16(de, str, de_rahead);
#ifdef GFS2_HAS_DE_COOKIE
CPIN_32(de, str, de_cookie);
CPIN_08(de, str, pad3, 8);
#else
CPIN_08(de, str, pad2, 12);
#endif /* GFS2_HAS_DE_COOKIE */
#else
CPIN_08(de, str, __pad, 14);
#endif /* GFS2_HAS_DE_RAHEAD */
}
void gfs2_dirent_out(struct gfs2_dirent *de, char *buf)
{
struct gfs2_dirent *str = (struct gfs2_dirent *)buf;
gfs2_inum_out(&de->de_inum, buf);
CPOUT_32(de, str, de_hash);
CPOUT_16(de, str, de_rec_len);
CPOUT_16(de, str, de_name_len);
CPOUT_16(de, str, de_type);
#ifdef GFS2_HAS_DE_RAHEAD
CPOUT_16(de, str, de_rahead);
#ifdef GFS2_HAS_DE_COOKIE
CPOUT_32(de, str, de_cookie);
CPOUT_08(de, str, pad3, 8);
#else
CPOUT_08(de, str, pad2, 12);
#endif /* GFS2_HAS_DE_COOKIE */
#else
CPOUT_08(de, str, __pad, 14);
#endif /* GFS2_HAS_DE_RAHEAD */
}
void gfs2_leaf_in(struct gfs2_leaf *lf, char *buf)
{
struct gfs2_leaf *str = (struct gfs2_leaf *)buf;
gfs2_meta_header_in(&lf->lf_header, buf);
CPIN_16(lf, str, lf_depth);
CPIN_16(lf, str, lf_entries);
CPIN_32(lf, str, lf_dirent_format);
CPIN_64(lf, str, lf_next);
#ifdef GFS2_HAS_LEAF_HINTS
CPIN_64(lf, str, lf_inode);
CPIN_32(lf, str, lf_dist);
CPIN_32(lf, str, lf_nsec);
CPIN_64(lf, str, lf_sec);
CPIN_08(lf, str, lf_reserved2, 40);
#else
CPIN_08(lf, str, lf_reserved, 32);
#endif
}
void gfs2_leaf_out(struct gfs2_leaf *lf, char *buf)
{
struct gfs2_leaf *str = (struct gfs2_leaf *)buf;
gfs2_meta_header_out(&lf->lf_header, buf);
CPOUT_16(lf, str, lf_depth);
CPOUT_16(lf, str, lf_entries);
CPOUT_32(lf, str, lf_dirent_format);
CPOUT_64(lf, str, lf_next);
#ifdef GFS2_HAS_LEAF_HINTS
CPOUT_64(lf, str, lf_inode);
CPOUT_32(lf, str, lf_dist);
CPOUT_32(lf, str, lf_nsec);
CPOUT_64(lf, str, lf_sec);
CPOUT_08(lf, str, lf_reserved2, 40);
#else
CPOUT_08(lf, str, lf_reserved, 64);
#endif
}
void gfs2_leaf_print(const struct gfs2_leaf *lf)
{
gfs2_meta_header_print(&lf->lf_header);
pv(lf, lf_depth, "%u", "0x%x");
pv(lf, lf_entries, "%u", "0x%x");
pv(lf, lf_dirent_format, "%u", "0x%x");
pv(lf, lf_next, "%llu", "0x%llx");
#ifdef GFS2_HAS_LEAF_HINTS
pv(lf, lf_inode, "%llu", "0x%llx");
pv(lf, lf_dist, "%u", "0x%x");
pv(lf, lf_nsec, "%u", "0x%x");
pv(lf, lf_sec, "%llu", "0x%llx");
#endif
}
void gfs2_ea_header_in(struct gfs2_ea_header *ea, char *buf)
{
struct gfs2_ea_header *str = (struct gfs2_ea_header *)buf;
CPIN_32(ea, str, ea_rec_len);
CPIN_32(ea, str, ea_data_len);
ea->ea_name_len = str->ea_name_len;
ea->ea_type = str->ea_type;
ea->ea_flags = str->ea_flags;
ea->ea_num_ptrs = str->ea_num_ptrs;
}
void gfs2_ea_header_print(const struct gfs2_ea_header *ea, char *name)
{
char buf[GFS2_EA_MAX_NAME_LEN + 1];
pv(ea, ea_rec_len, "%u", "0x%x");
pv(ea, ea_data_len, "%u", "0x%x");
pv(ea, ea_name_len, "%u", "0x%x");
pv(ea, ea_type, "%u", "0x%x");
pv(ea, ea_flags, "%u", "0x%x");
pv(ea, ea_num_ptrs, "%u", "0x%x");
memset(buf, 0, GFS2_EA_MAX_NAME_LEN + 1);
memcpy(buf, name, ea->ea_name_len);
print_it(" name", "%s", NULL, buf);
}
void gfs2_log_header_v1_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);
CPIN_64(lh, str, lh_sequence);
CPIN_32(lh, str, lh_flags);
CPIN_32(lh, str, lh_tail);
CPIN_32(lh, str, lh_blkno);
CPIN_32(lh, str, lh_hash);
}
void gfs2_log_header_in(struct gfs2_log_header *lh, char *buf)
{
gfs2_log_header_v1_in(lh, buf);
#ifdef GFS2_HAS_LH_V2
{
struct gfs2_log_header *str = (struct gfs2_log_header *)buf;
CPIN_32(lh, str, lh_crc);
CPIN_32(lh, str, lh_nsec);
CPIN_64(lh, str, lh_sec);
CPIN_64(lh, str, lh_addr);
CPIN_64(lh, str, lh_jinode);
CPIN_64(lh, str, lh_statfs_addr);
CPIN_64(lh, str, lh_quota_addr);
CPIN_64(lh, str, lh_local_total);
CPIN_64(lh, str, lh_local_free);
CPIN_64(lh, str, lh_local_dinodes);
}
#endif
}
void gfs2_log_header_v1_out(struct gfs2_log_header *lh, char *buf)
{
struct gfs2_log_header *str = (struct gfs2_log_header *)buf;
gfs2_meta_header_out(&lh->lh_header, buf);
CPOUT_64(lh, str, lh_sequence);
CPOUT_32(lh, str, lh_flags);
CPOUT_32(lh, str, lh_tail);
CPOUT_32(lh, str, lh_blkno);
CPOUT_32(lh, str, lh_hash);
}
void gfs2_log_header_out(struct gfs2_log_header *lh, char *buf)
{
gfs2_log_header_v1_out(lh, buf);
#ifdef GFS2_HAS_LH_V2
{
struct gfs2_log_header *str = (struct gfs2_log_header *)buf;
CPOUT_32(lh, str, lh_crc);
CPOUT_32(lh, str, lh_nsec);
CPOUT_64(lh, str, lh_sec);
CPOUT_64(lh, str, lh_addr);
CPOUT_64(lh, str, lh_jinode);
CPOUT_64(lh, str, lh_statfs_addr);
CPOUT_64(lh, str, lh_quota_addr);
CPOUT_64(lh, str, lh_local_total);
CPOUT_64(lh, str, lh_local_free);
CPOUT_64(lh, str, lh_local_dinodes);
}
#endif
}
void gfs2_log_header_v1_print(const struct gfs2_log_header *lh)
{
gfs2_meta_header_print(&lh->lh_header);
pv(lh, lh_sequence, "%llu", "0x%llx");
pv(lh, lh_flags, "0x%.8X", NULL);
pv(lh, lh_tail, "%u", "0x%x");
pv(lh, lh_blkno, "%u", "0x%x");
pv(lh, lh_hash, "0x%.8X", NULL);
}
void gfs2_log_header_print(const struct gfs2_log_header *lh)
{
gfs2_log_header_v1_print(lh);
#ifdef GFS2_HAS_LH_V2
pv(lh, lh_crc, "0x%.8X", NULL);
pv(lh, lh_nsec, "%u", "0x%x");
pv(lh, lh_sec, "%llu", "0x%llx");
pv(lh, lh_addr, "%llu", "0x%llx");
pv(lh, lh_jinode, "%llu", "0x%llx");
pv(lh, lh_statfs_addr, "%llu", "0x%llx");
pv(lh, lh_quota_addr, "%llu", "0x%llx");
pv(lh, lh_local_total, "%lld", "0x%llx");
pv(lh, lh_local_free, "%lld", "0x%llx");
pv(lh, lh_local_dinodes, "%lld", "0x%llx");
#endif
}
void gfs2_log_descriptor_in(struct gfs2_log_descriptor *ld, char *buf)
{
struct gfs2_log_descriptor *str = (struct gfs2_log_descriptor *)buf;
gfs2_meta_header_in(&ld->ld_header, buf);
CPIN_32(ld, str, ld_type);
CPIN_32(ld, str, ld_length);
CPIN_32(ld, str, ld_data1);
CPIN_32(ld, str, ld_data2);
CPIN_08(ld, str, ld_reserved, 32);
}
void gfs2_log_descriptor_out(struct gfs2_log_descriptor *ld, char *buf)
{
struct gfs2_log_descriptor *str = (struct gfs2_log_descriptor *)buf;
gfs2_meta_header_out(&ld->ld_header, buf);
CPOUT_32(ld, str, ld_type);
CPOUT_32(ld, str, ld_length);
CPOUT_32(ld, str, ld_data1);
CPOUT_32(ld, str, ld_data2);
CPOUT_08(ld, str, ld_reserved, 32);
}
void gfs2_log_descriptor_print(const struct gfs2_log_descriptor *ld)
{
gfs2_meta_header_print(&ld->ld_header);
pv(ld, ld_type, "%u", "0x%x");
pv(ld, ld_length, "%u", "0x%x");
pv(ld, ld_data1, "%u", "0x%x");
pv(ld, ld_data2, "%u", "0x%x");
}
void gfs2_statfs_change_in(struct gfs2_statfs_change *sc, char *buf)
{
struct gfs2_statfs_change *str = (struct gfs2_statfs_change *)buf;
CPIN_64(sc, str, sc_total);
CPIN_64(sc, str, sc_free);
CPIN_64(sc, 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;
CPOUT_64(sc, str, sc_total);
CPOUT_64(sc, str, sc_free);
CPOUT_64(sc, str, sc_dinodes);
}
void gfs2_statfs_change_print(const struct gfs2_statfs_change *sc)
{
pv(sc, sc_total, "%lld", "0x%llx");
pv(sc, sc_free, "%lld", "0x%llx");
pv(sc, sc_dinodes, "%lld", "0x%llx");
}
void gfs2_quota_change_in(struct gfs2_quota_change *qc, char *buf)
{
struct gfs2_quota_change *str = (struct gfs2_quota_change *)(buf +
sizeof(struct gfs2_meta_header));
CPIN_64(qc, str, qc_change);
CPIN_32(qc, str, qc_flags);
CPIN_32(qc, str, qc_id);
}
void gfs2_quota_change_out(struct gfs2_quota_change *qc, char *buf)
{
struct gfs2_quota_change *str = (struct gfs2_quota_change *)(buf +
sizeof(struct gfs2_meta_header));
CPOUT_64(qc, str, qc_change);
CPOUT_32(qc, str, qc_flags);
CPOUT_32(qc, str, qc_id);
}
void gfs2_quota_change_print(const struct gfs2_quota_change *qc)
{
pv(qc, qc_change, "%lld", "0x%llx");
pv(qc, qc_flags, "0x%.8X", NULL);
pv(qc, qc_id, "%u", "0x%x");
}