void ojdefimage (mstr *image)
{
static mstr imagebuf = {0, 0};
int4 status;
unsigned char local_buff[MAX_FILSPC_LEN];
short iosb[4];
unsigned short length;
struct
{
item_list_3 le[1];
int4 terminator;
} item_list;
if (!imagebuf.addr)
{
item_list.le[0].buffer_length = MAX_FILSPC_LEN;
item_list.le[0].item_code = JPI$_IMAGNAME;
item_list.le[0].buffer_address = local_buff;
item_list.le[0].return_length_address = &length;
item_list.terminator = 0;
status = sys$getjpi (0, 0, 0, &item_list, &iosb[0], 0, 0);
if (!(status & 1))
rts_error(VARLSTCNT(1) status);
sys$synch (efn_immed_wait, &iosb[0]);
if (!(iosb[0] & 1))
rts_error(VARLSTCNT(1) iosb[0]);
imagebuf.addr = malloc(length);
imagebuf.len = length;
memcpy(imagebuf.addr, local_buff, length);
}
*image = imagebuf;
return;
}
static int set_context(long * context) {
int status;
signed long long timevalue;
status = sys$gettim(&timevalue);
context[0] = timevalue; // fix later
int item_code;
int len = 0;
item_code = JPI$_CPUTIM;
status = lib$getjpi (&item_code, 0, 0, &context[1], 0, &len);
item_code = JPI$_BUFIO;
status = lib$getjpi (&item_code, 0, 0, &context[2], 0, &len);
item_code = JPI$_DIRIO;
status = lib$getjpi (&item_code, 0, 0, &context[3], 0, &len);
item_code = JPI$_PAGEFLTS;
status = lib$getjpi (&item_code, 0, 0, &context[4], 0, &len);
}
void mu_signal_process(char *command, int signal)
{
boolean_t pid_present, name_present;
int4 pid, length, status, item, outv;
char prc_nam[20];
unsigned short name_len;
$DESCRIPTOR(d_prc_nam,"");
memset(prc_nam, 0, SIZEOF(prc_nam));
pid_present = name_present = FALSE;
if (cli_present("id") == CLI_PRESENT)
{
if(!cli_get_hex("id", &pid))
return;
pid_present = TRUE;
}
if (cli_present("name") == CLI_PRESENT)
{
name_len = 20;
if (!cli_get_str("name", prc_nam, &name_len))
return;
if (prc_nam[name_len-1] == '"')
name_len--;
if (prc_nam[0] == '"')
{
d_prc_nam.dsc$a_pointer = &prc_nam[1];
name_len--;
} else
d_prc_nam.dsc$a_pointer = &prc_nam;
d_prc_nam.dsc$w_length = name_len;
name_present = TRUE;
}
if (!name_present)
{
if (SS$_NORMAL == send_signal(pid, signal))
SENDMSG_OUTPUT("", pid);
return;
}
item = JPI$_PID;
status = lib$getjpi(&item, 0, &d_prc_nam, &outv, 0, 0);
if (SS$_NORMAL != status)
{
rts_error(VARLSTCNT(1) status);
return;
}
if (!pid_present)
{
if (SS$_NORMAL == send_signal(outv, signal))
SENDMSG_OUTPUT(&prc_nam, outv);
return;
}
if (outv != pid)
{
util_out_print("ID !XL and NAME !AD are not the same process", FLUSH, pid, LEN_AND_STR(&prc_nam));
return;
}
if (SS$_NORMAL == send_signal(pid, signal))
SENDMSG_OUTPUT(&prc_nam, pid);
return;
}
int4 getstorage(void)
{
int4 status;
uint4 page_count;
status = lib$getjpi(&JPI$_FREPTECNT,0,0,&page_count,0,0);
if ((status & 1) == 0)
rts_error(status);
return (int4)(page_count < (MAXPOSINT4 / OS_PAGELET_SIZE) ? (page_count * OS_PAGELET_SIZE) : MAXPOSINT4);
}
asmlinkage int exe$getjpiw(unsigned int efn, unsigned int *pidadr, void * prcnam, void *itmlst, struct _iosb *iosb, void (*astadr)(), unsigned long long astprm)
{
/* I think this is about it */
int status=exe$getjpi(efn,pidadr,prcnam,itmlst,iosb,astadr,astprm);
if ((status&1)==0) return status;
return exe$synch(efn,iosb);
}
STATICFNDEF void get_cputime (ext_tms *curr)
{
int4 cpu_time_used;
int status;
int jpi_code = JPI$_CPUTIM;
if ((status = lib$getjpi(&jpi_code, &process_id, 0, &cpu_time_used, 0, 0)) != SS$_NORMAL)
MPROF_RTS_ERROR((CSA_ARG(NULL) VARLSTCNT(8) ERR_SYSCALL, 5, LEN_AND_LIT("LIB$GETJPI"), CALLFROM, status));
curr->tms_utime = cpu_time_used;
curr->tms_stime = 0;
return;
}
STATICFNDEF void get_cputime (struct tms *curr)
{
int4 cpu_time_used;
int status;
int jpi_code = JPI$_CPUTIM;
if ((status = lib$getjpi(&jpi_code, &process_id, 0, &cpu_time_used, 0, 0)) != SS$_NORMAL)
rts_error(VARLSTCNT(8) ERR_SYSCALL, 5, LEN_AND_LIT("LIB$GETJPI"), CALLFROM, status);
curr->tms_utime = cpu_time_used;
curr->tms_stime = 0;
return;
}
void getjobnum(void)
{
uint4 status;
int4 item_code;
DCL_THREADGBL_ACCESS;
SETUP_THREADGBL_ACCESS;
item_code = JPI$_PID;
if (SS$_NORMAL !=(status = lib$getjpi(&item_code, 0, 0, &process_id, 0, 0)))
rts_error(VARLSTCNT(1) status);
get_proc_info(process_id, TADR(login_time), &image_count);
}
int rlPcontrol::isAlive()
{
#ifdef __VMS
long ret,code,mypid;
if(m_pid == -1) return 0;
mypid = m_pid;
code = JPI$_STATE;
ret = lib$getjpi(&code,&mypid,0,0,0,0);
if(ret != SS$_NORMAL)
{
//printf("lib$getjpi terminated abnormal\n");
return 0;
}
if(mypid == m_pid) return 1;
return 0;
#endif
#ifdef RLUNIX
int ret,status;
if(m_pid == -1) return 0;
ret = waitpid(m_pid, &status, WNOHANG);
//printf("isAlive pid=%ld\n",m_pid);
if(ret == 0) return 1;
return 0;
#endif
#ifdef RLWIN32
long status;
if(m_pid == -1) return 0;
if(GetExitCodeProcess((HANDLE) m_pid, (unsigned long *) &status) != 0) // success
{
if(status == STILL_ACTIVE) return 1;
else return 0;
}
return 0; // failure
#endif
}
void op_fngetjpi(mint jpid, mval *keyword, mval *ret)
{
out_struct out_quad;
int4 out_long, jpi_code, pid;
short index, length, slot, last_slot, out_len;
uint4 status;
char upcase[MAX_KEY_LEN];
$DESCRIPTOR(out_string, "");
error_def(ERR_BADJPIPARAM);
assert (stringpool.free >= stringpool.base);
assert (stringpool.top >= stringpool.free);
ENSURE_STP_FREE_SPACE(MAX_JPI_STRLEN);
MV_FORCE_STR(keyword);
if (keyword->str.len == 0)
rts_error(VARLSTCNT(4) ERR_BADJPIPARAM, 2, 4, "Null");
if (keyword->str.len > MAX_KEY_LEN)
rts_error(VARLSTCNT(4) ERR_BADJPIPARAM, 2, keyword->str.len, keyword->str.addr );
lower_to_upper((uchar_ptr_t)upcase, (uchar_ptr_t)keyword->str.addr, keyword->str.len);
if ((index = upcase[0] - 'A') < MIN_INDEX || index > MAX_INDEX)
rts_error(VARLSTCNT(4) ERR_BADJPIPARAM, 2, keyword->str.len, keyword->str.addr );
/* Before checking if it is a VMS JPI attribute, check if it is GT.M specific "ISPROCALIVE" attribute */
if ((keyword->str.len == STR_LIT_LEN("ISPROCALIVE")) && !memcmp(upcase, "ISPROCALIVE", keyword->str.len))
{
out_long = (0 != jpid) ? is_proc_alive(jpid, 0) : 1;
i2mval(ret, out_long);
return;
}
/* Check if it is a VMS JPI attribute */
slot = jpi_index_table[ index ].index;
last_slot = jpi_index_table[ index ].len;
jpi_code = 0;
/* future enhancement:
* (i) since keywords are sorted, we can exit the for loop if 0 < memcmp.
* (ii) also, the current comparison relies on kwd->str.len which means a C would imply CPUTIM instead of CSTIME
* or CUTIME this ambiguity should probably be removed by asking for an exact match of the full keyword
*/
for ( ; slot < last_slot ; slot++ )
{
if (jpi_param_table[ slot ].len == keyword->str.len
&& !(memcmp(jpi_param_table[ slot ].name, upcase, keyword->str.len)))
{
jpi_code = jpi_param_table[ slot ].item_code;
break;
}
}
if (!jpi_code)
rts_error(VARLSTCNT(4) ERR_BADJPIPARAM, 2, keyword->str.len, keyword->str.addr);
assert (jpid >= 0);
switch( jpi_code )
{
/* **** This is a fall through for all codes that require a string returned **** */
case JPI$_ACCOUNT:
case JPI$_AUTHPRIV:
case JPI$_CLINAME:
case JPI$_CURPRIV:
case JPI$_IMAGNAME:
case JPI$_IMAGPRIV:
case JPI$_PRCNAM:
case JPI$_PROCPRIV:
case JPI$_TABLENAME:
case JPI$_TERMINAL:
case JPI$_USERNAME:
out_string.dsc$a_pointer = stringpool.free;
out_string.dsc$w_length = MAX_JPI_STRLEN;
if ((status = lib$getjpi( &jpi_code
,&jpid
,0
,0
,&out_string
,&out_len )) != SS$_NORMAL)
{ rts_error(VARLSTCNT(1) status ); /* need a more specific GTM error message here and below */
}
ret->str.addr = stringpool.free;
ret->str.len = out_len;
ret->mvtype = MV_STR;
stringpool.free += out_len;
assert (stringpool.top >= stringpool.free);
assert (stringpool.free >= stringpool.base);
return;
case JPI$_LOGINTIM:
{ int4 days;
int4 seconds;
if ((status = lib$getjpi( &jpi_code
,&jpid
,0
,&out_quad
,0
,0 )) != SS$_NORMAL)
{ rts_error(VARLSTCNT(1) status );
}
if ((status = lib$day( &days
,&out_quad
,&seconds)) != SS$_NORMAL)
{ rts_error(VARLSTCNT(1) status );
}
days += DAYS;
seconds /= CENTISECONDS;
ret->str.addr = stringpool.free;
stringpool.free = i2s(&days);
*stringpool.free++ = ',';
stringpool.free = i2s(&seconds);
ret->str.len = (char *) stringpool.free - ret->str.addr;
ret->mvtype = MV_STR;
return;
}
default:
if ((status = lib$getjpi( &jpi_code
,&jpid
,0
,&out_long
,0
,0 )) != SS$_NORMAL)
{ rts_error(VARLSTCNT(1) status );
}
i2mval(ret, out_long) ;
return;
}
}
show_system(){
int i;
struct item_list_3 lst[14], syilst[4];
char scsnode[16];
char procname[15];
char proclen;
char version[16];
int versionlen;
unsigned long long boottime;
int boottimelen;
unsigned long upid,epid;
unsigned long upidlen,epidlen;
unsigned long state,statelen;
unsigned long pri,prilen;
unsigned long pagep, pageplen;
unsigned long pageg, pageglen;
unsigned long pagef, pageflen;
unsigned int dirio, diriolen, bufio, bufiolen;
int jpistatus;
int sts;
int retscsnodelen;
unsigned long long now;
char timestr[23];
$DESCRIPTOR(atimenow, timestr);
char timestr2[23];
$DESCRIPTOR(atimenow2, timestr2);
sys$gettim(&now);
sys$asctim(0,&atimenow,&now,0);
syilst[0].buflen=16;
syilst[0].item_code=SYI$_VERSION;
syilst[0].bufaddr=version;
syilst[0].retlenaddr=&versionlen;
syilst[1].buflen=16;
syilst[1].item_code=SYI$_BOOTTIME;
syilst[1].bufaddr=&boottime;
syilst[1].retlenaddr=&boottimelen;
syilst[2].buflen=16;
syilst[2].item_code=SYI$_SCSNODE;
syilst[2].bufaddr=scsnode;
syilst[2].retlenaddr=&retscsnodelen;
syilst[3].buflen=0;
syilst[3].item_code=0;
sts=sys$getsyi(0,0,0,syilst,0,0,0);
long long delta = boottime - now;
int deltalen;
sys$asctim(0,&atimenow2,&delta,0);
lst[0].buflen=15;
lst[0].item_code=JPI$_PRCNAM;
lst[0].bufaddr=procname;
lst[0].retlenaddr=&proclen;
lst[1].buflen=4;
lst[1].item_code=JPI$_PID;
lst[1].bufaddr=&epid;
lst[1].retlenaddr=&epidlen;
lst[2].buflen=4;
lst[2].item_code=JPI$_MASTER_PID;
lst[2].bufaddr=&upid;
lst[2].retlenaddr=&upidlen;
lst[3].buflen=4;
lst[3].item_code=JPI$_STATE;
lst[3].bufaddr=&state;
lst[3].retlenaddr=&statelen;
lst[4].buflen=4;
lst[4].item_code=JPI$_PAGEFLTS;
lst[4].bufaddr=&pagef;
lst[4].retlenaddr=&pageflen;
lst[5].buflen=4;
lst[5].item_code=JPI$_PRI;
lst[5].bufaddr=&pri;
lst[5].retlenaddr=&prilen;
lst[6].buflen=4;
lst[6].item_code=JPI$_PPGCNT;
lst[6].bufaddr=&pagep;
lst[6].retlenaddr=&pageplen;
lst[7].buflen=4;
lst[7].item_code=JPI$_GPGCNT;
lst[7].bufaddr=&pageg;
lst[7].retlenaddr=&pageglen;
lst[8].buflen=4;
lst[8].item_code=JPI$_DIRIO;
lst[8].bufaddr=&dirio;
lst[8].retlenaddr=&diriolen;
lst[9].buflen=4;
lst[9].item_code=JPI$_BUFIO;
lst[9].bufaddr=&bufio;
lst[9].retlenaddr=&diriolen;
lst[10].buflen=4;
lst[10].item_code=JPI$_CPUTIM;
lst[10].bufaddr=δ
lst[10].retlenaddr=&deltalen;
lst[11].buflen=0;
lst[11].item_code=0;
// printf(" FreeVMS V0.0 on node %6s NN-OOO-2003 PP:QQ:RR.SS Uptime TT XX:YY:ZZ\n",scsnode);
#ifdef __x86_64__
int bits = 64;
#endif
#ifdef __i386__
int bits = 32;
#endif
#ifndef FREEVMS_BUILD
#define FREEVMS_BUILD 1
#endif
printf(" FreeVMS %d V%s build %d on node %6s %s Uptime %s\n", bits,version, FREEVMS_BUILD, scsnode, timestr, timestr2);
printf(" Pid Process Name State Pri I/O CPU Page flts Pages\n");
do {
jpistatus=sys$getjpi(0,0,0,lst,0,0,0);
if (jpistatus == SS$_NORMAL)
delta = -delta * 100000; // check multiplication
sys$asctim(0,&atimenow2,&delta,0);
printf("%8x %-15s %-6s %3x %9x %17s %6x %6x\n",epid,procname,states[state],31-pri,dirio+bufio,atimenow2.dsc$a_pointer,pagef,pagep+pageg);
} while (jpistatus == SS$_NORMAL);
//} while (jpistatus != SS$_NOMOREPROC);
}
asmlinkage int exe$getjpi_wrap(struct struct_getjpi *s)
{
return exe$getjpi(s->efn,s->pidadr,s->prcnam,s->itmlst,s->iosb,s->astadr,s->astprm);
}
