wirecheck.c

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

        BLANK_LINE();
        CHECK_STRUCT(llog_log_hdr);
        CHECK_MEMBER(llog_log_hdr, llh_hdr);
        CHECK_MEMBER(llog_log_hdr, llh_timestamp);
        CHECK_MEMBER(llog_log_hdr, llh_count);
        CHECK_MEMBER(llog_log_hdr, llh_bitmap_offset);
        CHECK_MEMBER(llog_log_hdr, llh_size);
        CHECK_MEMBER(llog_log_hdr, llh_flags);
        CHECK_MEMBER(llog_log_hdr, llh_cat_idx);
        CHECK_MEMBER(llog_log_hdr, llh_tgtuuid);
        CHECK_MEMBER(llog_log_hdr, llh_reserved);
        CHECK_MEMBER(llog_log_hdr, llh_bitmap);
        CHECK_MEMBER(llog_log_hdr, llh_tail);
}

static void
check_llog_cookie(void)
{
        BLANK_LINE();
        CHECK_STRUCT(llog_cookie);
        CHECK_MEMBER(llog_cookie, lgc_lgl);
        CHECK_MEMBER(llog_cookie, lgc_subsys);
        CHECK_MEMBER(llog_cookie, lgc_index);
        CHECK_MEMBER(llog_cookie, lgc_padding);
}

static void
check_llogd_body(void)
{
        BLANK_LINE();
        CHECK_STRUCT(llogd_body);
        CHECK_MEMBER(llogd_body, lgd_logid);
        CHECK_MEMBER(llogd_body, lgd_ctxt_idx);
        CHECK_MEMBER(llogd_body, lgd_llh_flags);
        CHECK_MEMBER(llogd_body, lgd_index);
        CHECK_MEMBER(llogd_body, lgd_saved_index);
        CHECK_MEMBER(llogd_body, lgd_len);
        CHECK_MEMBER(llogd_body, lgd_cur_offset);

        CHECK_CVALUE(LLOG_ORIGIN_HANDLE_CREATE);
        CHECK_CVALUE(LLOG_ORIGIN_HANDLE_NEXT_BLOCK);
        CHECK_CVALUE(LLOG_ORIGIN_HANDLE_READ_HEADER);
        CHECK_CVALUE(LLOG_ORIGIN_HANDLE_WRITE_REC);
        CHECK_CVALUE(LLOG_ORIGIN_HANDLE_CLOSE);
        CHECK_CVALUE(LLOG_ORIGIN_CONNECT);
        CHECK_CVALUE(LLOG_CATINFO);
        CHECK_CVALUE(LLOG_ORIGIN_HANDLE_PREV_BLOCK);
        CHECK_CVALUE(LLOG_ORIGIN_HANDLE_DESTROY);
}

static void
check_llogd_conn_body(void)
{
        BLANK_LINE();
        CHECK_STRUCT(llogd_conn_body);
        CHECK_MEMBER(llogd_conn_body, lgdc_gen);
        CHECK_MEMBER(llogd_conn_body, lgdc_logid);
        CHECK_MEMBER(llogd_conn_body, lgdc_ctxt_idx);
}

static void
check_mds_extent_desc(void)
{
        BLANK_LINE();
        CHECK_STRUCT(mds_extent_desc);
        CHECK_MEMBER(mds_extent_desc, med_start);
        CHECK_MEMBER(mds_extent_desc, med_len);
        CHECK_MEMBER(mds_extent_desc, med_lmm);
}

static void
check_llog_array_rec(void)
{
        BLANK_LINE();
        CHECK_STRUCT(llog_array_rec);
        CHECK_MEMBER(llog_array_rec, lmr_hdr);
        CHECK_MEMBER(llog_array_rec, lmr_med);
        CHECK_MEMBER(llog_array_rec, lmr_tail);
}

static void
check_qunit_data(void)
{
        BLANK_LINE();
        CHECK_STRUCT(qunit_data);
        CHECK_MEMBER(qunit_data, qd_id);
        CHECK_MEMBER(qunit_data, qd_flags);
        CHECK_MEMBER(qunit_data, qd_count);
        CHECK_MEMBER(qunit_data, qd_qunit);
        CHECK_MEMBER(qunit_data, padding );
}

static void
check_qunit_data_old2(void)
{
        BLANK_LINE();
        CHECK_STRUCT(qunit_data_old2);
        CHECK_MEMBER(qunit_data_old2, qd_id);
        CHECK_MEMBER(qunit_data_old2, qd_flags);
        CHECK_MEMBER(qunit_data_old2, qd_count);
}

