wirecheck.c

来自「lustre 1.6.5 source code」· C语言 代码 · 共 1,346 行 · 第 1/3 页

/* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
 * vim:expandtab:shiftwidth=8:tabstop=8:
 */
#include <stdio.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <liblustre.h>
#include <lustre_lib.h>
#include <lustre/lustre_idl.h>
#include <lustre_disk.h>

#define BLANK_LINE()                                            \
do {                                                            \
        printf("\n");                                           \
} while(0)

#define COMMENT(c)                                              \
do {                                                            \
        printf("        /* "c" */\n");                          \
} while(0)

#define STRINGIFY(a) #a


#define CHECK_CDEFINE(a)                                        \
        printf("        CLASSERT("#a" == "STRINGIFY(a) ");\n")

#define CHECK_CVALUE(a)                                         \
        printf("        CLASSERT("#a" == %lld);\n", (long long)a)

#define CHECK_DEFINE(a)                                         \
do {                                                            \
        printf("        LASSERTF("#a" == "STRINGIFY(a)          \
               ",\" found %%lld\\n\",\n                 "       \
               "(long long)"#a");\n");   \
} while(0)

#define CHECK_VALUE(a)                                          \
do {                                                            \
        printf("        LASSERTF("#a                            \
               " == %lld, \" found %%lld\\n\",\n                 "\
               "(long long)"#a");\n", (long long)a);            \
} while(0)

#define CHECK_VALUE_64(a)                                       \
do {                                                            \
        printf("        LASSERTF("#a                            \
               " == %lldULL, \" found %%lld\\n\",\n                 "\
               "(long long)"#a");\n", (long long)a);            \
} while(0)

#define CHECK_MEMBER_OFFSET(s,m)                                \
do {                                                            \
        CHECK_VALUE((int)offsetof(struct s, m));                \
} while(0)

#define CHECK_MEMBER_OFFSET_TYPEDEF(s,m)                        \
do {                                                            \
        CHECK_VALUE((int)offsetof(s, m));                       \
} while(0)

#define CHECK_MEMBER_SIZEOF(s,m)                                \
do {                                                            \
        CHECK_VALUE((int)sizeof(((struct s *)0)->m));           \
} while(0)

#define CHECK_MEMBER_SIZEOF_TYPEDEF(s,m)                        \
do {                                                            \
        CHECK_VALUE((int)sizeof(((s *)0)->m));                  \
} while(0)

#define CHECK_MEMBER(s,m)                                       \
do {                                                            \
        CHECK_MEMBER_OFFSET(s, m);                              \
        CHECK_MEMBER_SIZEOF(s, m);                              \
} while(0)

#define CHECK_MEMBER_TYPEDEF(s,m)                               \
do {                                                            \
        CHECK_MEMBER_OFFSET_TYPEDEF(s, m);                      \
        CHECK_MEMBER_SIZEOF_TYPEDEF(s, m);                      \
} while(0)

#define CHECK_STRUCT(s)                                         \
do {                                                            \
        COMMENT("Checks for struct "#s);                        \
                CHECK_VALUE((int)sizeof(struct s));             \
} while(0)

#define CHECK_STRUCT_TYPEDEF(s)                                 \
do {                                                            \
        COMMENT("Checks for type "#s);                          \
                CHECK_VALUE((int)sizeof(s));                    \
} while(0)

static void
check_lustre_handle(void)
{
        BLANK_LINE();
        CHECK_STRUCT(lustre_handle);
        CHECK_MEMBER(lustre_handle, cookie);
}

void
check_lustre_msg_v1(void)
{
        BLANK_LINE();
        CHECK_STRUCT(lustre_msg_v1);
        CHECK_MEMBER(lustre_msg_v1, lm_handle);
        CHECK_MEMBER(lustre_msg_v1, lm_magic);
        CHECK_MEMBER(lustre_msg_v1, lm_type);
        CHECK_MEMBER(lustre_msg_v1, lm_version);
        CHECK_MEMBER(lustre_msg_v1, lm_opc);
        CHECK_MEMBER(lustre_msg_v1, lm_last_xid);
        CHECK_MEMBER(lustre_msg_v1, lm_last_committed);
        CHECK_MEMBER(lustre_msg_v1, lm_transno);
        CHECK_MEMBER(lustre_msg_v1, lm_status);
        CHECK_MEMBER(lustre_msg_v1, lm_flags);
        CHECK_MEMBER(lustre_msg_v1, lm_conn_cnt);
        CHECK_MEMBER(lustre_msg_v1, lm_bufcount);
        CHECK_MEMBER(lustre_msg_v1, lm_buflens[0]);
}

void
check_lustre_msg_v2(void)
{
        BLANK_LINE();
        CHECK_STRUCT(lustre_msg_v2);
        CHECK_MEMBER(lustre_msg_v2, lm_bufcount);
        CHECK_MEMBER(lustre_msg_v2, lm_secflvr);
        CHECK_MEMBER(lustre_msg_v2, lm_magic);
        CHECK_MEMBER(lustre_msg_v2, lm_repsize);
        CHECK_MEMBER(lustre_msg_v2, lm_cksum);
        CHECK_MEMBER(lustre_msg_v2, lm_flags);
        CHECK_MEMBER(lustre_msg_v2, lm_padding_2);
        CHECK_MEMBER(lustre_msg_v2, lm_padding_3);
        CHECK_MEMBER(lustre_msg_v2, lm_buflens[0]);
}

void
check_ptlrpc_body(void)
{
        BLANK_LINE();
        CHECK_STRUCT(ptlrpc_body);
        CHECK_MEMBER(ptlrpc_body, pb_handle);
        CHECK_MEMBER(ptlrpc_body, pb_type);
        CHECK_MEMBER(ptlrpc_body, pb_version);
        CHECK_MEMBER(ptlrpc_body, pb_opc);
        CHECK_MEMBER(ptlrpc_body, pb_status);
        CHECK_MEMBER(ptlrpc_body, pb_last_xid);
        CHECK_MEMBER(ptlrpc_body, pb_last_seen);
        CHECK_MEMBER(ptlrpc_body, pb_last_committed);
        CHECK_MEMBER(ptlrpc_body, pb_transno);
        CHECK_MEMBER(ptlrpc_body, pb_flags);
        CHECK_MEMBER(ptlrpc_body, pb_op_flags);
        CHECK_MEMBER(ptlrpc_body, pb_conn_cnt);
        CHECK_MEMBER(ptlrpc_body, pb_timeout);
        CHECK_MEMBER(ptlrpc_body, pb_service_time);
        CHECK_MEMBER(ptlrpc_body, pb_slv);
        CHECK_MEMBER(ptlrpc_body, pb_limit);
}

static void check_obd_connect_data(void)
{
        BLANK_LINE();
        CHECK_STRUCT(obd_connect_data);
        CHECK_MEMBER(obd_connect_data, ocd_connect_flags);
        CHECK_MEMBER(obd_connect_data, ocd_version);
        CHECK_MEMBER(obd_connect_data, ocd_grant);
        CHECK_MEMBER(obd_connect_data, ocd_index);
        CHECK_MEMBER(obd_connect_data, ocd_brw_size);
        CHECK_MEMBER(obd_connect_data, ocd_ibits_known);
        CHECK_MEMBER(obd_connect_data, ocd_nllu);
        CHECK_MEMBER(obd_connect_data, ocd_nllg);
        CHECK_MEMBER(obd_connect_data, ocd_transno);
        CHECK_MEMBER(obd_connect_data, ocd_group);
        CHECK_MEMBER(obd_connect_data, ocd_cksum_types);
        CHECK_MEMBER(obd_connect_data, padding1);
        CHECK_MEMBER(obd_connect_data, padding2);

        CHECK_CDEFINE(OBD_CONNECT_RDONLY);
        CHECK_CDEFINE(OBD_CONNECT_INDEX);
        CHECK_CDEFINE(OBD_CONNECT_GRANT);
        CHECK_CDEFINE(OBD_CONNECT_SRVLOCK);
        CHECK_CDEFINE(OBD_CONNECT_VERSION);
        CHECK_CDEFINE(OBD_CONNECT_REQPORTAL);
        CHECK_CDEFINE(OBD_CONNECT_ACL);
        CHECK_CDEFINE(OBD_CONNECT_XATTR);
        CHECK_CDEFINE(OBD_CONNECT_CROW);
        CHECK_CDEFINE(OBD_CONNECT_TRUNCLOCK);
        CHECK_CDEFINE(OBD_CONNECT_TRANSNO);
        CHECK_CDEFINE(OBD_CONNECT_IBITS);
        CHECK_CDEFINE(OBD_CONNECT_JOIN);
        CHECK_CDEFINE(OBD_CONNECT_ATTRFID);
        CHECK_CDEFINE(OBD_CONNECT_NODEVOH);
        CHECK_CDEFINE(OBD_CONNECT_LCL_CLIENT);
        CHECK_CDEFINE(OBD_CONNECT_RMT_CLIENT);
        CHECK_CDEFINE(OBD_CONNECT_BRW_SIZE);
        CHECK_CDEFINE(OBD_CONNECT_QUOTA64);
        CHECK_CDEFINE(OBD_CONNECT_MDS_CAPA);
        CHECK_CDEFINE(OBD_CONNECT_OSS_CAPA);
        CHECK_CDEFINE(OBD_CONNECT_CANCELSET);
        CHECK_CDEFINE(OBD_CONNECT_SOM);
        CHECK_CDEFINE(OBD_CONNECT_AT);
        CHECK_CDEFINE(OBD_CONNECT_LRU_RESIZE);
        CHECK_CDEFINE(OBD_CONNECT_MDS_MDS);
        CHECK_CDEFINE(OBD_CONNECT_REAL);
        CHECK_CDEFINE(OBD_CONNECT_CKSUM);
}

static void
check_obdo(void)
{
        BLANK_LINE();
        CHECK_STRUCT(obdo);
        CHECK_MEMBER(obdo, o_valid);
        CHECK_MEMBER(obdo, o_id);
        CHECK_MEMBER(obdo, o_gr);
        CHECK_MEMBER(obdo, o_fid);
        CHECK_MEMBER(obdo, o_size);
        CHECK_MEMBER(obdo, o_mtime);
        CHECK_MEMBER(obdo, o_atime);
        CHECK_MEMBER(obdo, o_ctime);
        CHECK_MEMBER(obdo, o_blocks);
        CHECK_MEMBER(obdo, o_grant);
        CHECK_MEMBER(obdo, o_blksize);
        CHECK_MEMBER(obdo, o_mode);
        CHECK_MEMBER(obdo, o_uid);
        CHECK_MEMBER(obdo, o_gid);
        CHECK_MEMBER(obdo, o_flags);
        CHECK_MEMBER(obdo, o_nlink);
        CHECK_MEMBER(obdo, o_generation);
        CHECK_MEMBER(obdo, o_misc);
        CHECK_MEMBER(obdo, o_easize);
        CHECK_MEMBER(obdo, o_mds);
        CHECK_MEMBER(obdo, o_stripe_idx);
        CHECK_MEMBER(obdo, o_padding_1);
        CHECK_MEMBER(obdo, o_handle);
        CHECK_MEMBER(obdo, o_lcookie);
        CHECK_MEMBER(obdo, o_padding_2);
        CHECK_MEMBER(obdo, o_padding_3);
        CHECK_MEMBER(obdo, o_padding_4);
        CHECK_MEMBER(obdo, o_padding_5);
        CHECK_MEMBER(obdo, o_padding_6);

        CHECK_CDEFINE(OBD_MD_FLID);
        CHECK_CDEFINE(OBD_MD_FLATIME);
        CHECK_CDEFINE(OBD_MD_FLMTIME);
        CHECK_CDEFINE(OBD_MD_FLCTIME);
        CHECK_CDEFINE(OBD_MD_FLSIZE);
        CHECK_CDEFINE(OBD_MD_FLBLOCKS);
        CHECK_CDEFINE(OBD_MD_FLBLKSZ);
        CHECK_CDEFINE(OBD_MD_FLMODE);
        CHECK_CDEFINE(OBD_MD_FLTYPE);
        CHECK_CDEFINE(OBD_MD_FLUID);
        CHECK_CDEFINE(OBD_MD_FLGID);
        CHECK_CDEFINE(OBD_MD_FLFLAGS);
        CHECK_CDEFINE(OBD_MD_FLNLINK);
        CHECK_CDEFINE(OBD_MD_FLGENER);
        CHECK_CDEFINE(OBD_MD_FLRDEV);
        CHECK_CDEFINE(OBD_MD_FLEASIZE);
        CHECK_CDEFINE(OBD_MD_LINKNAME);
        CHECK_CDEFINE(OBD_MD_FLHANDLE);
        CHECK_CDEFINE(OBD_MD_FLCKSUM);
        CHECK_CDEFINE(OBD_MD_FLQOS);
        CHECK_CDEFINE(OBD_MD_FLCOOKIE);
        CHECK_CDEFINE(OBD_MD_FLGROUP);
        CHECK_CDEFINE(OBD_MD_FLFID);
        CHECK_CDEFINE(OBD_MD_FLEPOCH);
        CHECK_CDEFINE(OBD_MD_FLGRANT);
        CHECK_CDEFINE(OBD_MD_FLDIREA);
        CHECK_CDEFINE(OBD_MD_FLUSRQUOTA);
        CHECK_CDEFINE(OBD_MD_FLGRPQUOTA);
        CHECK_CDEFINE(OBD_MD_FLMODEASIZE);
        CHECK_CDEFINE(OBD_MD_MDS);
        CHECK_CDEFINE(OBD_MD_REINT);
        CHECK_CDEFINE(OBD_MD_FLXATTR);
        CHECK_CDEFINE(OBD_MD_FLXATTRLS);
        CHECK_CDEFINE(OBD_MD_FLXATTRRM);
        CHECK_CDEFINE(OBD_MD_FLACL);

        CHECK_CDEFINE(OBD_FL_INLINEDATA);
        CHECK_CDEFINE(OBD_FL_OBDMDEXISTS);
        CHECK_CDEFINE(OBD_FL_DELORPHAN);
        CHECK_CDEFINE(OBD_FL_NORPC);
        CHECK_CDEFINE(OBD_FL_IDONLY);
        CHECK_CDEFINE(OBD_FL_RECREATE_OBJS);
        CHECK_CDEFINE(OBD_FL_DEBUG_CHECK);
        CHECK_CDEFINE(OBD_FL_NO_USRQUOTA);
        CHECK_CDEFINE(OBD_FL_NO_GRPQUOTA);
        CHECK_CDEFINE(OBD_FL_CREATE_CROW);
        CHECK_CDEFINE(OBD_FL_TRUNCLOCK);
        CHECK_CDEFINE(OBD_FL_CKSUM_CRC32);
        CHECK_CDEFINE(OBD_FL_CKSUM_ADLER);
        CHECK_CVALUE(OBD_CKSUM_CRC32);
        CHECK_CVALUE(OBD_CKSUM_ADLER);
}

static void
check_lov_mds_md_v1(void)
{
        BLANK_LINE();
        CHECK_STRUCT(lov_mds_md_v1);
        CHECK_MEMBER(lov_mds_md_v1, lmm_magic);
        CHECK_MEMBER(lov_mds_md_v1, lmm_pattern);
        CHECK_MEMBER(lov_mds_md_v1, lmm_object_id);
        CHECK_MEMBER(lov_mds_md_v1, lmm_object_gr);
        CHECK_MEMBER(lov_mds_md_v1, lmm_stripe_size);
        CHECK_MEMBER(lov_mds_md_v1, lmm_stripe_count);
        CHECK_MEMBER(lov_mds_md_v1, lmm_objects);

        BLANK_LINE();
        CHECK_STRUCT(lov_ost_data_v1);
        CHECK_MEMBER(lov_ost_data_v1, l_object_id);
        CHECK_MEMBER(lov_ost_data_v1, l_object_gr);
        CHECK_MEMBER(lov_ost_data_v1, l_ost_gen);
        CHECK_MEMBER(lov_ost_data_v1, l_ost_idx);

        CHECK_CDEFINE(LOV_MAGIC_V1);
        CHECK_CDEFINE(LOV_MAGIC_JOIN);

        CHECK_VALUE(LOV_PATTERN_RAID0);
        CHECK_VALUE(LOV_PATTERN_RAID1);
}

static void
check_lov_mds_md_join(void)
{
        BLANK_LINE();
        CHECK_STRUCT(lov_mds_md_join);
        CHECK_MEMBER(lov_mds_md_join, lmmj_md);
        CHECK_MEMBER(lov_mds_md_join, lmmj_array_id);
        CHECK_MEMBER(lov_mds_md_join, lmmj_extent_count);
}

static void
check_obd_statfs(void)
{
        BLANK_LINE();
        CHECK_STRUCT(obd_statfs);
        CHECK_MEMBER(obd_statfs, os_type);
        CHECK_MEMBER(obd_statfs, os_blocks);
        CHECK_MEMBER(obd_statfs, os_bfree);
        CHECK_MEMBER(obd_statfs, os_bavail);
        CHECK_MEMBER(obd_statfs, os_ffree);
        CHECK_MEMBER(obd_statfs, os_fsid);
        CHECK_MEMBER(obd_statfs, os_bsize);
        CHECK_MEMBER(obd_statfs, os_namelen);
        CHECK_MEMBER(obd_statfs, os_state);
        CHECK_MEMBER(obd_statfs, os_spare1);
        CHECK_MEMBER(obd_statfs, os_spare2);
        CHECK_MEMBER(obd_statfs, os_spare3);
        CHECK_MEMBER(obd_statfs, os_spare4);
        CHECK_MEMBER(obd_statfs, os_spare5);
        CHECK_MEMBER(obd_statfs, os_spare6);
        CHECK_MEMBER(obd_statfs, os_spare7);
        CHECK_MEMBER(obd_statfs, os_spare8);
        CHECK_MEMBER(obd_statfs, os_spare9);
}

static void
check_obd_ioobj(void)
{
        BLANK_LINE();
        CHECK_STRUCT(obd_ioobj);
        CHECK_MEMBER(obd_ioobj, ioo_id);
        CHECK_MEMBER(obd_ioobj, ioo_gr);
        CHECK_MEMBER(obd_ioobj, ioo_type);
        CHECK_MEMBER(obd_ioobj, ioo_bufcnt);
}

static void
check_obd_quotactl(void)
{
        BLANK_LINE();
        CHECK_STRUCT(obd_quotactl);
        CHECK_MEMBER(obd_quotactl, qc_cmd);
        CHECK_MEMBER(obd_quotactl, qc_type);
        CHECK_MEMBER(obd_quotactl, qc_id);
        CHECK_MEMBER(obd_quotactl, qc_stat);
        CHECK_MEMBER(obd_quotactl, qc_dqinfo);
        CHECK_MEMBER(obd_quotactl, qc_dqblk);

        BLANK_LINE();
        CHECK_STRUCT(obd_dqinfo);
        CHECK_MEMBER(obd_dqinfo, dqi_bgrace);
        CHECK_MEMBER(obd_dqinfo, dqi_igrace);
        CHECK_MEMBER(obd_dqinfo, dqi_flags);
        CHECK_MEMBER(obd_dqinfo, dqi_valid);

        BLANK_LINE();
        CHECK_STRUCT(obd_dqblk);
        CHECK_MEMBER(obd_dqblk, dqb_bhardlimit);
        CHECK_MEMBER(obd_dqblk, dqb_bsoftlimit);
        CHECK_MEMBER(obd_dqblk, dqb_curspace);
        CHECK_MEMBER(obd_dqblk, dqb_ihardlimit);
        CHECK_MEMBER(obd_dqblk, dqb_isoftlimit);
        CHECK_MEMBER(obd_dqblk, dqb_curinodes);
        CHECK_MEMBER(obd_dqblk, dqb_btime);
        CHECK_MEMBER(obd_dqblk, dqb_itime);
        CHECK_MEMBER(obd_dqblk, dqb_valid);
        CHECK_MEMBER(obd_dqblk, padding);

        CHECK_DEFINE(Q_QUOTACHECK);
        CHECK_DEFINE(Q_INITQUOTA);
        CHECK_DEFINE(Q_GETOINFO);
        CHECK_DEFINE(Q_GETOQUOTA);
}

static void
check_niobuf_remote(void)
{
        BLANK_LINE();
        CHECK_STRUCT(niobuf_remote);
        CHECK_MEMBER(niobuf_remote, offset);
        CHECK_MEMBER(niobuf_remote, len);
        CHECK_MEMBER(niobuf_remote, flags);

        CHECK_VALUE(OBD_BRW_READ);
        CHECK_VALUE(OBD_BRW_WRITE);
        CHECK_VALUE(OBD_BRW_SYNC);
        CHECK_VALUE(OBD_BRW_FROM_GRANT);
        CHECK_VALUE(OBD_BRW_NOQUOTA);
}

static void
check_ost_body(void)
{
        BLANK_LINE();
        CHECK_STRUCT(ost_body);
        CHECK_MEMBER(ost_body, oa);
}

static void
check_ll_fid(void)
{
        BLANK_LINE();
        CHECK_STRUCT(ll_fid);
        CHECK_MEMBER(ll_fid, id);
        CHECK_MEMBER(ll_fid, generation);
        CHECK_MEMBER(ll_fid, f_type);
}

static void
check_mds_status_req(void)
{
        BLANK_LINE();
        CHECK_STRUCT(mds_status_req);
        CHECK_MEMBER(mds_status_req, flags);