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 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;
}
// ---------------------------------------------------------------------------
// CxaTM_RMMessage::link
// Purpose : Call to BMSG_LINK_.
// This function will retry any retriable errors such as FENOLCB (30).
// Parameters:
// pv_maxretries - maximum retries for retriable errors.
// Returns error from BMSG_LINK_ call.
// ---------------------------------------------------------------------------
short CxaTM_RMMessage::link(int32 pv_maxretries)
{
short lv_ret = 0;
int32 lv_retries = 0;
bool lv_exit = false;
TM_Txid_Internal *lp_transid = (TM_Txid_Internal *) &xid()->data[0];
XATrace(XATM_TraceExit, ("CxaTM_RMMessage::link ENTRY : ID (%d,%d), linker "
"tag(rmid) %d.\n", lp_transid->iv_node, lp_transid->iv_seq_num,
ip_RM->getRmid()));
do {
lv_ret = BMSG_LINK_(ip_RM->getRmPhandle(), // phandle,
&iv_msgid, // msgid
NULL, // reqctrl
0, // reqctrlsize
NULL, // replyctrl
0, // replyctrlmax
(char *) Req(), // reqdata
ReqLen(), // reqdatasize
(char *) Rsp(), // replydata
RspLen(), // replydatamax
ip_RM->getRmid(), // linkertag
TSE_LINK_PRIORITY, // pri
0, // xmitclass
BMSG_LINK_LDONEQ); // linkopts
lv_retries++;
if (lv_ret == FENOLCB &&
//((pv_maxretries == -1 && (lv_retries % TM_LINKRETRY_RETRIES == 0)) ||
(pv_maxretries == -1 ||
(pv_maxretries > 0 && (lv_retries <= pv_maxretries))))
{ // Message Descriptor depletion. This means we ran out of MDs.
// This is retriable, and we want to slow down the TM to allow
// some of the outstanding requests to complete.
XATrace(XATM_TraceError, ("CxaTM_RMMessage::link BMSG_LINK_ error %d, "
"linker tag(rmid) %d, retires %d/%d - Pausing thread for "
"%dms before retrying.\n", lv_ret, ip_RM->getRmid(),
lv_retries, pv_maxretries, TM_LINKRETRY_PAUSE));
tm_log_event(DTM_TM_LINK_PAUSED, SQ_LOG_WARNING, "DTM_TM_LINK_PAUSED",
lv_ret, -1, lp_transid->iv_node, lp_transid->iv_seq_num, -1, -1, -1, -1, lv_retries,
-1, -1, -1, -1, TM_LINKRETRY_PAUSE /*pause in ms*/, ip_RM->getRmid());
SB_Thread::Sthr::sleep(TM_LINKRETRY_PAUSE); // in msec
}
if (lv_ret != FENOLCB)
lv_exit = true;
else
if (pv_maxretries > 0 && lv_retries >= pv_maxretries)
lv_exit = true;
} while (!lv_exit);
if (lv_ret)
{
XATrace(XATM_TraceExit, ("CxaTM_RMMessage::link EXIT : returning error %d.\n", lv_ret));
}
else
{
XATrace(XATM_TraceExit, ("CxaTM_RMMessage::link EXIT : returning msgid %d.\n", iv_msgid));
}
return lv_ret;
} //CxaTM_RMMessage::link
int main(int argc, char *argv[]) {
int abandon = 0;
bool client = false;
int closes;
int count;
int count_abandon;
int ferr;
int inxl;
int inxo;
int inxs;
int lerr;
int loop = 10;
int maxcp = 1;
int maxout = 1;
int maxsp = 1;
int msgid[MAX_OUT];
int msg_count;
bool mq = false;
int oid;
TPT_DECL2 (phandle, MAX_SRV);
int recv_len;
RT results;
int send_len;
char serv[20];
BMS_SRE sre;
bool verbose = false;
TAD zargs[] = {
{ "-abandon", TA_Int, TA_NOMAX, &abandon },
{ "-client", TA_Bool, TA_NOMAX, &client },
{ "-loop", TA_Int, TA_NOMAX, &loop },
{ "-maxcp", TA_Int, MAX_CLI, &maxcp },
{ "-maxout", TA_Int, MAX_OUT, &maxout },
{ "-maxsp", TA_Int, MAX_SRV, &maxsp },
{ "-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);
msg_count = 0;
count_abandon = 0;
for (inxl = 0; inxl < loop; inxl++) {
for (inxs = 0; inxs < maxsp; inxs++) {
sprintf(serv, "$srv%d", inxs);
ferr = msg_mon_open_process((char *) serv, // name
TPT_REF2(phandle, inxs),
&oid);
TEST_CHK_FEOK(ferr);
}
count = 0;
if (abandon)
count_abandon = rnd(abandon);
for (inxs = 0; inxs < maxsp; inxs++) {
for (inxo = 0; inxo < maxout; inxo++) {
send_len = rnd(BUFSIZ);
ferr = BMSG_LINK_(TPT_REF2(phandle, inxs), // phandle
&msgid[inxo], // msgid
NULL, // reqctrl
0, // reqctrlsize
NULL, // replyctrl
0, // replyctrlmax
send_buffer[inxo], // reqdata
send_len, // reqdatasize
recv_buffer[inxo], // replydata
BUFSIZ, // replydatamax
0, // linkertag
0, // pri
0, // xmitclass
0); // linkopts
util_check("XMSG_LINK_", ferr);
}
}
for (inxs = 0; inxs < maxsp; inxs++) {
for (inxo = 0; inxo < maxout; inxo++) {
msg_count++;
if (verbose)
printf("client(%s): msg-count=%d\n",
my_name, msg_count);
count++;
if (abandon && (count >= count_abandon)) {
if (verbose)
printf("client(%s): sending abandon, count=%d\n",
my_name, count);
count_abandon = rnd(abandon);
count = 0;
ferr = XMSG_ABANDON_(msgid[inxo]);
util_check("XMSG_ABANDON_", ferr);
} else {
ferr = BMSG_BREAK_(msgid[inxo],
results.u.s,
TPT_REF2(phandle, inxs));
util_check("XMSG_BREAK_", ferr);
}
}
}
if (mq) {
if ((inxl % 100) == 0)
printf("client(%s): count=%d\n", my_name, inxl);
}
}
for (inxs = 0; inxs < maxsp; inxs++) {
ferr = msg_mon_close_process(TPT_REF2(phandle, inxs));
TEST_CHK_FEOK(ferr);
}
} else {
ferr = XCONTROLMESSAGESYSTEM(XCTLMSGSYS_SETRECVLIMIT,
XMAX_SETTABLE_RECVLIMIT);
assert(ferr == XZFIL_ERR_OK);
closes = 0;
msg_count = 0;
msg_mon_enable_mon_messages(true);
// process requests
for (;;) {
do {
lerr = XWAIT(LREQ, -1);
lerr = BMSG_LISTEN_((short *) &sre, // sre
0, // listenopts
0); // listenertag
} while (lerr == XSRETYPE_NOWORK);
if (sre.sre_flags & XSRE_MON) {
ferr = XMSG_READDATA_(sre.sre_msgId, // msgid
recv_buffer[0], // reqdata
BUFSIZ); // bytecount
util_check("XMSG_READDATA_", ferr);
MS_Mon_Msg *msg = (MS_Mon_Msg *) recv_buffer[0];
if (verbose)
printf("server(%s): mon-msg type=%d\n",
my_name, msg->type);
if (msg->type == MS_MsgType_Close) {
closes++;
if (verbose)
printf("server(%s): closes=%d\n",
my_name, closes);
}
} else {
msg_count++;
if (verbose)
printf("server(%s): msg-count=%d\n",
my_name, msg_count);
}
recv_len = rnd(BUFSIZ);
BMSG_REPLY_(sre.sre_msgId, // msgid
NULL, // replyctrl
0, // replyctrlsize
recv_buffer[0], // replydata
recv_len, // replydatasize
0, // errorclass
NULL); // newphandle
if (closes >= maxcp)
break;
}
}
ferr = msg_mon_process_shutdown();
TEST_CHK_FEOK(ferr);
util_test_finish(client);
return 0;
}
//
// plugin - send msg to ms-ic
//
static void sb_pi_ic_send(MS_Mon_Node_Info_Entry_Type *pp_node,
MS_Mon_Process_Info_Type *pp_proc,
Sqstate_Pi_Info_Type *pp_info,
char *pp_title,
bool pv_title,
const char *pp_lib,
const char *pp_call,
char *pp_rsp,
int pv_rsplen,
int *pp_rsplen) {
char la_ctrl[200];
char *lp_data;
char *lp_p;
char la_rsp[MAX_RSP];
short *lp_ctrl;
short *lp_results;
char *lp_rsp;
int lv_clen;
int lv_disable;
int lv_dlen;
int lv_fserr;
int lv_inx;
int lv_len;
int lv_msgid;
int lv_oid;
bool lv_open;
MS_Result_Type lv_results;
int lv_rsplen;
pp_node = pp_node; // touch
if (pp_rsplen != NULL)
*pp_rsplen = 0;
lv_open = (strcmp(pp_proc->process_name, gp_pname) != 0);
gp_pname = pp_proc->process_name;
if (strcmp(pp_call, "ic_unload") == 0)
sprintf(la_ctrl, "unload" ":" ":" "all");
else
sprintf(la_ctrl, "call" ":" "%s" ":" "%s", pp_lib, pp_call);
lv_clen = static_cast<int>(strlen(la_ctrl)) + 1;
lv_dlen = 0;
for (lv_inx = 0; lv_inx < pp_info->ic_argc; lv_inx++)
lv_dlen += static_cast<int>(strlen(pp_info->ic_argv[lv_inx])) + 1;
if (lv_dlen > 0) {
lp_data = new char[lv_dlen];
lp_p = lp_data;
for (lv_inx = 0; lv_inx < pp_info->ic_argc; lv_inx++) {
lv_len = sprintf(lp_p, "%s", pp_info->ic_argv[lv_inx]);
lp_p += lv_len + 1;
}
} else
lp_data = NULL;
if (lv_open) {
if (gv_verbosev)
sb_pi_verb_printf("opening %s...\n", gp_pname);
if (gv_opened) {
gv_opened = false;
lv_fserr = msg_mon_close_process(&gv_phandle);
CHK_FEIGNORE(lv_fserr);
}
lv_disable = msg_test_assert_disable();
if (pp_info->self)
lv_fserr = msg_mon_open_process_self_ic(&gv_phandle, &lv_oid);
else
lv_fserr = msg_mon_open_process_ic(gp_pname, &gv_phandle, &lv_oid);
msg_test_assert_enable(lv_disable);
sb_pi_verb_ok(lv_fserr, "open");
} else
lv_fserr = XZFIL_ERR_OK;
if (lv_fserr != XZFIL_ERR_OK) {
sb_pi_verb_printf("ERROR: could not open %s, fserr=%d\n",
gp_pname,
lv_fserr);
} else {
lp_ctrl = reinterpret_cast<short *>(la_ctrl);
gv_opened = true;
if (gv_verbose)
sb_pi_verb_printf("linking %s, ctrl=%s...\n", gp_pname, la_ctrl);
lv_disable = msg_test_assert_disable();
if (pp_rsp == NULL) {
lp_rsp = la_rsp;
lv_rsplen = MAX_RSP;
} else {
lp_rsp = pp_rsp;
lv_rsplen = pv_rsplen;
}
lv_fserr = BMSG_LINK_(&gv_phandle, // phandle
&lv_msgid, // msgid
lp_ctrl, // reqctrl
lv_clen, // reqctrlsize
NULL, // replyctrl
0, // replyctrlmax
lp_data, // reqdata
lv_dlen, // reqdatasize
lp_rsp, // replydata
lv_rsplen, // replydatamax
0, // linkertag
0, // pri
0, // xmitclass
BMSG_LINK_MSINTERCEPTOR); // linkopts
msg_test_assert_enable(lv_disable);
sb_pi_verb_ok(lv_fserr, "link");
if (lv_fserr != XZFIL_ERR_OK) {
sb_pi_printf("ERROR: error in link to %s, fserr=%d\n",
gp_pname, lv_fserr);
} else {
if (gv_verbosev)
sb_pi_verb_printf("breaking %s...\n", gp_pname);
lp_results = reinterpret_cast<short *>(&lv_results);
lv_disable = msg_test_assert_disable();
lv_fserr = BMSG_BREAK_(lv_msgid, lp_results, &gv_phandle);
msg_test_assert_enable(lv_disable);
sb_pi_verb_ok(lv_fserr, "break");
if (lv_fserr == XZFIL_ERR_OK) {
if (pp_rsp == NULL)
sb_pi_ic_call_print_rsp(pp_title,
pv_title,
la_rsp,
lv_results.rr_datasize);
else if (pp_rsplen != NULL)
*pp_rsplen = lv_results.rr_datasize;
} else {
sb_pi_printf("ERROR: error in break to %s, fserr=%d\n",
gp_pname, lv_fserr);
}
}
}
}
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[]) {
char *cli;
int ferr;
int lerr;
int msgid;
int nid;
int oid;
TPT_DECL (phandle);
int pid;
MS_Result_Type results;
int send_len;
const char *sname = "$srv";
MS_SRE sre;
ferr = msg_init(&argc, &argv);
TEST_CHK_FEOK(ferr);
ferr = msg_mon_process_startup(true); // system messages?
TEST_CHK_FEOK(ferr);
ferr = msg_mon_get_my_process_name(pname, sizeof(pname));
TEST_CHK_FEOK(ferr);
msg_mon_enable_mon_messages(true);
sprintf(prog, "%s/%s", getenv("PWD"), argv[0]);
cli = strstr(prog, "cli");
strcpy(cli, "srv");
nid = 0;
ferr = msg_mon_start_process_nowait(prog, // prog
(char *) sname, // name
retname, // ret-name
argc, // argc
argv, // argv
TPT_REF(phandle), // phandle
MS_ProcessType_Generic, // type
0, // priority
false, // debug
false, // backup
0x123456789abcdefLL, // tag
&nid, // nid
&pid, // pid
NULL, // infile
NULL); // outfile
TEST_CHK_FEOK(ferr);
assert(strcasecmp(retname, sname) == 0);
assert(nid == 0);
lerr = XWAIT(LREQ, -1);
TEST_CHK_WAITIGNORE(lerr);
for (;;) {
lerr = XMSG_LISTEN_((short *) &sre, // sre
0, // listenopts
0); // listenertag
if (lerr == XSRETYPE_NOWORK)
continue;
ferr = XMSG_READDATA_(sre.sre_msgId, // msgid
recv_buffer, // reqdata
BUFSIZ); // bytecount
TEST_CHK_FEOK(ferr);
if (sre.sre_flags & XSRE_MON) {
MS_Mon_Msg *msg = (MS_Mon_Msg *) recv_buffer;
printf("client (%s) received mon message, type=%d\n",
pname, msg->type);
assert(msg->type == MS_MsgType_ProcessCreated);
printf("client (%s) received new process message, ferr=%d, nid=%d, pid=%d, tag=0x%llx, pname=%s\n",
pname,
msg->u.process_created.ferr,
msg->u.process_created.nid,
msg->u.process_created.pid,
msg->u.process_created.tag,
msg->u.process_created.process_name);
assert(msg->u.process_created.ferr == XZFIL_ERR_OK);
assert(msg->u.process_created.tag == 0x123456789abcdefLL);
ferr = msg_mon_open_process((char *) sname, // name
TPT_REF(phandle),
&oid);
TEST_CHK_FEOK(ferr);
}
XMSG_REPLY_(sre.sre_msgId, // msgid
NULL, // replyctrl
0, // replyctrlsize
NULL, // replydata
0, // replydatasize
0, // errorclass
NULL); // newphandle
if (sre.sre_flags & XSRE_MON)
break;
}
strcpy(send_buffer, "hello, greetings from client");
send_len = (int) strlen(send_buffer) + 1;
ferr = BMSG_LINK_(TPT_REF(phandle), // phandle
&msgid, // msgid
NULL, // reqctrl
0, // 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
TEST_CHK_FEOK(ferr);
ferr = BMSG_BREAK_(msgid, (short *) &results, TPT_REF(phandle));
TEST_CHK_FEOK(ferr);
printf("%s\n", recv_buffer);
ferr = msg_mon_close_process(TPT_REF(phandle));
TEST_CHK_FEOK(ferr);
ferr = msg_mon_process_shutdown();
TEST_CHK_FEOK(ferr);
return 0;
}
//
// plugin - send message to interceptor
//
SB_Export bool sqstatepi_send_ic_ok(const char *pp_module,
const char *pp_call,
MS_Mon_Node_Info_Entry_Type *pp_node,
MS_Mon_Process_Info_Type *pp_proc,
Sqstate_Pi_Info_Type *pp_info,
const char *pp_lib,
char *pp_rsp,
int pv_rsp_len,
int *pp_rsp_len) {
char la_ctrl[200];
char *lp_data;
char *lp_p;
short *lp_results;
int lv_clen;
int lv_dlen;
int lv_fserr;
int lv_inx;
int lv_len;
int lv_msgid;
int lv_oid;
int lv_ok;
bool lv_open;
MS_Result_Type lv_results;
pp_node = pp_node; // touch
lv_ok = false;
*pp_rsp_len = 0;
lv_open = (strcmp(pp_proc->process_name, gp_sqstatepi_pname) != 0);
gp_sqstatepi_pname = pp_proc->process_name;
sqstatepi_set_ctrl(la_ctrl, pp_info, pp_lib, pp_module, pp_call);
lv_clen = static_cast<int>(strlen(la_ctrl)) + 1;
lv_dlen = 0;
for (lv_inx = 0; lv_inx < pp_info->ic_argc; lv_inx++)
lv_dlen += static_cast<int>(strlen(pp_info->ic_argv[lv_inx])) + 1;
if (lv_dlen > 0) {
lp_data = new char[lv_dlen];
lp_p = lp_data;
for (lv_inx = 0; lv_inx < pp_info->ic_argc; lv_inx++) {
lv_len = sprintf(lp_p, "%s", pp_info->ic_argv[lv_inx]);
lp_p += lv_len + 1;
}
} else
lp_data = NULL;
if (lv_open) {
if (pp_info->verbosev)
sqstatepi_printf("opening %s...\n", gp_sqstatepi_pname);
if (gv_sqstatepi_opened) {
gv_sqstatepi_opened = false;
lv_fserr = msg_mon_close_process(&gv_sqstatepi_phandle);
CHK_FEIGNORE(lv_fserr);
}
if (pp_info->self)
lv_fserr = msg_mon_open_process_self_ic(&gv_sqstatepi_phandle,
&lv_oid);
else
lv_fserr = msg_mon_open_process_ic(gp_sqstatepi_pname,
&gv_sqstatepi_phandle,
&lv_oid);
sqstatepi_verbose_ok(pp_info, lv_fserr, "open");
} else
lv_fserr = XZFIL_ERR_OK;
if (lv_fserr != XZFIL_ERR_OK) {
sqstatepi_printf("ERROR: could not open %s, fserr=%d\n",
gp_sqstatepi_pname, lv_fserr);
} else {
gv_sqstatepi_opened = true;
if (pp_info->verbose)
sqstatepi_printf("linking %s, ctrl=%s...\n",
gp_sqstatepi_pname, la_ctrl);
lv_fserr = BMSG_LINK_(&gv_sqstatepi_phandle, // phandle
&lv_msgid, // msgid
(short *) la_ctrl, // reqctrl
lv_clen, // reqctrlsize
NULL, // replyctrl
0, // replyctrlmax
lp_data, // reqdata
lv_dlen, // reqdatasize
pp_rsp, // replydata
pv_rsp_len, // replydatamax
0, // linkertag
0, // pri
0, // xmitclass
BMSG_LINK_MSINTERCEPTOR); // linkopts
sqstatepi_verbose_ok(pp_info, lv_fserr, "link");
if (lv_fserr != XZFIL_ERR_OK) {
sqstatepi_printf("ERROR: error in link to %s, fserr=%d\n",
gp_sqstatepi_pname, lv_fserr);
} else {
if (pp_info->verbosev)
sqstatepi_printf("breaking %s...\n", gp_sqstatepi_pname);
lp_results = (short *) &lv_results;
lv_fserr = BMSG_BREAK_(lv_msgid, lp_results, &gv_sqstatepi_phandle);
sqstatepi_verbose_ok(pp_info, lv_fserr, "break");
if (lv_fserr == XZFIL_ERR_OK) {
*pp_rsp_len = lv_results.rr_datasize;
lv_ok = true;
} else {
sqstatepi_printf("ERROR: error in break to %s, fserr=%d\n",
gp_sqstatepi_pname, lv_fserr);
}
}
}
if (lp_data != NULL)
delete [] lp_data;
return lv_ok;
}