static void
check_qunit_data_old(void)
{
        BLANK_LINE();
        CHECK_STRUCT(qunit_data_old);
        CHECK_MEMBER(qunit_data_old, qd_id);
        CHECK_MEMBER(qunit_data_old, qd_type);
        CHECK_MEMBER(qunit_data_old, qd_count);
        CHECK_MEMBER(qunit_data_old, qd_isblk);
}

static void
check_mgs_target_info(void)
{
        BLANK_LINE();
        CHECK_STRUCT(mgs_target_info);
        CHECK_MEMBER(mgs_target_info, mti_lustre_ver);
        CHECK_MEMBER(mgs_target_info, mti_stripe_index);
        CHECK_MEMBER(mgs_target_info, mti_config_ver);
        CHECK_MEMBER(mgs_target_info, mti_flags);
        CHECK_MEMBER(mgs_target_info, mti_nid_count);
        CHECK_MEMBER(mgs_target_info, mti_fsname);
        CHECK_MEMBER(mgs_target_info, mti_svname);
        CHECK_MEMBER(mgs_target_info, mti_uuid);
        CHECK_MEMBER(mgs_target_info, mti_nids);
        CHECK_MEMBER(mgs_target_info, mti_params);
}

static void
check_lustre_disk_data(void)
{
        BLANK_LINE();
        CHECK_STRUCT(lustre_disk_data);
        CHECK_MEMBER(lustre_disk_data, ldd_magic);
        CHECK_MEMBER(lustre_disk_data, ldd_feature_compat);
        CHECK_MEMBER(lustre_disk_data, ldd_feature_rocompat);
        CHECK_MEMBER(lustre_disk_data, ldd_feature_incompat);
        CHECK_MEMBER(lustre_disk_data, ldd_config_ver);
        CHECK_MEMBER(lustre_disk_data, ldd_flags);
        CHECK_MEMBER(lustre_disk_data, ldd_svindex);
        CHECK_MEMBER(lustre_disk_data, ldd_mount_type);
        CHECK_MEMBER(lustre_disk_data, ldd_fsname);
        CHECK_MEMBER(lustre_disk_data, ldd_svname);
        CHECK_MEMBER(lustre_disk_data, ldd_uuid);
        CHECK_MEMBER(lustre_disk_data, ldd_userdata);
        CHECK_MEMBER(lustre_disk_data, ldd_mount_opts);
        CHECK_MEMBER(lustre_disk_data, ldd_params);
}

static void
check_posix_acl_xattr_entry(void)
{
        BLANK_LINE();
        CHECK_STRUCT_TYPEDEF(posix_acl_xattr_entry);
        CHECK_MEMBER_TYPEDEF(posix_acl_xattr_entry, e_tag);
        CHECK_MEMBER_TYPEDEF(posix_acl_xattr_entry, e_perm);
        CHECK_MEMBER_TYPEDEF(posix_acl_xattr_entry, e_id);
}

static void
check_posix_acl_xattr_header(void)
{
        BLANK_LINE();
        CHECK_STRUCT_TYPEDEF(posix_acl_xattr_header);
        CHECK_MEMBER_TYPEDEF(posix_acl_xattr_header, a_version);
        CHECK_MEMBER_TYPEDEF(posix_acl_xattr_header, a_entries);
}

static void
check_quota_adjust_qunit(void)
{
        BLANK_LINE();
        CHECK_STRUCT(quota_adjust_qunit);
        CHECK_MEMBER(quota_adjust_qunit, qaq_flags);
        CHECK_MEMBER(quota_adjust_qunit, qaq_id);
        CHECK_MEMBER(quota_adjust_qunit, qaq_bunit_sz);
        CHECK_MEMBER(quota_adjust_qunit, qaq_iunit_sz);
}

static void
system_string (char *cmdline, char *str, int len)
{
        int   fds[2];
        int   rc;
        pid_t pid;

        rc = pipe(fds);
        if (rc != 0)
                abort();

        pid = fork();
        if (pid == 0) {
                /* child */
                int   fd = fileno(stdout);

                rc = dup2(fds[1], fd);
                if (rc != fd)
                        abort();

                exit(system(cmdline));
                /* notreached */
        } else if ((int)pid < 0) {
                abort();
        } else {
                FILE *f = fdopen(fds[0], "r");

                if (f == NULL)
                        abort();

                close(fds[1]);

                if (fgets(str, len, f) == NULL)
                        abort();

                if (waitpid(pid, &rc, 0) != pid)
                        abort();

                if (!WIFEXITED(rc) || WEXITSTATUS(rc) != 0)
                        abort();

                if (strnlen(str, len) == len)
                        str[len - 1] = 0;

                if (str[strlen(str) - 1] == '\n')
                        str[strlen(str) - 1] = 0;

                fclose(f);
        }
}

