int main(int argc, char *argv[]) {
bool client = false;
int ferr;
int inx;
int loop = 10;
int msgid;
int oid;
RT results;
TPT_DECL (phandle);
int send_len;
TAD zargs[] = {
{ "-loop", TA_Int, TA_NOMAX, &loop },
{ "", TA_End, TA_NOMAX, NULL }
};
msfs_util_init_role(true, &argc, &argv, msg_debug_hook);
arg_proc_args(zargs, false, argc, argv);
client = true;
util_test_start(client);
ferr = msg_mon_process_startup(!client); // system messages
TEST_CHK_FEOK(ferr);
ferr = msg_mon_open_process((char *) "$srv", // name
TPT_REF(phandle),
&oid);
TEST_CHK_FEOK(ferr);
util_gethostname(my_name, sizeof(my_name));
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;
ferr = XMSG_LINK_(TPT_REF(phandle), // phandle
&msgid, // msgid
send_buffer2, // reqctrl
(ushort) ((inx & 1) + 1), // reqctrlsize
recv_buffer3, // replyctrl
2, // 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_REF(phandle));
util_check("XMSG_BREAK_", ferr);
assert(results.u.t.ctrl_size == (uint) ((inx & 1) + 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);
}
ferr = msg_mon_close_process(TPT_REF(phandle));
printf("close ferr=%d\n", ferr);
printf("client shutting down\n");
ferr = msg_mon_process_shutdown();
TEST_CHK_FEOK(ferr);
util_test_finish(client);
return 0;
}
int main(int argc, char *argv[]) {
bool client = false;
int disable;
int ferr;
int oid;
TPT_DECL (phandle);
TAD zargs[] = {
{ "-client", TA_Bool, TA_NOMAX, &client },
{ "-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(true); // system messages?
TEST_CHK_FEOK(ferr);
if (client) {
disable = msg_test_assert_disable();
ferr = msg_mon_open_process((char *) "$srv", // name
TPT_REF(phandle),
&oid);
TEST_CHK_FEIGNORE(ferr);
msg_test_assert_enable(disable);
}
ferr = msg_mon_process_shutdown();
TEST_CHK_FEOK(ferr);
util_test_finish(client);
return 0;
}
int main(int argc, char *argv[]) {
bool client = false;
int ferr;
char my_name[BUFSIZ];
int oid;
TPT_DECL (phandle);
TAD zargs[] = {
{ "-client", TA_Bool, TA_NOMAX, &client },
{ "-server", TA_Ign, TA_NOMAX, NULL },
{ "", TA_End, TA_NOMAX, NULL }
};
msg_mon_enable_mon_messages(true);
msfs_util_init(&argc, &argv, msg_debug_hook);
arg_proc_args(zargs, false, argc, argv);
util_test_start(client);
ferr = msg_mon_process_startup(true); // system messages
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_open_process((char *) "$srv", // name
TPT_REF(phandle),
&oid);
TEST_CHK_FEOK(ferr);
do_readmsg(); // open message
} else {
do_readmsg(); // open message
ferr = msg_mon_open_process((char *) "$cli", // name
TPT_REF(phandle),
&oid);
TEST_CHK_FEOK(ferr);
}
util_gethostname(my_name, sizeof(my_name));
if (client) {
ferr = msg_mon_close_process(TPT_REF(phandle));
TEST_CHK_FEOK(ferr);
ferr = msg_mon_process_close();
TEST_CHK_FEOK(ferr);
printf("if there were no asserts, all is well\n");
} else {
ferr = msg_mon_process_close();
TEST_CHK_FEOK(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(client);
return 0;
}
static void frmt_SMSG(FS_Receiveinfo_Type *receiveInfo, FILE* fp)
{
char obuffer[1000];
char* pbuffer = obuffer;
int ip;
short filenum;
TCPU_DECL(cpu); //short cpu;
TPIN_DECL(pin);//short pin;
int node;
short tag;
short procname_len = 0,nodename_len = 0;
char procname[81];
char nodename[50];
char tbuffer[128];
short maxlen = sizeof(procname)-1;
// NSK_PROCESS_HANDLE pHandle;
TPT_DECL(pHandle);
filenum = receiveInfo->file_number;
memcpy(TPT_REF(pHandle),&receiveInfo->sender,sizeof(pHandle));
tag = receiveInfo->message_tag;
short error = PROCESSHANDLE_DECOMPOSE_ (
TPT_REF(pHandle)
,&cpu /*cpu*/
,&pin /*pin*/
,&node /*nodenumber*/
,(char*)&nodename /*nodename:nmax*/
,sizeof(nodename)
,&nodename_len /*nlen*/
,procname
,maxlen
,&procname_len);
procname[procname_len] = 0;
nodename[nodename_len] = 0;
sprintf(tbuffer,"%s.%s",nodename,procname);
strcpy(procname,tbuffer);
ip=sprintf(pbuffer,"\t<MSG FORMAT>\n");
pbuffer +=ip;ip=sprintf(pbuffer,"\t\t%15.15s\t\t=\t\t%d\n","filenum",filenum);
pbuffer +=ip;ip=sprintf(pbuffer,"\t\t%15.15s\t\t=\t\t%d\n","cpu",cpu);
pbuffer +=ip;ip=sprintf(pbuffer,"\t\t%15.15s\t\t=\t\t%d\n","pin",pin);
pbuffer +=ip;ip=sprintf(pbuffer,"\t\t%15.15s\t\t=\t\t%d\n","node",node);
pbuffer +=ip;ip=sprintf(pbuffer,"\t\t%15.15s\t\t=\t\t%d\n","tag",tag);
pbuffer +=ip;ip=sprintf(pbuffer,"\t\t%15.15s\t\t=\t\t%s\n","process",procname);
fwrite(obuffer, strlen(obuffer),1,fp);
fwrite("\r\n",2,1,fp);
fflush(fp);
}
void restart_server() {
int disable;
int ferr;
MS_Mon_Process_Info_Type info;
char prog[BUFSIZ];
TPT_DECL (server_phandle);
ferr = msg_mon_get_process_info_detail((char *) "$srv", &info);
if (ferr == XZFIL_ERR_OK)
return; // server is alive
sprintf(prog, "%s/%s", getenv("PWD"), gargv[0]);
if (verbose)
printf("%s - starting server\n", who);
// TODO: remove disable/loop
disable = msg_test_assert_disable();
do {
ferr = msg_mon_start_process(prog, // prog
(char *) "$srv", // name
NULL, // ret name
*gargc,
gargv,
TPT_REF(server_phandle),
0, // open
NULL, // oid
MS_ProcessType_Generic, // type
0, // priority
0, // debug
0, // backup
NULL, // nid
NULL, // pid
NULL, // infile
NULL); // outfile
if (ferr == XZFIL_ERR_BOUNDSERR) {
printf("TODO: remove this sleep - $srv already in use\n");
sleep(1);
}
} while (ferr == XZFIL_ERR_BOUNDSERR);
TEST_CHK_FEOK(ferr);
msg_test_assert_enable(disable);
}
int main(int argc, char *argv[]) {
bool client = false;
int ferr;
int inx;
int inx2;
int lerr;
int loop = 10;
int oid;
TPT_DECL (phandle);
MS_SRE sre;
long t_elapsed;
struct timeval t_start;
struct timeval t_stop;
bool verbose = false;
TAD zargs[] = {
{ "-client", TA_Bool, TA_NOMAX, &client },
{ "-loop", TA_Int, TA_NOMAX, &loop },
{ "-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(client);
ferr = msg_mon_process_startup(!client); // system messages?
TEST_CHK_FEOK(ferr);
util_time_timer_start(&t_start);
if (client) {
for (inx = 0; inx < loop; inx++) {
if (verbose)
printf("opening inx=%d\n", inx);
ferr = msg_mon_open_process((char *) "$srv", // name
TPT_REF(phandle),
&oid);
TEST_CHK_FEOK(ferr);
ferr = msg_mon_close_process(TPT_REF(phandle));
TEST_CHK_FEOK(ferr);
}
} else {
msg_mon_enable_mon_messages(true);
for (inx = 0; inx < loop; inx++) {
for (inx2 = 0; inx2 < 2; inx2++) {
do {
lerr = XWAIT(LREQ, -1);
TEST_CHK_WAITIGNORE(lerr);
lerr = XMSG_LISTEN_((short *) &sre, // sre
0, // listenopts
0); // listenertag
} while (lerr == XSRETYPE_NOWORK);
if (verbose)
printf("replying inx=%d\n", inx);
XMSG_REPLY_(sre.sre_msgId, // msgid
NULL, // replyctrl
0, // replyctrlsize
NULL, // replydata
0, // replydatasize
0, // errorclass
NULL); // newphandle
}
}
}
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[]) {
bool chook = false;
bool client = false;
FILE *f;
bool fail = false;
int ferr;
int lerr;
int msgid;
int oid;
TPT_DECL (phandle);
MS_Result_Type results;
MS_SRE sre;
TAD zargs[] = {
{ "-chook", TA_Bool, TA_NOMAX, &chook },
{ "-client", TA_Bool, TA_NOMAX, &client },
{ "-cluster", TA_Ign, TA_NOMAX, NULL },
{ "-fail", TA_Bool, TA_NOMAX, &fail },
{ "-verbose", TA_Ign, TA_NOMAX, NULL },
{ "", TA_End, TA_NOMAX, NULL }
};
arg_proc_args(zargs, false, argc, argv);
if (chook)
test_debug_hook("c", "c");
util_test_start(true);
if (client) {
f = NULL;
while (f == NULL) {
f = fopen("z100", "r");
if (f == NULL)
sleep(1);
}
fclose(f);
}
if (client)
ferr = msg_init_attach(&argc, &argv, true, (char *) "$CLI");
else
ferr = msg_init(&argc, &argv);
TEST_CHK_FEOK(ferr);
ferr = msg_mon_process_startup(!client); // system messages
TEST_CHK_FEOK(ferr);
if (client) {
ferr = msg_mon_open_process((char *) "$SRV", TPT_REF(phandle), &oid);
TEST_CHK_FEOK(ferr);
if (fail)
util_abort_core_free();
ferr = XMSG_LINK_(TPT_REF(phandle), // phandle
&msgid, // msgid
NULL, // reqctrl
0, // reqctrlsize
recv_buffer3, // replyctrl
0, // replyctrlmax
NULL, // reqdata
0, // reqdatasize
recv_buffer, // replydata
0, // replydatamax
0, // linkertag
0, // pri
0, // xmitclass
0); // linkopts
TEST_CHK_FEOK(ferr);
ferr = XMSG_BREAK_(msgid, (short *) &results, TPT_REF(phandle));
TEST_CHK_FEOK(ferr);
} else {
f = fopen("z100", "w");
assert(f != NULL);
fclose(f);
for (;;) {
do {
lerr = XWAIT(LREQ, 20);
TEST_CHK_WAITIGNORE(lerr);
if (!lerr)
continue;
lerr = XMSG_LISTEN_((short *) &sre, // sre
0, // listenopts
0); // listenertag
} while (lerr == XSRETYPE_NOWORK);
if (sre.sre_flags & XSRE_MON)
printf("server received mon message\n");
else
printf("server received regular message\n");
XMSG_REPLY_(sre.sre_msgId, // msgid
recv_buffer2, // replyctrl
0, // replyctrlsize
recv_buffer, // replydata
0, // replydatasize
0, // errorclass
NULL); // newphandle
if ((sre.sre_flags & XSRE_MON) == 0)
break;
}
}
ferr = msg_mon_process_shutdown();
TEST_CHK_FEOK(ferr);
util_test_finish(true);
return 0;
}
int main(int argc, char *argv[]) {
bool client = false;
bool client1 = false;
bool client2 = false;
bool client3 = false;
int ferr;
int inx;
int lerr;
int loop = 10;
int msgid;
int oid;
TPT_DECL (phandle);
MS_Result_Type results;
MS_SRE sre;
MS_Mon_Transid_Type transid;
TAD zargs[] = {
{ "-client1", TA_Bool, TA_NOMAX, &client1 },
{ "-client2", TA_Bool, TA_NOMAX, &client2 },
{ "-client3", TA_Bool, TA_NOMAX, &client3 },
{ "-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);
if (client1)
client = true;
if (client2)
client = true;
if (client3)
client = true;
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);
}
util_gethostname(my_name, sizeof(my_name));
if (client) {
if (client1)
sleep(5);
else if (client2) {
util_abort_core_free();
} else {
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, (short *) &results, TPT_REF(phandle));
util_check("XMSG_BREAK_", ferr);
}
} else {
msg_mon_enable_mon_messages(true);
for (inx = 0; inx < 7; inx++) {
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_READDATA_(sre.sre_msgId, // msgid
recv_buffer, // reqdata
40000); // bytecount
util_check("XMSG_READDATA_", ferr);
if (sre.sre_flags & XSRE_MON) {
MS_Mon_Msg *msg = (MS_Mon_Msg *) recv_buffer;
if (msg->type == MS_MsgType_Open) {
if (strcasecmp(msg->u.open.target_process_name, "$cli2") == 0) {
transid.id[0] = -1;
transid.id[1] = -1;
transid.id[2] = -1;
transid.id[3] = -1;
ferr = msg_mon_deregister_death_notification(-1, // msg->u.open.nid,
-1, // msg->u.open.pid,
transid);
TEST_CHK_FEOK(ferr);
}
}
printf("server reply type=%d, inx=%d\n", msg->type, inx);
} else
printf("server reply inx=%d\n", inx);
XMSG_REPLY_(sre.sre_msgId, // msgid
NULL, // replyctrl
0, // replyctrlsize
recv_buffer, // replydata
0, // replydatasize
0, // errorclass
NULL); // newphandle
}
}
if (client) {
ferr = msg_mon_close_process(TPT_REF(phandle));
TEST_CHK_FEOK(ferr);
}
ferr = msg_mon_process_shutdown();
TEST_CHK_FEOK(ferr);
util_test_finish(client);
return 0;
}
void CNSKListener::OpenTraceFile()
{
struct timeb CurrentTime;
short error;
// short processId;
// short cpuNumber;
short errorDetail;
short procname_len = 0;
char procname[81];
short maxlen = sizeof(procname)-1;
//NSK_PROCESS_HANDLE pHandle;
TPT_DECL(pHandle);
TCPU_DECL(cpuNumber);
TCPU_DECL(processId); //processId
if ((error = PROCESSHANDLE_NULLIT_ (TPT_REF(pHandle))) != 0)
{
m_TransportTrace = 0;
return;
}
if ((error = PROCESSHANDLE_GETMINE_(TPT_REF(pHandle))) != 0)
{
m_TransportTrace = 0;
return;
}
procname[0]=0;
if ((error = PROCESSHANDLE_DECOMPOSE_ (
TPT_REF(pHandle)
,&cpuNumber //[ short *cpu ]
,&processId //[ short *pin ]
,OMITREF //[ long *nodenumber ]
,OMITREF //[ char *nodename ]
,OMITSHORT //[ short maxlen ]
,OMITREF //[ short *nodename-length ]
,procname //[ char *procname ]
,maxlen //[ short maxlen ]
,&procname_len //[ short *procname-length ]
,OMITREF //[ long long *sequence-number ]
)) != 0)
{
m_TransportTrace = 0;
return;
}
procname[procname_len] = 0;
ftime(&CurrentTime);
sprintf( m_TraceFileName, "TT%s",procname+1);
// sprintf( m_TraceFileName, "TT%02d%03d",cpuNumber, processId);
FILE* fp = fopen_guardian( m_TraceFileName,"w");
if (fp != NULL)
{
fprintf(fp,"<==========SERVER TRACE (%s)==========>\n",frmt_current_date(CurrentTime));
TCP_PROCESSNAME_PORT(fp);
fprintf(fp,"<==========PROCESS %s (%02d,%03d) ==========>\n\n",procname, cpuNumber, processId);
fflush(fp);
fclose(fp);
}
else
m_TransportTrace = 0;
}
int main(int argc, char *argv[]) {
bool client = false;
unsigned expR3;
int ferr;
int inx;
int lc;
int lerr;
int msgid;
int oid;
RT results;
TPT_DECL (phandle);
MS_SRE sre;
TAD zargs[] = {
{ "-client", TA_Bool, TA_NOMAX, &client },
{ "-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);
}
util_gethostname(my_name, sizeof(my_name));
lc = (int) (sizeof(res)/sizeof(Test_Results));
for (inx = 0; inx < lc; inx++) {
if (client) {
sprintf(send_buffer, "hello, greetings from %s, inx=%d",
my_name, inx);
ferr = XMSG_LINK_(TPT_REF(phandle), // phandle
&msgid, // msgid
ctrl_buffer, // reqctrl
res[inx].cQc, // reqctrlsize
ctrl_buffer, // replyctrl
res[inx].cPcM, // replyctrlmax
send_buffer, // reqdata
res[inx].cQd, // reqdatasize
recv_buffer, // replydata
res[inx].cPdM, // replydatamax
0, // linkertag
0, // pri
0, // xmitclass
0); // linkopts
util_check("XMSG_LINK_", ferr);
// ferr = XMSG_ISDONE_(msgid);
// checkdone("XMSG_ISDONE_", ferr);
results.u.t.ctrl_size = (uint) -1;
results.u.t.data_size = (uint) -1;
results.u.t.errm = (uint) -1;
ferr = XMSG_BREAK_(msgid, results.u.s, TPT_REF(phandle));
util_check("XMSG_BREAK_", ferr);
if (results.u.t.ctrl_size != res[inx].cEpC) {
printf("*** ERROR inx=%d, results.ctrl_size=%d, cEpC=%d\n",
inx, (int) results.u.t.ctrl_size, (int) res[inx].cEpC);
assert(results.u.t.ctrl_size == res[inx].cEpC);
}
if (results.u.t.data_size != (uint) res[inx].cEpD) {
printf("*** ERROR inx=%d, results.data_size=%d, cEpD=%d\n",
inx, (int) results.u.t.data_size, (int) res[inx].cEpD);
assert(results.u.t.data_size == res[inx].cEpD);
}
expR3 = 0x0; // no-data
if (res[inx].cEpD > 0)
expR3 |= 0x2; // data
if (results.u.t.errm != expR3) {
printf("*** ERROR inx=%d, results.errm=%x, expR3=%x\n",
inx, results.u.t.errm, expR3);
assert(results.u.t.errm == expR3);
}
} else {
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_reqCtrlSize != res[inx].sEqC) {
printf("*** ERROR inx=%d, sre.sre_reqCtrlSize=%d, sEqC=%d\n",
inx, sre.sre_reqCtrlSize, res[inx].sEqC);
assert(sre.sre_reqCtrlSize == res[inx].sEqC);
}
if (sre.sre_reqDataSize != res[inx].sEqD) {
printf("*** ERROR inx=%d, sre.sre_reqDataSize=%d, sEqD=%d\n",
inx, sre.sre_reqDataSize, res[inx].sEqD);
assert(sre.sre_reqDataSize == res[inx].sEqD);
}
ferr = XMSG_READCTRL_(sre.sre_msgId, // msgid
ctrl_buffer, // reqctrl
res[inx].sQc); // bytecount
util_check("XMSG_READCTRL_", ferr);
ferr = XMSG_READDATA_(sre.sre_msgId, // msgid
recv_buffer, // reqdata
res[inx].sQd); // bytecount
util_check("XMSG_READDATA_", ferr);
XMSG_REPLY_(sre.sre_msgId, // msgid
(short *) recv_buffer, // replyctrl
res[inx].sPc, // replyctrlsize
recv_buffer, // replydata
res[inx].sPd, // replydatasize
0, // errorclass
NULL); // newphandle
}
}
if (client) {
ferr = msg_mon_close_process(TPT_REF(phandle));
TEST_CHK_FEOK(ferr);
printf("if there were no asserts, all is well\n");
}
ferr = msg_mon_process_shutdown();
TEST_CHK_FEOK(ferr);
util_test_finish(client);
return 0;
}
int main(int argc, char *argv[]) {
bool client = false;
int ferr;
int inxl;
int inxo;
int inxs;
int maxs = 2;
int msgid[MAX_OUT];
bool mq = false;
int oid;
TPT_DECL (phandle);
void *res;
RT results;
const char *serv = "$srv";
int status;
TAD zargs[] = {
{ "-client", TA_Bool, TA_NOMAX, &client },
{ "-loop", TA_Int, TA_NOMAX, &loop },
{ "-maxout", TA_Int, MAX_OUT, &maxout },
{ "-maxs", TA_Int, MAX_THR_S, &maxs },
{ "-mq", TA_Bool, TA_NOMAX, &mq },
{ "-server", TA_Ign, TA_NOMAX, NULL },
{ "-v", TA_Bool, TA_NOMAX, &verbose },
{ "", TA_End, TA_NOMAX, NULL }
};
ferr = msg_init(&argc, &argv);
TEST_CHK_FEOK(ferr);
msfs_util_init_fs(&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);
ferr = msg_mon_get_my_process_name(my_name, BUFSIZ);
util_check("msg_mon_get_my_process_name", ferr);
if (client) {
ferr = XCONTROLMESSAGESYSTEM(XCTLMSGSYS_SETSENDLIMIT,
XMAX_SETTABLE_SENDLIMIT);
assert(ferr == XZFIL_ERR_OK);
atomic_set(&msg_count, 0);
for (inxl = 0; inxl < loop; inxl++) {
ferr = msg_mon_open_process((char *) serv, // name
TPT_REF(phandle),
&oid);
TEST_CHK_FEOK(ferr);
count = 0;
for (inxo = 0; inxo < 2; inxo++) {
ferr = BMSG_LINK_(TPT_REF(phandle), // phandle
&msgid[inxo], // msgid
NULL, // reqctrl
0, // reqctrlsize
send_buffer2[inxo], // replyctrl
24, // replyctrlmax
send_buffer[inxo], // reqdata
0, // reqdatasize
recv_buffer[inxo], // replydata
BUFSIZ, // replydatamax
0, // linkertag
0, // pri
0, // xmitclass
0); // linkopts
util_check("XMSG_LINK_", ferr);
atomic_inc(&msg_count);
}
ferr = XMSG_ABANDON_(msgid[0]);
util_check("XMSG_ABANDON_", ferr);
ferr = BMSG_LINK_(TPT_REF(phandle), // phandle
&msgid[inxo], // msgid
NULL, // reqctrl
0, // reqctrlsize
send_buffer2[inxo], // replyctrl
24, // replyctrlmax
send_buffer[inxo], // reqdata
0, // reqdatasize
recv_buffer[inxo], // replydata
BUFSIZ, // replydatamax
0, // linkertag
0, // pri
0, // xmitclass
0); // linkopts
util_check("XMSG_LINK_", ferr);
atomic_inc(&msg_count);
ferr = BMSG_BREAK_(msgid[inxo],
results.u.s,
TPT_REF(phandle));
util_check("XMSG_BREAK_", ferr);
ferr = XMSG_ABANDON_(msgid[1]);
util_check("XMSG_ABANDON_", ferr);
if (maxout < 4)
maxout = 4;
for (inxo = 3; inxo < maxout; inxo++) {
ferr = BMSG_LINK_(TPT_REF(phandle), // phandle
&msgid[inxo], // msgid
NULL, // reqctrl
0, // reqctrlsize
send_buffer2[inxo], // replyctrl
60, // replyctrlmax
send_buffer[inxo], // reqdata
120, // reqdatasize
recv_buffer[inxo], // replydata
BUFSIZ, // replydatamax
0, // linkertag
0, // pri
0, // xmitclass
0); // linkopts
util_check("XMSG_LINK_", ferr);
atomic_inc(&msg_count);
if (verbose)
printf("client(%s): msg-count=%d\n",
my_name, atomic_read(&msg_count));
count++;
ferr = BMSG_BREAK_(msgid[inxo],
results.u.s,
TPT_REF(phandle));
util_check("XMSG_BREAK_", ferr);
}
if (mq) {
if ((inxl % 100) == 0)
printf("client(%s): count=%d\n", my_name, inxl);
}
}
ferr = msg_mon_close_process(TPT_REF(phandle));
TEST_CHK_FEOK(ferr);
} else {
ferr = XCONTROLMESSAGESYSTEM(XCTLMSGSYS_SETRECVLIMIT,
XMAX_SETTABLE_RECVLIMIT);
assert(ferr == XZFIL_ERR_OK);
closes = 0;
maxmsg = loop * maxout;
atomic_set(&msg_count, 0);
msg_mon_enable_mon_messages(true);
for (inxs = 0; inxs < maxs; inxs++) {
char lname[10];
sprintf(lname, "s%d", inxs);
thrs[inxs] = new MyThread(server_thr, lname, inxs);
}
for (inxs = 0; inxs < maxs; inxs++)
thrs[inxs]->start();
for (inxs = 0; inxs < maxs; inxs++) {
status = thrs[inxs]->join(&res);
TEST_CHK_STATUSOK(status);
printf("joined with server %d\n", inxs);
}
}
ferr = msg_mon_process_shutdown();
TEST_CHK_FEOK(ferr);
util_test_finish(client);
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[]) {
bool client = false;
int count;
int disable;
int ferr;
MS_Mon_Open_Info_Type info;
MS_Mon_Open_Info_Max_Type info_max[MAX_OPENS];
int inx;
int len;
int lerr;
int loop = 10;
int msgid;
int oid;
TPT_DECL (phandle);
RT results;
int send_len;
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);
// 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) {
ferr = msg_mon_open_process((char *) "$srv", // name
TPT_REF(phandle),
&oid);
TEST_CHK_FEOK(ferr);
} else
util_gethostname(my_name, sizeof(my_name));
msg_mon_enable_mon_messages(true);
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);
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_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 {
if (inx == 0) {
sleep(3); // wait for monitor replicate
disable = msg_test_assert_disable();
ferr = msg_mon_get_open_info(-1,
-1,
(char *) "$srv",
1,
&info);
assert(ferr == XZFIL_ERR_INVALOP);
ferr = msg_mon_get_open_info_max(-1,
-1,
(char *) "$srv",
false,
&count,
MAX_OPENS,
info_max);
assert(ferr == XZFIL_ERR_INVALOP);
msg_test_assert_enable(disable);
}
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[]) {
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 disable;
int ferr;
int inx;
int len;
int lerr;
int loop = 10;
int msgid;
int oid;
TPT_DECL (phandle);
RT results;
MS_SRE sre;
TPT_DECL (xphandle);
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 }
};
setenv("MS_STREAMS_MAX", "10", 1);
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);
} else {
disable = msg_test_assert_disable();
for (inx = 0; inx < 20; inx++) {
ferr = msg_mon_open_process((char *) "$crap", // name
TPT_REF(xphandle),
&oid);
assert(ferr != XZFIL_ERR_OK);
}
msg_test_assert_enable(disable);
}
util_gethostname(my_name, sizeof(my_name));
for (inx = 0; inx < loop; inx++) {
if (client) {
sprintf(send_buffer, "hello, greetings from %s, inx=%d",
my_name, inx);
ferr = XMSG_LINK_(TPT_REF(phandle), // phandle
&msgid, // msgid
NULL, // reqctrl
0, // reqctrlsize
NULL, // replyctrl
0, // replyctrlmax
send_buffer, // reqdata
39000, // reqdatasize
recv_buffer, // replydata
40000, // 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);
assert(results.u.t.ctrl_size == 0);
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_READCTRL_(sre.sre_msgId, // msgid
NULL, // reqctrl
0); // bytecount
util_check("XMSG_READCTRL_", ferr);
ferr = XMSG_READDATA_(sre.sre_msgId, // msgid
recv_buffer, // reqdata
40000); // bytecount
util_check("XMSG_READDATA_", ferr);
strcat(recv_buffer, "- reply from ");
strcat(recv_buffer, my_name);
len = (int) strlen(recv_buffer) + 1;
len = len; // touch - not currently used
XMSG_REPLY_(sre.sre_msgId, // msgid
NULL, // replyctrl
0, // replyctrlsize
recv_buffer, // replydata
39000, // replydatasize
0, // errorclass
NULL); // newphandle
}
}
if (client) {
ferr = msg_mon_close_process(TPT_REF(phandle));
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 client = false;
int disable;
int ferr;
int inx;
int lerr;
int loop = 10;
int msgid;
int oid;
TPT_DECL (phandle);
RT results;
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);
}
util_gethostname(my_name, sizeof(my_name));
if (client) {
for (inx = 0; inx < loop; inx++) {
disable = msg_test_assert_disable();
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));
assert(ferr);
msg_test_assert_enable(disable);
}
} else {
msg_mon_enable_mon_messages(true);
do {
lerr = XWAIT(LREQ, -1);
TEST_CHK_WAITIGNORE(lerr);
lerr = XMSG_LISTEN_((short *) &sre, // sre
0, // listenopts
0); // listenertag
} while (lerr == XSRETYPE_NOWORK);
XMSG_REPLY_(sre.sre_msgId, // msgid
NULL, // replyctrl
0, // replyctrlsize
recv_buffer, // replydata
0, // replydatasize
0, // errorclass
NULL); // newphandle
util_abort_core_free();
}
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 client = false;
int exprinx;
int ferr;
int inx;
int len;
int lerr;
int loop = 100;
int msgid[MAX_MSGS];
int oid;
char *p;
TPT_DECL (phandle);
int pri;
RT results;
int rinx;
BMS_SRE sre;
BMS_SRE_LDONE sre_ldone;
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);
} else
msg_enable_priority_queue();
util_gethostname(my_name, sizeof(my_name));
if (client) {
for (inx = 0; inx < loop; inx++) {
sprintf(send_buffer[inx], "hello, greetings from %s, inx=%d",
my_name, inx);
pri = 2 * inx + 5;
ferr = BMSG_LINK_(TPT_REF(phandle), // phandle
&msgid[inx], // msgid
NULL, // reqctrl
0, // reqctrlsize
NULL, // replyctrl
0, // replyctrlmax
send_buffer[inx], // reqdata
100, // reqdatasize
recv_buffer[inx], // replydata
100, // replydatamax
inx, // linkertag
(short) pri, // pri
0, // xmitclass
BMSG_LINK_LDONEQ); // linkopts
util_check("BMSG_LINK_", ferr);
}
exprinx = loop - 1;
for (inx = 0; inx < loop;) {
lerr = XWAIT(LDONE, -1);
TEST_CHK_WAITIGNORE(lerr);
do {
lerr = BMSG_LISTEN_((short *) &sre_ldone, // sre
0, // listenopts
0); // listenertag
if (lerr == BSRETYPE_LDONE) {
ferr = BMSG_BREAK_(sre_ldone.sre_msgId, results.u.s, TPT_REF(phandle));
util_check("BMSG_BREAK_", ferr);
assert(results.u.t.ctrl_size == 0);
assert(results.u.t.errm == RT_DATA_RCVD); // data
printf("%s\n", recv_buffer[sre_ldone.sre_linkTag]);
p = strchr(recv_buffer[sre_ldone.sre_linkTag], '=');
assert(p != NULL);
rinx = atoi(&p[1]);
if (rinx != exprinx) {
printf("rinx=%d, exprinx=%d\n", rinx, exprinx);
assert(rinx == exprinx);
}
inx++;
exprinx--;
}
} while (lerr == BSRETYPE_LDONE);
}
} else {
for (inx = 0; inx < loop; inx++) {
do {
lerr = XWAIT(LREQ, -1);
if (inx == 0)
sleep(5);
lerr = BMSG_LISTEN_((short *) &sre, // sre
0, // listenopts
0); // listenertag
} while (lerr == BSRETYPE_NOWORK);
ferr = BMSG_READCTRL_(sre.sre_msgId, // msgid
NULL, // reqctrl
0); // bytecount
util_check("BMSG_READCTRL_", ferr);
ferr = BMSG_READDATA_(sre.sre_msgId, // msgid
recv_buffer[inx], // reqdata
100); // bytecount
util_check("BMSG_READDATA_", ferr);
strcat(recv_buffer[inx], "- reply from ");
strcat(recv_buffer[inx], my_name);
len = (int) strlen(recv_buffer[inx]) + 1;
len = len; // touch - not currently used
BMSG_REPLY_(sre.sre_msgId, // msgid
NULL, // replyctrl
0, // replyctrlsize
recv_buffer[inx], // replydata
100, // replydatasize
0, // errorclass
NULL); // newphandle
}
}
if (client) {
ferr = msg_mon_close_process(TPT_REF(phandle));
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 attach = false;
bool chook = false;
bool client = false;
const char *cname = "$cli";
int count;
int ferr;
int inx;
int len;
int lerr;
int loop = 10;
int msgid;
int oid;
TPT_DECL (phandle);
char *pname = NULL;
RT results;
int send_len;
bool shook = false;
const char *sname = "$srv";
MS_SRE sre;
long t_elapsed;
struct timeval t_start;
struct timeval t_stop;
TAD zargs[] = {
{ "-attach", TA_Bool, TA_NOMAX, &attach },
{ "-chook", TA_Bool, TA_NOMAX, &chook },
{ "-client", TA_Bool, TA_NOMAX, &client },
{ "-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 },
{ "", TA_End, TA_NOMAX, NULL }
};
arg_proc_args(zargs, false, argc, argv);
if (client && chook)
test_debug_hook("c", "c");
if (!client && shook)
test_debug_hook("s", "s");
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);
// 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) {
ferr = msg_mon_open_process((char *) sname, // name
TPT_REF(phandle),
&oid);
TEST_CHK_FEOK(ferr);
}
util_gethostname(my_name, sizeof(my_name));
msg_mon_enable_mon_messages(true);
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_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 {
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);
}
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[]) {
bool client = false;
bool disable = false;
int ferr;
int lerr;
int msgid;
int oid;
TPT_DECL (phandle);
RT results;
MS_SRE sre;
TAD zargs[] = {
{ "-client", TA_Bool, TA_NOMAX, &client },
{ "-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);
}
util_gethostname(my_name, sizeof(my_name));
if (client) {
sprintf(send_buffer, "hello, greetings from %s", my_name);
ferr = XMSG_LINK_(TPT_REF(phandle), // phandle
&msgid, // msgid
NULL, // reqctrl
0, // reqctrlsize
NULL, // replyctrl
0, // replyctrlmax
send_buffer, // reqdata
39000, // reqdatasize
recv_buffer, // replydata
40000, // replydatamax
0, // linkertag
0, // pri
0, // xmitclass
0); // linkopts
util_check("XMSG_LINK_", ferr);
disable = msg_test_assert_disable();
ferr = XMSG_BREAK_(msgid, results.u.s, TPT_REF(phandle));
msg_test_assert_enable(disable);
assert(ferr == XZFIL_ERR_PATHDOWN);
disable = msg_test_assert_disable();
ferr = XMSG_LINK_(TPT_REF(phandle), // phandle
&msgid, // msgid
NULL, // reqctrl
0, // reqctrlsize
NULL, // replyctrl
0, // replyctrlmax
send_buffer, // reqdata
39000, // reqdatasize
recv_buffer, // replydata
40000, // replydatamax
0, // linkertag
0, // pri
0, // xmitclass
0); // linkopts
util_check("XMSG_LINK_", ferr);
msg_test_assert_enable(disable);
ferr = XMSG_ABANDON_(msgid);
util_check("XMSG_ABANDON_", ferr);
} else {
for (;;) {
do {
lerr = XWAIT(LREQ, -1);
TEST_CHK_WAITIGNORE(lerr);
lerr = XMSG_LISTEN_((short *) &sre, // sre
0, // listenopts
0); // listenertag
} while (lerr == XSRETYPE_NOWORK);
util_abort_core_free();
}
}
if (client) {
ferr = msg_mon_close_process(TPT_REF(phandle));
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[]) {
int arg;
bool attach = false;
_xcc_status cc;
bool chook = false;
bool client = false;
unsigned short count_read;
unsigned short count_written;
int ferr;
short filenum;
int inx;
int loop = 10;
char my_name[BUFSIZ];
char prog[MS_MON_MAX_PROCESS_PATH];
char recv_buffer[BUFSIZ];
char ret_name[MS_MON_MAX_PROCESS_NAME];
char send_buffer[BUFSIZ];
const char *server_name = "$SRV";
int server_nid = -1;
TPT_DECL (server_phandle);
int server_pid;
bool shook = false;
TAD zargs[] = {
{ "-attach", TA_Bool, TA_NOMAX, &attach },
{ "-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 }
};
#ifdef DEBUG_ENV
env = environ;
while (*env != NULL) {
printf("env=%s\n", *env);
env++;
}
#endif
arg_proc_args(zargs, false, argc, argv);
if (chook && client)
test_debug_hook("c", "c");
if (shook && !client)
test_debug_hook("s", "s");
if (client && attach)
ferr = file_init_attach(&argc, &argv, true, (char *) "$CLI");
else
ferr = file_init(&argc, &argv);
TEST_CHK_FEOK(ferr);
util_test_start(client);
ferr = file_mon_process_startup(!client); // system messages
TEST_CHK_FEOK(ferr);
util_gethostname(my_name, sizeof(my_name));
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";
ferr = msg_mon_start_process(prog, // prog
(char *) server_name, // name
ret_name, // 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
TEST_CHK_FEOK(ferr);
assert(strcmp(ret_name, server_name) == 0);
ferr = XFILE_OPEN_((char *) server_name, (short) strlen(server_name), &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);
cc = XWRITEREADX(filenum,
send_buffer,
(short) (strlen(send_buffer) + 1),
BUFSIZ,
&count_read,
0);
TEST_CHK_CCEQ(cc);
printf("%s\n", send_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 = (short) (strlen(recv_buffer) + 1);
cc = XREPLYX(recv_buffer,
count_read,
&count_written,
0,
XZFIL_ERR_OK);
TEST_CHK_CCEQ(cc);
}
}
ferr = file_mon_process_shutdown();
TEST_CHK_FEOK(ferr);
util_test_finish(client);
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;
}
void pp_pairinfo(bool pri) {
TPT_DECL (bphandle);
short ferr;
static bool init = true;
int nid;
char pair[MS_MON_MAX_PROCESS_NAME+1];
short pair_length;
static TPT_DECL (phandle);
TPT_DECL (pphandle);
int pid;
if (init) {
ferr = XPROCESSHANDLE_GETMINE_(TPT_REF(phandle));
myassert(ferr == XZFIL_ERR_OK);
init = false;
}
ferr = XPROCESS_GETPAIRINFO_(TPT_REF(phandle), // phandle
pair,
MS_MON_MAX_PROCESS_NAME+1, // maxlen
&pair_length,
TPT_REF(pphandle), // primary_phandle
TPT_REF(bphandle)); // backup_phandle
if (pri)
myassert(ferr == XPROC_PRIMARY); // caller is primary
else
myassert(ferr == XPROC_BACKUP); // caller is backup
pair[pair_length] = 0;
myassert(strcmp(pair, "$SRV") == 0);
myassert(XPROCESSHANDLE_COMPARE_(TPT_REF(pphandle),
TPT_REF(bphandle)) == 1);
ferr = XPROCESS_GETPAIRINFO_(TPT_REF(phandle), // phandle
pair,
MS_MON_MAX_PROCESS_NAME+1, // maxlen
NULL,
TPT_REF(pphandle), // primary_phandle
TPT_REF(bphandle)); // backup_phandle
if (pri)
myassert(ferr == XPROC_PRIMARY); // caller is primary
else
myassert(ferr == XPROC_BACKUP); // caller is backup
myassert(XPROCESSHANDLE_COMPARE_(TPT_REF(pphandle),
TPT_REF(bphandle)) == 1);
ferr = XPROCESS_GETPAIRINFO_(NULL, // phandle
pair,
MS_MON_MAX_PROCESS_NAME+1, // maxlen
NULL,
TPT_REF(pphandle), // primary_phandle
TPT_REF(bphandle)); // backup_phandle
if (pri)
myassert(ferr == XPROC_PRIMARY); // caller is primary
else
myassert(ferr == XPROC_BACKUP); // caller is backup
myassert(XPROCESSHANDLE_COMPARE_(TPT_REF(pphandle),
TPT_REF(bphandle)) == 1);
ferr = XPROCESS_GETPAIRINFO_(NULL, // phandle
pair,
MS_MON_MAX_PROCESS_NAME+1, // maxlen
&pair_length,
TPT_REF(pphandle), // primary_phandle
TPT_REF(bphandle)); // backup_phandle
if (pri)
myassert(ferr == XPROC_PRIMARY); // caller is primary
else
myassert(ferr == XPROC_BACKUP); // caller is backup
myassert(strcmp(pair, "$SRV") == 0);
myassert(XPROCESSHANDLE_COMPARE_(TPT_REF(pphandle),
TPT_REF(bphandle)) == 1);
ferr = XPROCESSHANDLE_DECOMPOSE_(TPT_REF(pphandle), &nid, &pid);
myassert(ferr == XZFIL_ERR_OK);
if (pri) {
myassert(nid == gnid);
myassert(pid == gpid);
} else {
myassert(nid == gpeer_nid);
myassert(pid == gpeer_pid);
}
ferr = XPROCESSHANDLE_DECOMPOSE_(TPT_REF(bphandle), &nid, &pid);
myassert(ferr == XZFIL_ERR_OK);
if (pri) {
myassert(nid == gpeer_nid);
myassert(pid == gpeer_pid);
} else {
myassert(nid == gnid);
myassert(pid == gpid);
}
}
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[]) {
bool client = false;
int ferr;
int inx;
int loop = 10;
int msgid;
int oid;
TPT_DECL (phandle);
char recv_buffer[40000];
RT results;
char send_buffer[40000];
int status;
TAD zargs[] = {
{ "-client", TA_Bool, TA_NOMAX, &client },
{ "-delay", TA_Bool, TA_NOMAX, &delay },
{ "-loop", TA_Int, TA_NOMAX, &loop },
{ "-maxs", TA_Int, TA_NOMAX, &maxs },
{ "-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(client);
ferr = msg_mon_process_startup(!client); // system messages?
TEST_CHK_FEOK(ferr);
util_gethostname(my_name, sizeof(my_name));
if (client) {
ferr = msg_mon_open_process((char *) "$srv", // name
TPT_REF(phandle),
&oid);
TEST_CHK_FEOK(ferr);
for (inx = 0; inx < loop; inx++) {
sprintf(send_buffer, "hello, greetings from %s, inx=%d",
my_name, inx);
ferr = XMSG_LINK_(TPT_REF(phandle), // phandle
&msgid, // msgid
NULL, // reqctrl
0, // reqctrlsize
NULL, // replyctrl
0, // replyctrlmax
send_buffer, // reqdata
39000, // reqdatasize
recv_buffer, // replydata
40000, // 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);
assert(results.u.t.ctrl_size == 0);
assert(results.u.t.errm == RT_DATA_RCVD); // data
printf("%s\n", recv_buffer);
}
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);
printf("fin %d\n", inx);
}
} else {
msg_mon_enable_mon_messages(true);
for (inx = 0; inx < maxs; inx++) {
char name[10];
sprintf(name, "s%d", inx);
thrs[inx] = new Server_Thread(server_thr, name, inx);
}
for (inx = 0; inx < maxs; inx++) {
thrs[inx]->start();
SB_Thread::Sthr::yield();
}
for (inx = 0; inx < maxs; inx++) {
void *res;
status = thrs[inx]->join(&res);
TEST_CHK_STATUSOK(status);
printf("joined with server %d\n", inx);
}
}
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[]) {
SB_Array<int> array(MAX_OUT);
int client = false;
int disable = 0;
int ferr;
int inx;
int lerr;
int linker = false;
int listener = false;
int oid;
int req_ctrl_size;
int req_data_size;
int rep_ctrl_size;
int rep_data_size;
RT results;
TPT_DECL (phandle);
TAD zargs[] = {
{ "-client", TA_Bool, TA_NOMAX, &client },
{ "-linker", TA_Bool, TA_NOMAX, &linker },
{ "-listener", TA_Bool, TA_NOMAX, &listener },
{ "-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);
for (inx = 0; inx < MAX_OUT; inx++) {
req_ctrl_size = (inx + 1) % MAX_DATA;
req_data_size = (inx + 2) % MAX_DATA;
ferr = XMSG_LINK_(TPT_REF(phandle), // phandle
&msgids[inx], // msgid
send_cli_c_buffer[inx], // reqctrl
(ushort) req_ctrl_size, // reqctrlsize
recv_cli_c_buffer[inx], // replyctrl
(ushort) MAX_DATA, // replyctrlmax
send_cli_d_buffer[inx], // reqdata
(ushort) req_data_size, // reqdatasize
recv_cli_d_buffer[inx], // replydata
(ushort) MAX_DATA, // replydatamax
0, // linkertag
0, // pri
0, // xmitclass
0); // linkopts
util_check("XMSG_LINK_", ferr);
}
if (linker) {
sleep(1);
util_abort_core_free();
}
for (inx = 0; inx < MAX_OUT; inx++) {
array.add();
array.set_val(inx, inx);
}
for (inx = 0; inx < MAX_OUT; inx++) {
int rnd =
(int) (1.0 * array.get_size() * rand_r(&seed) / (RAND_MAX + 1.0));
int xinx = array.get_val(rnd);
array.remove(rnd);
rep_ctrl_size = (xinx + 3) % MAX_DATA;
rep_data_size = (xinx + 4) % MAX_DATA;
if (listener)
disable = msg_test_assert_disable();
ferr = XMSG_BREAK_(msgids[xinx], results.u.s, TPT_REF(phandle));
if (listener) {
assert(ferr == XZFIL_ERR_PATHDOWN);
msg_test_assert_enable(disable);
} else {
util_check("XMSG_BREAK_", ferr);
assert(results.u.t.ctrl_size == (unsigned short) rep_ctrl_size);
assert(results.u.t.data_size == (unsigned short) rep_data_size);
}
}
printf("if there were no asserts, all is well\n");
} else {
for (inx = 0; inx < MAX_OUT; inx++) {
lerr = XWAIT(LREQ, -1);
TEST_CHK_WAITIGNORE(lerr);
do {
lerr = XMSG_LISTEN_((short *) &sres[inx], // sre
0, // listenopts
0); // listenertag
if (lerr == XSRETYPE_NOWORK)
util_time_sleep_ms(1);
} while (lerr == XSRETYPE_NOWORK);
}
for (inx = 0; inx < MAX_OUT; inx++) {
array.add();
array.set_val(inx, inx);
}
for (inx = 0; inx < MAX_OUT; inx++) {
int rnd =
(int) (1.0 * array.get_size() * rand_r(&seed) / (RAND_MAX + 1.0));
int xinx = array.get_val(rnd);
array.remove(rnd);
req_ctrl_size = (xinx + 1) % MAX_DATA;
req_data_size = (xinx + 2) % MAX_DATA;
assert(req_ctrl_size == sres[xinx].sre_reqCtrlSize);
assert(req_data_size == sres[xinx].sre_reqDataSize);
ferr = XMSG_READCTRL_(sres[xinx].sre_msgId, // msgid
recv_srv_c_buffer[xinx], // reqctrl
sres[xinx].sre_reqCtrlSize); // bytecount
util_check("XMSG_READCTRL_", ferr);
ferr = XMSG_READDATA_(sres[xinx].sre_msgId, // msgid
recv_srv_d_buffer[xinx], // reqdata
sres[xinx].sre_reqDataSize); // bytecount
util_check("XMSG_READDATA_", ferr);
}
for (inx = 0; inx < MAX_OUT; inx++) {
array.add();
array.set_val(inx, inx);
}
if (linker)
sleep(1);
if (listener)
util_abort_core_free();
for (inx = 0; inx < MAX_OUT; inx++) {
int rnd =
(int) (1.0 * array.get_size() * rand_r(&seed) / (RAND_MAX + 1.0));
int xinx = array.get_val(rnd);
array.remove(rnd);
rep_ctrl_size = (xinx + 3) % MAX_DATA;
rep_data_size = (xinx + 4) % MAX_DATA;
XMSG_REPLY_(sres[xinx].sre_msgId, // msgid
recv_srv_c_buffer[xinx], // replyctrl
(ushort) rep_ctrl_size, // replyctrlsize
recv_srv_d_buffer[xinx], // replydata
(ushort) rep_data_size, // replydatasize
0, // errorclass
NULL); // newphandle
}
}
if (client) {
ferr = msg_mon_close_process(TPT_REF(phandle));
TEST_CHK_FEOK(ferr);
}
ferr = msg_mon_process_shutdown();
TEST_CHK_FEOK(ferr);
if (linker)
util_test_finish(!client);
else
util_test_finish(client);
return 0;
}
int main(int argc, char *argv[]) {
bool check = false;
int csize = -1;
bool client = false;
int dsize = MAX_BUF;
int ferr;
int inx;
int len;
int lerr;
int loop = 10;
int min_csize;
int min_dsize;
int max_csize = -1;
int max_dsize = -1;
int msgid;
int oid;
TPT_DECL (phandle);
uint result;
RT results;
BMS_SRE sre;
bool verbose = false;
TAD zargs[] = {
{ "-check", TA_Bool, TA_NOMAX, &check },
{ "-client", TA_Bool, TA_NOMAX, &client },
{ "-csize", TA_Int, MAX_BUF, &csize },
{ "-dsize", TA_Int, MAX_BUF, &dsize },
{ "-loop", TA_Int, TA_NOMAX, &loop },
{ "-maxcsize", TA_Int, MAX_BUF, &max_csize },
{ "-maxdsize", TA_Int, MAX_BUF, &max_dsize },
{ "-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(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);
}
util_gethostname(my_name, sizeof(my_name));
msg_mon_enable_mon_messages(true);
if (check) {
if (csize < 0)
csize = 0;
if (dsize == MAX_BUF)
dsize = 0;
min_csize = csize;
min_dsize = dsize;
min_csize = min_csize; // touch
min_dsize = min_dsize; // touch
if (client) {
for (inx = 0; inx < MAX_BUF; inx++) {
send_buffer[inx] = (char) inx; // cast
send_buffer2[inx] = (short) inx; // cast
}
}
} else
min_csize = 0;
for (inx = 0; inx < loop; inx++) {
if (verbose)
printf("client=%d, csize=%d, dsize=%d\n", client, csize, dsize);
else if (check && (csize == min_csize))
printf("client=%d, csize=%d, dsize=%d\n", client, csize, dsize);
if (client) {
if (check) {
send_buffer[0] = (char) dsize; // cast
send_buffer2[0] = (short) csize; // cast
len = 0;
} else {
sprintf(send_buffer, "hello, greetings from %s, inx=%d",
my_name, inx);
len = (int) strlen(send_buffer) + 1; // cast
}
ferr = BMSG_LINK_(TPT_REF(phandle), // phandle
&msgid, // msgid
send_buffer2, // reqctrl
csize < 0 ? // reqctrlsize
(inx & 1) : csize,
recv_buffer3, // replyctrl
csize < 0 ? 1 : csize, // replyctrlmax
send_buffer, // reqdata
check ? dsize : len, // reqdatasize
recv_buffer, // replydata
MAX_BUF, // replydatamax
0, // linkertag
0, // pri
0, // xmitclass
0); // linkopts
util_check("BMSG_LINK_", ferr);
ferr = BMSG_BREAK_(msgid, results.u.s, TPT_REF(phandle));
util_check("BMSG_BREAK_", ferr);
if (check)
assert(results.u.t.ctrl_size == (uint) csize);
else
assert(results.u.t.ctrl_size == (uint) (csize < 0 ? (inx & 1) : csize));
if (check)
assert(results.u.t.data_size == (uint) dsize);
else
assert(results.u.t.data_size > (strlen(send_buffer) + 14));
if (check) {
if (dsize)
result = RT_DATA_RCVD; // data
else
result = 0x0; // no-data
assert(results.u.t.errm == result);
check_buf(send_buffer2, recv_buffer3, csize);
check_buf(send_buffer, recv_buffer, dsize);
} else {
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 = BMSG_LISTEN_((short *) &sre, // sre
0, // listenopts
0); // listenertag
} while (lerr == XSRETYPE_NOWORK);
ferr = BMSG_READCTRL_(sre.sre_msgId, // msgid
recv_buffer2, // reqctrl
sre.sre_reqCtrlSize); // bytecount
util_check("BMSG_READCTRL_", ferr);
ferr = BMSG_READDATA_(sre.sre_msgId, // msgid
recv_buffer, // reqdata
sre.sre_reqDataSize); // bytecount
util_check("BMSG_READDATA_", ferr);
if (sre.sre_flags & XSRE_MON) {
printf("server received mon message\n");
inx--;
len = 0;
} else {
if (!check) {
strcat(recv_buffer, "- reply from ");
strcat(recv_buffer, my_name);
len = (int) strlen(recv_buffer) + 1; // cast
} else
len = 0;
}
BMSG_REPLY_(sre.sre_msgId, // msgid
recv_buffer2, // replyctrl
sre.sre_reqCtrlSize, // replyctrlsize
recv_buffer, // replydata
check ? sre.sre_reqDataSize : len, // replydatasize
0, // errorclass
NULL); // newphandle
if (sre.sre_flags & XSRE_MON)
continue;
}
if (check) {
if (max_csize >= 0) {
csize++;
if (csize >= max_csize)
csize = min_csize;
}
if ((max_dsize >= 0) && (csize == min_csize))
dsize++;
if (dsize >= max_dsize) {
printf("break client=%d, csize=%d, dsize=%d\n", client, csize, dsize);
break;
}
if ((max_csize >= 0) || (max_dsize >= 0)) {
inx--;
continue;
}
}
}
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 client = false;
int count;
int ferr;
int inx;
int lerr;
int loop = 10;
int msgid;
int oid;
TPT_DECL (phandle);
RT results;
MS_SRE sre;
BMS_SRE sre_tb;
MS_SRE sre_tx;
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);
} else
msg_mon_enable_mon_messages(true); // need this
util_gethostname(my_name, sizeof(my_name));
for (inx = 0; inx < loop; inx++) {
count = inx % 100;
if (client) {
ferr = XMSG_LINK_(TPT_REF(phandle), // phandle
&msgid, // msgid
send_bufferc, // reqctrl
(short) count, // reqctrlsize
recv_bufferc, // replyctrl
(short) (count+1), // replyctrlmax
send_buffer, // reqdata
(short) (count+2), // reqdatasize
recv_buffer, // replydata
(short) (count+3), // replydatamax
0, // linkertag
(short) count, // 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);
} else {
do {
lerr = XWAIT(LREQ, -1);
TEST_CHK_WAITIGNORE(lerr);
lerr = XMSG_LISTEN_((short *) &sre_tx, // sre
XLISTEN_TEST_IREQM, // listenopts
0); // listenertag
if (lerr == XSRETYPE_NOWORK)
continue;
if (sre_tx.sre_flags & XSRE_MON) {
// toss out monitor messages
lerr = XMSG_LISTEN_((short *) &sre, // sre
0, // listenopts
0); // listenertag
assert(lerr == XSRETYPE_IREQ);
assert(sre_tx.sre_flags & XSRE_MON);
lerr = XSRETYPE_NOWORK;
XMSG_REPLY_(sre.sre_msgId, // msgid
NULL, // replyctrl
0, // replyctrlsize
NULL, // replydata
0, // replydatasize
0, // errorclass
NULL); // newphandle
continue;
}
lerr = BMSG_LISTEN_((short *) &sre_tb, // sre
BLISTEN_TEST_IREQM, // listenopts
0); // listenertag
assert(lerr == BSRETYPE_IREQ);
lerr = XMSG_LISTEN_((short *) &sre, // sre
0, // listenopts
0); // listenertag
assert(lerr == XSRETYPE_IREQ);
} while (lerr == XSRETYPE_NOWORK);
assert(sre.sre_pri == count);
assert(sre.sre_reqCtrlSize == count);
assert(sre.sre_reqDataSize == (count + 2));
assert(sre.sre_replyCtrlMax == (count + 1));
assert(sre.sre_replyDataMax == (count + 3));
assert(sre.sre_msgId == sre_tx.sre_msgId);
assert(sre.sre_flags == sre_tx.sre_flags);
assert(sre.sre_pri == sre_tx.sre_pri);
assert(sre.sre_reqCtrlSize == sre_tx.sre_reqCtrlSize);
assert(sre.sre_reqDataSize == sre_tx.sre_reqDataSize);
assert(sre.sre_replyCtrlMax == sre_tx.sre_replyCtrlMax);
assert(sre.sre_replyDataMax == sre_tx.sre_replyDataMax);
assert(sre.sre_msgId == sre_tb.sre_msgId);
assert(sre.sre_flags == sre_tb.sre_flags);
assert(sre.sre_pri == sre_tb.sre_pri);
assert(sre.sre_reqCtrlSize == sre_tb.sre_reqCtrlSize);
assert(sre.sre_reqDataSize == sre_tb.sre_reqDataSize);
assert(sre.sre_replyCtrlMax == sre_tb.sre_replyCtrlMax);
assert(sre.sre_replyDataMax == sre_tb.sre_replyDataMax);
XMSG_REPLY_(sre.sre_msgId, // msgid
NULL, // replyctrl
0, // replyctrlsize
recv_buffer, // replydata
0, // 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[]) {
_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[]) {
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;
}
// -------------------------------------------------------------
// adp_module_init
// Purpose - initialize module for use
// -------------------------------------------------------------
void TM_Audit::adp_module_init()
{
TMTrace(2, ("TM_Audit::adp_module_init: ENTER\n"));
MS_Mon_Reg_Get_Type lv_info;
char lv_my_pname[8+1];
char lv_tlog_pname[8+1];
int lv_len = 8;
int lv_err = 0;
int32 lv_oid = 0;
TPT_DECL (lv_phandle);
int lv_TLOG_index = TLOG_AuditTrailIndex;
if (iv_initialized)
return;
msg_mon_get_my_process_name(lv_my_pname,lv_len);
lv_err = msg_mon_reg_get(MS_Mon_ConfigType_Process, false,
lv_my_pname, (char *)"TMASE", &lv_info);
if ((lv_err == 0) && (lv_info.num_returned == 1))
{
strncpy (lv_tlog_pname, lv_info.list[0].value, 8);
TMTrace(3, ("TM_Audit::adp_module_init: %s opening TLOG %s\n", lv_my_pname, lv_tlog_pname));
lv_err = msg_mon_open_process(lv_tlog_pname, &lv_phandle, &lv_oid);
if (!lv_err)
{
memcpy (&iv_adp_phandle, &lv_phandle, sizeof (SB_Phandle_Type));
// If we using multiple TLOGs, we need to set the correct index (= nid)
if (gv_tm_info.TLOGperTM())
lv_TLOG_index = gv_tm_info.nid();
iv_initialized = true;
}
else
{
TMTrace(1, ("TM_Audit::adp_module_init: error %d opening TLOG %s\n",
lv_err, lv_tlog_pname));
tm_log_event(DTM_AUDIT_FAILED_ADPOPEN, SQ_LOG_CRIT, "DTM_AUDIT_FAILED_ADPOPEN",
lv_err, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, lv_my_pname);
// Fast fail here if $TLOG is gone as we can't continue in M8.
if (lv_err == FENOSUCHDEV)
{
gv_tm_info.error_shutdown_abrupt(lv_err);
// Abort without core - don't need the core in this case.
struct rlimit limit;
limit.rlim_cur = 0;
limit.rlim_max = 0;
setrlimit(RLIMIT_CORE, &limit);
abort();
}
iv_initialized = false;
}
} // lv_err = 0
else
iv_initialized = false;
if (gv_tm_info.TLOGperTM())
{
TMTrace(2, ("TM_Audit::adp_module_init: EXIT, initialized = %d, name %s, TLOG%d.\n",
iv_initialized, ia_vol_name2, lv_TLOG_index));
}
else
{
TMTrace(2, ("TM_Audit::adp_module_init: EXIT, initialized = %d, name %s, single TLOG.\n",
iv_initialized, ia_vol_name2));
}
}
