// ***************************************************************************** // * * // * Function: TokenKeyContents::populate * // * * // * Populates fields of a token key using information from current * // * process (node, PID, etc.) and encoding (base64). * // * * // ***************************************************************************** void TokenKeyContents::populate() { msg_mon_get_my_process_name(u.token.processName, MS_MON_MAX_PROCESS_NAME); msg_mon_get_process_info( NULL, &u.token.nodeId, &u.token.processId ); ID[0] = USERTOKEN_ID_1; ID[1] = USERTOKEN_ID_2; // Generate Random bytes srandom ((unsigned)time(NULL)); for (int i=0; i < sizeof(u.token.rand); i++) u.token.rand[i] = (char)(random() & 0xFF); // Base 64 encoding char buf[sizeof(u)]= {0}; base64((const char *)&u.token, sizeof(u.token), buf, true); memcpy(u.encoded.b64, buf, sizeof(u.encoded.b64)); u.encoded.zero='\0'; }
// ***************************************************************************** // * * // * Function: TokenKey::verify * // * * // * Determines if a token key is valid. * // * * // ***************************************************************************** // * * // * Parameters: * // * * // * <tokenKey> TokenKey & In * // * is the token key to be validated against. * // * * // ***************************************************************************** bool TokenKey::verify(TokenKey &tokenKey) const { // Check to see that the process name matches with the node ID and process IDd int retval = XZFIL_ERR_OK; int nid, pid, decoded_nid, decoded_pid; if (!(*this == tokenKey)) return false; // decode the token to get the process info TokenKeyContents decoded_token; base64((const char *) self.u.encoded.b64,sizeof(self.u.encoded.b64), (char *) decoded_token.u.encoded.b64,false); retval = msg_mon_get_process_info(decoded_token.u.token.processName,&nid,&pid); decoded_nid = decoded_token.u.token.nodeId; decoded_pid = decoded_token.u.token.processId; if ((retval == XZFIL_ERR_OK) && (nid == decoded_nid) && (pid == decoded_pid)) return true; return false; }
void start_backup(int nid) { int ferr; nid = nid; // no-warn ferr = msg_mon_get_process_info(NULL, &nid, &gpeer_pid); TEST_CHK_FEOK(ferr); gpeer_nid = 1 - nid; gpeer_pid = -1; myprintf("starting backup process with open.\n"); ferr = msg_mon_start_process(gprog, // prog gname, // name NULL, // ret name gargc, gargp, TPT_REF(gpeer_phandle), 0, // open &gpeer_oid, MS_ProcessType_Generic, // type 0, // priority 0, // debug 1, // backup &gpeer_nid, // nid &gpeer_pid, // pid NULL, // infile NULL); // outfile TEST_CHK_FEOK(ferr); ferr = msg_mon_open_process_backup(gname, TPT_REF(gpeer_phandle), &gpeer_oid); TEST_CHK_FEOK(ferr); myprintf("after start_backup - peer p-id=%d/%d\n", gpeer_nid, gpeer_pid); mypairinfo(true); }
int main(int argc, char *argv[]) { int ferr; int nid; int pid; MS_Mon_Transid_Type transid; msfs_util_init(&argc, &argv, msg_debug_hook); util_test_start(true); ferr = msg_mon_process_startup(true); // system messages TEST_CHK_FEOK(ferr); ferr = msg_mon_get_process_info((char *) "", &nid, &pid); TEST_CHK_FEOK(ferr); ferr = msg_mon_trans_register_tmlib(tm_inherit_tx); TEST_CHK_FEOK(ferr); TRANSID_SET_SEQ(transid, 1); ferr = msg_mon_trans_enlist(nid, pid, transid); TEST_CHK_FEOK(ferr); ferr = msg_mon_trans_delist(nid, pid, transid); TEST_CHK_FEOK(ferr); ferr = msg_mon_trans_end(nid, pid, transid); TEST_CHK_FEOK(ferr); ferr = msg_mon_process_shutdown(); TEST_CHK_FEOK(ferr); util_test_finish(true); printf("if there were no asserts, all is well\n"); return 0; }
void pp_start_backup(int nid) { int ferr; if (gshutdown) { if (gverbosepp) pp_printf("NOT starting backup process - shutdown.\n"); return; } nid = nid; // no-warn ferr = msg_mon_get_process_info(NULL, &nid, &gpeer_pid); TEST_CHK_FEOK(ferr); for (;;) { gpeer_nid = -1; if (gnid == 1) gpeer_nid = 2; else gpeer_nid = 1; gpeer_pid = -1; if (gverbosepp) pp_printf("starting backup process with open, nid=%d.\n", gpeer_nid); ferr = msg_mon_start_process(gprog, // prog gname, // name NULL, // ret name gargc, gargp, TPT_REF(gpeer_phandle), 0, // open &gpeer_oid, MS_ProcessType_TSE, // type 0, // priority 0, // debug 1, // backup &gpeer_nid, // nid &gpeer_pid, // pid NULL, // infile NULL); // outfile if (ferr == XZFIL_ERR_OK) break; printf("backup did not start error=%d\n", ferr); sleep(1); } TEST_CHK_FEOK(ferr); ferr = msg_mon_open_process_backup(gname, TPT_REF(gpeer_phandle), &gpeer_oid); TEST_CHK_FEOK(ferr); if (gverbosepp) pp_printf("after start_backup - peer p-id=%d/%d\n", gpeer_nid, gpeer_pid); pp_pairinfo(true); }
void getTMLoggingHeaderInfo(posix_sqlog_severity_t severity, logLevel &ll_severity, char *processName, int processNameLen, int &my_nid, int &my_pid) { char my_name[MS_MON_MAX_PROCESS_NAME+1]; int error; error = msg_mon_get_my_process_name( my_name, sizeof(my_name) ); if (error == 0) { error = msg_mon_get_process_info( my_name, &my_nid, &my_pid ); if (error != 0) { my_nid = -1; my_pid = -1; } } else strcpy(my_name, "UNKNOWN"); int len = strlen(my_name); if (len < processNameLen) len = processNameLen-1; strncpy(processName, my_name, len); processName[len] = '\0'; switch (severity) { case SQ_LOG_EMERG: ll_severity = LL_FATAL; break; case SQ_LOG_ALERT: ll_severity = LL_WARN; break; case SQ_LOG_CRIT: ll_severity = LL_FATAL; break; case SQ_LOG_ERR: ll_severity = LL_ERROR; break; case SQ_LOG_WARNING: ll_severity = LL_WARN; break; case SQ_LOG_NOTICE: ll_severity = LL_INFO; break; case SQ_LOG_INFO: ll_severity = LL_INFO; break; case SQ_LOG_DEBUG: ll_severity = LL_DEBUG; break; default: ll_severity = LL_INFO; break; } return; }
/* * Registers for process death messages for the specified process name * This will be used by the mxosrvrs and mxocfg process'es to register * for mxoas death messages, instead of polling every 15 seconds to * check if the mxoas process is still around */ bool RegisterProcessDeathMessage(char *processName) { int ferr; // file system errors int nid; // node id int pid; // process id ferr = msg_mon_get_process_info(processName,&nid,&pid); if(ferr != XZFIL_ERR_OK || nid == -1 || pid == -1) return false; ferr = msg_mon_register_death_notification(nid, pid); if(ferr != XZFIL_ERR_OK) return false; } /* RegisterProcessDeathMessage() */
// ***************************************************************************** // * * // * Function: MyProcInfo * // * * // * Get the process info from monitor * // ***************************************************************************** // * * // * Parameters: * // * <proc_info> ProcInfo * In * // * * // * Returns: * // * * // * None * // * * // ***************************************************************************** void MyProcInfo(ProcInfo *proc_info) // Address of struct to return results { short res; int nid, pid; MS_Mon_Node_Info_Type node_info; // char *nodename; // Get process info res = msg_mon_get_process_info( NULL, &nid, &pid ); proc_info->nid = nid; proc_info->pid = pid; // res = msg_mon_get_node_info_detail(nid, &node_info); // nodename = strtok(node_info.node[0].node_name, "."); }
// ---------------------------------------------------------- // start_adp // Purpose - initialize the module and vol name for the ADP // ---------------------------------------------------------- int TM_Audit::initialize_adp() { TMTrace(2, ("TM_Audit::initialize_adp: ENTRY\n")); char la_name[8]; int32 lv_nid; int32 lv_pid; if (!iv_initialized) { msg_mon_get_process_info (NULL, &lv_nid, &lv_pid); sprintf(la_name, "0DTM%d", lv_nid); memcpy (ia_vol_name, la_name, strlen(la_name)); sprintf (ia_vol_name2, la_name, strlen(la_name)); iv_mutex.lock(); iv_mutex.unlock(); } TMTrace(2, ("TM_Audit::initialize_adp: EXIT, name %s\n", ia_vol_name2)); return TM_OK; }
static int do_cb(JNIEnv *j_env, char **snames, int count) { jclass cb_class; jmethodID id_cb; int inx; int nid; int pid; jstring *str; jobjectArray str_array; jclass str_class; cb_class = j_env->GetObjectClass(j_cb); assert(cb_class != 0); id_cb = j_env->GetMethodID(cb_class, "cb", "(II[Ljava/lang/String;)I"); assert(id_cb != 0); str_class = j_env->FindClass("java/lang/String"); assert(str_class != 0); str_array = j_env->NewObjectArray(count, str_class, NULL); assert(str_array != 0); str = new jstring[count]; for (inx = 0; inx < count; inx++) { str[inx] = j_env->NewStringUTF(snames[inx]); assert(str[inx] != 0); j_env->SetObjectArrayElement(str_array, inx, str[inx]); } msg_mon_get_process_info(NULL, &nid, &pid); j_env->CallIntMethod(j_cb, id_cb, nid, pid, str_array); for (inx = 0; inx < count; inx++) { j_env->DeleteLocalRef(str[inx]); } j_env->DeleteLocalRef(str_array); return 0; }
static int do_cb(JNIEnv *pp_j_env, char **ppp_snames, int pv_count) { jstring *lp_str; jclass lv_cb_class; jmethodID lv_id_cb; int lv_inx; int lv_nid; int lv_pid; jobjectArray lv_str_array; jclass lv_str_class; lv_cb_class = pp_j_env->GetObjectClass(gv_j_cb); assert(lv_cb_class != 0); lv_id_cb = pp_j_env->GetMethodID(lv_cb_class, "cb", "(II[Ljava/lang/String;)I"); assert(lv_id_cb != 0); lv_str_class = pp_j_env->FindClass("java/lang/String"); assert(lv_str_class != 0); lv_str_array = pp_j_env->NewObjectArray(pv_count, lv_str_class, NULL); assert(lv_str_array != 0); lp_str = new jstring[pv_count]; for (lv_inx = 0; lv_inx < pv_count; lv_inx++) { lp_str[lv_inx] = pp_j_env->NewStringUTF(ppp_snames[lv_inx]); assert(lp_str[lv_inx] != 0); pp_j_env->SetObjectArrayElement(lv_str_array, lv_inx, lp_str[lv_inx]); } msg_mon_get_process_info(NULL, &lv_nid, &lv_pid); pp_j_env->CallIntMethod(gv_j_cb, lv_id_cb, lv_nid, lv_pid, lv_str_array); for (lv_inx = 0; lv_inx < pv_count; lv_inx++) { pp_j_env->DeleteLocalRef(lp_str[lv_inx]); } pp_j_env->DeleteLocalRef(lv_str_array); return 0; }
int main(int argc, char *argv[]) { char *args[4]; bool attach = false; bool chook = false; bool client = false; bool clientd = false; int cli_nid = -1; int cli_pid = -1; const char *cname = "$cli"; int count; int ferr; int inx; int len; int lerr; int loop = 10; TPT_DECL (mphandle); char *mphandlec = (char *) &mphandle; TPT_DECL_INT (mphandlei); int msgid; int my_mon_nid; int my_mon_pid; int my_mon_ptype; int my_mon_zid; int my_os_pid; long my_os_tid; int my_compid; int my_pnid; int my_segid; int nid; int oid; TPT_DECL (phandle); int pid; char *pname = NULL; int ptype; RT results; int scollpid = -1; int scompid = -1; int send_len; bool shook = false; const char *sname = "$srv"; bool sonar = false; MS_SRE sre; int srv_nid = -1; int srv_pid = -1; MS_Mon_Monitor_Stats_Type stats; int status; long t_elapsed; struct timeval t_start; struct timeval t_stop; int tm_seq; bool val_bool; int val_int; const char *val_str; int winx; pid_t wpid; TAD zargs[] = { { "-attach", TA_Bool, TA_NOMAX, &attach }, { "-chook", TA_Bool, TA_NOMAX, &chook }, { "-client", TA_Bool, TA_NOMAX, &client }, { "-clientd", TA_Bool, TA_NOMAX, &clientd }, { "-cname", TA_Str, TA_NOMAX, &cname }, { "-loop", TA_Int, TA_NOMAX, &loop }, { "-name", TA_Str, TA_NOMAX, &pname }, { "-server", TA_Ign, TA_NOMAX, NULL }, { "-shook", TA_Bool, TA_NOMAX, &shook }, { "-sname", TA_Str, TA_NOMAX, &sname }, { "-sonar", TA_Bool, TA_NOMAX, &sonar }, { "", TA_End, TA_NOMAX, NULL } }; #ifdef DEBUG_ENV env = environ; while (*env != NULL) { printf("env=%s\n", *env); env++; } #endif arg_proc_args(zargs, false, argc, argv); if (client && chook) test_debug_hook("c", "c"); if (!client && shook) test_debug_hook("s", "s"); setenv("TESTKEYBOOL", "1", 1); setenv("TESTKEYINT", "44", 1); setenv("TESTKEYSTR", "TESTVALSTR", 1); // // test msg_getenv* before msg_init // val_bool = true; msg_getenv_bool("TESTKEYBOOL", &val_bool); assert(val_bool); val_bool = false; msg_getenv_bool("TESTKEYBOOL", &val_bool); assert(!val_bool); val_int = 0; msg_getenv_int("TESTKEYINT", &val_int); assert(val_int == 0); val_int = 1; msg_getenv_int("TESTKEYINT", &val_int); assert(val_int == 1); val_str = (const char *) 1; val_str = msg_getenv_str("TESTKEYSTR"); assert(val_str == NULL); if (attach) msfs_util_init_attach(&argc, &argv, msg_debug_hook, false, pname); else msfs_util_init(&argc, &argv, msg_debug_hook); arg_proc_args(zargs, false, argc, argv); util_time_timer_start(&t_start); util_test_start(client); ferr = msg_mon_process_startup(!client); // system messages? TEST_CHK_FEOK(ferr); // // test msg_getenv* after msg_init // msg_getenv_bool("TESTKEYBOOL", &val_bool); assert(val_bool); msg_getenv_int("TESTKEYINT", &val_int); assert(val_int == 44); val_str = msg_getenv_str("TESTKEYSTR"); assert(strcmp(val_str, "TESTVALSTR") == 0); // process-wait for server/shell ferr = msfs_util_wait_process_count(MS_ProcessType_Generic, 2, NULL, false); TEST_CHK_FEOK(ferr); // process-wait for client ferr = msfs_util_wait_process_count(MS_ProcessType_TSE, 1, NULL, false); TEST_CHK_FEOK(ferr); if (client) { if (sonar) { scollpid = fork(); if (scollpid == 0) { // child args[0] = (char *) "sonarcollector"; args[1] = (char *) "-i"; // sampling interval // cast args[2] = (char *) "1"; // cast args[3] = NULL; lerr = execvp(args[0], args); assert(lerr == 0); } } ferr = msg_mon_open_process((char *) sname, // name TPT_REF(phandle), &oid); TEST_CHK_FEOK(ferr); } // this phandle check assumed a particular data structure ferr = msg_mon_get_my_process_name(my_name, BUFSIZ); util_check("msg_mon_get_my_process_name", ferr); ferr = XPROCESSHANDLE_GETMINE_(TPT_REF(mphandle)); util_check("XPROCESSHANDLE_GETMINE_", ferr); TPT_COPY_INT(mphandlei, mphandle); assert((mphandlei[0] & 0xf0) == 0x20); // named assert(strncmp(my_name, &mphandlec[4], 32) == 0); printf("phandle=%x.%x.%x.%x.%x\n", mphandlei[0], mphandlei[1], mphandlei[2], mphandlei[3], mphandlei[4]); ferr = msg_mon_get_my_info(&my_mon_nid, &my_mon_pid, my_mon_name, BUFSIZ, &my_mon_ptype, &my_mon_zid, &my_os_pid, &my_os_tid); util_check("msg_mon_get_my_info", ferr); printf("nid=%d, pid=%d, name=%s, ptype=%d, zid=%d, os-pid=%d, os-tid=%ld\n", my_mon_nid, my_mon_pid, my_mon_name, my_mon_ptype, my_mon_zid, my_os_pid, my_os_tid); my_mon_nid = -1; my_mon_pid = -1; my_mon_ptype = -1; my_mon_zid = -1; my_os_pid = -1; my_os_tid = -1; my_compid = -1; my_pnid = -1; ferr = msg_mon_get_my_info3(&my_mon_nid, &my_mon_pid, my_mon_name3, BUFSIZ, &my_mon_ptype, &my_mon_zid, &my_os_pid, &my_os_tid, &my_compid, &my_pnid); util_check("msg_mon_get_my_info3", ferr); printf("nid=%d, pid=%d, name=%s, ptype=%d, zid=%d, os-pid=%d, os-tid=%ld, compid=%d, pnid=%d\n", my_mon_nid, my_mon_pid, my_mon_name3, my_mon_ptype, my_mon_zid, my_os_pid, my_os_tid, my_compid, my_pnid); ferr = msg_mon_get_my_segid(&my_segid); util_check("msg_mon_get_my_segid", ferr); printf("segid=%d\n", my_segid); ferr = msg_mon_get_monitor_stats(&stats); util_check("msg_mon_get_monitor_stats", ferr); printf("avail_min=%d, acquired_max=%d, buf_misses=%d\n", stats.avail_min, stats.acquired_max, stats.buf_misses); util_gethostname(my_name, sizeof(my_name)); msg_mon_enable_mon_messages(true); ferr = msg_mon_get_tm_seq(&tm_seq); util_check("msg_mon_get_tm_seq", ferr); printf("tm_seq=%d\n", tm_seq); if (client) { ferr = msg_mon_get_process_info_type(MS_ProcessType_TSE, &count, 0, NULL); TEST_CHK_FEOK(ferr); if (!attach) assert(count == 1); ferr = msg_mon_get_process_info_type(MS_ProcessType_TSE, &count, 1, info); TEST_CHK_FEOK(ferr); if (!attach) assert(count == 1); } for (inx = 0; inx < loop; inx++) { if (client) { sprintf(send_buffer, "hello, greetings from %s, inx=%d", my_name, inx); send_len = (int) strlen(send_buffer) + 1; ferr = XMSG_LINK_(TPT_REF(phandle), // phandle &msgid, // msgid send_buffer2, // reqctrl (ushort) (inx & 1), // reqctrlsize recv_buffer3, // replyctrl 1, // replyctrlmax send_buffer, // reqdata (ushort) send_len, // reqdatasize recv_buffer, // replydata BUFSIZ, // replydatamax 0, // linkertag (short) (inx+1), // pri 0, // xmitclass 0); // linkopts util_check("XMSG_LINK_", ferr); ferr = XMSG_BREAK_(msgid, results.u.s, TPT_REF(phandle)); util_check("XMSG_BREAK_", ferr); assert(results.u.t.ctrl_size == (uint) (inx & 1)); assert(results.u.t.data_size > (strlen(send_buffer) + 14)); assert(results.u.t.errm == RT_DATA_RCVD); // data printf("%s\n", recv_buffer); } else { do { lerr = XWAIT(LREQ, -1); TEST_CHK_WAITIGNORE(lerr); lerr = XMSG_LISTEN_((short *) &sre, // sre 0, // listenopts 0); // listenertag } while (lerr == XSRETYPE_NOWORK); ferr = XMSG_GETREQINFO_(MSGINFO_NID, sre.sre_msgId, &nid); util_check("XMSG_GETREQINFO_", ferr); ferr = XMSG_GETREQINFO_(MSGINFO_PID, sre.sre_msgId, &pid); util_check("XMSG_GETREQINFO_", ferr); ferr = XMSG_GETREQINFO_(MSGINFO_PTYPE, sre.sre_msgId, &ptype); util_check("XMSG_GETREQINFO_", ferr); if (sre.sre_flags & XSRE_MON) { // mon messages have our nid/pid if (srv_nid < 0) { ferr = msg_mon_get_process_info((char *) "", &srv_nid, &srv_pid); TEST_CHK_FEOK(ferr); } if (!clientd) { assert(nid == srv_nid); assert(pid == srv_pid); } } else { assert(sre.sre_pri == ((inx+1) & 0xffff)); if (cli_nid < 0) { ferr = msg_mon_get_process_info((char *) cname, &cli_nid, &cli_pid); TEST_CHK_FEOK(ferr); } if (!attach) assert(ptype == MS_ProcessType_TSE); assert(nid == cli_nid); assert(pid == cli_pid); } ferr = XMSG_READCTRL_(sre.sre_msgId, // msgid recv_buffer2, // reqctrl 1); // bytecount util_check("XMSG_READCTRL_", ferr); ferr = XMSG_READDATA_(sre.sre_msgId, // msgid recv_buffer, // reqdata BUFSIZ); // bytecount util_check("XMSG_READDATA_", ferr); if (sre.sre_flags & XSRE_MON) { printf("server received mon message\n"); inx--; len = 0; if (clientd) { MS_Mon_Msg *msg = (MS_Mon_Msg *) recv_buffer; if (msg->type == MS_MsgType_Close) inx = loop; } } else { strcat(recv_buffer, "- reply from "); strcat(recv_buffer, my_name); len = (int) strlen(recv_buffer) + 1; } XMSG_REPLY_(sre.sre_msgId, // msgid recv_buffer2, // replyctrl sre.sre_reqCtrlSize, // replyctrlsize recv_buffer, // replydata (ushort) len, // replydatasize 0, // errorclass NULL); // newphandle } } if (sonar) { if (client) { // for some reason [monitor?], one 'sonarcom stop' doesn't stop coll for (winx = 0; winx < 20; winx++) { scompid = fork(); if (scompid == 0) { // child args[0] = (char *) "sonarcom"; args[1] = (char *) "stop"; args[2] = NULL; lerr = execvp(args[0], args); assert(lerr == 0); } wpid = waitpid(scompid, &status, 0); assert(wpid == scompid); wpid = waitpid(scollpid, &status, WNOHANG); if (wpid == scollpid) break; else sleep(1); } assert(wpid == scollpid); ferr = XMSG_LINK_(TPT_REF(phandle), // phandle &msgid, // msgid NULL, // reqctrl 0, // reqctrlsize NULL, // replyctrl 0, // replyctrlmax NULL, // reqdata 0, // reqdatasize NULL, // replydata 0, // replydatamax 0, // linkertag 0, // pri 0, // xmitclass 0); // linkopts TEST_CHK_FEOK(ferr); ferr = XMSG_BREAK_(msgid, results.u.s, TPT_REF(phandle)); TEST_CHK_FEOK(ferr); } else { do { lerr = XWAIT(LREQ, -1); lerr = XMSG_LISTEN_((short *) &sre, // sre 0, // listenopts 0); // listenertag } while (lerr == XSRETYPE_NOWORK); XMSG_REPLY_(sre.sre_msgId, // msgid NULL, // replyctrl 0, // replyctrlsize NULL, // replydata 0, // replydatasize 0, // errorclass NULL); // newphandle } } if (client) { ferr = msg_mon_close_process(TPT_REF(phandle)); TEST_CHK_FEOK(ferr); } else { if (!clientd) { ferr = msg_mon_process_close(); TEST_CHK_FEOK(ferr); } } util_time_timer_stop(&t_stop); t_elapsed = (t_stop.tv_sec * 1000000 + t_stop.tv_usec) - (t_start.tv_sec * 1000000 + t_start.tv_usec); ferr = msg_mon_process_shutdown(); TEST_CHK_FEOK(ferr); util_test_finish(client); if (client) { printf("elapsed time (gettimeofday us)=%ld\n", t_elapsed); } return 0; }
int main(int argc, char *argv[]) { void *buf; _xcc_status cc; unsigned short count_read; unsigned short count_written; unsigned short count_xferred; int ferr; short filenum; short lasterr; int inx; int loop = 10; char my_name[BUFSIZ]; bool nowait = false; int nid; char *p; int pid; char recv_buffer[BUFSIZ]; char send_buffer[BUFSIZ]; SB_Tag_Type tag; short tfilenum; int tm_seq; int timeout = -1; MS_Mon_Transid_Type transid; TAD zargs[] = { { "-client", TA_Bool, TA_NOMAX, &client }, { "-loop", TA_Int, TA_NOMAX, &loop }, { "-nowait", TA_Bool, TA_NOMAX, &nowait }, { "-print", TA_Bool, TA_NOMAX, &print }, { "-server", TA_Ign, TA_NOMAX, NULL }, { "", TA_End, TA_NOMAX, NULL } }; TRANSID_SET_NULL(curr_transid); TRANSID_SET_NULL(exp_trans); ferr = file_init(&argc, &argv); TEST_CHK_FEOK(ferr); msfs_util_init_fs(&argc, &argv, file_debug_hook); arg_proc_args(zargs, false, argc, argv); util_test_start(client); ferr = file_mon_process_startup(!client); // system messages TEST_CHK_FEOK(ferr); util_gethostname(my_name, sizeof(my_name)); ferr = msg_mon_trans_register_tmlib(tmlib); TEST_CHK_FEOK(ferr); ferr = msg_mon_get_process_info(NULL, &nid, &pid); TEST_CHK_FEOK(ferr); if (client) { ferr = XFILE_OPEN_((char *) "$srv", 4, &filenum, 0, 0, nowait ? (short) 1 : (short) 0, 0, 0, 0, 0, NULL); TEST_CHK_FEOK(ferr); for (inx = 0; inx < loop; inx++) { ferr = msg_mon_get_tm_seq(&tm_seq); TEST_CHK_FEOK(ferr); if (inx & 1) cc = XSETMODE(filenum, 117, 1, 0, NULL); // suppress else cc = XSETMODE(filenum, 117, 0, 0, NULL); // normal TEST_CHK_CCEQ(cc); ferr = XFILE_GETINFO_(-1, &lasterr, NULL, 0, NULL, NULL, NULL); assert(lasterr == XZFIL_ERR_OK); sprintf(send_buffer, "hello, greetings from %s, inx=%d, trans=%d", my_name, inx, tm_seq); if (print) printf("client enlist, transid=%d\n", tm_seq); TRANSID_SET_SEQ(transid, tm_seq); trans_set_curr(transid); if ((inx & 1) == 0) { ferr = msg_mon_trans_enlist(nid, pid, transid); TEST_CHK_FEOK(ferr); } if ((inx & 1) == 0) fun_set(TMLIB_FUN_GET_TX, TMLIB_FUN_REINSTATE_TX); else fun_set(-1, -1); trans_set(transid); cc = XWRITEREADX(filenum, send_buffer, (short) (strlen(send_buffer) + 1), BUFSIZ, &count_read, 0); if (nowait) { TEST_CHK_CCEQ(cc); tfilenum = filenum; cc = XAWAITIOX(&tfilenum, &buf, &count_xferred, &tag, timeout, NULL); } TEST_CHK_CCEQ(cc); fun_check(-1); if (print) printf("client end, transid=%d\n", tm_seq); if ((inx & 1) == 0) { ferr = msg_mon_trans_end(nid, pid, transid); TEST_CHK_FEOK(ferr); TRANSID_SET_NULL(transid); trans_set_curr(transid); // no more trans } printf("%s\n", send_buffer); } ferr = XFILE_CLOSE_(filenum, 0); TEST_CHK_FEOK(ferr); } else { ferr = XFILE_OPEN_((char *) "$RECEIVE", 8, &filenum, 0, 0, nowait ? (short) 1 : (short) 0, 1, 1, // no sys msg 0, 0, NULL); TEST_CHK_FEOK(ferr); for (inx = 0; inx < loop; inx++) { if ((inx & 1) == 0) fun_set(TMLIB_FUN_REG_TX, -1); else fun_set(-1, -1); cc = XREADUPDATEX(filenum, recv_buffer, BUFSIZ, &count_read, 0); TEST_CHK_CCEQ(cc); if (nowait) { tfilenum = filenum; cc = XAWAITIOX(&tfilenum, &buf, &count_xferred, &tag, timeout, NULL); TEST_CHK_CCEQ(cc); } if (inx & 1) { TRANSID_SET_NULL(transid); } else { p = &recv_buffer[strlen(recv_buffer)]; while ((p > recv_buffer) && (*p != '=')) p--; if (*p == '=') { p++; sscanf(p, "%d", &tm_seq); TRANSID_SET_SEQ(transid, tm_seq); } else TRANSID_SET_NULL(transid); } if (inx & 1) { MS_Mon_Transid_Type ltransid; TRANSID_SET_NULL(ltransid); trans_set_curr(ltransid); } trans_set(transid); trans_check(curr_transid); fun_check(-1); if ((inx & 1) == 0) fun_set(TMLIB_FUN_CLEAR_TX, -1); else fun_set(-1, -1); strcat(recv_buffer, "- reply from "); strcat(recv_buffer, my_name); count_read = (short) (strlen(recv_buffer) + 1); cc = XREPLYX(recv_buffer, count_read, &count_written, 0, XZFIL_ERR_OK); TEST_CHK_FEOK(ferr); fun_check(-1); } ferr = XFILE_CLOSE_(filenum, 0); TEST_CHK_FEOK(ferr); } ferr = file_mon_process_shutdown(); TEST_CHK_FEOK(ferr); util_test_finish(client); return 0; }
void send_to_eventlog (short evt_num, short EventLogType, char *ComponentName, char *ObjectRef, short nToken, va_list marker) { BOOL found = FALSE; short i,j; int err, tokIdLen, idx; char sqleventBuf[MAX_EVT_BUF_SIZE]; char *TokenPtr; char tmpBuf[MS_MON_MAX_PROCESS_NAME + 64]; size_t szBuf = MAX_EVT_BUF_SIZE; logLevel severity; sqleventBuf[0] = '\0'; string logMsg; logMsg.reserve(MAX_EVT_BUF_SIZE); static char process_name[MS_MON_MAX_PROCESS_NAME]; static int nid, pid; if (process_name[0] == 0) { msg_mon_get_my_process_name(process_name ,MS_MON_MAX_PROCESS_NAME ); msg_mon_get_process_info(process_name, &nid, &pid); } for (i = 0, found = FALSE; eventDataMap[i].eventId != 0L ; i++) { if (eventDataMap[i].eventId == evt_num) { found = TRUE; //sprintf(tmpBuf, "%.30s (%d,%d): %ld ",process_name, nid, pid, getLongEventId(1, SQEVL_NDCS, evt_num, 9)); sprintf(tmpBuf, "Node Number: %d, CPU: %d, PIN:%ld, Process Name:%.30s , , ,", nid, nid, pid, process_name); logMsg.append(tmpBuf); for (j=0;eventDataMap[i].msgPtr[j] !=NULL || j>6 ;j++ ) { logMsg.append(eventDataMap[i].msgPtr[j]); } break; } } if (!found) { stringstream ss("ODBCMXEventMsg::send_to_eventlog: eventDataMap entry not found "); throw(ss.str()) ; } _itoa(EventLogType, tmpBuf, 10); // if (findString("<1>",&idx, logMsg)) // logMsg.replace( logMsg.find("<1>"), 3, tmpBuf ); // if (findString("<2>",&idx, logMsg)) // logMsg.replace( logMsg.find("<2>"), 3, ComponentName ); // if (findString("<3>",&idx, logMsg)) // logMsg.replace( logMsg.find("<3>"), 3, ObjectRef ); for ( i=0,j=4; i<nToken; i++,j++ ) { TokenPtr = va_arg(marker, char *); //errno = strstr(TokenPtr, "4126"); tokIdLen = sprintf(tmpBuf,"<%d>",j); if (!findString(tmpBuf,&idx, logMsg)) logMsg.append( TokenPtr ); else logMsg.replace( idx, tokIdLen, TokenPtr ); } va_end(marker); const char *logMsgStr = logMsg.c_str(); switch (EventLogType) { case EVENTLOG_ERROR_TYPE: severity = LL_ERROR; break; case EVENTLOG_WARNING_TYPE: severity = LL_WARN; break; case EVENTLOG_INFORMATION_TYPE: severity = LL_INFO; break; default: severity = LL_ERROR; } CommonLogger::log(MXOSRVR_COMPONENT, severity, logMsgStr); }
ExWorkProcRetcode ExCancelTcb::work() { ExMasterStmtGlobals *masterGlobals = getGlobals()->castToExExeStmtGlobals()->castToExMasterStmtGlobals(); CliGlobals *cliGlobals = masterGlobals->getCliGlobals(); while ((qparent_.down->isEmpty() == FALSE) && (qparent_.up->isFull() == FALSE)) { ex_queue_entry *pentry_down = qparent_.down->getHeadEntry(); switch (step_) { case NOT_STARTED: { if (pentry_down->downState.request == ex_queue::GET_NOMORE) step_ = DONE; else { retryCount_ = 0; // Priv checking is done during compilation. To support // REVOKE, prevent a prepared CANCEL/SUSPEND/ACTIVATE // that was compiled more than 1 second ago from executing // by raising the 8734 error to force an AQR. Int64 microSecondsSinceCompile = NA_JulianTimestamp() - masterGlobals->getStatement()->getCompileEndTime(); if (microSecondsSinceCompile > 1000*1000) { ComDiagsArea *diagsArea = ComDiagsArea::allocate(getGlobals()->getDefaultHeap()); *diagsArea << DgSqlCode(-CLI_INVALID_QUERY_PRIVS); reportError(diagsArea); step_ = DONE; break; } // Figure out which MXSSMP broker to use. if (cancelTdb().getAction() == ComTdbCancel::CancelByPname) { int nid = -1; int rc = msg_mon_get_process_info(cancelTdb().getCancelPname(), &nid, &pid_); switch (rc) { case XZFIL_ERR_OK: cpu_ = (short) nid; break; case XZFIL_ERR_NOTFOUND: case XZFIL_ERR_BADNAME: case XZFIL_ERR_NOSUCHDEV: { ComDiagsArea *diagsArea = ComDiagsArea::allocate(getGlobals()->getDefaultHeap()); *diagsArea << DgSqlCode(-EXE_CANCEL_PROCESS_NOT_FOUND); *diagsArea << DgString0(cancelTdb().getCancelPname()); reportError(diagsArea); step_ = DONE; break; } default: { char buf[200]; str_sprintf(buf, "Unexpected error %d returned from " "msg_mon_get_process_info", rc); ex_assert(0, buf); } } if (step_ != NOT_STARTED) break; } else if (cancelTdb().getAction() == ComTdbCancel::CancelByNidPid) { cpu_ = (short) cancelTdb().getCancelNid(); pid_ = cancelTdb().getCancelPid(); // check that process exists, if not report error. char processName[MS_MON_MAX_PROCESS_NAME]; int rc = msg_mon_get_process_name(cpu_, pid_, processName); if (XZFIL_ERR_OK == rc) ; // good. nid & pid are valid. else { if ((XZFIL_ERR_NOTFOUND != rc) && (XZFIL_ERR_BADNAME != rc) && (XZFIL_ERR_NOSUCHDEV != rc)) { // Log rc in case it needs investigation later. char buf[200]; str_sprintf(buf, "Unexpected error %d returned from " "msg_mon_get_process_name", rc); SQLMXLoggingArea::logExecRtInfo(__FILE__, __LINE__, buf, 0); } char nid_pid_str[32]; str_sprintf(nid_pid_str, "%d, %d", cpu_, pid_); ComDiagsArea *diagsArea = ComDiagsArea::allocate(getGlobals()->getDefaultHeap()); *diagsArea << DgSqlCode(-EXE_CANCEL_PROCESS_NOT_FOUND); *diagsArea << DgString0(nid_pid_str); reportError(diagsArea); step_ = DONE; break; } } else { char * qid = cancelTdb().qid_; Lng32 qid_len = str_len(qid); // This static method is defined in SqlStats.cpp. It side-effects // the nodeName and cpu_ according to the input qid. if (getMasterCpu( qid, qid_len, nodeName_, sizeof(nodeName_) - 1, cpu_) == -1) { ComDiagsArea *diagsArea = ComDiagsArea::allocate(getGlobals()->getDefaultHeap()); *diagsArea << DgSqlCode(-EXE_RTS_INVALID_QID); reportError(diagsArea); step_ = DONE; break; } } // Testpoints for hard to reproduce problems: bool fakeError8028 = false; fakeError8028 = (getenv("HP_FAKE_ERROR_8028") != NULL); if ((cliGlobals->getCbServerClass() == NULL) || fakeError8028) { ComDiagsArea *diagsArea = ComDiagsArea::allocate(getGlobals()->getDefaultHeap()); *diagsArea << DgSqlCode(-EXE_CANCEL_PROCESS_NOT_FOUND); *diagsArea << DgString0("$ZSM000"); reportError(diagsArea); step_ = DONE; break; } ComDiagsArea *diagsArea = NULL; bool fakeError2024 = false; fakeError2024 = (getenv("HP_FAKE_ERROR_2024") != NULL); if (fakeError2024) { cbServer_ = NULL; diagsArea = ComDiagsArea::allocate(getGlobals()->getDefaultHeap()); if (getenv("HP_FAKE_ERROR_8142")) { *diagsArea << DgSqlCode(-8142); *diagsArea << DgString0(__FILE__); *diagsArea << DgString1("cbServer_ is NULL"); } else *diagsArea << DgSqlCode(-2024); } else cbServer_ = cliGlobals->getCbServerClass()->allocateServerProcess( &diagsArea, cliGlobals->getEnvironment()->getHeap(), nodeName_, cpu_, IPC_PRIORITY_DONT_CARE, FALSE, // usesTransactions TRUE, // waitedCreation 2 // maxNowaitRequests -- cancel+(1 extra). ); if (cbServer_ == NULL || cbServer_->getControlConnection() == NULL) { ex_assert(diagsArea != NULL, "allocateServerProcess failed, but no diags"); // look for SQLCode 2024 // "*** ERROR[2024] Server Process $0~string0 // is not running or could not be created. Operating System // Error $1~int0 was returned." // Remap to cancel-specfic error 8028. if (diagsArea->contains(-2024) && cancelTdb().actionIsCancel()) { diagsArea->deleteError(diagsArea->returnIndex(-2024)); reportError(diagsArea, true, EXE_CANCEL_PROCESS_NOT_FOUND, nodeName_, cpu_); } else reportError(diagsArea); step_ = DONE; break; } // the reportError method was not called -- see break above. if (diagsArea != NULL) diagsArea->decrRefCount(); //Create the stream on the IpcHeap, since we don't dispose // of it immediately. We just add it to the list of completed // messages in the IpcEnv, and it is disposed of later. cancelStream_ = new (cliGlobals->getIpcHeap()) CancelMsgStream(cliGlobals->getEnvironment(), this); cancelStream_->addRecipient(cbServer_->getControlConnection()); } step_ = SEND_MESSAGE; break; } // end case NOT_STARTED #pragma warning (disable : 4291) case SEND_MESSAGE: { RtsHandle rtsHandle = (RtsHandle) this; if (cancelTdb().actionIsCancel()) { Int64 cancelStartTime = JULIANTIMESTAMP(); Lng32 firstEscalationInterval = cliGlobals->currContext()-> getSessionDefaults()->getCancelEscalationInterval(); Lng32 secondEscalationInterval = cliGlobals->currContext()-> getSessionDefaults()->getCancelEscalationMxosrvrInterval(); NABoolean cancelEscalationSaveabend = cliGlobals->currContext()-> getSessionDefaults()->getCancelEscalationSaveabend(); bool cancelLogging = (TRUE == cliGlobals->currContext()-> getSessionDefaults()->getCancelLogging()); CancelQueryRequest *cancelMsg = new (cliGlobals->getIpcHeap()) CancelQueryRequest(rtsHandle, cliGlobals->getIpcHeap(), cancelStartTime, firstEscalationInterval, secondEscalationInterval, cancelEscalationSaveabend, cancelTdb().getCommentText(), str_len(cancelTdb().getCommentText()), cancelLogging, cancelTdb().action_ != ComTdbCancel::CancelByQid, pid_, cancelTdb().getCancelPidBlockThreshold()); #pragma warning (default : 4291) *cancelStream_ << *cancelMsg; cancelMsg->decrRefCount(); } else if (ComTdbCancel::Suspend == cancelTdb().action_) { bool suspendLogging = (TRUE == cliGlobals->currContext()-> getSessionDefaults()->getSuspendLogging()); #pragma warning (disable : 4291) SuspendQueryRequest * suspendMsg = new (cliGlobals->getIpcHeap()) SuspendQueryRequest(rtsHandle, cliGlobals->getIpcHeap(), ComTdbCancel::Force == cancelTdb().forced_, suspendLogging); #pragma warning (default : 4291) *cancelStream_ << *suspendMsg; suspendMsg->decrRefCount(); } else { ex_assert( ComTdbCancel::Activate == cancelTdb().action_, "invalid action for ExCancelTcb"); bool suspendLogging = (TRUE == cliGlobals->currContext()-> getSessionDefaults()->getSuspendLogging()); #pragma warning (disable : 4291) ActivateQueryRequest * activateMsg = new (cliGlobals->getIpcHeap()) ActivateQueryRequest(rtsHandle, cliGlobals->getIpcHeap(), suspendLogging); #pragma warning (default : 4291) *cancelStream_ << *activateMsg; activateMsg->decrRefCount(); } if ((cancelTdb().getAction() != ComTdbCancel::CancelByPname) && (cancelTdb().getAction() != ComTdbCancel::CancelByNidPid)) { char * qid = cancelTdb().qid_; Lng32 qid_len = str_len(qid); #pragma warning (disable : 4291) RtsQueryId *rtsQueryId = new (cliGlobals->getIpcHeap()) RtsQueryId( cliGlobals->getIpcHeap(), qid, qid_len); #pragma warning (default : 4291) *cancelStream_ << *rtsQueryId; rtsQueryId->decrRefCount(); } // send a no-wait request to the cancel broker. cancelStream_->send(FALSE); step_ = GET_REPLY; // Come back when I/O completes. return WORK_OK; break; } // end case SEND_MESSAGE case GET_REPLY: { // Handle general IPC error. bool fakeError201 = false; fakeError201 = (getenv("HP_FAKE_ERROR_201") != NULL); if ((cbServer_->getControlConnection()->getErrorInfo() != 0) || fakeError201) { ComDiagsArea *diagsArea = ComDiagsArea::allocate(getGlobals()->getDefaultHeap()); cbServer_->getControlConnection()-> populateDiagsArea( diagsArea, getGlobals()->getDefaultHeap()); if (fakeError201) { *diagsArea << DgSqlCode(-2034) << DgInt0(201) << DgString0("I say") << DgString1("control broker"); } if (diagsArea->contains(-8921)) { // Should not get timeout error 8921. Get a core-file // of the SSMP and this process too so that this can be // debugged. cbServer_->getControlConnection()-> dumpAndStopOtherEnd(true, false); genLinuxCorefile("Unexpected timeout error"); } reportError(diagsArea); step_ = DONE; break; } // See if stream has the reply yet. if (!cancelStream_->moreObjects()) return WORK_OK; #pragma warning (disable : 4291) ControlQueryReply *reply = new (cliGlobals->getIpcHeap()) ControlQueryReply(INVALID_RTS_HANDLE, cliGlobals->getIpcHeap()); #pragma warning (default : 4291) *cancelStream_ >> *reply; if (reply->didAttemptControl()) { // yeaah! cancelStream_->clearAllObjects(); } else { if (cancelStream_->moreObjects() && cancelStream_->getNextObjType() == IPC_SQL_DIAG_AREA) { ComDiagsArea *diagsArea = ComDiagsArea::allocate(getGlobals()->getDefaultHeap()); *cancelStream_ >> *diagsArea; cancelStream_->clearAllObjects(); if ( retryQidNotActive_ && (diagsArea->mainSQLCODE() == -EXE_SUSPEND_QID_NOT_ACTIVE) && (++retryCount_ <= 60)) { SQLMXLoggingArea::logExecRtInfo(__FILE__, __LINE__, "Retrying error 8672.", 0); DELAY(500); diagsArea->decrRefCount(); step_ = SEND_MESSAGE; break; } reportError(diagsArea); } else ex_assert(0, "Control failed, but no diagnostics."); } step_ = DONE; break; } case DONE: { if (cancelStream_) { cancelStream_->addToCompletedList(); cancelStream_ = NULL; } if (cbServer_) { cbServer_->release(); cbServer_ = NULL; } ex_queue_entry * up_entry = qparent_.up->getTailEntry(); up_entry->copyAtp(pentry_down); up_entry->upState.parentIndex = pentry_down->downState.parentIndex; up_entry->upState.downIndex = qparent_.down->getHeadIndex(); up_entry->upState.setMatchNo(1); up_entry->upState.status = ex_queue::Q_NO_DATA; qparent_.up->insert(); qparent_.down->removeHead(); step_ = NOT_STARTED; break; } default: ex_assert( 0, "Unknown step_."); }
int main(int argc, char *argv[]) { bool client = false; int event_len; int ferr; int inx; int len; int lerr; int linx; int loop = 10; int msgid; int oid; TPT_DECL (phandle); RT results; int send_len; int srv_nid = -1; int srv_pid = -1; MS_SRE sre; TAD zargs[] = { { "-client", TA_Bool, TA_NOMAX, &client }, { "-loop", TA_Int, TA_NOMAX, &loop }, { "-server", TA_Ign, TA_NOMAX, NULL }, { "", TA_End, TA_NOMAX, NULL } }; msfs_util_init(&argc, &argv, msg_debug_hook); arg_proc_args(zargs, false, argc, argv); util_test_start(client); ferr = msg_mon_process_startup(!client); // system messages? TEST_CHK_FEOK(ferr); if (client) { ferr = msg_mon_open_process((char *) "$srv", // name TPT_REF(phandle), &oid); TEST_CHK_FEOK(ferr); ferr = msg_mon_get_process_info((char *) "$srv", &srv_nid, &srv_pid); TEST_CHK_FEOK(ferr); } util_gethostname(my_name, sizeof(my_name)); msg_mon_enable_mon_messages(true); for (inx = 0; inx < MS_MON_MAX_SYNC_DATA; inx++) event_data[inx] = (char) (inx + 1); for (inx = 0; inx < loop; inx++) { if (client) { sprintf(send_buffer, "hello, greetings from %s, inx=%d", my_name, inx); send_len = (int) strlen(send_buffer) + 1; ferr = XMSG_LINK_(TPT_REF(phandle), // phandle &msgid, // msgid send_buffer2, // reqctrl (ushort) (inx & 1), // reqctrlsize recv_buffer3, // replyctrl 1, // replyctrlmax send_buffer, // reqdata (ushort) send_len, // reqdatasize recv_buffer, // replydata BUFSIZ, // replydatamax 0, // linkertag 0, // pri 0, // xmitclass 0); // linkopts util_check("XMSG_LINK_", ferr); lerr = XWAIT(LDONE, 10); TEST_CHK_WAITIGNORE(lerr); assert(!XMSG_ISDONE_(msgid)); ferr = msg_mon_event_send(srv_nid, // nid srv_pid, // pid MS_ProcessType_Undefined, // process-type inx, // event-id inx % MS_MON_MAX_SYNC_DATA, // event-len event_data); // event-data TEST_CHK_FEOK(ferr); ferr = XMSG_BREAK_(msgid, results.u.s, TPT_REF(phandle)); util_check("XMSG_BREAK_", ferr); assert(results.u.t.ctrl_size == (uint) (inx & 1)); assert(results.u.t.data_size > (strlen(send_buffer) + 14)); assert(results.u.t.errm == RT_DATA_RCVD); // data printf("%s\n", recv_buffer); } else { do { lerr = XWAIT(LREQ, -1); lerr = XMSG_LISTEN_((short *) &sre, // sre 0, // listenopts 0); // listenertag } while (lerr == XSRETYPE_NOWORK); ferr = XMSG_READCTRL_(sre.sre_msgId, // msgid recv_buffer2, // reqctrl 1); // bytecount util_check("XMSG_READCTRL_", ferr); ferr = XMSG_READDATA_(sre.sre_msgId, // msgid recv_buffer, // reqdata BUFSIZ); // bytecount util_check("XMSG_READDATA_", ferr); if (sre.sre_flags & XSRE_MON) { printf("server received mon message\n"); inx--; len = 0; } else { memset(event_data, 0, sizeof(event_data)); ferr = msg_mon_event_wait(inx, &event_len, event_data); TEST_CHK_FEOK(ferr); assert(event_len == (inx % MS_MON_MAX_SYNC_DATA)); for (linx = 0; linx < event_len; linx++) assert(event_data[linx] == (linx + 1)); strcat(recv_buffer, "- reply from "); strcat(recv_buffer, my_name); len = (int) strlen(recv_buffer) + 1; } XMSG_REPLY_(sre.sre_msgId, // msgid recv_buffer2, // replyctrl sre.sre_reqCtrlSize, // replyctrlsize recv_buffer, // replydata (ushort) len, // replydatasize 0, // errorclass NULL); // newphandle } } if (client) { ferr = msg_mon_close_process(TPT_REF(phandle)); TEST_CHK_FEOK(ferr); } else { ferr = msg_mon_process_close(); TEST_CHK_FEOK(ferr); } ferr = msg_mon_process_shutdown(); TEST_CHK_FEOK(ferr); util_test_finish(client); return 0; }
int main(int argc, char *argv[]) { bool chook = false; int client = false; int dinx; int disable; int ferr; int inx; char lname[10]; bool mq = false; int oid; void *res; bool rnd = false; int sleept; int snid; int spid; int status; TAD zargs[] = { { "-chook", TA_Bool, TA_NOMAX, &chook }, { "-client", TA_Bool, TA_NOMAX, &client }, { "-dloop", TA_Int, MAX_OUT, &gdloop }, { "-dsize", TA_Int, TA_NOMAX, &gdsize }, { "-ksleep", TA_Int, TA_NOMAX, &gksleep }, { "-loop", TA_Int, TA_NOMAX, &gloop }, { "-maxc", TA_Int, MAX_THR, &gmaxc }, { "-maxs", TA_Int, MAX_THR, &gmaxs }, { "-mq", TA_Bool, TA_NOMAX, &mq }, { "-nodecycle", TA_Bool, TA_NOMAX, &gnodecycle }, { "-rnd", TA_Bool, TA_NOMAX, &rnd }, { "-server", TA_Ign, TA_NOMAX, NULL }, { "-v", TA_Bool, TA_NOMAX, &gverbose }, { "-vpp", TA_Bool, TA_NOMAX, &gverbosepp }, { "", TA_End, TA_NOMAX, NULL } }; arg_proc_args(zargs, false, argc, argv); if (client && chook) test_debug_hook("c", "c"); msfs_util_init(&argc, &argv, msg_debug_hook); util_test_start(client); if (!client) setup_sig(); ferr = msg_mon_process_startup(true); // system messages TEST_CHK_FEOK(ferr); gargc = argc; // after msg_init - it removes args gargp = argv; sprintf(gprog, "%s/%s", getenv("PWD"), argv[0]); gvirtual = (getenv("SQ_VIRTUAL_NODES") != NULL); ferr = msg_mon_get_my_process_name(gname, sizeof(gname)); assert(ferr == XZFIL_ERR_OK); if (client) { msg_mon_enable_mon_messages(true); // get mon messages ferr = msg_mon_get_process_info(NULL, &gcnid, NULL); assert(ferr == XZFIL_ERR_OK); ferr = XCONTROLMESSAGESYSTEM(XCTLMSGSYS_SETSENDLIMIT, (short) (gmaxc * gdloop)); assert(ferr == XZFIL_ERR_OK); srand(1); sleept = 1000; start_server(argc, argv); sleep(1); ferr = msg_mon_open_process((char *) "$srv", // name TPT_REF(gphandle), &oid); TEST_CHK_FEOK(ferr); ferr = XPROCESSHANDLE_DECOMPOSE_(TPT_REF(gphandle), &snid, &spid); TEST_CHK_FEOK(ferr); for (inx = 0; inx < gloop; inx++) { if (mq) printf("client: inx=%d\n", inx); for (dinx = 0; dinx < gmaxc; dinx++) { sprintf(lname, "c%d", dinx); gthrc[dinx] = new MyThread(client_thr, lname, dinx); } disable = msg_test_assert_disable(); for (dinx = 0; dinx < gmaxc; dinx++) gthrc[dinx]->start(); if (rnd) sleept = (int) ((float) gksleep * (rand_r(&gseed) / (RAND_MAX + 1.0))); usleep(sleept); for (dinx = 0; dinx < gmaxc; dinx++) { status = gthrc[dinx]->join(&res); TEST_CHK_STATUSOK(status); if (gverbose) printf("joined with client %d\n", dinx); } for (dinx = 0; dinx < gmaxc; dinx++) delete gthrc[dinx]; msg_test_assert_enable(disable); } } else { msg_mon_enable_mon_messages(true); // get mon messages ferr = XCONTROLMESSAGESYSTEM(XCTLMSGSYS_SETRECVLIMIT, XMAX_SETTABLE_RECVLIMIT); assert(ferr == XZFIL_ERR_OK); pp_init(); if (!gshutdown) { for (dinx = 0; dinx < gmaxs; dinx++) { char lname[10]; sprintf(lname, "s%d", dinx); gthrs[dinx] = new SB_Thread::Thread(server_thr, lname); } for (dinx = 0; dinx < gmaxs; dinx++) gthrs[dinx]->start(); for (dinx = 0; dinx < gmaxs; dinx++) { status = gthrs[dinx]->join(&res); TEST_CHK_STATUSOK(status); if (gverbose) printf("joined with server %d\n", dinx); } } if (gverbosepp) pp_printf("exit pid=%d\n", getpid()); } if (client) { sleep(1); ferr = msg_mon_close_process(TPT_REF(gphandle)); TEST_CHK_FEOK(ferr); } ferr = msg_mon_process_shutdown(); TEST_CHK_FEOK(ferr); util_test_finish(client); return 0; }
int main(int argc, char *argv[]) { char cli[10]; bool closer; int disable; int event_len; int ferr; int inst = 0; int inx; int lerr; int loop = 10; int msgid; int nid; int oid; TPT_DECL (phandle); int pid; char recv_buffer[30000]; RT results; char send_buffer[10]; MS_SRE sre; TAD zargs[] = { { "-client", TA_Ign, TA_NOMAX, NULL }, { "-inst", TA_Int, TA_NOMAX, &inst }, { "-loop", TA_Int, TA_NOMAX, &loop }, { "-maxcp", TA_Int, TA_NOMAX, &maxcp }, { "-maxs", TA_Int, TA_NOMAX, &maxs }, { "-maxsp", TA_Next, TA_NOMAX, NULL }, { "-name", TA_Next, TA_NOMAX, NULL }, { "-server", TA_Ign, TA_NOMAX, NULL }, { "-v", TA_Bool, TA_NOMAX, &verbose }, { "", TA_End, TA_NOMAX, NULL } }; msfs_util_init(&argc, &argv, msg_debug_hook); arg_proc_args(zargs, false, argc, argv); util_test_start(true); ferr = msg_mon_process_startup(true); // system messages? TEST_CHK_FEOK(ferr); ferr = msg_mon_get_my_process_name(my_name, sizeof(my_name)); TEST_CHK_FEOK(ferr); msg_mon_enable_mon_messages(true); // process-wait for clients/shell // (needed so msg_mon_register_death_notification below works correctly) ferr = msfs_util_wait_process_count(MS_ProcessType_TSE, maxcp, NULL, false); TEST_CHK_FEOK(ferr); sleep(1); if (verbose) printf("%s: inst=%d, maxcp=%d\n", my_name, inst, maxcp); closer = (inst == (maxcp -1)); if (closer && (maxcp > 1)) { if (verbose) printf("%s: register-death-notifications\n", my_name); for (inx = 0; inx < (maxcp - 1); inx++) { sprintf(cli, "$c%d", inx); ferr = msg_mon_get_process_info(cli, &nid, &pid); TEST_CHK_FEOK(ferr); ferr = msg_mon_register_death_notification(nid, pid); TEST_CHK_FEOK(ferr); } } // // wait here until all clients sync-up // (needed so msg_mon_register_death_notification above works correctly) // ferr = msg_mon_event_send(-1, // nid -1, // pid MS_ProcessType_TSE, // process-type 3, // event-id 0, // event-len NULL); // event-data TEST_CHK_FEOK(ferr); for (inx = 0; inx < maxcp; inx++) { ferr = msg_mon_event_wait(3, &event_len, event_data); TEST_CHK_FEOK(ferr); } disable = msg_test_assert_disable(); // check process-type range ferr = msg_mon_event_send(-1, // nid -1, // pid -1, // process-type 4, // event-id 0, // event-len NULL); // event-data assert(ferr == XZFIL_ERR_BOUNDSERR); ferr = msg_mon_event_send(-1, // nid -1, // pid MS_ProcessType_SMS + 1, // process-type 5, // event-id 0, // event-len NULL); // event-data assert(ferr == XZFIL_ERR_BOUNDSERR); msg_test_assert_enable(disable); ferr = msg_mon_open_process((char *) "$srv", // name TPT_REF(phandle), &oid); TEST_CHK_FEOK(ferr); for (inx = 0; inx < loop; inx++) { ferr = XMSG_LINK_(TPT_REF(phandle), // phandle &msgid, // msgid NULL, // reqctrl 0, // reqctrlsize NULL, // replyctrl 0, // replyctrlmax send_buffer, // reqdata 1, // reqdatasize recv_buffer, // replydata 0, // replydatamax 0, // linkertag 0, // pri 0, // xmitclass 0); // linkopts util_check("XMSG_LINK_", ferr); ferr = XMSG_BREAK_(msgid, results.u.s, TPT_REF(phandle)); util_check("XMSG_BREAK_", ferr); } if (closer) { inx = 0; while (inx < (maxcp - 1)) { do { lerr = XWAIT(LREQ, -1); TEST_CHK_WAITIGNORE(lerr); lerr = XMSG_LISTEN_((short *) &sre, // sre 0, // listenopts 0); // listenertag } while (lerr == XSRETYPE_NOWORK); if (sre.sre_flags & XSRE_MON) { ferr = BMSG_READDATA_(sre.sre_msgId, // msgid recv_buffer, // reqdata BUFSIZ); // bytecount TEST_CHK_FEOK(ferr); MS_Mon_Msg *msg = (MS_Mon_Msg *) recv_buffer; if (msg->type == MS_MsgType_ProcessDeath) { if (verbose) printf("%s: process death process=%s\n", my_name, msg->u.death.process_name); inx++; } } XMSG_REPLY_(sre.sre_msgId, // msgid NULL, // replyctrl 0, // replyctrlsize recv_buffer, // replydata 0, // replydatasize 0, // errorclass NULL); // newphandle } if (verbose) printf("%s: sending stop\n", my_name); for (inx = 0; inx < maxs; inx++) { ferr = XMSG_LINK_(TPT_REF(phandle), // phandle &msgid, // msgid NULL, // reqctrl 0, // reqctrlsize NULL, // replyctrl 0, // replyctrlmax send_buffer, // reqdata 0, // reqdatasize recv_buffer, // replydata 0, // replydatamax 0, // linkertag 0, // pri 0, // xmitclass 0); // linkopts util_check("XMSG_LINK_", ferr); ferr = XMSG_BREAK_(msgid, results.u.s, TPT_REF(phandle)); util_check("XMSG_BREAK_", ferr); } } ferr = msg_mon_close_process(TPT_REF(phandle)); TEST_CHK_FEOK(ferr); ferr = msg_mon_process_shutdown(); TEST_CHK_FEOK(ferr); util_test_finish(true); return 0; }
int main(int argc, char *argv[]) { bool client = false; int client_mon; int cnid = -1; bool commit_rcvd = false; int cpid = -1; int disable; bool done = false; int event_len; int ferr; int first; int handle; int inx; int len; int lerr; int loop = 10; int msgid; int nid; bool open_rcvd = false; int orig_tag; TPT_DECL2 (phandle,MAX_SERVERS); int pid; int pinx; RT results; int send_len; MS_SRE sre; int status; bool sync = false; bool threaded = false; bool verbose = false; TAD zargs[] = { { "-client", TA_Bool, TA_NOMAX, &client }, { "-loop", TA_Int, TA_NOMAX, &loop }, { "-quiet", TA_Bool, TA_NOMAX, &quiet }, { "-server", TA_Ign, TA_NOMAX, NULL }, { "-sync", TA_Bool, TA_NOMAX, &sync }, { "-threaded", TA_Bool, TA_NOMAX, &threaded }, { "-v", TA_Bool, TA_NOMAX, &verbose }, { "", TA_End, TA_NOMAX, NULL } }; msfs_util_init(&argc, &argv, msg_debug_hook); arg_proc_args(zargs, false, argc, argv); util_test_start(client); ferr = msg_mon_process_startup(!client); // system messages? TEST_CHK_FEOK(ferr); sleep(1); // wait for client to get into msg_mon_process_info ferr = msg_mon_get_my_process_name(pname, sizeof(pname)); TEST_CHK_FEOK(ferr); if (strcasecmp(pname, "$tm0") == 0) tag = TAG0; else if (strcasecmp(pname, "$tm1") == 0) tag = TAG1; else tag = TAG2; ferr = msg_mon_get_process_info(NULL, &snid, &spid); TEST_CHK_FEOK(ferr); if (client) { char serv[BUFSIZ]; for (pinx = 0; pinx < MAX_SERVERS; pinx++) { sprintf(serv, "$tm%d", pinx); ferr = msg_mon_open_process(serv, // name TPT_REF2(phandle,pinx), &oid[pinx]); TEST_CHK_FEOK(ferr); } } else { first = (strcasecmp(pname, "$tm0") == 0); disable = msg_test_assert_disable(); ferr = msg_mon_tm_leader_set(&nid, &pid, lname); msg_test_assert_enable(disable); if (first) { TEST_CHK_FEOK(ferr); } else assert(ferr != XZFIL_ERR_OK); printf("leader is p-id=%d/%d, name=%s\n", nid, pid, lname); } util_gethostname(my_name, sizeof(my_name)); msg_mon_enable_mon_messages(true); if (!client) { ferr = msg_mon_event_wait(1, &event_len, event_data); util_check("msg_mon_event_wait", ferr); ferr = msg_mon_tmsync_register(tmsync_cb); util_check("msg_mon_tmsync_register", ferr); if (sync) { char serv[BUFSIZ]; for (pinx = 0; pinx < MAX_SERVERS; pinx++) { sprintf(serv, "$tm%d", pinx); if (strcasecmp(serv, pname) != 0) { ferr = msg_mon_open_process(serv, // name TPT_REF2(phandle,pinx), &oid[pinx]); TEST_CHK_FEOK(ferr); } } // at this point, we know everyone is registered // if everyone isn't registered, there will be an abort do_sync(); if (threaded) do_sync_threaded(); } } if (client) { for (inx = 0; inx < loop; inx++) { sprintf(send_buffer, "hello, greetings from %s, inx=%d", my_name, inx); send_len = (int) strlen(send_buffer) + 1; for (pinx = 0; pinx < MAX_SERVERS; pinx++) { if (verbose) printf("%s: sending message, pinx=%d, inx=%d\n", pname, pinx, inx); ferr = XMSG_LINK_(TPT_REF2(phandle,pinx), // phandle &msgid, // msgid send_buffer2, // reqctrl (ushort) (inx & 1), // reqctrlsize recv_buffer3, // replyctrl 1, // replyctrlmax send_buffer, // reqdata (ushort) send_len, // reqdatasize recv_buffer, // replydata BUFSIZ, // replydatamax 0, // linkertag 0, // pri 0, // xmitclass 0); // linkopts util_check("XMSG_LINK_", ferr); ferr = XMSG_BREAK_(msgid, results.u.s, TPT_REF2(phandle,pinx)); util_check("XMSG_BREAK_", ferr); assert(results.u.t.ctrl_size == (uint) (inx & 1)); assert(results.u.t.data_size > (strlen(send_buffer) + 14)); assert(results.u.t.errm == RT_DATA_RCVD); // data if (!quiet) printf("%s\n", recv_buffer); } } for (pinx = 0; pinx < MAX_SERVERS; pinx++) { ferr = msg_mon_close_process(TPT_REF2(phandle,pinx)); TEST_CHK_FEOK(ferr); } } else { inx = 0; while (!done) { lerr = XWAIT(LREQ, -1); TEST_CHK_WAITIGNORE(lerr); for (;;) { lerr = XMSG_LISTEN_((short *) &sre, // sre 0, // listenopts 0); // listenertag if (lerr == XSRETYPE_NOWORK) break; ferr = XMSG_READCTRL_(sre.sre_msgId, // msgid recv_buffer2, // reqctrl 1); // bytecount util_check("XMSG_READCTRL_", ferr); ferr = XMSG_READDATA_(sre.sre_msgId, // msgid recv_buffer, // reqdata BUFSIZ); // bytecount util_check("XMSG_READDATA_", ferr); if (sre.sre_flags & XSRE_MON) { MS_Mon_Msg *msg = (MS_Mon_Msg *) recv_buffer; if (cnid < 0) { ferr = msg_mon_get_process_info((char *) "$cli", &cnid, &cpid); if (ferr != XZFIL_ERR_OK) { cnid = -1; cpid = -1; } } client_mon = true; Item *item_hdl; Item *item_tag; const char *type; switch (msg->type) { case MS_MsgType_Close: type = "close"; if ((cnid == msg->u.close.nid) && (cpid == msg->u.close.pid)) { } else client_mon = false; break; case MS_MsgType_NodeDown: type = "node-down"; break; case MS_MsgType_Open: type = "open"; if ((cnid == msg->u.open.nid) && (cpid == msg->u.open.pid)) open_rcvd = true; else client_mon = false; break; case MS_MsgType_ProcessDeath: type = "process-death"; break; case MS_MsgType_Shutdown: type = "shutdown"; done = true; break; case MS_MsgType_TmSyncAbort: case MS_MsgType_TmSyncCommit: if (msg->type == MS_MsgType_TmSyncAbort) type = "tmsync-abort"; else type = "tmsync-commit"; nid = msg->u.tmsync.nid[0]; handle = msg->u.tmsync.handle[0]; if (msg->u.tmsync.orig_count == 0) { msg->u.tmsync.orig_tag[0] = -1; msg->u.tmsync.orig_handle[0] = -1; } orig_tag = msg->u.tmsync.orig_tag[0]; if (!quiet) { printf("server (%s) received (%s) mon message, type=%s(%d), nid=%d\n", pname, client_mon ? "cli" : "dtm", type, msg->type, nid); printf(" orig_count=%d, orig_tag=%d, orig_handle=%d, count=%d, handle[0]=%d\n", msg->u.tmsync.orig_count, orig_tag, msg->u.tmsync.orig_handle[0], msg->u.tmsync.count, handle); } if (nid == snid) { if (!quiet) printf("server (%s) commit handle=%d, orig-count=%d\n", pname, handle, msg->u.tmsync.orig_count); for (int inx2 = 0; inx2 < msg->u.tmsync.count; inx2++) { int ltag = msg->u.tmsync.orig_tag[inx2]; int lhandle = msg->u.tmsync.orig_handle[inx2]; if (!quiet) printf("server (%s) commit orig-tag/handle=%d/%d\n", pname, ltag, lhandle); item_tag = (Item *) tag_issue_map.remove(ltag); assert(item_tag != NULL); delete item_tag; item_hdl = (Item *) handle_issue_map.remove(lhandle); assert(item_hdl != NULL); delete item_hdl; } } else { assert(msg->u.tmsync.orig_count == 0); } commit_rcvd = true; break; default: type = "<unknown>"; } if (!quiet) printf("server (%s) received (%s) mon message, type=%s(%d)\n", pname, client_mon ? "cli" : "dtm", type, msg->type); len = 0; } else { inx++; if (verbose) printf("%s: received non-mon message, inx=%d\n", pname, inx); if (!sync) assert(sync_rcvd); assert(commit_rcvd); assert(open_rcvd); strcat(recv_buffer, "- reply from "); strcat(recv_buffer, my_name); strcat(recv_buffer, " - "); strcat(recv_buffer, pname); len = (int) strlen(recv_buffer) + 1; } XMSG_REPLY_(sre.sre_msgId, // msgid recv_buffer2, // replyctrl sre.sre_reqCtrlSize, // replyctrlsize recv_buffer, // replydata (ushort) len, // replydatasize 0, // errorclass NULL); // newphandle } } assert(inx == loop); assert(tag_issue_map.empty()); assert(handle_issue_map.empty()); // need to wait for shutdown to be started ferr = msg_mon_event_wait(2, &event_len, event_data); util_check("msg_mon_event_wait", ferr); if (sync && threaded) { sync_thr_shutdown = true; for (int thr = 0; thr < MAX_THR; thr++) { void *larg; status = sync_thr[thr]->join(&larg); TEST_CHK_STATUSOK(status); } } } ferr = msg_mon_process_shutdown(); TEST_CHK_FEOK(ferr); util_test_finish(client); return 0; }
int main(int argc, char *argv[]) { int cycle; int disable; int ferr; #ifndef USE_OPEN int lnid; int lpid; #endif int msgid; char process_name[MS_MON_MAX_PROCESS_NAME]; char recvbuf[100]; MS_Result_Type results; int retries; int sendbuf[3]; ferr = msfs_util_init_role(true, &argc, &argv, msg_debug_hook); TEST_CHK_FEOK(ferr); ferr = msg_mon_get_my_process_name(gdisplay_name, sizeof(gdisplay_name)); assert(ferr == XZFIL_ERR_OK); myprintf("processing startup.\n"); util_test_start(true); ferr = msg_mon_process_startup(true); // system messages TEST_CHK_FEOK(ferr); ferr = msg_mon_get_process_info(gdisplay_name, &gnid, &gpid); TEST_CHK_FEOK(ferr); strcpy(process_name, "$srv"); myprintf("opening server %s.\n", process_name); #ifdef USE_OPEN ferr = msg_mon_open_process(process_name, TPT_REF(gserver_phandle), &gserver_oid); TEST_CHK_FEOK(ferr); #else gserver_phandlep = msg_get_phandle(process_name); assert(gserver_phandlep != NULL); #endif // do the work myprintf("Starting work with server\n"); disable = msg_test_assert_disable(); for (cycle = 0; cycle < MAX_CYCLES + 1; cycle++) { sendbuf[0] = gpid; sendbuf[1] = cycle; switch (cycle) { case 5: sendbuf[2] = CMD_ABORT; break; case 6: sendbuf[2] = CMD_CP_AB; break; case MAX_CYCLES: sendbuf[2] = CMD_END; break; default: sendbuf[2] = CMD_CONT; } retries = 5; do { myprintf("sending %d.%d.%d to server\n", sendbuf[0], sendbuf[1], sendbuf[2]); #ifdef USE_OPEN ferr = XMSG_LINK_(TPT_REF(gserver_phandle), // phandle #else ferr = XPROCESSHANDLE_DECOMPOSE_(gserver_phandlep, &lnid, &lpid); assert(ferr == XZFIL_ERR_OK); printf("phandle nid=%d, pid=%d\n", lnid, lpid); ferr = XMSG_LINK_(gserver_phandlep, // phandle #endif &msgid, // msgid NULL, // reqctrl 0, // reqctrlsize NULL, // replyctrl 0, // replyctrlmax (char *) sendbuf, // reqdata sizeof(sendbuf), // reqdatasize recvbuf, // replydata sizeof(recvbuf), // replydatamax 0, // linkertag 0, // pri 0, // xmitclass 0); // linkopts TEST_CHK_FEOK(ferr); ferr = XMSG_BREAK_(msgid, (short *) &results, #ifdef USE_OPEN TPT_REF(gserver_phandle)); #else gserver_phandlep); #endif if (ferr == XZFIL_ERR_OK) myprintf("Cycle # %d - %s\n", cycle, recvbuf); else myprintf("XMSG_BREAK_ error ferr=%d\n", ferr); if (ferr != XZFIL_ERR_OK) { retries--; sleep(1); if (retries <= 0) { myprintf("retries exhausted\n"); assert(retries > 0); } myprintf("retrying\n"); } else retries = 0; } while (retries > 0); } msg_test_assert_enable(disable); // close the server processes myprintf("closing server %s.\n", process_name); #ifdef USE_OPEN ferr = msg_mon_close_process(TPT_REF(gserver_phandle)); #else ferr = msg_mon_close_process(gserver_phandlep); #endif TEST_CHK_FEOK(ferr); myprintf("sending exit process message.\n"); ferr = msg_mon_process_shutdown(); TEST_CHK_FEOK(ferr); util_test_finish(true); return 0; }
int main(int argc, char *argv[]) { int arg; bool bm = false; char *buf; double busy; bool chook = false; bool client = false; char errnobuf[100]; char error_txt[200]; int event_len; char event_data[MS_MON_MAX_SYNC_DATA]; int ferr; int inx; int key; int lerr; int loop = 10; int msid; int pid; char prog[MS_MON_MAX_PROCESS_PATH]; struct rusage r_start; struct rusage r_stop; const char *server_name = "$SRV"; int server_nid; TPT_DECL (server_phandle); int server_pid; bool shook = false; struct timeval t_elapsed; struct timeval t_start; struct timeval t_stop; TAD zargs[] = { { "-bm", TA_Bool, TA_NOMAX, &bm }, { "-chook", TA_Bool, TA_NOMAX, &chook }, { "-client", TA_Bool, TA_NOMAX, &client }, { "-loop", TA_Int, TA_NOMAX, &loop }, { "-server", TA_Ign, TA_NOMAX, NULL }, { "-shook", TA_Bool, TA_NOMAX, &shook }, { "", TA_End, TA_NOMAX, NULL } }; ferr = msg_init(&argc, &argv); arg_proc_args(zargs, false, argc, argv); if (chook && client) test_debug_hook("c", "c"); if (shook && !client) test_debug_hook("s", "s"); util_test_start(client); ferr = msg_mon_process_startup(!client); // system messages? TEST_CHK_FEOK(ferr); proc_enable_external_wakeups(); // allow external wakeups if (client) { ferr = msg_mon_get_process_info(NULL, &server_nid, &server_pid); TEST_CHK_FEOK(ferr); sprintf(prog, "%s/%s", getenv("PWD"), argv[0]); for (arg = 0; arg < argc; arg++) if (strcmp(argv[arg], "-client") == 0) // start_process argv[arg] = (char *) "-server"; ferr = msg_mon_start_process(prog, // prog (char *) server_name, // name NULL, // ret name argc, argv, TPT_REF(server_phandle), 0, // open NULL, // oid MS_ProcessType_Generic, // type 0, // priority 0, // debug 0, // backup &server_nid, // nid &server_pid, // pid NULL, // infile NULL); // outfile printf("process started, err=%d\n", ferr); TEST_CHK_FEOK(ferr); } util_gethostname(my_name, sizeof(my_name)); lerr = XWAIT(LREQ, -1); // remove first LREQ assert(lerr == LREQ); ferr = msg_mon_get_my_segid(&key); TEST_CHK_FEOK(ferr); // process-wait for client/server/shell ferr = msfs_util_wait_process_count(MS_ProcessType_Generic, 3, NULL, false); TEST_CHK_FEOK(ferr); if (client) { ferr = msg_mon_event_wait(1, &event_len, event_data); TEST_CHK_FEOK(ferr); msid = shmget(key, sizeof(recv_buffer), 0640); if (msid == -1) { perror("client shmget"); sprintf(error_txt, "client shmget(%d)=%s\n", key, strerror_r(errno, errnobuf, sizeof(errnobuf))); } assert(msid != -1); buf = (char *) shmat(msid, NULL, 0); assert(buf != NULL); } else { msid = shmget(key, sizeof(recv_buffer), IPC_CREAT | 0640); if (msid == -1) { perror("server shmget"); sprintf(error_txt, "server shmget(%d)=%s\n", key, strerror_r(errno, errnobuf, sizeof(errnobuf))); } assert(msid != -1); buf = (char *) shmat(msid, NULL, 0); assert(buf != NULL); ferr = msg_mon_event_send(-1, // nid -1, // pid MS_ProcessType_Undefined, // process-type 1, // event-id 0, // event-len NULL); // event-data TEST_CHK_FEOK(ferr); ferr = msg_mon_event_wait(1, &event_len, event_data); TEST_CHK_FEOK(ferr); } util_time_timer_start(&t_start); util_cpu_timer_start(&r_start); if (client) { pid = server_pid; for (inx = 0; inx < loop; inx++) { lerr = XPROCESS_AWAKE_(pid, LREQ); assert(lerr == XZFIL_ERR_OK); lerr = XWAIT(LDONE, -1); assert(lerr == LDONE); } } else { ferr = msg_mon_get_process_info((char *) "$CLI", &server_nid, &pid); TEST_CHK_FEOK(ferr); for (inx = 0; inx < loop; inx++) { lerr = XWAIT(LREQ, -1); assert(lerr == LREQ); lerr = XPROCESS_AWAKE_(pid, LDONE); assert(lerr == XZFIL_ERR_OK); } } util_cpu_timer_stop(&r_stop); util_time_timer_stop(&t_stop); util_time_elapsed(&t_start, &t_stop, &t_elapsed); util_cpu_timer_busy(&r_start, &r_stop, &t_elapsed, &busy); if (client) { if (!bm) print_elapsed("", &t_elapsed); print_rate(bm, "", loop, 1024, &t_elapsed, busy); } else print_server_busy(bm, "", busy); ferr = msg_mon_process_shutdown(); TEST_CHK_FEOK(ferr); util_test_finish(client); return 0; }
int main(int argc, char *argv[]) { int arg; bool chook = false; bool client = false; int ferr; int inx; int loop = 10; char my_name[BUFSIZ]; bool nowait = false; int nid; int pid; char prog[MS_MON_MAX_PROCESS_PATH]; char retname[BUFSIZ]; char server_name[30]; int server_nid; TPT_DECL (server_phandle); int server_pid; bool shook = false; int status; TAD zargs[] = { { "-chook", TA_Bool, TA_NOMAX, &chook }, { "-client", TA_Bool, TA_NOMAX, &client }, { "-loop", TA_Int, TA_NOMAX, &loop }, { "-nowait", TA_Bool, TA_NOMAX, &nowait }, { "-server", TA_Ign, TA_NOMAX, NULL }, { "-shook", TA_Bool, TA_NOMAX, &shook }, { "", TA_End, TA_NOMAX, NULL } }; arg_proc_args(zargs, false, argc, argv); if (chook && client) test_debug_hook("c", "c"); if (shook && !client) test_debug_hook("s", "s"); ferr = msg_init(&argc, &argv); TEST_CHK_FEOK(ferr); if (client) msg_mon_enable_mon_messages(true); util_test_start(client); msg_mon_enable_mon_messages(true); ferr = msg_mon_process_startup(client); // system messages TEST_CHK_FEOK(ferr); ferr = msg_mon_get_process_info(NULL, &nid, &pid); TEST_CHK_FEOK(ferr); ferr = msg_mon_get_my_process_name(my_name, sizeof(my_name)); TEST_CHK_FEOK(ferr); if (client) { sprintf(prog, "%s/%s", getenv("PWD"), argv[0]); for (arg = 0; arg < argc; arg++) if (strcmp(argv[arg], "-client") == 0) // start_process argv[arg] = (char *) "-server"; for (inx = 0; inx < loop; inx++) { sprintf(server_name, "$SRV%d", inx); server_nid = -1; if (nowait) ferr = msg_mon_start_process_nowait_cb(cb, // callback prog, // prog server_name, // name retname, // ret-name argc, // argc argv, // argv MS_ProcessType_Generic, // type 0, // priority false, // debug false, // backup inx, // tag &server_nid, // nid &server_pid, // pid NULL, // infile NULL); // outfile else ferr = msg_mon_start_process(prog, // prog server_name, // name NULL, // ret name argc, argv, TPT_REF(server_phandle), 0, // open NULL, // oid MS_ProcessType_Generic, // type 0, // priority 0, // debug 0, // backup &server_nid, // nid &server_pid, // pid NULL, // infile NULL); // outfile printf("process started, err=%d\n", ferr); TEST_CHK_FEOK(ferr); if (nowait) { status = cv.wait(true); TEST_CHK_STATUSOK(status); } wait_death(); } } ferr = msg_mon_process_shutdown(); TEST_CHK_FEOK(ferr); util_test_finish(client); return 0; }
int main(int argc, char *argv[]) { _bcc_status bcc; bool client = false; int count_read; int count_written; int disable; int err; short error_reply; int ferr; short filenum; int inx; short lasterr; int loop = 10; int msgnum; bool open = false; short sender_len; xzsys_ddl_smsg_def *sys_msg = (xzsys_ddl_smsg_def *) recv_buffer; RI_Type ri; TAD zargs[] = { { "-client", TA_Bool, TA_NOMAX, &client }, { "-loop", TA_Int, TA_NOMAX, &loop }, { "-server", TA_Ign, TA_NOMAX, NULL }, { "", TA_End, TA_NOMAX, NULL } }; ferr = file_init(&argc, &argv); TEST_CHK_FEOK(ferr); msfs_util_init_fs(&argc, &argv, file_debug_hook); arg_proc_args(zargs, false, argc, argv); util_test_start(true); ferr = msg_mon_process_startup(!client); // system messages TEST_CHK_FEOK(ferr); ferr = msg_mon_get_my_process_name(my_name, BUFSIZ); TEST_CHK_FEOK(ferr); ferr = msg_mon_get_process_info(NULL, &my_nid, &my_pid); TEST_CHK_FEOK(ferr); if (client) { printf("client name=%s, nid=%d, pid=%d\n", my_name, my_nid, my_pid); start_server(argc, argv); server_name_len = (short) strlen(server_name); ferr = BFILE_OPEN_((char *) server_name, server_name_len, &filenum, 0, 0, 0, 0, 0, 0, 0, NULL); TEST_CHK_FEOK(ferr); for (inx = 0; inx < loop; inx++) { sprintf(send_buffer, "hello, greetings from %s, inx=%d", my_name, inx); disable = msg_test_assert_disable(); bcc = BWRITEREADX(filenum, send_buffer, (int) (strlen(send_buffer) + 1), // cast BUFSIZ, &count_read, 0); msg_test_assert_enable(disable); if (_bstatus_eq(bcc)) printf("%s\n", send_buffer); else { ferr = XFILE_GETINFO_(-1, &lasterr, NULL, 0, NULL, NULL, NULL); printf("WRITEREAD error=%d\n", lasterr); } kill(server_pid, SIGKILL); for (;;) { err = kill(server_pid, 0); if ((err == -1) && (errno == ESRCH)) break; usleep(10000); } start_server(argc, argv); } kill(server_pid, SIGKILL); for (;;) { err = kill(server_pid, 0); if ((err == -1) && (errno == ESRCH)) break; usleep(10000); } ferr = BFILE_CLOSE_(filenum, 0); TEST_CHK_FEOK(ferr); } else { printf("server name=%s, nid=%d, pid=%d\n", my_name, my_nid, my_pid); ferr = BFILE_OPEN_((char *) "$RECEIVE", 8, &filenum, 0, 0, 0, 1, 0, // sys msg 0, 0, NULL); TEST_CHK_FEOK(ferr); for (inx = 0; inx < loop; inx++) { bcc = BREADUPDATEX(filenum, recv_buffer, BUFSIZ, &count_read, 0); getri(&ri); printri(&ri); sender_len = 0; sender_nid = -1; sender_pid = -1; disable = msg_test_assert_disable(); // errors are ok ferr = XPROCESSHANDLE_DECOMPOSE_(TPT_REF(ri.sender), &sender_nid, // cpu &sender_pid, // pin NULL, // nodenumber NULL, // nodename 0, // nodename NULL, // nodename_length sender, sizeof(sender), &sender_len, NULL); // sequence_number TEST_CHK_FEIGNORE(ferr); msg_test_assert_enable(disable); sender[sender_len] = 0; printf("sender=%s, nid=%d, pid=%d\n", sender, sender_nid, sender_pid); error_reply = XZFIL_ERR_OK; if (_bstatus_eq(bcc)) { if (open) { assert(sender_nid == open_sender_nid); assert(sender_pid == open_sender_pid); assert(strcmp(sender, open_sender) == 0); assert(ri.file_number == open_sender_file_number); strcat(recv_buffer, "- reply from "); strcat(recv_buffer, my_name); count_read = (int) (strlen(recv_buffer) + 1); // cast } else { printf("server not opened by client - returning WRONGID\n"); error_reply = XZFIL_ERR_WRONGID; } } else { msgnum = sys_msg->u_z_msg.z_msgnumber[0]; switch (msgnum) { case XZSYS_VAL_SMSG_OPEN: printf("msgnum=%d (open)\n", msgnum); assert(!open); TPT_COPY_INT(TPT_REF(open_sender_phandle), ri.sender); strcpy(open_sender, sender); open_sender_nid = sender_nid; open_sender_pid = sender_pid; open_sender_file_number = ri.file_number; open = true; break; case XZSYS_VAL_SMSG_CLOSE: printf("msgnum=%d (close)\n", msgnum); assert(open); open = false; break; case XZSYS_VAL_SMSG_SHUTDOWN: printf("msgnum=%d (shutdown)\n", msgnum); inx = loop; // exit break; default: printf("unexpected msgnum=%d\n", msgnum); abort(); } count_read = 0; inx--; } bcc = BREPLYX(recv_buffer, count_read, &count_written, 0, error_reply); TEST_CHK_BCCEQ(bcc); } ferr = XFILE_CLOSE_(filenum, 0); TEST_CHK_FEOK(ferr); } ferr = msg_mon_process_shutdown(); TEST_CHK_FEOK(ferr); util_test_finish(true); printf("if there were no asserts, all is well\n"); return 0; }
int main(int argc, char *argv[]) { _xcc_status cc; bool client = false; unsigned short count_read; int count_read_b; unsigned short count_written; TCPU_DECL (cpu); int ferr; short filenum; int inx; int loop = 10; TPT_DECL (mphandle); char *mphandlec = (char *) &mphandle; TPT_DECL_INT (mphandlei); int nid; char nodename[20]; short nodename_length; int nodenumber; int pid; TPIN_DECL (pin); char procname[40]; short procname_length; SB_Int64_Type sequence_number; const char *sname = "$srv"; TAD zargs[] = { { "-client", TA_Bool, TA_NOMAX, &client }, { "-loop", TA_Int, TA_NOMAX, &loop }, { "-server", TA_Ign, TA_NOMAX, NULL }, { "-sname", TA_Str, TA_NOMAX, &sname }, { "", TA_End, TA_NOMAX, NULL } }; ferr = file_init(&argc, &argv); TEST_CHK_FEOK(ferr); msfs_util_init_fs(&argc, &argv, file_debug_hook); arg_proc_args(zargs, false, argc, argv); util_test_start(client); ferr = file_mon_process_startup(!client); // system messages? TEST_CHK_FEOK(ferr); ferr = msg_mon_get_my_process_name(my_name, BUFSIZ); util_check("msg_mon_get_my_process_name", ferr); ferr = msg_mon_get_process_info(my_name, &nid, &pid); TEST_CHK_FEOK(ferr); ferr = XPROCESSHANDLE_GETMINE_(TPT_REF(mphandle)); util_check("XPROCESSHANDLE_GETMINE_", ferr); TPT_COPY_INT(mphandlei, mphandle); assert((mphandlei[0] & 0xf0) == 0x20); // named assert(strncmp(my_name, &mphandlec[4], 32) == 0); printf("phandle=%x.%x.%x.%x.%x, pname=%s\n", mphandlei[0], mphandlei[1], mphandlei[2], mphandlei[3], mphandlei[4], my_name); ferr = XPROCESSHANDLE_DECOMPOSE_(TPT_REF(mphandle), &cpu, &pin, &nodenumber, nodename, sizeof(nodename), &nodename_length, procname, sizeof(procname), &procname_length, &sequence_number); assert(cpu == nid); assert(pin == pid); assert(nodenumber == 0); assert(nodename_length == 4); nodename[nodename_length] = 0; assert(strcmp(nodename, "\\NSK") == 0); procname[procname_length] = 0; assert(strcmp(procname, my_name) == 0); #ifdef SQ_PHANDLE_VERIFIER assert(sequence_number != 0); #else assert(sequence_number == 0); #endif if (client) { ferr = XFILE_OPEN_((char *) sname, 4, &filenum, 0, 0, 0, 0, 0, 0, 0, NULL); TEST_CHK_FEOK(ferr); for (inx = 0; inx < loop; inx++) { sprintf(send_buffer, "hello, greetings from %s, inx=%d", my_name, inx); if ((inx & 1) == 0) cc = XWRITEREADX2(filenum, send_buffer, (unsigned short) (strlen(send_buffer) + 1), // cast recv_buffer, BUFSIZ, &count_read, 0); else cc = BWRITEREADX2(filenum, send_buffer, (unsigned short) (strlen(send_buffer) + 1), // cast recv_buffer, BUFSIZ, &count_read_b, 0); TEST_CHK_CCEQ(cc); printf("%s\n", recv_buffer); } ferr = XFILE_CLOSE_(filenum, 0); TEST_CHK_FEOK(ferr); } else { ferr = XFILE_OPEN_((char *) "$RECEIVE", 8, &filenum, 0, 0, 0, 1, 1, // no sys msg 0, 0, NULL); TEST_CHK_FEOK(ferr); for (inx = 0; inx < loop; inx++) { cc = XREADUPDATEX(filenum, recv_buffer, BUFSIZ, &count_read, 0); TEST_CHK_CCEQ(cc); strcat(recv_buffer, "- reply from "); strcat(recv_buffer, my_name); count_read = (unsigned short) (strlen(recv_buffer) + 1); // cast cc = XREPLYX(recv_buffer, count_read, &count_written, 0, XZFIL_ERR_OK); TEST_CHK_CCEQ(cc); } ferr = XFILE_CLOSE_(filenum, 0); TEST_CHK_FEOK(ferr); } ferr = file_mon_process_shutdown(); TEST_CHK_FEOK(ferr); util_test_finish(client); return 0; }
int main(int argc, char *argv[]) { enum { MAX_RETRIES = 100 }; enum { SLEEP_US = 1000 }; bool attach = false; _xcc_status cc; bool client = false; int count; int count_read; int count_written; bool dif = false; double dloop; double dms; double dsec; int err; bool exec = false; int ferr; bool fin = false; MS_Mon_Process_Info_Type info; MS_Mon_Process_Info_Type *infop; int inx; int inx2; int inx3; short len; short lerr; short lerr2; int loop = 10; int max; int nid; pid_t pid; int sargc; ssize_t size; int snid; int spid; bool startup = false; xzsys_ddl_smsg_def *sys_msgp = (xzsys_ddl_smsg_def *) recv_buffer; int sys_msg; int sys_msg_count; bool verbose = false; TAD zargs[] = { { "-attach", TA_Bool, TA_NOMAX, &attach }, { "-client", TA_Bool, TA_NOMAX, &client }, { "-dif", TA_Bool, TA_NOMAX, &dif }, { "-exec", TA_Bool, TA_NOMAX, &exec }, { "-loop", TA_Int, TA_NOMAX, &loop }, { "-maxsp", TA_Int, TA_NOMAX, &maxsp }, { "-server", TA_Ign, TA_NOMAX, NULL }, { "-startup", TA_Bool, TA_NOMAX, &startup }, { "-trace", TA_Bool, TA_NOMAX, &trace }, { "-v", TA_Bool, TA_NOMAX, &verbose }, { "-verbose", TA_Ign, TA_NOMAX, NULL }, { "", TA_End, TA_NOMAX, NULL } }; arg_proc_args(zargs, false, argc, argv); sprintf(fifo1, "%s-%s", FIFO1, getenv("USER")); sprintf(fifo2, "%s-%s", FIFO2, getenv("USER")); if (trace) msg_init_trace(); if (exec) return 0; if (startup) { err = fifo_open(fifo1, O_WRONLY); assert(err != -1); ffds[1] = err; err = fifo_open(fifo2, O_RDONLY); assert(err != -1); ffds[0] = err; if (trace) trace_printf("cli: writing fifo\n"); size = write(ffds[1], recv_buffer, 1); if (trace) trace_printf("cli: fifo write, size=%d\n", (int) size); assert(size == 1); if (trace) trace_printf("cli: fifo written\n"); close(ffds[1]); return 0; } if (attach) ferr = file_init_attach(&argc, &argv, false, NULL); else ferr = file_init(&argc, &argv); TEST_CHK_FEOK(ferr); util_test_start(client); ferr = msg_mon_process_startup(true); // system messages util_check("msg_mon_process_startup", ferr); ferr = msg_mon_get_my_process_name(procname, BUFSIZ); util_check("msg_mon_get_my_process_name", ferr); ferr = msg_mon_get_process_info(procname, &nid, &pid); TEST_CHK_FEOK(ferr); if (trace) trace_printf("proc=%s, nid=%d, pid=%d\n", procname, nid, pid); dloop = (double) loop; for (inx = 0; inx < T_MAX; inx++) t_elapsed[inx] = 0.0; if (client) { printf("loop=%d, maxsp=%d\n", loop, maxsp); sargc = argc; assert(sargc < MAX_ARGS); for (inx2 = 0; inx2 < argc; inx2++) { if (strcmp(argv[inx2], "-client") == 0) sargv[inx2] = (char *) "-server"; else sargv[inx2] = argv[inx2]; if (strcmp(argv[inx2], "-attach") == 0) sargv[inx2] = (char *) "-server"; } sargv[argc] = NULL; sprintf(sprog, "%s/%s", getenv("PWD"), argv[0]); time_start(T_TOTAL); for (inx = 0; inx < loop; inx += maxsp) { if (dif) snid = -1; else snid = nid; max = loop - inx; if (max > maxsp) max = maxsp; for (inx2 = 0; inx2 < max; inx2++) sname[inx2][0] = 0; // mon picks name if (trace) trace_printf("cli: newproc, inx=%d\n", inx); time_start(T_NEWPROC); for (inx2 = 0; inx2 < max; inx2++) { ferr = msg_mon_start_process(sprog, // prog sname[inx2], // name sname[inx2], // ret_name sargc, // argc sargv, // argv TPT_REF2(sphandle,inx2),// phandle false, // open &soid[inx2], // oid MS_ProcessType_Generic, // type 0, // priority false, // debug false, // backup &snid, // nid &spid, // pid NULL, // infile NULL); // outfile TEST_CHK_FEOK(ferr); } time_stop(T_NEWPROC); time_elapsed(T_NEWPROC); // wait here until processes are 'up' // so that open timing is correct inx3 = 0; for (inx2 = 0; inx2 < max; inx2++) { ferr = msg_mon_get_process_info_detail(sname[inx2], &info); TEST_CHK_FEOK(ferr); if (info.state != MS_Mon_State_Up) { inx3++; if (inx3 > MAX_RETRIES) { printf("process %s did not enter 'UP' state\n", sname[inx2]); assert(inx3 < MAX_RETRIES); } usleep(SLEEP_US); inx2--; continue; } else inx3 = 0; } if (trace) trace_printf("cli: open, inx=%d\n", inx); time_start(T_OPEN); for (inx2 = 0; inx2 < max; inx2++) { if (trace) trace_printf("cli: opening inx=%d, name=%s\n", inx, sname[inx2]); len = (short) strlen(sname[inx2]); ferr = BFILE_OPEN_(sname[inx2], len, &sfilenum[inx2], 0, 0, 0, 0, 0, 0, 0); if (trace) trace_printf("cli: open, inx=%d, name=%s, ferr=%d\n", inx, sname[inx2], ferr); TEST_CHK_FEOK(ferr); } time_stop(T_OPEN); time_elapsed(T_OPEN); if (trace) trace_printf("cli: procinfo, inx=%d\n", inx); time_start(T_PROCINFO); for (inx2 = 0; inx2 < max; inx2++) { ferr = msg_mon_get_process_info_detail(sname[inx2], &info); TEST_CHK_FEOK(ferr); } time_stop(T_PROCINFO); time_elapsed(T_PROCINFO); if (trace) trace_printf("cli: procinfo-type, inx=%d\n", inx); time_start(T_PROCINFO_TYPE); ferr = msg_mon_get_process_info_type(MS_ProcessType_Generic, &count, MAX_SRV, infotype); TEST_CHK_FEOK(ferr); time_stop(T_PROCINFO_TYPE); time_elapsed(T_PROCINFO_TYPE); if (verbose) { for (inx2 = 0; inx2 < count; inx2++) { infop = &infotype[inx2]; char s_em = infop->event_messages ? 'E' : '-'; char s_sm = infop->system_messages ? 'S' : '-'; char s_pr = infop->pending_replication ? 'R' : '-'; char s_pd = infop->pending_delete ? 'D' : '-'; char s_s = infop->state == MS_Mon_State_Up ? 'A' : 'U'; char s_o = infop->opened ? 'O' : '-'; char s_p = infop->paired ? 'P' : infop->backup ? 'B' : '-'; printf("%3.3d,%8.8d %3.3d %d %c%c%c%c%c%c%c %-11s %-11s %-15s\n", infop->nid, infop->pid, infop->priority, infop->state, s_em, s_sm, s_pr, s_pd, s_s, s_o, s_p, infop->process_name, infop->parent_name, infop->program); } } if (trace) trace_printf("cli: close, inx=%d\n", inx); time_start(T_CLOSE); for (inx2 = 0; inx2 < max; inx2++) { ferr = BFILE_CLOSE_(sfilenum[inx2]); TEST_CHK_FEOK(ferr); } time_stop(T_CLOSE); time_elapsed(T_CLOSE); // re-open/close for (inx2 = 0; inx2 < max; inx2++) { if (trace) trace_printf("cli: re-opening inx=%d, name=%s\n", inx, sname[inx2]); len = (short) strlen(sname[inx2]); ferr = BFILE_OPEN_(sname[inx2], len, &sfilenum[inx2], 0, 0, 0, 0, 0, 0, 0); TEST_CHK_FEOK(ferr); } if (trace) trace_printf("cli: re-close, inx=%d\n", inx); for (inx2 = 0; inx2 < max; inx2++) { ferr = BFILE_CLOSE_(sfilenum[inx2]); TEST_CHK_FEOK(ferr); } if (trace) trace_printf("cli: newproc-forkexec, inx=%d\n", inx); sargc = 2; sargv[0] = argv[0]; sargv[1] = (char *) "-exec"; if (trace) sargv[sargc++] = (char *) "-trace"; sargv[sargc] = NULL; time_start(T_FORKEXEC); for (inx2 = 0; inx2 < max; inx2++) { pid = fork(); assert(pid >= 0); if (pid == 0) { // child err = execv(sprog, sargv); assert(err == 0); } } time_stop(T_FORKEXEC); time_elapsed(T_FORKEXEC); if (trace) trace_printf("cli: newproc-forkexec-su, inx=%d\n", inx); sargc = 2; sargv[0] = argv[0]; sargv[1] = (char *) "-startup"; if (trace) sargv[sargc++] = (char *) "-trace"; sargv[sargc] = NULL; time_start(T_FORKEXEC_SU); for (inx2 = 0; inx2 < max; inx2++) { fifo_create(fifo1, fifo2); pid = fork(); assert(pid >= 0); if (pid > 0) { // parent err = fifo_open(fifo1, O_RDONLY); assert(err != -1); ffds[0] = err; err = fifo_open(fifo2, O_WRONLY); assert(err != -1); ffds[1] = err; if (trace) trace_printf("cli: reading fifo, inx=%d\n", inx2); size = ::read(ffds[0], recv_buffer, 1); if (trace) trace_printf("cli: fifo read, size=%d\n", (int) size); assert(size == 1); if (trace) trace_printf("cli: fifo read, inx=%d\n", inx2); ::read(ffds[0], recv_buffer, 1); err = fifo_close(ffds[0]); assert(err == 0); err = fifo_close(ffds[1]); assert(err == 0); fifo_destroy(fifo1, fifo1); } else { // child err = execv(sprog, sargv); assert(err == 0); } } fifo_destroy(fifo2, fifo2); time_stop(T_FORKEXEC_SU); time_elapsed(T_FORKEXEC_SU); } } else { sys_msg_count = 0; time_start(T_TOTAL); ferr = BFILE_OPEN_((char *) "$RECEIVE", 8, &filenumr, 0, 0, 0, 1, 0); // sys msgs TEST_CHK_FEOK(ferr); for (inx = 0; !fin; inx++) { if (trace) trace_printf("srv: readupdate, inx=%d\n", inx); cc = BREADUPDATEX(filenumr, recv_buffer, 4, &count_read, 0); sys_msg = _xstatus_ne(cc); if (trace && sys_msg) trace_printf("srv: rcvd sys msg=%d\n", sys_msgp->u_z_msg.z_msgnumber[0]); if (sys_msg) { sys_msg_count++; inx--; } lerr2 = BFILE_GETINFO_(filenumr, &lerr); TEST_CHK_FEIGNORE(lerr2); if (trace) trace_printf("srv: reply, inx=%d\n", inx); cc = BREPLYX(recv_buffer, (unsigned short) 0, &count_written, 0, XZFIL_ERR_OK); TEST_CHK_CCEQ(cc); if (sys_msg_count >= 4) fin = true; } } time_stop(T_TOTAL); time_elapsed(T_TOTAL); if (client) { dsec = time_sec(T_TOTAL); dms = dsec * 1000.0; printf("elapsed=%f\n", dms); printf("open/close/newprocess/processinfo/forkexec=%d\n", loop); dsec = time_sec(T_OPEN); dms = dsec * 1000.0; printf("open : total-time=%f ms, time/loop=%f ms, ops/sec=%f\n", dms, dms / dloop, dloop / dsec); dsec = time_sec(T_CLOSE); dms = dsec * 1000.0; printf("close : total-time=%f ms, time/loop=%f ms, ops/sec=%f\n", dms, dms / dloop, dloop / dsec); dsec = time_sec(T_PROCINFO); dms = dsec * 1000.0; printf("procinfo : total-time=%f ms, time/loop=%f ms, ops/sec=%f\n", dms, dms / dloop, dloop / dsec); dsec = time_sec(T_PROCINFO_TYPE); dms = dsec * 1000.0; printf("procinfo-type : total-time=%f ms, time/loop=%f ms, ops/sec=%f\n", dms, dms / dloop, dloop / dsec); dsec = time_sec(T_NEWPROC); dms = dsec * 1000.0; printf("newproc : total-time=%f ms, time/loop=%f ms, ops/sec=%f\n", dms, dms / dloop, dloop / dsec); dsec = time_sec(T_FORKEXEC); dms = dsec * 1000.0; printf("forkexec : total-time=%f ms, time/loop=%f ms, ops/sec=%f\n", dms, dms / dloop, dloop / dsec); dsec = time_sec(T_FORKEXEC_SU); dms = dsec * 1000.0; printf("forkexec-startup: total-time=%f ms, time/loop=%f ms, ops/sec=%f\n", dms, dms / dloop, dloop / dsec); } ferr = msg_mon_process_shutdown(); TEST_CHK_FEOK(ferr); util_test_finish(client); return 0; }
int main(int argc, char *argv[]) { bool exit; int ferr; int lerr; int msgid; int nid; int oid; int pid; TPT_DECL (phandle); char recv_buffer[BUFSIZ]; short recv_buffer2[BUFSIZ]; MS_Result_Type results; MS_SRE sre; ferr = msfs_util_init_role(true, &argc, &argv, msg_debug_hook); TEST_CHK_FEOK(ferr); util_test_start(true); ferr = msg_mon_process_startup(true); // system messages TEST_CHK_FEOK(ferr); msg_mon_enable_mon_messages(true); printf("cli: opening server\n"); ferr = msg_mon_get_process_info((char *) "$srv", &nid, &pid); TEST_CHK_FEOK(ferr); printf("cli: server opened\n"); ferr = msg_mon_open_process((char *) "$srv", // name TPT_REF(phandle), &oid); TEST_CHK_FEOK(ferr); exit = false; while (!exit) { lerr = XWAIT(LREQ, -1); TEST_CHK_WAITIGNORE(lerr); for (;;) { lerr = XMSG_LISTEN_((short *) &sre, // sre 0, // listenopts 0); // listenertag if (lerr == XSRETYPE_NOWORK) break; ferr = XMSG_READDATA_(sre.sre_msgId, // msgid recv_buffer, // reqdata BUFSIZ); // bytecount util_check("XMSG_READDATA_", ferr); if (sre.sre_flags & XSRE_MON) { MS_Mon_Msg *msg = (MS_Mon_Msg *) recv_buffer; printf("cli: mon message, type=%d\n", msg->type); if (msg->type == MS_MsgType_Open) { ferr = msg_mon_get_process_info((char *) "$srv", &nid, &pid); TEST_CHK_FEOK(ferr); assert(msg->u.open.nid == nid); assert(msg->u.open.pid == pid); assert(strcasecmp(msg->u.open.target_process_name, "$srv") == 0); exit = true; } } else { printf("cli: NON-mon message\n"); } XMSG_REPLY_(sre.sre_msgId, // msgid NULL, // replyctrl 0, // replyctrlsize NULL, // replydata 0, // replydatasize 0, // errorclass NULL); // newphandle } } printf("cli: sending message to server\n"); ferr = XMSG_LINK_(TPT_REF(phandle), // phandle &msgid, // msgid NULL, // reqctrl 0, // reqctrlsize recv_buffer2, // replyctrl 1, // replyctrlmax NULL, // reqdata 0, // reqdatasize recv_buffer, // replydata BUFSIZ, // replydatamax 0, // linkertag 0, // pri 0, // xmitclass 0); // linkopts util_check("XMSG_LINK_", ferr); ferr = XMSG_BREAK_(msgid, (short *) &results, TPT_REF(phandle)); util_check("XMSG_BREAK_", ferr); exit = false; while (!exit) { lerr = XWAIT(LREQ, -1); for (;;) { lerr = XMSG_LISTEN_((short *) &sre, // sre 0, // listenopts 0); // listenertag if (lerr == XSRETYPE_NOWORK) break; ferr = XMSG_READDATA_(sre.sre_msgId, // msgid recv_buffer, // reqctrl BUFSIZ); // bytecount util_check("XMSG_READDATA_", ferr); if (sre.sre_flags & XSRE_MON) { MS_Mon_Msg *msg = (MS_Mon_Msg *) recv_buffer; printf("cli: mon message, type=%d\n", msg->type); if (msg->type == MS_MsgType_ProcessDeath) { assert(msg->u.death.nid == nid); assert(msg->u.death.pid == pid); exit = true; } } else printf("cli: NON-mon message\n"); XMSG_REPLY_(sre.sre_msgId, // msgid NULL, // replyctrl 0, // replyctrlsize NULL, // replydata 0, // replydatasize 0, // errorclass NULL); // newphandle } } ferr = msg_mon_process_shutdown(); TEST_CHK_FEOK(ferr); util_test_finish(true); return 0; }
int main(int argc, char *argv[]) { int exit; int ferr; bool ldone; int lerr; int msgid; int nid; int oid; int pid; TPT_DECL (phandle); char recv_buffer[BUFSIZ]; short recv_buffer2[BUFSIZ]; RT results; MS_SRE sre; MS_Mon_Transid_Type transid; ferr = msfs_util_init_role(true, &argc, &argv, msg_debug_hook); TEST_CHK_FEOK(ferr); util_test_start(true); ferr = msg_mon_process_startup(true); // system messages TEST_CHK_FEOK(ferr); msg_mon_enable_mon_messages(true); ferr = msg_mon_get_process_info((char *) "$srv", &nid, &pid); TEST_CHK_FEOK(ferr); ferr = msg_mon_open_process((char *) "$srv", // name TPT_REF(phandle), &oid); TEST_CHK_FEOK(ferr); TRANSID_SET_NULL(transid); ferr = msg_mon_deregister_death_notification(nid, pid, transid); TEST_CHK_FEOK(ferr); ferr = msg_mon_register_death_notification(nid, pid); TEST_CHK_FEOK(ferr); ferr = XMSG_LINK_(TPT_REF(phandle), // phandle &msgid, // msgid NULL, // reqctrl 0, // reqctrlsize recv_buffer2, // replyctrl 1, // replyctrlmax NULL, // reqdata 0, // reqdatasize recv_buffer, // replydata BUFSIZ, // replydatamax 0, // linkertag 0, // pri 0, // xmitclass XMSG_LINK_LDONEQ); // linkopts util_check("XMSG_LINK_", ferr); exit = 0; ldone = false; while (!exit) { do { lerr = XWAIT(LREQ|LDONE, -1); TEST_CHK_WAITIGNORE(lerr); if (lerr == LDONE) { ldone = true; break; } lerr = XMSG_LISTEN_((short *) &sre, // sre 0, // listenopts 0); // listenertag } while (lerr == XSRETYPE_NOWORK); if (ldone) { printf("LINK done\n"); lerr = XMSG_LISTEN_((short *) &sre, // sre XLISTEN_ALLOW_LDONEM, // listenopts 0); // listenertag assert(lerr == XSRETYPE_LDONE); ferr = XMSG_BREAK_(sre.sre_msgId, results.u.s, TPT_REF(phandle)); assert(ferr == XZFIL_ERR_OK); break; } ferr = XMSG_READDATA_(sre.sre_msgId, // msgid recv_buffer, // reqdata BUFSIZ); // bytecount util_check("XMSG_READDATA_", ferr); if (sre.sre_flags & XSRE_MON) { MS_Mon_Msg *msg = (MS_Mon_Msg *) recv_buffer; printf("cli: mon message, type=%d\n", msg->type); if (msg->type == MS_MsgType_ProcessDeath) { assert(msg->u.death.nid == nid); assert(msg->u.death.pid == pid); exit = 1; } else if (msg->type == MS_MsgType_Shutdown) { printf("cli: received cluster shutdown, level=%d\n", msg->u.shutdown.level); assert(msg->u.shutdown.level==MS_Mon_ShutdownLevel_Immediate); } } else printf("cli: NON-mon message\n"); XMSG_REPLY_(sre.sre_msgId, // msgid NULL, // replyctrl 0, // replyctrlsize NULL, // replydata 0, // replydatasize 0, // errorclass NULL); // newphandle } ferr = msg_mon_process_shutdown(); TEST_CHK_FEOK(ferr); util_test_finish(true); return 0; }