int getmaxprocount()
{
int status;
unsigned long maxprocount;
item_list itmlst3[2];
item_list *itml3 = itmlst3;
itmlst3[0].wlength = sizeof (maxprocount);
itmlst3[0].wcode = SYI$_MAXPROCESSCNT;
itmlst3[0].pbuffer = &maxprocount;
itmlst3[0].pretlen = NULL;
itmlst3[1].wlength = 0;
itmlst3[1].wcode = 0;
itmlst3[1].pbuffer = NULL;
itmlst3[1].pretlen = NULL;
status = sys$getsyiw (0, 0, 0, itmlst3, 0, 0, 0);
if ($VMS_STATUS_SUCCESS (status))
{
return maxprocount;
}
else
{
return 0;
}
}
Boolean ComputerSystem::getOtherIdentifyingInfo(CIMProperty& p)
{
// return model for this property
int status;
Array<String> s;
char hwname[32];
typedef struct {
unsigned short wlength;
unsigned short wcode;
void *pbuffer;
void *pretlen; } item_list;
item_list itmlst3[2];
itmlst3[0].wlength = sizeof(hwname);
itmlst3[0].wcode = SYI$_HW_NAME;
itmlst3[0].pbuffer = hwname;
itmlst3[0].pretlen = NULL;
itmlst3[1].wlength = 0;
itmlst3[1].wcode = 0;
itmlst3[1].pbuffer = NULL;
itmlst3[1].pretlen = NULL;
status = sys$getsyiw (0, 0, 0, itmlst3, 0, 0, 0);
if ($VMS_STATUS_SUCCESS(status))
{
_otherInfo.assign(hwname);
s.append(_otherInfo);
p = CIMProperty(PROPERTY_OTHER_IDENTIFYING_INFO,s);
return true;
}
else
return false;
}
fint hostname_c( fchar name )
{
#if defined(__vms__) /* VMS */
char hnam[VMSHOSTNAMELEN]; /* buffer for hostname */
long status; /* status return */
short len; /* length */
struct { /* Item list for sys$getsyiw */
short l; /* length */
short c; /* command */
int *a; /* address for output */
int *r; /* address for output length */
int e; /* stop word */
} itmlst;
itmlst.a = hnam; /* hostname goes here */
itmlst.c = SYI$_NODENAME; /* this is the command */
itmlst.r = &len; /* output size goes here */
itmlst.l = VMSHOSTNAMELEN; /* input size */
itmlst.e = 0; /* stop word */
status = sys$getsyiw( NULL, NULL, NULL, &itmlst, NULL, NULL, NULL );
if (status != SS$_NORMAL) {
return( -1 ); /* error code */
} else {
int i; /* counter */
for (i = 0; i < len && i < name.l; i++) name.a[i] = hnam[i];
while (i < name.l) name.a[i++] = ' '; /* fill with blanks */
return( 0 );
}
#elif defined(__bsd__) /* BSD systems */
int i, r;
r = gethostname( name.a, (int) name.l );
if (!r) {
for (i = 0; i < name.l && name.a[i]; i++);
for ( ; i < name.l; name.a[i++] = ' ');
}
return( r );
#elif defined(__sysv__) /* SYSV systems */
int i, r = -1;
struct utsname n;
if (uname( &n ) != -1) {
r = 0;
for (i = 0; i < name.l && n.nodename[i]; i++) {
name.a[i] = n.nodename[i];
}
for ( ; i < name.l; name.a[i++] = ' ');
}
return( r );
#endif
}
static i4
vms_get_num_of_processors()
{
i4 num_processors;
ILE3 itmlst[] =
{ { sizeof(num_processors), SYI$_AVAILCPU_CNT, &num_processors, 0},
{ 0, 0, 0, 0}
};
IOSB iosb;
int status = sys$getsyiw(EFN$C_ENF, NULL, NULL, itmlst, &iosb, NULL, 0);
if (status & 1)
status = iosb.iosb$w_status;
if (status != SS$_NORMAL)
num_processors = 1;
return num_processors;
}
i4
iiCL_increase_fd_table_size(i4 maximum, i4 increase_fds)
{
i4 sts;
i4 channelcnt = 0;
ILE3 itmlst[2];
IOSB iosb;
itmlst[0].ile3$w_length = sizeof(channelcnt);
itmlst[0].ile3$w_code = SYI$_CHANNELCNT;
itmlst[0].ile3$ps_bufaddr = &channelcnt;
itmlst[0].ile3$ps_retlen_addr = NULL;
itmlst[1].ile3$w_length = 0;
itmlst[1].ile3$w_code = 0;
sts = sys$getsyiw (EFN$C_ENF, NULL, NULL, itmlst, &iosb, NULL, 0);
if (sts & STS$M_SUCCESS) sts = iosb.iosb$w_status;
if (!(sts & STS$M_SUCCESS)) lib$signal (sts);
return (channelcnt);
}
std::string EnvironmentImpl::getsyi(unsigned short code)
{
#pragma pointer_size save
#pragma pointer_size 32
unsigned char result[16];
unsigned short length;
ILE3 items[2];
items[0].ile3$w_code = code;
items[0].ile3$w_length = sizeof(result);
items[0].ile3$ps_bufaddr = result;
items[0].ile3$ps_retlen_addr = &length;
items[1].ile3$w_code = 0;
items[1].ile3$w_length = 0;
if (sys$getsyiw(0, 0, 0, items, 0, 0, 0) == 1)
return std::string((char*) result, length);
else
throw SystemException("$GETSYI failed");
#pragma pointer_size restore
}
unsigned EnvironmentImpl::processorCountImpl()
{
#pragma pointer_size save
#pragma pointer_size 32
Poco::UInt32 count;
unsigned short length;
ILE3 items[2];
items[0].ile3$w_code = SYI$_ACTIVECPU_CNT;
items[0].ile3$w_length = sizeof(count);
items[0].ile3$ps_bufaddr = &count;
items[0].ile3$ps_retlen_addr = &length;
items[1].ile3$w_code = 0;
items[1].ile3$w_length = 0;
if (sys$getsyiw(0, 0, 0, items, 0, 0, 0) == 1)
return count;
else
throw SystemException("$GETSYI failed");
#pragma pointer_size restore
}
unsigned char mu_cre_file(void)
{
unsigned char *inadr[2], *c, exit_stat;
enum db_acc_method temp_acc_meth;
uint4 lcnt, retadr[2];
int4 blk_init_size, initial_alq, free_blocks;
gtm_uint64_t free_blocks_ll, blocks_for_extension;
char buff[GLO_NAME_MAXLEN], fn_buff[MAX_FN_LEN];
unsigned int status;
int free_space;
struct FAB *fcb;
struct NAM nam;
gds_file_id new_id;
io_status_block_disk iosb;
char node[16];
short len;
struct {
short blen;
short code;
char *buf;
short *len;
int4 terminator;
} item = {15, SYI$_NODENAME, &node, &len, 0};
$DESCRIPTOR(desc, buff);
exit_stat = EXIT_NRM;
/* The following calculations should duplicate the BT_SIZE macro from GDSBT and the LOCK_BLOCK macro from GDSFHEAD.H,
* but without using a sgmnt_data which is not yet set up at this point
*/
#ifdef GT_CX_DEF
/* This section needs serious chnages for the fileheader changes in V5 if it is ever resurrected */
over_head = DIVIDE_ROUND_UP(SIZEOF_FILE_HDR_DFLT
+ (WC_MAX_BUFFS + getprime(WC_MAX_BUFFS) + 1) * SIZEOF(bt_rec), DISK_BLOCK_SIZE);
if (gv_cur_region->dyn.addr->acc_meth == dba_bg)
{
free_space = over_head - DIVIDE_ROUND_UP(SIZEOF_FILE_HDR_DFLT
+ (gv_cur_region->dyn.addr->global_buffers + getprime(gv_cur_region->dyn.addr->global_buffers) + 1)
* SIZEOF(bt_rec), DISK_BLOCK_SIZE);
over_head += gv_cur_region->dyn.addr->lock_space ? gv_cur_region->dyn.addr->lock_space
: DEF_LOCK_SIZE / OS_PAGELET_SIZE;
} else if (gv_cur_region->dyn.addr->acc_meth == dba_mm)
{
free_space = over_head - DIVIDE_ROUND_UP(SIZEOF_FILE_HDR_DFLT, DISK_BLOCK_SIZE);
if (gv_cur_region->dyn.addr->lock_space)
{
over_head += gv_cur_region->dyn.addr->lock_space;
free_space += gv_cur_region->dyn.addr->lock_space;
} else
{
over_head += DEF_LOCK_SIZE / OS_PAGELET_SIZE;
free_space += DEF_LOCK_SIZE / OS_PAGELET_SIZE;
}
}
free_space *= DISK_BLOCK_SIZE;
#else
assert(START_VBN_CURRENT > DIVIDE_ROUND_UP(SIZEOF_FILE_HDR_DFLT, DISK_BLOCK_SIZE));
free_space = ((START_VBN_CURRENT - 1) * DISK_BLOCK_SIZE) - SIZEOF_FILE_HDR_DFLT;
#endif
switch (gv_cur_region->dyn.addr->acc_meth)
{
case dba_bg:
case dba_mm:
mu_cre_vms_structs(gv_cur_region);
fcb = ((vms_gds_info *)(gv_cur_region->dyn.addr->file_cntl->file_info))->fab;
cs_addrs = &((vms_gds_info *)(gv_cur_region->dyn.addr->file_cntl->file_info))->s_addrs;
fcb->fab$b_shr &= FAB$M_NIL; /* No access to this file while it is created */
fcb->fab$l_nam = &nam;
nam = cc$rms_nam;
/* There are (bplmap - 1) non-bitmap blocks per bitmap, so add (bplmap - 2) to number of non-bitmap blocks
* and divide by (bplmap - 1) to get total number of bitmaps for expanded database. (must round up in this
* manner as every non-bitmap block must have an associated bitmap)
*/
fcb->fab$l_alq += DIVIDE_ROUND_UP(fcb->fab$l_alq, BLKS_PER_LMAP - 1); /* Bitmaps */
blk_init_size = fcb->fab$l_alq;
fcb->fab$l_alq *= BLK_SIZE / DISK_BLOCK_SIZE;
fcb->fab$l_alq += START_VBN_CURRENT - 1;
initial_alq = fcb->fab$l_alq;
fcb->fab$w_mrs = 512; /* no longer a relevent field to us */
break;
case dba_usr:
util_out_print("Database file for region !AD not created; access method is not GDS.", TRUE,
REG_LEN_STR(gv_cur_region));
return EXIT_WRN;
default:
gtm_putmsg(VARLSTCNT(1) ERR_BADACCMTHD);
return EXIT_ERR;
}
nam.nam$b_ess = SIZEOF(fn_buff);
nam.nam$l_esa = fn_buff;
nam.nam$b_nop |= NAM$M_SYNCHK;
status = sys$parse(fcb, 0, 0);
if (RMS$_NORMAL != status)
{
gtm_putmsg(VARLSTCNT(8) ERR_DBFILERR, 2, fcb->fab$b_fns, fcb->fab$l_fna, status, 0, fcb->fab$l_stv, 0);
return EXIT_ERR;
}
if (nam.nam$b_node != 0)
{
status = sys$getsyiw(EFN$C_ENF, 0, 0, &item, &iosb, 0, 0);
if (SS$_NORMAL == status)
status = iosb.cond;
if (SS$_NORMAL == status)
{
if (len == nam.nam$b_node-2 && !memcmp(nam.nam$l_esa, node, len))
{
fcb->fab$l_fna = nam.nam$l_esa + nam.nam$b_node;
fcb->fab$b_fns = nam.nam$b_esl - nam.nam$b_node;
}
} else
{
util_out_print("Could not get node for !AD.", TRUE, REG_LEN_STR(gv_cur_region));
exit_stat = EXIT_WRN;
}
}
assert(gv_cur_region->dyn.addr->acc_meth == dba_bg || gv_cur_region->dyn.addr->acc_meth == dba_mm);
nam.nam$l_esa = NULL;
nam.nam$b_esl = 0;
status = sys$create(fcb);
if (status != RMS$_CREATED && status != RMS$_FILEPURGED)
{
switch(status)
{
case RMS$_FLK:
util_out_print("Database file for region !AD not created; currently locked by another user.", TRUE,
REG_LEN_STR(gv_cur_region));
exit_stat = EXIT_INF;
break;
case RMS$_NORMAL:
util_out_print("Database file for region !AD not created; already exists.", TRUE,
REG_LEN_STR(gv_cur_region));
exit_stat = EXIT_INF;
break;
case RMS$_SUPPORT:
util_out_print("Database file for region !AD not created; cannot create across network.", TRUE,
REG_LEN_STR(gv_cur_region));
exit_stat = EXIT_WRN;
break;
case RMS$_FUL:
send_msg(VARLSTCNT(8) ERR_DBFILERR, 2, fcb->fab$b_fns, fcb->fab$l_fna,
status, 0, fcb->fab$l_stv, 0);
/* intentionally falling through */
default:
gtm_putmsg(VARLSTCNT(8) ERR_DBFILERR, 2, fcb->fab$b_fns, fcb->fab$l_fna,
status, 0, fcb->fab$l_stv, 0);
exit_stat = EXIT_ERR;
}
sys$dassgn(fcb->fab$l_stv);
return exit_stat;
}
memcpy(new_id.dvi, nam.nam$t_dvi, SIZEOF(nam.nam$t_dvi));
memcpy(new_id.did, nam.nam$w_did, SIZEOF(nam.nam$w_did));
memcpy(new_id.fid, nam.nam$w_fid, SIZEOF(nam.nam$w_fid));
global_name("GT$S", &new_id, buff); /* 2nd parm is actually a gds_file_id * in global_name */
desc.dsc$w_length = buff[0]; /* By definition, a gds_file_id is dvi,fid,did from nam */
desc.dsc$a_pointer = &buff[1];
cs_addrs->db_addrs[0] = cs_addrs->db_addrs[1] = inadr[0] = inadr[1] = inadr; /* used to determine p0 or p1 allocation */
status = init_sec(cs_addrs->db_addrs, &desc, fcb->fab$l_stv, (START_VBN_CURRENT - 1),
SEC$M_DZRO|SEC$M_GBL|SEC$M_WRT|SEC$M_EXPREG);
if ((SS$_CREATED != status) && (SS$_NORMAL != status))
{
gtm_putmsg(VARLSTCNT(8) ERR_DBFILERR, 2, fcb->fab$b_fns, fcb->fab$l_fna, status, 0, fcb->fab$l_stv, 0);
sys$dassgn(fcb->fab$l_stv);
return EXIT_ERR;
}
cs_data = (sgmnt_data *)cs_addrs->db_addrs[0];
memset(cs_data, 0, SIZEOF_FILE_HDR_DFLT);
cs_data->createinprogress = TRUE;
cs_data->trans_hist.total_blks = (initial_alq - (START_VBN_CURRENT - 1)) / (BLK_SIZE / DISK_BLOCK_SIZE);
/* assert that total_blks stored in file-header = non-bitmap blocks (initial allocation) + bitmap blocks */
assert(cs_data->trans_hist.total_blks == gv_cur_region->dyn.addr->allocation +
DIVIDE_ROUND_UP(gv_cur_region->dyn.addr->allocation, BLKS_PER_LMAP - 1));
cs_data->start_vbn = START_VBN_CURRENT;
temp_acc_meth = gv_cur_region->dyn.addr->acc_meth;
cs_data->acc_meth = gv_cur_region->dyn.addr->acc_meth = dba_bg;
cs_data->extension_size = gv_cur_region->dyn.addr->ext_blk_count;
mucregini(blk_init_size);
cs_addrs->hdr->free_space = free_space;
#ifndef GT_CX_DEF
cs_addrs->hdr->unbacked_cache = TRUE;
#endif
cs_data->acc_meth = gv_cur_region->dyn.addr->acc_meth = temp_acc_meth;
cs_data->createinprogress = FALSE;
if (SS$_NORMAL == (status = disk_block_available(fcb->fab$l_stv, &free_blocks)))
{
blocks_for_extension = (cs_data->blk_size / DISK_BLOCK_SIZE *
(DIVIDE_ROUND_UP(EXTEND_WARNING_FACTOR * (gtm_uint64_t)cs_data->extension_size, BLKS_PER_LMAP - 1)
+ EXTEND_WARNING_FACTOR * (gtm_uint64_t)cs_data->extension_size));
if ((gtm_uint64_t)free_blocks < blocks_for_extension)
{
free_blocks_ll = (gtm_uint64_t)free_blocks;
gtm_putmsg(VARLSTCNT(8) ERR_LOWSPACECRE, 6, fcb->fab$b_fns, fcb->fab$l_fna, EXTEND_WARNING_FACTOR,
&blocks_for_extension, DISK_BLOCK_SIZE, &free_blocks_ll);
send_msg(VARLSTCNT(8) ERR_LOWSPACECRE, 6, fcb->fab$b_fns, fcb->fab$l_fna, EXTEND_WARNING_FACTOR,
&blocks_for_extension, DISK_BLOCK_SIZE, &free_blocks_ll);
}
}
if (SS$_NORMAL == (status = sys$updsec(((vms_gds_info *)(gv_cur_region->dyn.addr->file_cntl->file_info))->s_addrs.db_addrs,
NULL, PSL$C_USER, 0, efn_immed_wait, &iosb, NULL, 0)))
{
status = sys$synch(efn_immed_wait, &iosb);
if (SS$_NORMAL == status)
status = iosb.cond;
} else if (SS$_NOTMODIFIED == status)
status = SS$_NORMAL;
if (SS$_NORMAL == status)
status = del_sec(SEC$M_GBL, &desc, 0);
if (SS$_NORMAL == status)
status = sys$deltva(cs_addrs->db_addrs, retadr, PSL$C_USER);
if (SS$_NORMAL == status)
status = sys$dassgn(fcb->fab$l_stv);
if (SS$_NORMAL == status)
{
util_out_print("Database file for region !AD created.", TRUE, REG_LEN_STR(gv_cur_region));
/* the open and close are an attempt to ensure that the file is available, not under the control of an ACP,
* before MUPIP exits */
fcb->fab$b_shr = FAB$M_SHRPUT | FAB$M_SHRGET | FAB$M_UPI;
fcb->fab$l_fop = 0;
for (lcnt = 1; (60 * MAX_OPEN_RETRY) >= lcnt; lcnt++)
{ /* per VMS engineering a delay is expected. We will wait up to an hour as a
* Delete Global Section operation is essentially and inherently asynchronous in nature
* and could take an arbitrary amount of time.
*/
if (RMS$_FLK != (status = sys$open(fcb, NULL, NULL)))
break;
wcs_sleep(lcnt);
}
assert(RMS$_NORMAL == status);
if (RMS$_NORMAL == status)
{
status = sys$close(fcb);
assert(RMS$_NORMAL == status);
}
if (RMS$_NORMAL != status)
exit_stat = EXIT_WRN;
} else
exit_stat = EXIT_ERR;
if (RMS$_NORMAL != status)
gtm_putmsg(VARLSTCNT(8) ERR_DBFILERR, 2, fcb->fab$b_fns, fcb->fab$l_fna, status, 0, fcb->fab$l_stv, 0);
if ((MAX_RMS_RECORDSIZE - SIZEOF(shmpool_blk_hdr)) < cs_data->blk_size)
gtm_putmsg(VARLSTCNT(5) ERR_MUNOSTRMBKUP, 3, fcb->fab$b_fns, fcb->fab$l_fna, 32 * 1024 - DISK_BLOCK_SIZE);
return exit_stat;
}
Boolean Process::getCPUTime (Uint32& i32)
const
{
int status = SS$_NORMAL;
long lKernelTicks = 0;
long lExecTicks = 0;
long lSuperTicks = 0;
long lUserTicks = 0;
long lTotalTicks = 0;
long avcpucnt;
__int64 pstartime;
__int64 qcurtime;
float fTotalTicks;
float fpercntime;
struct k1_arglist
{ // kernel call arguments
long lCount; // number of arguments
long epid;
long *pKernelTicks;
long *pExecTicks;
long *pSuperTicks;
long *pUserTicks;
} getcputickskargs = {5}; // init to 5 arguments
item_list itmlst3[2];
getcputickskargs.epid = pInfo.pid;
getcputickskargs.pKernelTicks = &lKernelTicks;
getcputickskargs.pExecTicks = &lExecTicks;
getcputickskargs.pSuperTicks = &lSuperTicks;
getcputickskargs.pUserTicks = &lUserTicks;
status = sys$cmkrnl (GetCPUTicks, &getcputickskargs);
if (!$VMS_STATUS_SUCCESS (status))
{
return false;
}
lTotalTicks = lKernelTicks + lExecTicks + lSuperTicks + lUserTicks;
fTotalTicks = lTotalTicks; // 10 millisec ticks
fTotalTicks = fTotalTicks * 10000000; // 100 nanosec ticks
pstartime = pInfo.p_stime; // 100 nanosec ticks
itmlst3[0].wlength = 4;
itmlst3[0].wcode = SYI$_AVAILCPU_CNT;
itmlst3[0].pbuffer = &avcpucnt;
itmlst3[0].pretlen = NULL;
itmlst3[1].wlength = 0;
itmlst3[1].wcode = 0;
itmlst3[1].pbuffer = NULL;
itmlst3[1].pretlen = NULL;
status = sys$getsyiw (0, 0, 0, itmlst3, 0, 0, 0);
if (!$VMS_STATUS_SUCCESS (status))
{
return false;
}
status = sys$gettim (&qcurtime);
if (!$VMS_STATUS_SUCCESS (status))
{
return false;
}
fpercntime = avcpucnt;
fpercntime = fpercntime * (qcurtime - pstartime);
fpercntime = (fTotalTicks / fpercntime) * 100;
i32 = fpercntime;
return true;
}