int
main(int argc, char **argv)
{
        char unameinfo[80];
        char gccinfo[80];

        system_string("uname -a", unameinfo, sizeof(unameinfo));
        system_string(CC " -v 2>&1 | tail -1", gccinfo, sizeof(gccinfo));

        printf ("void lustre_assert_wire_constants(void)\n"
                "{\n"
                "        /* Wire protocol assertions generated by 'wirecheck'\n"
                "         * (make -C lustre/utils newwiretest)\n"
                "         * running on %s\n"
                "         * with %s */\n"
                "\n", unameinfo, gccinfo);

        BLANK_LINE ();

        COMMENT("Constants...");
        CHECK_DEFINE(LUSTRE_MSG_MAGIC_V1);
        CHECK_DEFINE(LUSTRE_MSG_MAGIC_V2);
        CHECK_DEFINE(PTLRPC_MSG_VERSION);
        CHECK_VALUE(MSGHDR_AT_SUPPORT);

        CHECK_VALUE(PTL_RPC_MSG_REQUEST);
        CHECK_VALUE(PTL_RPC_MSG_ERR);
        CHECK_VALUE(PTL_RPC_MSG_REPLY);

        CHECK_VALUE(MSG_LAST_REPLAY);
        CHECK_VALUE(MSG_RESENT);
        CHECK_VALUE(MSG_REPLAY);

        CHECK_VALUE(MSG_CONNECT_RECOVERING);
        CHECK_VALUE(MSG_CONNECT_RECONNECT);
        CHECK_VALUE(MSG_CONNECT_REPLAYABLE);

        CHECK_VALUE(OST_REPLY);
        CHECK_VALUE(OST_GETATTR);
        CHECK_VALUE(OST_SETATTR);
        CHECK_VALUE(OST_READ);
        CHECK_VALUE(OST_WRITE);
        CHECK_VALUE(OST_CREATE);
        CHECK_VALUE(OST_DESTROY);
        CHECK_VALUE(OST_GET_INFO);
        CHECK_VALUE(OST_CONNECT);
        CHECK_VALUE(OST_DISCONNECT);
        CHECK_VALUE(OST_PUNCH);
        CHECK_VALUE(OST_OPEN);
        CHECK_VALUE(OST_CLOSE);
        CHECK_VALUE(OST_STATFS);
        CHECK_VALUE(OST_SYNC);
        CHECK_VALUE(OST_QUOTACHECK);
        CHECK_VALUE(OST_QUOTACTL);
        CHECK_VALUE(OST_QUOTA_ADJUST_QUNIT);
        CHECK_VALUE(OST_LAST_OPC);

        CHECK_DEFINE(OBD_OBJECT_EOF);

        CHECK_VALUE(MDS_GETATTR);
        CHECK_VALUE(MDS_GETATTR_NAME);
        CHECK_VALUE(MDS_CLOSE);
        CHECK_VALUE(MDS_REINT);
        CHECK_VALUE(MDS_READPAGE);
        CHECK_VALUE(MDS_CONNECT);
        CHECK_VALUE(MDS_DISCONNECT);
        CHECK_VALUE(MDS_GETSTATUS);
        CHECK_VALUE(MDS_STATFS);
        CHECK_VALUE(MDS_PIN);
        CHECK_VALUE(MDS_UNPIN);
        CHECK_VALUE(MDS_SYNC);
        CHECK_VALUE(MDS_DONE_WRITING);
        CHECK_VALUE(MDS_SET_INFO);
        CHECK_VALUE(MDS_QUOTACHECK);
        CHECK_VALUE(MDS_QUOTACTL);
        CHECK_VALUE(MDS_LAST_OPC);

        CHECK_VALUE(REINT_SETATTR);
        CHECK_VALUE(REINT_CREATE);
        CHECK_VALUE(REINT_LINK);
        CHECK_VALUE(REINT_UNLINK);
        CHECK_VALUE(REINT_RENAME);
        CHECK_VALUE(REINT_OPEN);
        CHECK_VALUE(REINT_MAX);

        CHECK_VALUE(MGS_CONNECT);
        CHECK_VALUE(MGS_DISCONNECT);
        CHECK_VALUE(MGS_EXCEPTION);
        CHECK_VALUE(MGS_TARGET_REG);
        CHECK_VALUE(MGS_TARGET_DEL);
        CHECK_VALUE(MGS_SET_INFO);

        CHECK_VALUE(DISP_IT_EXECD);
        CHECK_VALUE(DISP_LOOKUP_EXECD);
        CHECK_VALUE(DISP_LOOKUP_NEG);
        CHECK_VALUE(DISP_LOOKUP_POS);
        CHECK_VALUE(DISP_OPEN_CREATE);
        CHECK_VALUE(DISP_OPEN_OPEN);

        CHECK_VALUE(MDS_STATUS_CONN);
        CHECK_VALUE(MDS_STATUS_LOV);

        CHECK_VALUE(LDLM_ENQUEUE);
        CHECK_VALUE(LDLM_CONVERT);
        CHECK_VALUE(LDLM_CANCEL);
        CHECK_VALUE(LDLM_BL_CALLBACK);
        CHECK_VALUE(LDLM_CP_CALLBACK);
        CHECK_VALUE(LDLM_GL_CALLBACK);
        CHECK_VALUE(LDLM_LAST_OPC);

        CHECK_VALUE(LCK_EX);
        CHECK_VALUE(LCK_PW);
        CHECK_VALUE(LCK_PR);
        CHECK_VALUE(LCK_CW);
        CHECK_VALUE(LCK_CR);
        CHECK_VALUE(LCK_NL);
        CHECK_VALUE(LCK_GROUP);
        CHECK_VALUE(LCK_MAXMODE);
        CHECK_VALUE(LCK_MODE_NUM);

        CHECK_CVALUE(LDLM_PLAIN);
        CHECK_CVALUE(LDLM_EXTENT);
        CHECK_CVALUE(LDLM_FLOCK);
        CHECK_CVALUE(LDLM_IBITS);

        CHECK_VALUE(OBD_PING);
        CHECK_VALUE(OBD_LOG_CANCEL);
        CHECK_VALUE(OBD_QC_CALLBACK);
        CHECK_VALUE(OBD_LAST_OPC);

        CHECK_VALUE(QUOTA_DQACQ);
        CHECK_VALUE(QUOTA_DQREL);

        CHECK_VALUE(MGS_CONNECT);
        CHECK_VALUE(MGS_DISCONNECT);
        CHECK_VALUE(MGS_EXCEPTION);   
        CHECK_VALUE(MGS_TARGET_REG);
        CHECK_VALUE(MGS_TARGET_DEL);
        CHECK_VALUE(MGS_SET_INFO);

        COMMENT("Sizes and Offsets");
        BLANK_LINE();
        CHECK_STRUCT(obd_uuid);
        check_lustre_handle();
        check_lustre_msg_v1();
        check_lustre_msg_v2();
        printf("        LASSERT(offsetof(struct lustre_msg_v1, lm_magic) == "
               "offsetof(struct lustre_msg_v2, lm_magic));\n");
        check_ptlrpc_body();
        check_obd_connect_data();
        check_obdo();
        check_lov_mds_md_v1();
        check_lov_mds_md_join();
        check_obd_statfs();
        check_obd_ioobj();
        check_obd_quotactl();
        check_niobuf_remote();
        check_ost_body();
        check_ll_fid();
        check_mds_status_req();
        check_mds_body();
        check_mds_rec_setattr();
        check_mds_rec_create();
        check_mds_rec_link();
        check_mds_rec_unlink();
        check_mds_rec_rename();
        check_mds_rec_join();
        check_lov_desc();
        check_ldlm_res_id();
        check_ldlm_extent();
        check_ldlm_flock();
        check_ldlm_inodebits();
        check_ldlm_intent();
        check_ldlm_resource_desc();
        check_ldlm_lock_desc();
        check_ldlm_request();
        check_ldlm_reply();
        check_ldlm_lvb();
        check_llog_logid();
        check_llog_catid();
        check_llog_rec_hdr();
        check_llog_rec_tail();
        check_llog_logid_rec();
        check_llog_create_rec();
        check_llog_orphan_rec();
        check_llog_unlink_rec();
        check_llog_setattr_rec();
        check_llog_size_change_rec();
        check_llog_gen();
        check_llog_gen_rec();
        check_llog_log_hdr();
        check_llog_cookie();
        check_llogd_body();
        check_llogd_conn_body();
        check_llog_array_rec();
        check_mds_extent_desc();
        check_qunit_data();
        check_qunit_data_old2();
        check_qunit_data_old();
        check_quota_adjust_qunit();
        check_mgs_target_info();
        check_lustre_disk_data();
        printf("#ifdef LIBLUSTRE_POSIX_ACL\n");
#ifndef LIBLUSTRE_POSIX_ACL
#error build generator without LIBLUSTRE_POSIX_ACL defined - produce wrong check code.
#endif
        check_posix_acl_xattr_entry();
        check_posix_acl_xattr_header();
        printf("#endif\n");


        printf("}\n\n");

        return(0);
}