short NAProcessHandle::getmine()
{
short err=0;
err = XPROCESSHANDLE_GETMINE_( (SB_Phandle_Type *) &this->phandle_);
return err;
}
// ---------------------------------------------------------------------------
// GETMINE
// ---------------------------------------------------------------------------
// Encapsulates the PROCESSHANDLE_GETMINE_ request for the different supported
// platforms - NSK, WINNT, and LINUX
//
// Keeps a copy of phandle in the NAProcessHandle instance and copies to
// phandle input parameter to be returned to the caller.
//
// If an error occurs, return the appropriate file system error
// ---------------------------------------------------------------------------
short NAProcessHandle::getmine(SB_Phandle_Type *phandle)
{
Int32 err=0;
err = XPROCESSHANDLE_GETMINE_( (SB_Phandle_Type *) &this->phandle_);
memcpy (phandle, &this->phandle_, PhandleSize);
return err;
}
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[]) {
char *args[4];
bool attach = false;
bool chook = false;
bool client = false;
bool clientd = false;
int cli_nid = -1;
int cli_pid = -1;
const char *cname = "$cli";
int count;
int ferr;
int inx;
int len;
int lerr;
int loop = 10;
TPT_DECL (mphandle);
char *mphandlec = (char *) &mphandle;
TPT_DECL_INT (mphandlei);
int msgid;
int my_mon_nid;
int my_mon_pid;
int my_mon_ptype;
int my_mon_zid;
int my_os_pid;
long my_os_tid;
int my_compid;
int my_pnid;
int my_segid;
int nid;
int oid;
TPT_DECL (phandle);
int pid;
char *pname = NULL;
int ptype;
RT results;
int scollpid = -1;
int scompid = -1;
int send_len;
bool shook = false;
const char *sname = "$srv";
bool sonar = false;
MS_SRE sre;
int srv_nid = -1;
int srv_pid = -1;
MS_Mon_Monitor_Stats_Type stats;
int status;
long t_elapsed;
struct timeval t_start;
struct timeval t_stop;
int tm_seq;
bool val_bool;
int val_int;
const char *val_str;
int winx;
pid_t wpid;
TAD zargs[] = {
{ "-attach", TA_Bool, TA_NOMAX, &attach },
{ "-chook", TA_Bool, TA_NOMAX, &chook },
{ "-client", TA_Bool, TA_NOMAX, &client },
{ "-clientd", TA_Bool, TA_NOMAX, &clientd },
{ "-cname", TA_Str, TA_NOMAX, &cname },
{ "-loop", TA_Int, TA_NOMAX, &loop },
{ "-name", TA_Str, TA_NOMAX, &pname },
{ "-server", TA_Ign, TA_NOMAX, NULL },
{ "-shook", TA_Bool, TA_NOMAX, &shook },
{ "-sname", TA_Str, TA_NOMAX, &sname },
{ "-sonar", TA_Bool, TA_NOMAX, &sonar },
{ "", TA_End, TA_NOMAX, NULL }
};
#ifdef DEBUG_ENV
env = environ;
while (*env != NULL) {
printf("env=%s\n", *env);
env++;
}
#endif
arg_proc_args(zargs, false, argc, argv);
if (client && chook)
test_debug_hook("c", "c");
if (!client && shook)
test_debug_hook("s", "s");
setenv("TESTKEYBOOL", "1", 1);
setenv("TESTKEYINT", "44", 1);
setenv("TESTKEYSTR", "TESTVALSTR", 1);
//
// test msg_getenv* before msg_init
//
val_bool = true;
msg_getenv_bool("TESTKEYBOOL", &val_bool);
assert(val_bool);
val_bool = false;
msg_getenv_bool("TESTKEYBOOL", &val_bool);
assert(!val_bool);
val_int = 0;
msg_getenv_int("TESTKEYINT", &val_int);
assert(val_int == 0);
val_int = 1;
msg_getenv_int("TESTKEYINT", &val_int);
assert(val_int == 1);
val_str = (const char *) 1;
val_str = msg_getenv_str("TESTKEYSTR");
assert(val_str == NULL);
if (attach)
msfs_util_init_attach(&argc, &argv, msg_debug_hook, false, pname);
else
msfs_util_init(&argc, &argv, msg_debug_hook);
arg_proc_args(zargs, false, argc, argv);
util_time_timer_start(&t_start);
util_test_start(client);
ferr = msg_mon_process_startup(!client); // system messages?
TEST_CHK_FEOK(ferr);
//
// test msg_getenv* after msg_init
//
msg_getenv_bool("TESTKEYBOOL", &val_bool);
assert(val_bool);
msg_getenv_int("TESTKEYINT", &val_int);
assert(val_int == 44);
val_str = msg_getenv_str("TESTKEYSTR");
assert(strcmp(val_str, "TESTVALSTR") == 0);
// process-wait for server/shell
ferr = msfs_util_wait_process_count(MS_ProcessType_Generic, 2, NULL, false);
TEST_CHK_FEOK(ferr);
// process-wait for client
ferr = msfs_util_wait_process_count(MS_ProcessType_TSE, 1, NULL, false);
TEST_CHK_FEOK(ferr);
if (client) {
if (sonar) {
scollpid = fork();
if (scollpid == 0) {
// child
args[0] = (char *) "sonarcollector";
args[1] = (char *) "-i"; // sampling interval // cast
args[2] = (char *) "1"; // cast
args[3] = NULL;
lerr = execvp(args[0], args);
assert(lerr == 0);
}
}
ferr = msg_mon_open_process((char *) sname, // name
TPT_REF(phandle),
&oid);
TEST_CHK_FEOK(ferr);
}
// this phandle check assumed a particular data structure
ferr = msg_mon_get_my_process_name(my_name, BUFSIZ);
util_check("msg_mon_get_my_process_name", ferr);
ferr = XPROCESSHANDLE_GETMINE_(TPT_REF(mphandle));
util_check("XPROCESSHANDLE_GETMINE_", ferr);
TPT_COPY_INT(mphandlei, mphandle);
assert((mphandlei[0] & 0xf0) == 0x20); // named
assert(strncmp(my_name, &mphandlec[4], 32) == 0);
printf("phandle=%x.%x.%x.%x.%x\n",
mphandlei[0],
mphandlei[1],
mphandlei[2],
mphandlei[3],
mphandlei[4]);
ferr = msg_mon_get_my_info(&my_mon_nid,
&my_mon_pid,
my_mon_name,
BUFSIZ,
&my_mon_ptype,
&my_mon_zid,
&my_os_pid,
&my_os_tid);
util_check("msg_mon_get_my_info", ferr);
printf("nid=%d, pid=%d, name=%s, ptype=%d, zid=%d, os-pid=%d, os-tid=%ld\n",
my_mon_nid,
my_mon_pid,
my_mon_name,
my_mon_ptype,
my_mon_zid,
my_os_pid,
my_os_tid);
my_mon_nid = -1;
my_mon_pid = -1;
my_mon_ptype = -1;
my_mon_zid = -1;
my_os_pid = -1;
my_os_tid = -1;
my_compid = -1;
my_pnid = -1;
ferr = msg_mon_get_my_info3(&my_mon_nid,
&my_mon_pid,
my_mon_name3,
BUFSIZ,
&my_mon_ptype,
&my_mon_zid,
&my_os_pid,
&my_os_tid,
&my_compid,
&my_pnid);
util_check("msg_mon_get_my_info3", ferr);
printf("nid=%d, pid=%d, name=%s, ptype=%d, zid=%d, os-pid=%d, os-tid=%ld, compid=%d, pnid=%d\n",
my_mon_nid,
my_mon_pid,
my_mon_name3,
my_mon_ptype,
my_mon_zid,
my_os_pid,
my_os_tid,
my_compid,
my_pnid);
ferr = msg_mon_get_my_segid(&my_segid);
util_check("msg_mon_get_my_segid", ferr);
printf("segid=%d\n", my_segid);
ferr = msg_mon_get_monitor_stats(&stats);
util_check("msg_mon_get_monitor_stats", ferr);
printf("avail_min=%d, acquired_max=%d, buf_misses=%d\n",
stats.avail_min, stats.acquired_max, stats.buf_misses);
util_gethostname(my_name, sizeof(my_name));
msg_mon_enable_mon_messages(true);
ferr = msg_mon_get_tm_seq(&tm_seq);
util_check("msg_mon_get_tm_seq", ferr);
printf("tm_seq=%d\n", tm_seq);
if (client) {
ferr = msg_mon_get_process_info_type(MS_ProcessType_TSE,
&count,
0,
NULL);
TEST_CHK_FEOK(ferr);
if (!attach)
assert(count == 1);
ferr = msg_mon_get_process_info_type(MS_ProcessType_TSE,
&count,
1,
info);
TEST_CHK_FEOK(ferr);
if (!attach)
assert(count == 1);
}
for (inx = 0; inx < loop; inx++) {
if (client) {
sprintf(send_buffer, "hello, greetings from %s, inx=%d",
my_name, inx);
send_len = (int) strlen(send_buffer) + 1;
ferr = XMSG_LINK_(TPT_REF(phandle), // phandle
&msgid, // msgid
send_buffer2, // reqctrl
(ushort) (inx & 1), // reqctrlsize
recv_buffer3, // replyctrl
1, // replyctrlmax
send_buffer, // reqdata
(ushort) send_len, // reqdatasize
recv_buffer, // replydata
BUFSIZ, // replydatamax
0, // linkertag
(short) (inx+1), // pri
0, // xmitclass
0); // linkopts
util_check("XMSG_LINK_", ferr);
ferr = XMSG_BREAK_(msgid,
results.u.s,
TPT_REF(phandle));
util_check("XMSG_BREAK_", ferr);
assert(results.u.t.ctrl_size == (uint) (inx & 1));
assert(results.u.t.data_size > (strlen(send_buffer) + 14));
assert(results.u.t.errm == RT_DATA_RCVD); // data
printf("%s\n", recv_buffer);
} else {
do {
lerr = XWAIT(LREQ, -1);
TEST_CHK_WAITIGNORE(lerr);
lerr = XMSG_LISTEN_((short *) &sre, // sre
0, // listenopts
0); // listenertag
} while (lerr == XSRETYPE_NOWORK);
ferr = XMSG_GETREQINFO_(MSGINFO_NID,
sre.sre_msgId,
&nid);
util_check("XMSG_GETREQINFO_", ferr);
ferr = XMSG_GETREQINFO_(MSGINFO_PID,
sre.sre_msgId,
&pid);
util_check("XMSG_GETREQINFO_", ferr);
ferr = XMSG_GETREQINFO_(MSGINFO_PTYPE,
sre.sre_msgId,
&ptype);
util_check("XMSG_GETREQINFO_", ferr);
if (sre.sre_flags & XSRE_MON) {
// mon messages have our nid/pid
if (srv_nid < 0) {
ferr = msg_mon_get_process_info((char *) "",
&srv_nid,
&srv_pid);
TEST_CHK_FEOK(ferr);
}
if (!clientd) {
assert(nid == srv_nid);
assert(pid == srv_pid);
}
} else {
assert(sre.sre_pri == ((inx+1) & 0xffff));
if (cli_nid < 0) {
ferr = msg_mon_get_process_info((char *) cname,
&cli_nid,
&cli_pid);
TEST_CHK_FEOK(ferr);
}
if (!attach)
assert(ptype == MS_ProcessType_TSE);
assert(nid == cli_nid);
assert(pid == cli_pid);
}
ferr = XMSG_READCTRL_(sre.sre_msgId, // msgid
recv_buffer2, // reqctrl
1); // bytecount
util_check("XMSG_READCTRL_", ferr);
ferr = XMSG_READDATA_(sre.sre_msgId, // msgid
recv_buffer, // reqdata
BUFSIZ); // bytecount
util_check("XMSG_READDATA_", ferr);
if (sre.sre_flags & XSRE_MON) {
printf("server received mon message\n");
inx--;
len = 0;
if (clientd) {
MS_Mon_Msg *msg = (MS_Mon_Msg *) recv_buffer;
if (msg->type == MS_MsgType_Close)
inx = loop;
}
} else {
strcat(recv_buffer, "- reply from ");
strcat(recv_buffer, my_name);
len = (int) strlen(recv_buffer) + 1;
}
XMSG_REPLY_(sre.sre_msgId, // msgid
recv_buffer2, // replyctrl
sre.sre_reqCtrlSize, // replyctrlsize
recv_buffer, // replydata
(ushort) len, // replydatasize
0, // errorclass
NULL); // newphandle
}
}
if (sonar) {
if (client) {
// for some reason [monitor?], one 'sonarcom stop' doesn't stop coll
for (winx = 0; winx < 20; winx++) {
scompid = fork();
if (scompid == 0) {
// child
args[0] = (char *) "sonarcom";
args[1] = (char *) "stop";
args[2] = NULL;
lerr = execvp(args[0], args);
assert(lerr == 0);
}
wpid = waitpid(scompid, &status, 0);
assert(wpid == scompid);
wpid = waitpid(scollpid, &status, WNOHANG);
if (wpid == scollpid)
break;
else
sleep(1);
}
assert(wpid == scollpid);
ferr = XMSG_LINK_(TPT_REF(phandle), // phandle
&msgid, // msgid
NULL, // reqctrl
0, // reqctrlsize
NULL, // replyctrl
0, // replyctrlmax
NULL, // reqdata
0, // reqdatasize
NULL, // replydata
0, // replydatamax
0, // linkertag
0, // pri
0, // xmitclass
0); // linkopts
TEST_CHK_FEOK(ferr);
ferr = XMSG_BREAK_(msgid,
results.u.s,
TPT_REF(phandle));
TEST_CHK_FEOK(ferr);
} else {
do {
lerr = XWAIT(LREQ, -1);
lerr = XMSG_LISTEN_((short *) &sre, // sre
0, // listenopts
0); // listenertag
} while (lerr == XSRETYPE_NOWORK);
XMSG_REPLY_(sre.sre_msgId, // msgid
NULL, // replyctrl
0, // replyctrlsize
NULL, // replydata
0, // replydatasize
0, // errorclass
NULL); // newphandle
}
}
if (client) {
ferr = msg_mon_close_process(TPT_REF(phandle));
TEST_CHK_FEOK(ferr);
} else {
if (!clientd) {
ferr = msg_mon_process_close();
TEST_CHK_FEOK(ferr);
}
}
util_time_timer_stop(&t_stop);
t_elapsed = (t_stop.tv_sec * 1000000 + t_stop.tv_usec) -
(t_start.tv_sec * 1000000 + t_start.tv_usec);
ferr = msg_mon_process_shutdown();
TEST_CHK_FEOK(ferr);
util_test_finish(client);
if (client) {
printf("elapsed time (gettimeofday us)=%ld\n", t_elapsed);
}
return 0;
}
int main(int argc, char *argv[]) {
_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;
}
void runServer(Int32 argc, char **argv)
{
Int32 shmid;
jmp_buf sscpJmpBuf;
StatsGlobals *statsGlobals = NULL;
void *statsGlobalsAddr;
NABoolean createStatsGlobals = FALSE;
CliGlobals *cliGlobals = CliGlobals::createCliGlobals(FALSE);
char tmbuf[64];
time_t now;
struct tm *nowtm;
long maxSegSize = STATS_MAX_SEG_SIZE;
char *envSegSize = getenv("MX_RTS_STATS_SEG_SIZE");
if (envSegSize)
{
maxSegSize = (long) str_atoi(envSegSize, str_len(envSegSize));
if (maxSegSize < 32)
maxSegSize = 32;
else if (maxSegSize > 256)
maxSegSize = 256;
maxSegSize *= 1024 * 1024;
}
long enableHugePages = 0;
int shmFlag = RMS_SHMFLAGS;
char *envShmHugePages = getenv("SQ_RMS_ENABLE_HUGEPAGES");
if (envShmHugePages != NULL)
{
enableHugePages = (long) str_atoi(envShmHugePages,
str_len(envShmHugePages));
if (enableHugePages > 0)
shmFlag = shmFlag | SHM_HUGETLB;
}
now = time(NULL);
nowtm = localtime(&now);
strftime(tmbuf, sizeof tmbuf, "%Y-%m-%d %H:%M:%S ", nowtm);
if ((shmid = shmget((key_t)getStatsSegmentId(),
0, // size doesn't matter unless we are creating.
shmFlag)) == -1)
{
if (errno == ENOENT)
{
// Normal case, segment does not exist yet. Try to create.
bool didCreate = true;
if ((shmid = shmget((key_t)getStatsSegmentId(),
maxSegSize,
shmFlag | IPC_CREAT)) == -1)
{
if (enableHugePages > 0)
{
enableHugePages = 0;
// try again withouf hugepages
shmFlag = shmFlag & ~SHM_HUGETLB;
if ((shmid = shmget((key_t)getStatsSegmentId(),
maxSegSize,
shmFlag | IPC_CREAT)) == -1)
didCreate = false;
}
else
didCreate = false;
}
if (didCreate)
{
cout << tmbuf
<< " RMS Shared segment id = "
<< shmid << ", key = "
<< (key_t)getStatsSegmentId() ;
if (enableHugePages > 0)
cout << ", created with huge pages support." << endl;
else
cout << ", created without huge pages support." << endl;
createStatsGlobals = TRUE;
}
else
{
cout << tmbuf
<< " Shmget failed, key = "
<< getStatsSegmentId()
<<", Error code: "
<< errno
<< " ("
<< strerror(errno)
<< ")" << endl;
exit(errno);
}
} // if ENOENT (i.e., attempting creation.)
}
else
{
cout << tmbuf << " RMS Shared segment exists, attaching to it, shmid="<< shmid << ", key=" << (key_t)getStatsSegmentId() << "\n";
}
if ((statsGlobalsAddr = shmat(shmid, getRmsSharedMemoryAddr(), 0))
== (void *)-1)
{
cout << tmbuf << "Shmat failed, shmid=" <<shmid << ", key=" << (key_t) getStatsSegmentId() << ", Error code : " << errno << "(" << strerror(errno) << ")\n";
exit(errno);
}
char *statsGlobalsStartAddr = (char *)statsGlobalsAddr;
if (createStatsGlobals)
{
short envType = StatsGlobals::RTS_GLOBAL_ENV;
statsGlobals = new (statsGlobalsStartAddr)
StatsGlobals((void *)statsGlobalsAddr, envType, maxSegSize);
cliGlobals->setSharedMemId(shmid);
// We really should not squirrel the statsGlobals pointer away like
// this until the StatsGloblas is initialized, but
// statsGlobals->init() needs it ......
cliGlobals->setStatsGlobals(statsGlobals);
statsGlobals->init();
}
else
{
statsGlobals = (StatsGlobals *)statsGlobalsAddr;
cliGlobals->setSharedMemId(shmid);
cliGlobals->setStatsGlobals(statsGlobals);
}
XPROCESSHANDLE_GETMINE_(statsGlobals->getSscpProcHandle());
NAHeap *sscpHeap = cliGlobals->getExecutorMemory();
cliGlobals->setJmpBufPtr(&sscpJmpBuf);
if (setjmp(sscpJmpBuf))
NAExit(1); // Abend
IpcEnvironment *sscpIpcEnv = new (sscpHeap) IpcEnvironment(sscpHeap, cliGlobals->getEventConsumed(),
FALSE, IPC_SQLSSCP_SERVER, FALSE, TRUE);
SscpGlobals *sscpGlobals = NULL;
sscpGlobals = new (sscpHeap) SscpGlobals(sscpHeap, statsGlobals);
// Currently open $RECEIVE with 256
SscpGuaReceiveControlConnection *cc =
new(sscpHeap) SscpGuaReceiveControlConnection(sscpIpcEnv,
sscpGlobals,
256);
sscpIpcEnv->setControlConnection(cc);
while (TRUE)
{
while (cc->getConnection() == NULL)
cc->wait(IpcInfiniteTimeout);
#ifdef _DEBUG_RTS
cerr << "No. of Requesters-1 " << cc->getNumRequestors() << " \n";
#endif
while (cc->getNumRequestors() > 0)
{
sscpIpcEnv->getAllConnections()->waitOnAll(IpcInfiniteTimeout);
} // Inner while
}
} // runServer
SB_Export short XPROCESS_GETPAIRINFO_(SB_Phandle_Type *pp_phandle,
char *pp_pair,
short pv_maxlen,
short *pp_pair_length,
SB_Phandle_Type *pp_primary_phandle,
SB_Phandle_Type *pp_backup_phandle,
int *pp_search,
SB_Phandle_Type *pp_ancestor_phandle,
char *pp_node,
short pv_node_len,
short pv_options,
char *pp_ancestor_desc,
short pv_ancestor_desc_maxlen,
short *pp_ancestor_desc_len,
short *pp_error_detail) {
const char *WHERE = "XPROCESS_GETPAIRINFO_";
char la_name[MS_MON_MAX_PROCESS_NAME];
char *lp_name;
short *lp_phandles;
int lv_fserr;
short lv_param;
SB_Phandle_Type lv_phandle;
bool lv_phandle_null;
MS_Mon_Process_Info_Type lv_pi;
bool lv_pi_get;
bool lv_pi_ok;
short lv_ret;
int lv_status;
SB_API_CTR (lv_zctr, XPROCESS_GETPAIRINFO_);
lv_pi_get = true;
lv_pi_ok = false;
lp_phandles = reinterpret_cast<short *>(pp_phandle);
if ((pp_phandle == NULL) || (lp_phandles[0] == -1))
lv_phandle_null = true;
else
lv_phandle_null = false;
if (gv_ms_trace_params) {
char la_phandlet[MSG_UTIL_PHANDLE_LEN];
msg_util_format_phandle(la_phandlet, pp_phandle);
trace_where_printf(WHERE, "ENTER phandle=%s, pair=%p, maxlen=%d, pair-length=%p, p-phandle=%p, b-phandle=%p\n",
la_phandlet,
pfp(pp_pair),
pv_maxlen,
pfp(pp_pair_length),
pfp(pp_primary_phandle),
pfp(pp_backup_phandle));
trace_where_printf(WHERE, "search=%p(%d), a-phandle=%p, node=%p, nodelen=%d, options=%d, a-desc=%p, a-desc-maxlen=%d, a-desc-len=%p, err-detail=%p\n",
pfp(pp_search),
(pp_search != NULL) ? *pp_search : -1,
pfp(pp_ancestor_phandle),
pfp(pp_node),
pv_node_len,
pv_options,
pfp(pp_ancestor_desc),
pv_ancestor_desc_maxlen,
pfp(pp_ancestor_desc_len),
pfp(pp_error_detail));
}
if (!gv_ms_calls_ok) {
lv_ret = XPROC_INVSTATE;
return ms_err_rtn_msg(WHERE, "msg_init() not called or shutdown",
lv_ret);
}
lv_ret = XPROC_OK;
lv_fserr = XZFIL_ERR_OK;
if (pp_error_detail != NULL)
*pp_error_detail = 0;
// check 'legacy' parameters and reject
if ((pp_search != NULL) && (*pp_search != -1)) {
lv_ret = XPROC_PRM_UNSUP;
lv_param = PGPI_PARAM_SEARCH;
if (pp_error_detail != NULL)
*pp_error_detail = lv_param;
return ms_err_rtn_msg(WHERE, "search (non -1) parameter unsupported", lv_ret);
}
if (pp_ancestor_phandle != NULL) {
lv_ret = XPROC_PRM_UNSUP;
lv_param = PGPI_PARAM_ANCESTOR_PHANDLE;
if (pp_error_detail != NULL)
*pp_error_detail = lv_param;
return ms_err_rtn_msg(WHERE, "ancestor-phandle parameter unsupported", lv_ret);
}
if ((pp_node != NULL) && pv_node_len) {
lv_ret = XPROC_PRM_UNSUP;
lv_param = PGPI_PARAM_NODE;
if (pp_error_detail != NULL)
*pp_error_detail = lv_param;
return ms_err_rtn_msg(WHERE, "node/len parameter unsupported", lv_ret);
}
if (pv_options) {
lv_ret = XPROC_PRM_UNSUP;
lv_param = PGPI_PARAM_OPTIONS;
if (pp_error_detail != NULL)
*pp_error_detail = lv_param;
return ms_err_rtn_msg(WHERE, "options (non-zero) parameter unsupported", lv_ret);
}
if ((pp_ancestor_desc != NULL) && pv_ancestor_desc_maxlen) {
lv_ret = XPROC_PRM_UNSUP;
lv_param = PGPI_PARAM_ANCESTOR_DESC;
if (pp_error_detail != NULL)
*pp_error_detail = lv_param;
return ms_err_rtn_msg(WHERE, "ancestor-desc/maxlen parameter unsupported", lv_ret);
}
if (lv_phandle_null) {
// null phandle, check pair param
if (pp_pair_length == NULL) { // in
// use pair name to create phandle
if (pp_pair == NULL) {
lv_ret = XPROC_BNDS;
lv_param = PGPI_PARAM_PAIR;
if (pp_error_detail != NULL)
*pp_error_detail = lv_param;
return ms_err_rtn_msg(WHERE, "invalid pair", lv_ret);
}
if (gv_ms_trace_params)
trace_where_printf(WHERE, "pair=%s\n", pp_pair);
lp_name = la_name;
memcpy(la_name, pp_pair, sbmin(pv_maxlen, static_cast<int>(sizeof(la_name))));
if (pv_maxlen < static_cast<int>(sizeof(la_name)))
la_name[pv_maxlen] = '\0';
else
la_name[MS_MON_MAX_PROCESS_NAME-1] = '\0';
lv_pi_get = false;
lv_fserr = msg_mon_get_process_info_detail(la_name, &lv_pi);
if (lv_fserr == XZFIL_ERR_OK) {
ms_util_fill_phandle_name(&lv_phandle,
la_name,
lv_pi.nid,
lv_pi.pid
#ifdef SQ_PHANDLE_VERIFIER
,lv_pi.verifier
#endif
);
lv_pi_ok = true;
} else if (lv_fserr == XZFIL_ERR_NOTFOUND)
lv_ret = XPROC_NONEXTANT;
else
lv_ret = XPROC_NODEDOWN;
} else { // out
// use our phandle and return pair
lv_fserr = XPROCESSHANDLE_GETMINE_(&lv_phandle);
lp_name = ms_od_map_phandle_to_name(&lv_phandle);
if ((pp_pair != NULL) && (lv_fserr == XZFIL_ERR_OK)) {
*pp_pair_length = static_cast<short>(strlen(lp_name));
memcpy(pp_pair, lp_name, *pp_pair_length);
if (gv_ms_trace_params)
trace_where_printf(WHERE, "pair=%s\n", lp_name);
}
if (lv_fserr != XZFIL_ERR_OK)
lv_ret = XPROC_INVSTATE;
}
} else {
lp_name = ms_od_map_phandle_to_name(pp_phandle);
lv_pi_get = false;
lv_fserr = msg_mon_get_process_info_detail(lp_name, &lv_pi);
if (lv_fserr == XZFIL_ERR_OK) {
lv_pi_ok = true;
ms_util_fill_phandle_name(&lv_phandle,
lp_name,
lv_pi.nid,
lv_pi.pid
#ifdef SQ_PHANDLE_VERIFIER
,lv_pi.verifier
#endif
);
if (pp_pair_length != NULL) { // out
*pp_pair_length = static_cast<short>(strlen(lp_name));
memcpy(pp_pair, lp_name, *pp_pair_length);
if (gv_ms_trace_params)
trace_where_printf(WHERE, "pair=%s\n", lp_name);
}
} else if (lv_fserr == XZFIL_ERR_NOTFOUND)
lv_ret = XPROC_NONEXTANT;
else
lv_ret = XPROC_NODEDOWN;
}
// at this point, name pair should be setup
if (lv_fserr == XZFIL_ERR_OK) {
if (lv_pi_get)
lv_fserr = msg_mon_get_process_info_detail(lp_name, &lv_pi);
if (lv_fserr == XZFIL_ERR_OK) {
lv_pi_ok = true;
if (pp_primary_phandle != NULL) {
ms_util_fill_phandle_name(pp_primary_phandle,
lp_name,
!lv_pi.backup ? lv_pi.nid : lv_pi.parent_nid,
!lv_pi.backup ? lv_pi.pid : lv_pi.parent_pid
#ifdef SQ_PHANDLE_VERIFIER
,!lv_pi.backup ? lv_pi.verifier : lv_pi.parent_verifier
#endif
);
if (gv_ms_trace_params) {
char la_phandlet[MSG_UTIL_PHANDLE_LEN];
msg_util_format_phandle(la_phandlet, pp_primary_phandle);
trace_where_printf(WHERE, "p-phandle=%s\n", la_phandlet);
}
}
if (pp_backup_phandle != NULL) {
if (strcmp(lv_pi.parent_name, lv_pi.process_name) == 0)
ms_util_fill_phandle_name(pp_backup_phandle,
lp_name,
!lv_pi.backup ? lv_pi.parent_nid : lv_pi.nid,
!lv_pi.backup ? lv_pi.parent_pid : lv_pi.pid
#ifdef SQ_PHANDLE_VERIFIER
,!lv_pi.backup ? lv_pi.parent_verifier : lv_pi.verifier
#endif
);
else {
lv_status = XPROCESSHANDLE_NULLIT_(pp_backup_phandle);
CHK_FEIGNORE(lv_status);
}
if (gv_ms_trace_params) {
char la_phandlet[MSG_UTIL_PHANDLE_LEN];
msg_util_format_phandle(la_phandlet, pp_backup_phandle);
trace_where_printf(WHERE, "b-phandle=%s\n", la_phandlet);
}
}
} else if (lv_fserr == XZFIL_ERR_NOTFOUND)
lv_ret = XPROC_NONEXTANT;
else
lv_ret = XPROC_NODEDOWN;
}
if (lv_pi_ok) {
if (strcmp(lv_pi.parent_name, lv_pi.process_name) == 0) {
// process-pair
if (!lv_pi.backup) {
if ((lv_pi.nid == gv_ms_su_nid) &&
(lv_pi.pid == gv_ms_su_pid))
lv_ret = XPROC_PRIMARY;
else if ((lv_pi.parent_nid == gv_ms_su_nid) &&
(lv_pi.parent_pid == gv_ms_su_pid))
lv_ret = XPROC_BACKUP;
else
lv_ret = XPROC_OK; // not the calling process
} else {
if ((lv_pi.nid == gv_ms_su_nid) &&
(lv_pi.pid == gv_ms_su_pid))
lv_ret = XPROC_BACKUP;
else if ((lv_pi.parent_nid == gv_ms_su_nid) &&
(lv_pi.parent_pid == gv_ms_su_pid))
lv_ret = XPROC_PRIMARY;
else
lv_ret = XPROC_OK; // not the calling process
}
} else
lv_ret = XPROC_SINGLE;
}
return ms_err_rtn_msg_noassert(WHERE, "EXIT", lv_ret);
}
Int32 SQLMXLoggingArea::logSQLMXEventForError( ULng32 sqlcode,
const char* experienceLevel,
const char* severityLevel,
const char* eventTarget,
const char *msgTxt,
const char* sqlId,
const Lng32 Int0,
const Lng32 Int1,
const Lng32 Int2,
const Lng32 Int3,
const Lng32 Int4,
const char *String0,
const char * String1,
const char * String2,
const char * String3,
const char * String4,
const char * serverName,
const char * connectionName,
const char * constraintCatalog,
const char * constraintSchema,
const char * constraintName,
const char * triggerCatalog,
const char * triggerSchema,
const char *triggerName,
const char *catalogName,
const char *schemaName,
const char *tableName,
const char *columnName,
const Int64 currTransid,
const Lng32 rowNumber,
const Lng32 platformCode,
NABoolean isWarning
)
{
Int32 rc = 0;
// sealog logging of sql error events
// declare a event stack variable and populate
#ifndef SP_DIS
bool lockedMutex = lockMutex();
sql::error_event sql_error_event;
Int32 qpidNodePort = atoi(getenv("QPID_NODE_PORT"));
common::event_header * eventHeader = sql_error_event.mutable_header();
common::info_header * infoHeader = eventHeader->mutable_header();
if (!SQLMXLoggingArea::establishedAMQPConnection())
{
rc = createAMQPConnection(NULL,-1);
if (rc)
{
if (lockedMutex)
unlockMutex();
return rc;
}
establishedAMQPConnection_ = TRUE;
}
char eventidStr[10]=" ";
Lng32 eventidLen = 0;
str_sprintf(eventidStr,"10%d%06d",SQEVL_SQL,sqlcode);
str_strip_blanks(eventidStr,eventidLen);
Lng32 eventIdVal = (Lng32)str_atoi(eventidStr,eventidLen);
sql_error_event.mutable_header()->set_event_id(eventIdVal);
sql_error_event.mutable_header()->set_event_severity(sqlToSLSeverity(severityLevel, isWarning));
sql_error_event.set_sqlcode(sqlcode);
if (sqlId)
sql_error_event.set_sqlid(sqlId);
else
{
SB_Phandle_Type myphandle;
XPROCESSHANDLE_GETMINE_(&myphandle);
char charProcHandle[200];
char myprocname[30];
Int32 mycpu,mypin,mynodenumber=0;
short myproclength = 0;
XPROCESSHANDLE_DECOMPOSE_(&myphandle, &mycpu, &mypin, &mynodenumber,NULL,100, NULL, myprocname,100, &myproclength);
myprocname[myproclength] = '\0';
str_sprintf(charProcHandle,"%d,%d,%d,%s",mycpu,mypin,mynodenumber,myprocname);
sql_error_event.set_sqlid(charProcHandle);
}
sql_error_event.set_message_text(msgTxt);
sql_error_event.set_err_experience_level(experienceLevel);
sql_error_event.set_err_target(eventTarget);
sql_error_event.set_int0(Int0);
sql_error_event.set_int1(Int1);
sql_error_event.set_int2(Int2);
sql_error_event.set_int3(Int3);
sql_error_event.set_int4(Int4);
if (String0)
sql_error_event.set_string0(String0);
if (String1)
sql_error_event.set_string1(String1);
if (String2)
sql_error_event.set_string2(String2);
if (String3)
sql_error_event.set_string3(String3);
if (String4)
sql_error_event.set_string4(String4);
//LCOV_EXCL_START - unused members of diags are
if (serverName)
sql_error_event.set_server_name(serverName);
if (connectionName)
sql_error_event.set_connection_name(connectionName);
//LCOV_EXCL_STOP
if (constraintCatalog)
sql_error_event.set_constraint_catalog(constraintCatalog);
if (constraintSchema)
sql_error_event.set_constraint_schema(constraintSchema);
if (constraintName)
sql_error_event.set_constraint_name(constraintName);
if (triggerCatalog)
sql_error_event.set_trigger_catalog(triggerCatalog);
if (triggerSchema)
sql_error_event.set_trigger_schema(triggerSchema);
if (triggerName)
sql_error_event.set_trigger_name(triggerName);
if (catalogName)
sql_error_event.set_catalog_name(catalogName);
if (schemaName)
sql_error_event.set_schema_name(schemaName);
if (tableName)
sql_error_event.set_table_name(tableName);
if (columnName)
sql_error_event.set_column_name(columnName);
sql_error_event.set_current_transid(currTransid);
sql_error_event.set_row_number(rowNumber);
sql_error_event.set_platform_error_code(platformCode);
rc = initAMQPInfoHeader(infoHeader, SQEVL_SQL);
if (rc)
{
closeAMQPConnection();
establishedAMQPConnection_ = FALSE;
if (lockedMutex)
unlockMutex();
return rc;
}
AMQPRoutingKey routingKey(SP_EVENT, SP_SQLPACKAGE, SP_INSTANCE,
SP_PUBLIC, SP_GPBPROTOCOL, "error_event");
try {
rc = sendAMQPMessage(true, sql_error_event.SerializeAsString(),
SP_CONTENT_TYPE_APP, routingKey);
if (rc) throw 1;
} catch (...) {
closeAMQPConnection();
establishedAMQPConnection_ = FALSE;
if (!rc) rc = SP_SEND_FAILED;
if (lockedMutex)
unlockMutex();
return rc;
}
if (lockedMutex)
unlockMutex();
#else
rc = 0;
#endif
return rc;
}
