/*
**++
** ROUTINE: sp_once
**
** FUNCTIONAL DESCRIPTION:
**
**
** RETURNS: cond_value, longword (unsigned), write only, by value
**
** PROTOTYPE:
**
** sp_once(struct dsc$descriptor *cmd, struct dsc$descriptor *rcvstr,
** int *rcvlen)
**
** IMPLICIT INPUTS: None.
**
** IMPLICIT OUTPUTS: None.
**
** COMPLETION CODES:
** SS$_NORMAL: normal successful completion
** SS$_NONEXPR: subprocess doesn't exist any more
**
** SIDE EFFECTS: None.
**
**--
*/
void sp_once (void *cmd, void (*actrtn)(void *, struct dsc$descriptor *),
void *param) {
struct ONCE ctx;
int status;
struct dsc$descriptor eomcmd;
static char *eom = "MMK___SP_ONCE_EOM";
static $DESCRIPTOR(eomfao, "WRITE SYS$OUTPUT \"!AZ\"");
memset(&ctx, 0, sizeof(struct ONCE));
ctx.actrtn = actrtn;
ctx.param = param;
ctx.eom = eom;
ctx.eom_len = sizeof(eom)-1;
INIT_DYNDESC(eomcmd);
lib$sys_fao(&eomfao, 0, &eomcmd, eom);
status = sp_open(&ctx.spctx, cmd, sp_once_ast, &ctx);
if (OK(status)) {
status = sp_send(&ctx.spctx, &eomcmd);
if (OK(status)) {
do {
sys$hiber();
} while (!ctx.command_complete);
}
sp_close(&ctx.spctx);
}
str$free1_dx(&eomcmd);
} /* sp_once */
void mscp_talk_with(char * node, char * sysap)
{
// both parameters are unused right now
// we know they are the other node, and the second is mscp$disk
__du_init(); //temp placement?
signed long long time=-100000000;
int unit;
struct _cdrp * cdrp = vmalloc(sizeof(struct _cdrp));
struct _mscp_basic_pkt * basic = vmalloc(sizeof(struct _mscp_basic_pkt));
memset(cdrp,0,sizeof(struct _cdrp));
memset(basic,0,sizeof(struct _mscp_basic_pkt));
//basic->mscp$b_caa=MSCP$K_OP_READ;
for (unit=1; unit < 5; unit ++)
{
exe$schdwk(0,0,&time,0);
sys$hiber();
printk("probing other node dqa%x\n",unit);
basic->mscp$b_opcode = MSCP$K_OP_GTUNT;
basic->mscp$w_unit=unit;
basic->mscp$l_cmd_ref=0;
cdrp->cdrp$w_cdrpsize=600;
cdrp->cdrp$l_rspid=scs_std$alloc_rspid(0,0,cdrp,0);
cdrp->cdrp$l_cdt=find_mscp_cdt();
cdrp->cdrp$l_msg_buf=basic;
cdrp->cdrp$l_xct_len=sizeof(struct _mscp_basic_pkt);
if (cdrp->cdrp$l_cdt==0)
{
printk("gtunt cli no cdt\n");
return;
}
scs_std$senddg(0,600,cdrp);
}
}
int job_control(void *unused)
{
int sts;
struct _pcb *tsk = ctl$gl_pcb;
strcpy(tsk->pcb$t_lname, "JOB_CONTROL");
sts=exe$crembx(1,&mailbox_channel,512,512,0,0,0,0);
sys$ar_jobctlmb=ctl$gl_ccbbase[mailbox_channel].ccb$l_ucb;
do_mbx_read();
sys$hiber();
printk("job control should not get past sys$hiber\n");
}
main()
{
$DESCRIPTOR(secs,"0 00:00:20.00");
sys$gettim(&now);
sys$bintim(&secs,&step1);
if (now<0) printf("now less than 0\n");
if (step1<0) printf("step1 less than 0\n");
now=now-step1;
sys$schdwk(0,0,&now,&step1);
printf("before hiber %x\n",time(0));
sys$hiber();
sys$hiber();
sys$hiber();
printf("after hiber %x\n",time(0));
}
int main(int argc, char *argv[])
{
if (argc < 3)
{
printf("usage: %s <maxnodes> <us>\n", argv[0]);
return 2;
}
maxnode = atoi(argv[1]);
us = atoi(argv[2]);
start_lock();
while(1)
sys$hiber();
return SS$_NORMAL;
}
/***********************************************************************
This routine is called to wait for a clustered data base to transition
to a new state. If the "state" parameter is non-zero, then it is
considered a bit mask, with state zero being the lsb, etc. (All of
these masks are symbolically defined in ccp.h as CCST_MASK_nnnnn.)
In this case we will return when the state is obtained. If the
state is zero, we will return when the ccp_cycle count is bumped,
indicating that we have transitioned into read mode. In any event
we will return after the "next" cycle has passed, so that if we
"miss" our window, we can try again.
***********************************************************************/
bool ccp_userwait(gd_region *reg, uint4 state, int4 *timadr, unsigned short cycle)
/* if timadr is non-zero, then the timeout quadword, else use the seg's timeout interval */
{
int4 status;
static void ccp_nocomm();
bool timer_on;
sgmnt_data *seg;
sgmnt_addrs *csa;
int4 *timptr;
char buff[(MM_BLOCK - 1) * DISK_BLOCK_SIZE];
short iosb[4];
error_def(ERR_CCPNOTFND);
csa = &((vms_gds_info *)(reg->dyn.addr->file_cntl->file_info))->s_addrs;
seg = ((vms_gds_info *)(reg->dyn.addr->file_cntl->file_info))->s_addrs.hdr;
timptr = timadr ? timadr : (int4 *) &seg->ccp_response_interval;
timer_on = timptr[0] != 0 && timptr[1] != 0;
for (; ;)
{ ccp_communication_timeout = FALSE;
if (timer_on)
{
status = sys$setimr(0, timptr, ccp_nocomm, ccp_nocomm, 0);
if ((status & 1) == 0)
rts_error(VARLSTCNT(1) status);
}
while (!CCP_SEGMENT_STATE(csa->nl, state) && csa->nl->ccp_cycle == cycle && !ccp_communication_timeout)
{
sys$hiber();
}
if (ccp_communication_timeout && !(CCP_SEGMENT_STATE(csa->nl, state) || csa->nl->ccp_cycle != cycle))
{
status = sys$qiow(EFN$C_ENF, ((vms_gds_info *)(reg->dyn.addr->file_cntl->file_info))->fab->fab$l_stv,
IO$_READVBLK, &iosb[0], 0, 0, buff, SIZEOF(buff), 1, 0, 0, 0);
if ((status & 1) && (iosb[0] & 1) && ((sgmnt_data *)buff)->freeze)
continue;
rts_error(VARLSTCNT(1) ERR_CCPNOTFND);
}else
break;
}
if (timer_on)
sys$cantim(ccp_nocomm,0);
return CCP_SEGMENT_STATE(csa->nl, state);
}
unsigned int lib$wait(float *seconds, int flags, int float_type) {
// check pointer
if (*seconds<0 || *seconds>100000)
return LIB$_INVARG;
float hundreds_f = *seconds * 100;
long long hundreds = hundreds_f;
long long vmstime = - hundreds * 100000;
int sts;
if (flags & 1) { // LIB$K_NOWAKE is 1
sts = sys$setimr (0, &vmstime, dummyast, 0, 0);
if ((sts & 1) == 0)
return sts;
sts = sys$synch (0, 0);
if ((sts & 1) == 0)
return sts;
} else {
sts = sys$schdwk(0, 0, &vmstime, 0);
if ((sts & 1) == 0)
return sts;
return sys$hiber();
}
return SS$_NORMAL;
}
gtcm_server()
{
static readonly int4 reptim[2] = {-100000, -1}; /* 10ms */
static readonly int4 wait[2] = {-1000000, -1}; /* 100ms */
void gtcm_ch(), gtcm_exi_handler(), gtcm_init_ast(), gtcm_int_unpack(), gtcm_mbxread_ast(),
gtcm_neterr(), gtcm_read_ast(), gtcm_remove_from_action_queue(), gtcm_shutdown_ast(), gtcm_write_ast(),
la_freedb();
bool gtcm_link_accept();
bool alid;
char buff[512];
char *h = NULL;
char *la_getdb();
char nbuff[256];
char *pak = NULL;
char reply;
unsigned short outlen;
int4 closewait[2] = {0, -1};
int4 inid = 0, mdl = 0, nid = 0, days = 0;
int4 lic_status;
int4 lic_x;
int4 lm_mdl_nid();
uint4 status;
int i, receive(), value;
mstr name1, name2;
struct NTD *cmu_ntdroot();
connection_struct *prev_curr_entry;
struct dsc$descriptor_s dprd;
struct dsc$descriptor_s dver;
$DESCRIPTOR(node_name, nbuff);
$DESCRIPTOR(proc_name, "GTCM_SERVER");
$DESCRIPTOR(timout, buff);
DCL_THREADGBL_ACCESS;
GTM_THREADGBL_INIT;
assert(0 == EMPTY_QUEUE); /* check so dont need gdsfhead everywhere */
common_startup_init(GTCM_GNP_SERVER_IMAGE); /* Side-effect: Sets skip_dbtriggers to TRUE for non-trigger platforms */
gtm_env_init(); /* read in all environment variables */
name1.addr = "GTCMSVRNAM";
name1.len = SIZEOF("GTCMSVRNAM") - 1;
status = trans_log_name(&name1, &name2, nbuff);
if (SS$_NORMAL == status)
{
proc_name.dsc$a_pointer = nbuff;
proc_name.dsc$w_length = node_name.dsc$w_length = name2.len;
} else if (SS$_NOLOGNAM == status)
{
MEMCPY_LIT(nbuff, "GTCMSVR");
node_name.dsc$w_length = SIZEOF("GTCMSVR") - 1;
} else
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) status);
sys$setprn(&proc_name);
status = lib$get_foreign(&timout, 0, &outlen, 0);
if ((status & 1) && (6 > outlen))
{
for (i = 0; i < outlen; i++)
{
value = value * 10;
if (buff[i] <= '9' && buff[i] >= '0')
value += buff[i] - 48;
else
break;
}
if (outlen && (i == outlen))
{
cm_timeout = TRUE;
closewait[0] = value * -10000000;
}
}
dprd.dsc$w_length = cm_prd_len;
dprd.dsc$b_dtype = DSC$K_DTYPE_T;
dprd.dsc$b_class = DSC$K_CLASS_S;
dprd.dsc$a_pointer= cm_prd_name;
dver.dsc$w_length = cm_ver_len;
dver.dsc$b_dtype = DSC$K_DTYPE_T;
dver.dsc$b_class = DSC$K_CLASS_S;
dver.dsc$a_pointer= cm_ver_name;
ast_init();
licensed = TRUE;
lkid = 2;
# ifdef NOLICENSE
lid = 1;
# else
/* this code used to be scattered to discourage reverse engineering, but since it now disabled, that seems pointless */
lic_status = ((NULL == (h = la_getdb(LMDB))) ? LP_NOCNFDB : SS$_NORMAL);
lic_status = ((1 == (lic_status & 1)) ? lm_mdl_nid(&mdl, &nid, &inid) : lic_status);
lic_status = ((1 == (lic_status & 1)) ? lp_licensed(h, &dprd, &dver, mdl, nid, &lid, &lic_x, &days, pak) : lic_status);
if (LP_NOCNFDB != lic_status)
la_freedb(h);
if (1 == (lic_status & 1))
{
licensed = TRUE;
if (days < 14)
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_WILLEXPIRE);
} else
{
licensed = FALSE;
sys$exit(lic_status);
}
# endif
gtcm_ast_avail = astq_dyn_avail - GTCM_AST_OVRHD;
stp_init(STP_INITSIZE);
rts_stringpool = stringpool;
cache_init();
procnum = 0;
get_proc_info(0, TADR(login_time), &image_count);
memset(proc_to_clb, 0, SIZEOF(proc_to_clb));
status = cmi_init(&node_name, 0, 0, gtcm_init_ast, gtcm_link_accept);
if (!(status & 1))
{
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ((status ^ 3) | 4));
sys$exit(status);
}
ntd_root = cmu_ntdroot();
ntd_root->mbx_ast = gtcm_mbxread_ast;
ntd_root->err = gtcm_neterr;
gtcm_connection = FALSE;
lib$establish(gtcm_ch);
gtcm_exi_blk.exit_hand = >cm_exi_handler;
gtcm_exi_blk.arg_cnt = 1;
gtcm_exi_blk.cond_val = >cm_exi_condition;
sys$dclexh(>cm_exi_blk);
INVOKE_INIT_SECSHR_ADDRS;
initialize_pattern_table();
assert(run_time); /* Should have been set by common_startup_init */
while (!cm_shutdown)
{
if (blkdlist)
gtcml_chkreg();
assert(!lib$ast_in_prog());
status = sys$dclast(>cm_remove_from_action_queue, 0, 0);
if (SS$_NORMAL != status)
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(4) CMERR_CMSYSSRV, 0, status, 0);
if (INTERLOCK_FAIL == curr_entry)
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) CMERR_CMINTQUE);
if (EMPTY_QUEUE != curr_entry)
{
switch (*curr_entry->clb_ptr->mbf)
{
case CMMS_L_LKCANALL:
reply = gtcmtr_lkcanall();
break;
case CMMS_L_LKCANCEL:
reply = gtcmtr_lkcancel();
break;
case CMMS_L_LKREQIMMED:
reply = gtcmtr_lkreqimmed();
break;
case CMMS_L_LKREQNODE:
reply = gtcmtr_lkreqnode();
break;
case CMMS_L_LKREQUEST:
reply = gtcmtr_lkrequest();
break;
case CMMS_L_LKRESUME:
reply = gtcmtr_lkresume();
break;
case CMMS_L_LKACQUIRE:
reply = gtcmtr_lkacquire();
break;
case CMMS_L_LKSUSPEND:
reply = gtcmtr_lksuspend();
break;
case CMMS_L_LKDELETE:
reply = gtcmtr_lkdelete();
break;
case CMMS_Q_DATA:
reply = gtcmtr_data();
break;
case CMMS_Q_GET:
reply = gtcmtr_get();
break;
case CMMS_Q_KILL:
reply = gtcmtr_kill();
break;
case CMMS_Q_ORDER:
reply = gtcmtr_order();
break;
case CMMS_Q_PREV:
reply = gtcmtr_zprevious();
break;
case CMMS_Q_PUT:
reply = gtcmtr_put();
break;
case CMMS_Q_QUERY:
reply = gtcmtr_query();
break;
case CMMS_Q_ZWITHDRAW:
reply = gtcmtr_zwithdraw();
break;
case CMMS_S_INITPROC:
reply = gtcmtr_initproc();
break;
case CMMS_S_INITREG:
reply = gtcmtr_initreg();
break;
case CMMS_S_TERMINATE:
reply = gtcmtr_terminate(TRUE);
break;
case CMMS_E_TERMINATE:
reply = gtcmtr_terminate(FALSE);
break;
case CMMS_U_LKEDELETE:
reply = gtcmtr_lke_clearrep(curr_entry->clb_ptr, curr_entry->clb_ptr->mbf);
break;
case CMMS_U_LKESHOW:
reply = gtcmtr_lke_showrep(curr_entry->clb_ptr, curr_entry->clb_ptr->mbf);
break;
case CMMS_B_BUFRESIZE:
reply = CM_WRITE;
value = *(unsigned short *)(curr_entry->clb_ptr->mbf + 1);
if (value > curr_entry->clb_ptr->mbl)
{
free(curr_entry->clb_ptr->mbf);
curr_entry->clb_ptr->mbf = malloc(value);
}
*curr_entry->clb_ptr->mbf = CMMS_C_BUFRESIZE;
curr_entry->clb_ptr->mbl = value;
curr_entry->clb_ptr->cbl = 1;
break;
case CMMS_B_BUFFLUSH:
reply = gtcmtr_bufflush();
break;
case CMMS_Q_INCREMENT:
reply = gtcmtr_increment();
break;
default:
reply = FALSE;
if (SS$_NORMAL == status)
rts_error_csa(CSA_ARG(NULL)
VARLSTCNT(3) ERR_BADGTMNETMSG, 1, (int)*curr_entry->clb_ptr->mbf);
break;
}
if (curr_entry) /* curr_entry can be NULL if went through gtcmtr_terminate */
{
status = sys$gettim(&curr_entry->lastact[0]);
if (SS$_NORMAL != status)
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) status);
/* curr_entry is used by gtcm_mbxread_ast to determine if it needs to defer the interrupt message */
prev_curr_entry = curr_entry;
if (CM_WRITE == reply)
{ /* if ast == gtcm_write_ast, let it worry */
curr_entry->clb_ptr->ast = gtcm_write_ast;
curr_entry = EMPTY_QUEUE;
cmi_write(prev_curr_entry->clb_ptr);
} else
{
curr_entry = EMPTY_QUEUE;
if (1 == (prev_curr_entry->int_cancel.laflag & 1))
{ /* valid interrupt cancel msg, handle in gtcm_mbxread_ast */
status = sys$dclast(gtcm_int_unpack, prev_curr_entry, 0);
if (SS$_NORMAL != status)
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) status);
} else if (CM_READ == reply)
{
prev_curr_entry->clb_ptr->ast = gtcm_read_ast;
cmi_read(prev_curr_entry->clb_ptr);
}
}
}
} else if (1 < astq_dyn_avail)
{
# ifdef GTCM_REPTIM
/* if reptim is not needed - and smw doesn't know why it would be - remove this */
status = sys$schdwk(0, 0, &wait[0], &reptim[0]);
# else
status = sys$schdwk(0, 0, &wait[0], 0);
# endif
sys$hiber();
sys$canwak(0, 0);
}
if (cm_timeout && (0 == gtcm_users))
sys$setimr(efn_ignore, closewait, gtcm_shutdown_ast, &cm_shutdown, 0);
}
}
