/* default priority adjustment functions */
void SetTaskPrio(const char* tName, const int tgtPrio)
{
int tid=0, curPrio=0, newPrio=0;
if ((tName != NULL) && (strlen(tName) > 0))
{
newPrio = tgtPrio;
if (newPrio < 0)
{
newPrio = 0;
}
else if (newPrio > 255)
{
newPrio = 255;
}
tid = taskNameToId(tName);
if (tid != ERROR)
{
if (taskPriorityGet(tid, &curPrio) != ERROR)
{
printf("Setting %s priority from %d to %d\n", tName, curPrio, newPrio);
taskPrioritySet(tid, newPrio);
}
}
}
}
/* WARNING this function will changed the calling task priority if it is
lower than the Stuffer, to greater than the stuffer while putting fifo words
into the fifo buffer
*/
void set2ExpEndState() /* reprogram HSlines, ap registers to safe state, Normal end */
{
int callTaskId;
int callTaskPrior;
DPRINT(0,"set2ExpEndState");
#ifdef INOVA
/* Keep the MTS gradient amp disabled whenever possible! */
gpaTuneSet(pTheAutoObject, SET_GPAENABLE, GPA_DISABLE_DELAY);
DPRINT(0,"Stuff FIFO through Normal channels with Safe State & Run fifo");
fifoResetStufferFlagNSem(pTheFifoObject);
callTaskId = taskIdSelf();
taskPriorityGet(callTaskId,&callTaskPrior);
/* Lower priority to allow stuffer in, if needed */
/* if priority <= to that of the stuffer then lower the priority of this task */
/* thus allowing the stuffer to stuff the fifo */
DPRINT2(0,"set2ExpEndState: tid: 0x%lx, priority: %d\n",callTaskId,callTaskPrior);
setlksample();
set2khz();
activate_ssha();
/* reset priority back if changed */
if (callTaskPrior <= FIFO_STUFFER_PRIORITY)
{
DPRINT(0,"Set priority Back \n");
taskPrioritySet(callTaskId,callTaskPrior);
}
#endif
return;
}
/* WARNING this function will changed the calling task priority if it is
lower than the Stuffer, to greater than the stuffer while putting fifo words
into the fifo buffer
*/
void set2ExpEndState() /* reprogram HSlines, ap registers to safe state, Normal end */
{
int callTaskId;
int callTaskPrior;
DPRINT(0,"set2ExpEndState");
/* Keep the MTS gradient amp disabled whenever possible! */
gpaTuneSet(pTheAutoObject, SET_GPAENABLE, GPA_DISABLE_DELAY);
DPRINT(0,"Stuff FIFO through Normal channels with Safe State & Run fifo");
fifoLoadHsl(pTheFifoObject, STD_HS_LINES, pTheFifoObject->SafeHSLines);
fifoLoadHsl(pTheFifoObject, EXT_HS_LINES, pTheFifoObject->SafeHSLinesExt);
/* Each SafeState Code is actually two long words */
fifoResetStufferFlagNSem(pTheFifoObject);
callTaskId = taskIdSelf();
taskPriorityGet(callTaskId,&callTaskPrior);
/* Lower priority to allow stuffer in, if needed */
/* if priority <= to that of the stuffer then lower the priority of this task */
/* thus allowing the stuffer to stuff the fifo */
DPRINT2(0,"set2ExpEndState: tid: 0x%lx, priority: %d\n",callTaskId,callTaskPrior);
if (callTaskPrior <= FIFO_STUFFER_PRIORITY)
{
DPRINT(0,"Set priority lower than stuffer\n");
taskPrioritySet(callTaskId,(FIFO_STUFFER_PRIORITY+1));
}
if (numSafeStatCodes > 0)
{
fifoStuffIt(pTheFifoObject, pSafeStateCodes, numSafeStatCodes);/* into Fifo Buffer */
fifoStuffCode(pTheFifoObject, pTurnOffSshaCodes, numTurnOffSshaCodes);
fifoStuffCode(pTheFifoObject, pHaltOpCodes, numHaltOpCodes);
DPRINT(1,"Ready to start FIFO in set to exp end state\n" );
fifoStart(pTheFifoObject);
fifoWait4Stop(pTheFifoObject);
}
setlksample();
set2khz();
activate_ssha();
/* reset priority back if changed */
if (callTaskPrior <= FIFO_STUFFER_PRIORITY)
{
DPRINT(0,"Set priority Back \n");
taskPrioritySet(callTaskId,callTaskPrior);
}
return;
}
int vxhGo()
{
vxhStop();
tid = taskNameToId("tShell");
taskPrioritySet(tid,4);
tid = taskNameToId("tLogTask");
taskPrioritySet(tid,3);
tid = taskNameToId("tExcTask");
taskPrioritySet(tid,3);
tid = taskNameToId("tTelnetd");
taskPrioritySet(tid,5);
tid = taskNameToId("tTelnetOutTask");
taskPrioritySet(tid,6);
tid = taskNameToId("tTelnetInTask");
taskPrioritySet(tid,6);
tid = taskNameToId("tWdbTask");
taskPrioritySet(tid,7);
vxh_stop_flag=0;
vxh_count=0;
vxh_id = taskSpawn(0, //name
1, // priority
VX_FP_TASK, // options
0x2000, // stack size
(FUNCPTR) vxh_task, // entry point
0,0,0,0,0,
0,0,0,0,0);
return(0);
}
/*----------------------------------------------------------------------*/
static
void resetNameBufs() /* free all named buffers */
{
int retrys;
int callTaskId,DwnLkrTaskId;
int callTaskPrior;
/* Since reset2SafeState should have left the downLinker in a ready
state we now longer need change priority/etc. here to get it to clean
up. 8/6/97
*/
#ifdef XXX
callTaskId = taskIdSelf();
DwnLkrTaskId = taskNameToId("tDownLink");
taskPriorityGet(callTaskId,&callTaskPrior);
#endif
retrys=0;
/* start wdog timeout of 7 seconds */
pHandlerTimeout = 0;
wdStart(pHandlerWdTimeout,sysClkRateGet() * 7, pHandlerWdISR, 0);
/* free buffers until all are free or watch-dog timeout has occurred */
while ( ((dlbUsedBufs(pDlbDynBufs) > 0) || (dlbUsedBufs(pDlbFixBufs) > 0)) &&
(!pHandlerTimeout) )
{
retrys++;
DPRINT(0,"dlbFreeAll Dyn");
dlbFreeAll(pDlbDynBufs);
DPRINT(0,"dlbFreeAll Fix");
dlbFreeAll(pDlbFixBufs);
Tdelay(1);
DPRINT1(0,"resetNameBufs: retrys: %d\n",retrys);
#ifdef XXX
/* Lower priority to allow downlinker in */
if (callTaskPrior <= DOWNLINKER_TASK_PRIORITY)
taskPrioritySet(callTaskId,(DOWNLINKER_TASK_PRIORITY+1));
Tdelay(10);
DPRINT1(-1,"resetNameBufs: retrys: %d\n",retrys);
if (retrys > 7)
{
if (taskIsSuspended(DwnLkrTaskId))
{
DPRINT(-1,"resetNameBufs: clearCurrentNameBuffer()\n");
clearCurrentNameBuffer();
}
}
#endif
}
wdCancel(pHandlerWdTimeout);
/* taskPrioritySet(callTaskId,callTaskPrior); */
/* resumeDownLink(); */
}
int
osip_thread_set_priority (struct osip_thread * _thread, int priority)
{
osip_thread_t *thread = (osip_thread_t *)_thread;
if (thread == NULL)
return -1;
taskPrioritySet (thread->id, 1);
return 0;
}
void zmq::thread_t::
applySchedulingParameters () // to be called in secondary thread context
{
int priority = (thread_priority >= 0 ? thread_priority : DEFAULT_PRIORITY);
priority = (priority < 255 ? priority : DEFAULT_PRIORITY);
if (descriptor != NULL || descriptor > 0) {
taskPrioritySet (descriptor, priority);
}
}
int main (void)
#endif
{
int j;
float *data;
#ifdef VXWORKS
{ int currentPriority;
/* The producer needs to run at a lower priority, else it swamps
central and the consumer */
taskPriorityGet(taskIdSelf(), ¤tPriority);
taskPrioritySet(taskIdSelf(), currentPriority+10);
}
#endif
data = (float *)malloc(MAX_DATA_SIZE);
for (j = 0; j<MAX_DATA_SIZE/sizeof(float); j++)
data[j] = (float) j;
IPC_connect("sender");
IPC_defineMsg(NULL_MSG, 0, NULL);
IPC_defineMsg(FLOAT4_MSG, sizeof(float)*4, NULL);
IPC_defineMsg(FLOAT16_MSG, sizeof(float)*16, NULL);
IPC_defineMsg(FLOAT64_MSG, sizeof(float)*64, NULL);
IPC_defineMsg(FLOAT256_MSG, sizeof(float)*256, NULL);
IPC_defineMsg(FLOAT1K_MSG, sizeof(float)*1024, NULL);
IPC_defineMsg(FLOAT4K_MSG, sizeof(float)*4*1024, NULL);
IPC_defineMsg(FLOAT16K_MSG, sizeof(float)*16*1024, NULL);
IPC_defineMsg(FLOAT64K_MSG, sizeof(float)*64*1024, NULL);
IPC_defineMsg(FLOAT256K_MSG, sizeof(float)*256*1024, NULL);
IPC_subscribe(DONE_MSG, doneHandler, NULL);
sendMessages(NULL_MSG, 0, data);
sendMessages(FLOAT4_MSG, sizeof(float)*4, data);
sendMessages(FLOAT16_MSG, sizeof(float)*16, data);
sendMessages(FLOAT64_MSG, sizeof(float)*64, data);
sendMessages(FLOAT256_MSG, sizeof(float)*256, data);
sendMessages(FLOAT1K_MSG, sizeof(float)*1024, data);
sendMessages(FLOAT4K_MSG, sizeof(float)*4*1024, data);
sendMessages(FLOAT16K_MSG, sizeof(float)*16*1024, data);
sendMessages(FLOAT64K_MSG, sizeof(float)*64*1024, data);
sendMessages(FLOAT256K_MSG, sizeof(float)*256*1024, data);
/* Wait for everything to settle down before shutting down */
sleep(2);
/* shut down */
printf ("\n");
fflush(stdout);
IPC_disconnect();
#if !defined(VXWORKS)
return 0;
#endif
}
// Slower updates, lower priority, signals ready.
void readify(Flywheel *flywheel)
{
flywheel->ready = true;
flywheel->delay = FLYWHEEL_READY_DELAY;
if (flywheel->task)
{
taskPrioritySet(flywheel->task, FLYWHEEL_READY_PRIORITY);
}
// TODO: Signal ready?
}
// Faster updates, higher priority, signals active.
void activate(Flywheel *flywheel)
{
flywheel->ready = false;
flywheel->delay = FLYWHEEL_ACTIVE_DELAY;
if (flywheel->task)
{
taskPrioritySet(flywheel->task, FLYWHEEL_ACTIVE_PRIORITY);
}
// TODO: Signal not ready?
}
void NewPriority(Id* to, PriorityType newPrio)
{
assert(to);
// do set a new priority if the one pass to this function is is invalid!
if (newPrio != INVALID_PRIORITY)
{
if (taskPrioritySet(to->TaskId, GetOSPriority(newPrio)) != OK)
{
ExitFunctionsThreadList().CriticalError(errnoGet(), __FUNCTION__, __LINE__);
}
}
}
void ThreadImpl::setPriorityImpl(int prio)
{
if (prio != _pData->prio)
{
_pData->prio = prio;
_pData->osPrio = mapPrio(_pData->prio);
if (isRunningImpl())
{
if (taskPrioritySet(_pData->task, _pData->osPrio) != OK)
throw SystemException("cannot set task priority");
}
}
}
void ThreadImpl::setOSPriorityImpl(int prio, int /* policy */)
{
if (prio != _pData->osPrio)
{
_pData->prio = reverseMapPrio(prio);
_pData->osPrio = prio;
if (_pData->pRunnableTarget || _pData->pCallbackTarget)
{
if (taskPrioritySet(_pData->task, prio) != OK)
throw SystemException("cannot set task priority");
}
}
}
tstbarrier()
{
int i;
int retval;
int pTmpId, TmpPrior;
int status;
pTmpId = taskIdSelf();
taskPriorityGet(pTmpId,&TmpPrior);
taskPrioritySet(pTmpId,132);
status = nddsPublicationIssuesWait(pUploadSyncPub, 5, 0);
if ( status == -1)
DPRINT(-1,"sendDDRSync: error in waiting\n");
for(i=0; i < 100; i++)
{
/* DPRINT1(-1," %d: call barrier wait\n",i); */
retval = barrierWait();
if (retval == 42)
DPRINT1(-1,">>>> %d: <<<<<< returned from barrier wait\n",i);
}
taskPrioritySet(pTmpId,TmpPrior);
}
static
void resetSystem()
{
DPRINT(0,"AParserAA");
AParserAA();
/* PARALLEL_CHANS */
freeSorter();
DPRINT(0,"AupdtAA");
AupdtAA();
DPRINT(0,"ShandlerAA");
ShandlerAA();
DPRINT(0,"fifoStufferAA");
fifoStufferAA(pTheFifoObject);
stmAdcOvldClear(pTheStmObject);
/* stmReset(pTheStmObject); */
DPRINT(0,"Disable ADC Intrps");
adcItrpDisable(pTheAdcObject,ADC_ALLITRPS);
/* adcReset(pTheAdcObject); */
/* reset fifo Object not to use parallel channels */
fifoClearPChanId(pTheFifoObject);
/* Reset Safe State again after tasks restarted */
/*reset2SafeState();*/ /* reprogram HSlines, ap registers to safe state */
/* call to reset2SafeState removed; in each case where resetSystem */
/* is called, reset2SafeState is called immediately previously. */
/* it maybe safe here, but we have to flip flop priorities with the Stuffer */
DPRINT2(0,"resetSystem: tid: 0x%lx, priority: %d\n",pHandlerTid,pHandlerPriority);
taskPrioritySet(pHandlerTid,(FIFO_STUFFER_PRIORITY+1));
setlksample();
set2khz();
taskPrioritySet(pHandlerTid,pHandlerPriority);
return;
}
static void rootTask(long a0, long a1, long a2, long a3, long a4,
long a5, long a6, long a7, long a8, long a9)
{
TASK_ID tid;
int ret, n;
traceobj_enter(&trobj);
qid = msgQCreate(NMESSAGES, sizeof(int), MSG_Q_PRIORITY);
traceobj_assert(&trobj, qid != 0);
traceobj_mark(&trobj, 3);
ret = taskPrioritySet(taskIdSelf(), 10);
traceobj_assert(&trobj, ret == OK);
traceobj_mark(&trobj, 4);
tid = taskSpawn("peerTask",
11,
0, 0, peerTask, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
traceobj_assert(&trobj, tid != ERROR);
traceobj_mark(&trobj, 5);
n = 0;
do
ret = msgQSend(qid, (char *)&messages[n], sizeof(int), NO_WAIT, MSG_PRI_URGENT);
while(n++ < NMESSAGES && ret != ERROR);
traceobj_assert(&trobj, ret == ERROR && errno == S_objLib_OBJ_UNAVAILABLE && n == NMESSAGES + 1);
traceobj_mark(&trobj, 6);
ret = taskDelay(10);
traceobj_assert(&trobj, ret == OK);
traceobj_mark(&trobj, 7);
ret = msgQNumMsgs(qid);
traceobj_assert(&trobj, ret == 0);
traceobj_verify(&trobj, tseq, sizeof(tseq) / sizeof(int));
traceobj_exit(&trobj);
}
void BSP_PromptSet()
{
SHELL_ID shellId;
int taskId;
/* Get the shell context */
taskId = taskNameToId ("tShell0");
shellId = shellFirst ();
while (shellId != (SHELL_ID)0)
{
if (((SHELL_CTX *)shellId)->taskId == taskId)
break;
shellId = shellNext (shellId);
}
shellInterpPromptSet(shellId,"C","[C]->");
taskPrioritySet(taskId, 9);/*优先级与V9一致*/
}
static int __wind_task_priorityset(struct pt_regs *regs)
{
xnhandle_t handle = __xn_reg_arg1(regs);
int prio = __xn_reg_arg2(regs);
WIND_TCB *pTcb;
if (handle)
pTcb = __wind_lookup_task(handle);
else
pTcb = __wind_task_current(current);
if (!pTcb)
return S_objLib_OBJ_ID_ERROR;
if (taskPrioritySet((TASK_ID) pTcb, prio) == ERROR)
return wind_errnoget();
return 0;
}
static void * event_thread_func(void * arg) {
taskPrioritySet(0, VX_TASK_PRIORITY_MIN);
for (;;) {
struct event_info * info = loc_alloc(sizeof(struct event_info));
semTake(events_signal, WAIT_FOREVER);
SPIN_LOCK_ISR_TAKE(&events_lock);
if (events_buf_overflow && events_inp == events_out) {
SPIN_LOCK_ISR_GIVE(&events_lock);
loc_free(info);
break;
}
assert(events_inp != events_out);
*info = events[events_out];
events_out = (events_out + 1) % MAX_EVENTS;
SPIN_LOCK_ISR_GIVE(&events_lock);
post_event(event_handler, info);
}
post_event(event_error, NULL);
return NULL;
}
/**
* This routine changes a task's priority to a specified priority.
* Priorities range from 0, the highest priority, to 255, the lowest priority.
* Default task priority is 100.
* @param priority The priority the task should run at.
* @returns true on success.
*/
bool Task::SetPriority(INT32 priority)
{
m_priority = priority;
return HandleError(taskPrioritySet(m_taskID, m_priority));
}
void
CVMthreadSetPriority(CVMThreadID *t, CVMInt32 priority)
{
taskPrioritySet(t->taskID, JAVAPRIO2VXPRIO(priority));
}
/*
* main - parse arguments and handle options
*/
int
ntpdcmain(
int argc,
char *argv[]
)
{
extern int ntp_optind;
delay_time.l_ui = 0;
delay_time.l_uf = DEFDELAY;
#ifdef SYS_VXWORKS
clear_globals();
taskPrioritySet(taskIdSelf(), 100 );
#endif
init_lib(); /* sets up ipv4_works, ipv6_works */
ssl_applink();
/* Check to see if we have IPv6. Otherwise default to IPv4 */
if (!ipv6_works)
ai_fam_default = AF_INET;
progname = argv[0];
{
int optct = ntpOptionProcess(&ntpdcOptions, argc, argv);
argc -= optct;
argv += optct;
}
if (HAVE_OPT(IPV4))
ai_fam_templ = AF_INET;
else if (HAVE_OPT(IPV6))
ai_fam_templ = AF_INET6;
else
ai_fam_templ = ai_fam_default;
if (HAVE_OPT(COMMAND)) {
int cmdct = STACKCT_OPT( COMMAND );
const char** cmds = STACKLST_OPT( COMMAND );
while (cmdct-- > 0) {
ADDCMD(*cmds++);
}
}
debug = DESC(DEBUG_LEVEL).optOccCt;
if (HAVE_OPT(INTERACTIVE)) {
interactive = 1;
}
if (HAVE_OPT(NUMERIC)) {
showhostnames = 0;
}
if (HAVE_OPT(LISTPEERS)) {
ADDCMD("listpeers");
}
if (HAVE_OPT(PEERS)) {
ADDCMD("peers");
}
if (HAVE_OPT(SHOWPEERS)) {
ADDCMD("dmpeers");
}
if (ntp_optind == argc) {
ADDHOST(DEFHOST);
} else {
for (; ntp_optind < argc; ntp_optind++)
ADDHOST(argv[ntp_optind]);
}
if (numcmds == 0 && interactive == 0
&& isatty(fileno(stdin)) && isatty(fileno(stderr))) {
interactive = 1;
}
#if 0
ai_fam_templ = ai_fam_default;
while ((c = ntp_getopt(argc, argv, "46c:dilnps")) != EOF)
switch (c) {
case '4':
ai_fam_templ = AF_INET;
break;
case '6':
ai_fam_templ = AF_INET6;
break;
case 'c':
ADDCMD(ntp_optarg);
break;
case 'd':
++debug;
break;
case 'i':
interactive = 1;
break;
case 'l':
ADDCMD("listpeers");
break;
case 'n':
showhostnames = 0;
break;
case 'p':
ADDCMD("peers");
break;
case 's':
ADDCMD("dmpeers");
break;
default:
errflg++;
break;
}
if (errflg) {
(void) fprintf(stderr,
"usage: %s [-46dilnps] [-c cmd] host ...\n",
progname);
exit(2);
}
if (ntp_optind == argc) {
ADDHOST(DEFHOST);
} else {
for (; ntp_optind < argc; ntp_optind++)
ADDHOST(argv[ntp_optind]);
}
if (numcmds == 0 && interactive == 0
&& isatty(fileno(stdin)) && isatty(fileno(stderr))) {
interactive = 1;
}
#endif
#ifndef SYS_WINNT /* Under NT cannot handle SIGINT, WIN32 spawns a handler */
if (interactive)
(void) signal_no_reset(SIGINT, abortcmd);
#endif /* SYS_WINNT */
/*
* Initialize the packet data buffer
*/
pktdatasize = INITDATASIZE;
pktdata = emalloc(INITDATASIZE);
if (numcmds == 0) {
(void) openhost(chosts[0]);
getcmds();
} else {
int ihost;
int icmd;
for (ihost = 0; ihost < numhosts; ihost++) {
if (openhost(chosts[ihost]))
for (icmd = 0; icmd < numcmds; icmd++) {
if (numhosts > 1)
printf ("--- %s ---\n",chosts[ihost]);
docmd(ccmds[icmd]);
}
}
}
#ifdef SYS_WINNT
WSACleanup();
#endif
return(0);
} /* main end */
/*********************************************************************
*
* recovery, based on the cmd code decides what recovery action
* to perform.
*
* Author Greg Brissey 12-7-94
*/
void recovery(CNTLR_COMM_MSG *msge, int externflag)
{
char *token;
int len;
int cmd;
int i,nMsg2Read;
int bytes;
extern int systemConRestart();
CNTLR_COMM_MSG discardedmsge;
DPRINT(-1,"Local Exception\n");
switch( msge->cmd /* exceptionType */ )
{
case PANIC:
#ifdef INSTRUMENT
wvEvent(EVENT_PHDLR_PANIC,NULL,NULL);
#endif
errLogRet(LOGIT,debugInfo,
"phandler: Panic Error: %d", msge->errorcode);
break;
case WARNING_MSG:
#ifdef INSTRUMENT
wvEvent(EVENT_PHDLR_WARNMSG,NULL,NULL);
#endif
DPRINT2(-10,"WARNING: doneCode: %d, errorCode: %d\n",
msge->cmd,msge->errorcode);
/* errLogRet(LOGIT,debugInfo,
"phandler: Warning Message: %d", msge->reportEvent); */
/* the send2Expproc is commented out. The msg is send
/* via other ways. We got two warning msgs for the
/* following numbers:
/* PNEU_ERROR + PRESSURE;
/* PNEU_ERROR + NB_STACK;
/* PNEU_ERROR + VTTHRESH;
/* PNEU_ERROR + PS;
/* VTERROR + NOGAS
/* Don't send ADC overflows to Expproc */
/* if ( (msge->errorcode != WARNINGS+ADCOVER) &&
/* (msge->errorcode != SFTERROR+LOCKLOST) )
/* send2Expproc(CASE,msge->cmd,msge->errorcode,0,NULL,0);
*/
break;
case SOFT_ERROR:
#ifdef INSTRUMENT
wvEvent(EVENT_PHDLR_SOFTERROR,NULL,NULL);
#endif
/* update_acqstate( ACQ_IDLE ); INOVA */
DPRINT2(0,"SOFT_ERROR: doneCode: %d, errorCode: %d\n",
msge->cmd,msge->errorcode);
/* errLogRet(LOGIT,debugInfo,
"phandler: Soft Error: %d", msge->reportEvent); */
#ifdef INOVA
statMsg.Status = msge->exceptionType;
statMsg.Event = msge->reportEvent; /* Error Code */
msgQSend(pMsgesToHost,(char*) &statMsg,sizeof(statMsg),
WAIT_FOREVER, MSG_PRI_NORMAL);
#endif
break;
case EXP_ABORTED:
#ifdef INSTRUMENT
wvEvent(EVENT_PHDLR_EXPABORTED,NULL,NULL);
#endif
DPRINT(0,"Exp. Aborted");
case HARD_ERROR:
#ifdef INSTRUMENT
wvEvent(EVENT_PHDLR_HARDERROR,NULL,NULL);
#endif
DPRINT2(0,"HARD_ERROR: doneCode: %d, errorCode: %d\n", msge->cmd, msge->errorcode);
AbortExp(msge,externflag);
/* fifoCloseLog(pTheFifoObject); */
DPRINT(0,"Done");
break;
case INTERACTIVE_ABORT:
#ifdef INSTRUMENT
wvEvent(EVENT_PHDLR_HARDERROR,NULL,NULL);
#endif
/*
DPRINT1(0,"INTERACTIVE_ABORT: doneCode: %d, errorCode: %d\n", msge->reportEvent);
*/
AbortExp(msge,externflag);
/* fifoCloseLog(pTheFifoObject); */
DPRINT(0,"Done");
break;
case EXP_HALTED:
#ifdef INSTRUMENT
wvEvent(EVENT_PHDLR_EXPHALTED,NULL,NULL);
#endif
DPRINT2(0,"EXP_HALTED: doneCode: %d, errorCode: %d\n", msge->cmd, msge->errorcode);
AbortExp(msge,externflag);
break;
case STOP_CMPLT:
/* the monitor set the SA_Criteria value,
when the upLinker obtained a FID that meet this
Criteria the upLinker sent this msge here and
then blocked itself
Our job is to
1. Foward the Stopped msge to Host
2. reset hardware
3. put hardware into a safe state
4. call stmSA, clears upLinker msgQ, send SA msge
5. reset SA_Criteria back to Zero
6. give the semaphore to restart upLinker
7. reset update task
8. reset parser task
9. Free the buffers
10. Re-enable Interrupts
*/
#ifdef INSTRUMENT
wvEvent(EVENT_PHDLR_STOPCMPLT,NULL,NULL);
#endif
#ifdef INOVA
statMsg.Status = msge->exceptionType;
statMsg.Event = msge->reportEvent; /* Error Code */
msgQSend(pMsgesToHost,(char*) &statMsg,sizeof(statMsg),
WAIT_FOREVER, MSG_PRI_NORMAL);
errLogRet(LOGIT,debugInfo,
"phandler: Exp. Stopped: %d", msge->reportEvent);
/* reprogram HSlines, ap registers to safe state */
reset2SafeState( msge->exceptionType );
resetSystem(); /* reset fifo, disable intrps, reset tasks & buffers */
DPRINT2(0,"stmHaltCode: doneCode: %d, errorCode: %d\n",
msge->exceptionType,msge->reportEvent);
semGive(pSemSAStop); /* release the UpLinker */
/* stmHaltCode(pTheStmObject,(int) msge->exceptionType,
(int) msge->reportEvent);
*/
/* DPRINT(0,"stmSA"); stmSA(pTheStmObject); */
DPRINT(0,"STOP_CMPLT: lower priority below upLinker\n");
taskPrioritySet(pHandlerTid,(UPLINKER_TASK_PRIORITY+1));
taskPrioritySet(pHandlerTid,pHandlerPriority);
SA_Criteria = 0;
SA_Mod = 0L;
DPRINT(0,"wait4DowninkerReady");
wait4DownLinkerReady(); /* let downlinker become ready, then delete any left over buffers */
resetNameBufs(); /* free all named buffers */
/* stmInitial(pTheStmObject, 1, 1024, pUpLinkMsgQ, 0); */
clrDwnLkAbort();
wait4SystemReady(); /* pend till all activities are complete */
DPRINT(0,"enableInterrupts");
enableInterrupts();
/* now inform Expproc System is Ready */
statMsg.Status = SYSTEM_READY; /* Console Ready */
statMsg.Event = 0; /* Error Code */
msgQSend(pMsgesToHost,(char*) &statMsg,sizeof(statMsg),
WAIT_FOREVER, MSG_PRI_NORMAL);
update_acqstate( ACQ_IDLE );
getstatblock();
/*
if (pTheTuneObject != NULL)
semGive( pTheTuneObject->pSemAccessFIFO );
*/
#endif
sendSysReady();
break;
case LOST_CONN:
#ifdef INSTRUMENT
wvEvent(EVENT_PHDLR_LOSTCONN,NULL,NULL);
#endif
#ifdef INOVA
errLogRet(LOGIT,debugInfo,
"phandler: Host Closed Connection to Console: %d", msge->reportEvent);
update_acqstate( ACQ_IDLE );
/* stmItrpDisable(pTheStmObject, STM_ALLITRPS); */
storeConsoleDebug( SYSTEM_ABORT );
/* reprogram HSlines, ap registers to safe state */
reset2SafeState( msge->exceptionType );
resetSystem(); /* reset fifo, disable intrps, reset tasks & buffers */
/* stmReset(pTheStmObject); */
taskDelay(calcSysClkTicks(332)); /* taskDelay(20); */
resetNameBufs(); /* free all named buffers */
enableInterrupts();
/*
if (pTheTuneObject != NULL)
semGive( pTheTuneObject->pSemAccessFIFO );
*/
taskSpawn("tRestart",50,0,2048,systemConRestart,NULL,
2,3,4,5,6,7,8,9,10);
clrDwnLkAbort();
#endif
break;
case ALLOC_ERROR:
#ifdef INSTRUMENT
wvEvent(EVENT_PHDLR_ALLOCERROR,NULL,NULL);
#endif
#ifdef INOVA
errLogRet(LOGIT,debugInfo,
"phandler: Memory Allocation Error: %d", msge->reportEvent);
update_acqstate( ACQ_IDLE );
statMsg.Status = HARD_ERROR; /* HARD_ERROR */
statMsg.Event = msge->reportEvent; /* Error Code */
msgQSend(pMsgesToHost,(char*) &statMsg,sizeof(statMsg),
WAIT_FOREVER, MSG_PRI_URGENT);
/* report HARD_ERROR to Recvproc */
DPRINT2(0,"stmHaltCode: doneCode: %d, errorCode: %d\n",
HARD_ERROR,msge->reportEvent);
/*
stmHaltCode(pTheStmObject,(int) HARD_ERROR,
(int) msge->reportEvent);
*/
/* reprogram HSlines, ap registers to safe state */
reset2SafeState( msge->exceptionType );
resetSystem(); /* reset fifo, disable intrps, reset tasks & buffers */
#ifdef XXXX
statMsg.Status = WARNING_MSG;
statMsg.Event = WARNINGS + MEM_ALLOC_ERR; /* Error Code */
msgQSend(pMsgesToHost,(char*) &statMsg,sizeof(statMsg),
WAIT_FOREVER, MSG_PRI_NORMAL);
#endif
resetNameBufs(); /* free all named buffers */
/* stmInitial(pTheStmObject, 1, 1024, pUpLinkMsgQ, 0); */
clrDwnLkAbort();
DPRINT(0,"enableInterrupts");
enableInterrupts();
/* now inform Expproc System is Ready */
statMsg.Status = SYSTEM_READY; /* Console Ready */
statMsg.Event = 0; /* Error Code */
msgQSend(pMsgesToHost,(char*) &statMsg,sizeof(statMsg),
WAIT_FOREVER, MSG_PRI_NORMAL);
getstatblock();
/*
if (pTheTuneObject != NULL)
semGive( pTheTuneObject->pSemAccessFIFO );
*/
#endif
break;
case WATCHDOG:
#ifdef INOVA
#ifdef INSTRUMENT
wvEvent(EVENT_PHDLR_WATCHDOG,NULL,NULL);
#endif
/* Giv'm a bone */
errLogRet(LOGIT,debugInfo,
"phandler: Watch Dog: %d", msge->reportEvent);
#endif
break;
default:
/* Who Cares */
errLogRet(LOGIT,debugInfo,
"phandler: Invalid Exception Type: %d, Event: %d",
msge->cmd, msge->errorcode);
break;
}
/*
nMsg2Read = msgQNumMsgs(pMsgesToPHandlr);
DPRINT1(-1,"Message in Q: %d\n",nMsg2Read);
*/
if (msge->cmd != WARNING_MSG)
resumeLedShow(); /* resume LED Idle display */
while ( (bytes = msgQReceive(pMsgesToPHandlr, (char*) &discardedmsge, sizeof( CNTLR_COMM_MSG ), NO_WAIT)) != ERROR )
{
DPRINT(-1,"vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv\n");
DPRINT1(0,"Read %d bytes from Phandler msgQ, (Bogus Errors at this point)\n",bytes);
DPRINT4(-1,"'%s': Exception from: -> '%s' <-, Type: %d, ErrorCode: %d \n",
hostName, discardedmsge.cntlrId, discardedmsge.cmd, discardedmsge.errorcode);
DPRINT(-1,"^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n");
}
}
//---------------------------------------------------------------------------
//
// Function: openPowerlinkInit
//
// Description:
// Initialize and start the openPOWERLINK demo application
//
// Parameters:
// pszEthName = pointer to string with name of network interface to use
//
// Returns: int
//
//---------------------------------------------------------------------------
int openPowerlinkInit (char *pszEthName, unsigned int uiDevNumber)
{
tEplKernel EplRet;
static tEplApiInitParam EplApiInitParam = {0};
char* sHostname = HOSTNAME;
BOOL fApiInit = FALSE;
int tid;
// Adjust task priorities of system tasks
/* shell task is normally set to priority 1 which could disturb
* openPOWERLINK if long-running commands are entered. Therefore
* we lower the performance to 20
*/
tid = taskIdSelf();
printf ("Task ID: %d\n", tid);
taskPrioritySet(tid, 20);
/* The priority of the network stack task has to be increased (default:50)
* in order to get network packets in time!
*/
if ((tid = taskNameToId("tNet0")) != -1 )
{
taskPrioritySet(tid, 5);
}
// Initialize high-resolution timer library
hrtimer_init(EPL_TASK_PRIORITY_HRTIMER, EPL_TASK_STACK_SIZE);
// get node ID from insmod command line
EplApiInitParam.m_uiNodeId = uiNodeId_g;
if (EplApiInitParam.m_uiNodeId == EPL_C_ADR_INVALID)
{ // invalid node ID set
// set default node ID
EplApiInitParam.m_uiNodeId = NODEID;
}
uiNodeId_g = EplApiInitParam.m_uiNodeId;
// calculate IP address
EplApiInitParam.m_dwIpAddress = (0xFFFFFF00 & IP_ADDR) |
EplApiInitParam.m_uiNodeId;
EplApiInitParam.m_fAsyncOnly = FALSE;
// store the specified device name
EplApiInitParam.m_HwParam.m_pszDevName = pszEthName;
EplApiInitParam.m_HwParam.m_uiDevNumber = uiDevNumber;
EplApiInitParam.m_uiSizeOfStruct = sizeof (EplApiInitParam);
EPL_MEMCPY(EplApiInitParam.m_abMacAddress, abMacAddr,
sizeof (EplApiInitParam.m_abMacAddress));
EplApiInitParam.m_dwFeatureFlags = (DWORD) ~0UL;
EplApiInitParam.m_dwCycleLen = uiCycleLen_g; // required for error detection
EplApiInitParam.m_uiIsochrTxMaxPayload = 100; // const
EplApiInitParam.m_uiIsochrRxMaxPayload = 100; // const
EplApiInitParam.m_dwPresMaxLatency = 50000; // const; only required for IdentRes
EplApiInitParam.m_uiPreqActPayloadLimit = 36; // required for initialisation (+28 bytes)
EplApiInitParam.m_uiPresActPayloadLimit = 36; // required for initialisation of Pres frame (+28 bytes)
EplApiInitParam.m_dwAsndMaxLatency = 150000; // const; only required for IdentRes
EplApiInitParam.m_uiMultiplCycleCnt = 0; // required for error detection
EplApiInitParam.m_uiAsyncMtu = 1500; // required to set up max frame size
EplApiInitParam.m_uiPrescaler = 2; // required for sync
EplApiInitParam.m_dwLossOfFrameTolerance = 500000;
EplApiInitParam.m_dwAsyncSlotTimeout = 3000000;
EplApiInitParam.m_dwWaitSocPreq = 0;
EplApiInitParam.m_dwDeviceType = (DWORD) ~0UL; // NMT_DeviceType_U32
EplApiInitParam.m_dwVendorId = (DWORD) ~0UL; // NMT_IdentityObject_REC.VendorId_U32
EplApiInitParam.m_dwProductCode = (DWORD) ~0UL; // NMT_IdentityObject_REC.ProductCode_U32
EplApiInitParam.m_dwRevisionNumber = (DWORD) ~0UL; // NMT_IdentityObject_REC.RevisionNo_U32
EplApiInitParam.m_dwSerialNumber = (DWORD) ~0UL; // NMT_IdentityObject_REC.SerialNo_U32
EplApiInitParam.m_dwSubnetMask = SUBNET_MASK;
EplApiInitParam.m_dwDefaultGateway = 0;
EPL_MEMCPY(EplApiInitParam.m_sHostname, sHostname, sizeof(EplApiInitParam.m_sHostname));
EplApiInitParam.m_uiSyncNodeId = EPL_C_ADR_SYNC_ON_SOA; // for fSyncOnPrcNode==TRUE, this means last PRC node
EplApiInitParam.m_fSyncOnPrcNode = TRUE;
// set callback functions
EplApiInitParam.m_pfnCbEvent = AppCbEvent;
EplApiInitParam.m_pfnCbSync = AppCbSync;
EplApiInitParam.m_pfnObdInitRam = EplObdInitRam;
printf("\n\n Hello, I'm a VxWorks POWERLINK node running as %s!\n"
"(build: %s / %s)\n\n",
(uiNodeId_g == EPL_C_ADR_MN_DEF_NODE_ID ?
"Managing Node" : "Controlled Node"),
__DATE__, __TIME__);
// initialize POWERLINK stack
EplRet = EplApiInitialize(&EplApiInitParam);
if(EplRet != kEplSuccessful)
{
goto Exit;
}
fApiInit = TRUE;
// set CDC filename
EplRet = EplApiSetCdcFilename(pszCdcFilename_g);
if(EplRet != kEplSuccessful)
{
printf ("Error set cdc filename!\n");
goto Exit;
}
// initialize application
printf ("Initializing openPOWERLINK application...\n");
EplRet = AppInit();
if(EplRet != kEplSuccessful)
{
printf("ApiInit() failed!\n");
goto Exit;
}
// initialize process image
printf("Initializing process image...\n");
printf("Size of input process image: %ld\n", sizeof(AppProcessImageIn_g));
printf("Size of output process image: %ld\n", sizeof (AppProcessImageOut_g));
AppProcessImageCopyJob_g.m_fNonBlocking = FALSE;
AppProcessImageCopyJob_g.m_uiPriority = 0;
AppProcessImageCopyJob_g.m_In.m_pPart = &AppProcessImageIn_g;
AppProcessImageCopyJob_g.m_In.m_uiOffset = 0;
AppProcessImageCopyJob_g.m_In.m_uiSize = sizeof (AppProcessImageIn_g);
AppProcessImageCopyJob_g.m_Out.m_pPart = &AppProcessImageOut_g;
AppProcessImageCopyJob_g.m_Out.m_uiOffset = 0;
AppProcessImageCopyJob_g.m_Out.m_uiSize = sizeof (AppProcessImageOut_g);
EplRet = EplApiProcessImageAlloc(sizeof (AppProcessImageIn_g),
sizeof (AppProcessImageOut_g), 2, 2);
if (EplRet != kEplSuccessful)
{
goto Exit;
}
EplRet = EplApiProcessImageSetup();
if (EplRet != kEplSuccessful)
{
goto Exit;
}
// start the NMT state machine
EplRet = EplApiExecNmtCommand(kEplNmtEventSwReset);
Exit:
PRINTF("%s(): returns 0x%X\n", __func__, EplRet);
if (EplRet != kEplSuccessful)
{
if (fApiInit != FALSE)
{
EplApiShutdown();
}
// Shutdown high-resolution timer library
hrtimer_shutdown();
fOpenPowerlinkIsRunning_g = FALSE;
return -ENODEV;
}
else
{
fOpenPowerlinkIsRunning_g = TRUE;
return 0;
}
}
static void rootTask(long a0, long a1, long a2, long a3, long a4,
long a5, long a6, long a7, long a8, long a9)
{
int ret;
traceobj_enter(&trobj);
traceobj_mark(&trobj, 6);
ret = taskPrioritySet(taskIdSelf(), 11);
traceobj_assert(&trobj, ret == OK);
traceobj_mark(&trobj, 7);
sem_id = semMCreate(0xffffffff);
traceobj_assert(&trobj, sem_id == 0 && errno == S_semLib_INVALID_OPTION);
traceobj_mark(&trobj, 8);
sem_id = semMCreate(SEM_Q_PRIORITY|SEM_DELETE_SAFE|SEM_INVERSION_SAFE);
traceobj_assert(&trobj, sem_id != 0);
traceobj_mark(&trobj, 9);
ret = semTake(sem_id, WAIT_FOREVER);
traceobj_assert(&trobj, ret == OK);
traceobj_mark(&trobj, 10);
ret = semTake(sem_id, WAIT_FOREVER);
traceobj_assert(&trobj, ret == OK);
traceobj_mark(&trobj, 11);
ret = semGive(sem_id);
traceobj_assert(&trobj, ret == OK);
traceobj_mark(&trobj, 12);
ret = semGive(sem_id);
traceobj_assert(&trobj, ret == OK);
traceobj_mark(&trobj, 13);
ret = semGive(sem_id);
traceobj_assert(&trobj, ret == ERROR && errno == S_semLib_INVALID_OPERATION);
traceobj_mark(&trobj, 14);
ret = semTake(sem_id, WAIT_FOREVER);
traceobj_assert(&trobj, ret == OK);
traceobj_mark(&trobj, 15);
ret = taskSuspend(taskIdSelf());
traceobj_assert(&trobj, ret == OK);
traceobj_mark(&trobj, 16);
ret = semGive(sem_id);
traceobj_assert(&trobj, ret == OK);
traceobj_mark(&trobj, 17);
traceobj_exit(&trobj);
}
/*********************************************************************
*
* recovery, based on the cmd code decides what recovery action
* to perform.
*
* Author Greg Brissey 12-7-94
*/
void recovery(EXCEPTION_MSGE *msge)
{
char *token;
int len;
int cmd;
int i,nMsg2Read;
int bytes;
EXCEPTION_MSGE discardMsge;
extern int systemConRestart();
static void resetSystem();
static void resetNameBufs();
/* reset STM & ADC Intrp MsgQ to standard msgQ, encase they have been switched */
stmRestoreMsgQ(pTheStmObject);
switch( msge->exceptionType )
{
case PANIC:
#ifdef INSTRUMENT
wvEvent(EVENT_PHDLR_PANIC,NULL,NULL);
#endif
errLogRet(LOGIT,debugInfo,
"phandler: Panic Error: %d", msge->reportEvent);
break;
case WARNING_MSG:
#ifdef INSTRUMENT
wvEvent(EVENT_PHDLR_WARNMSG,NULL,NULL);
#endif
DPRINT2(0,"WARNING: doneCode: %d, errorCode: %d\n",
msge->exceptionType,msge->reportEvent);
/* errLogRet(LOGIT,debugInfo,
"phandler: Warning Message: %d", msge->reportEvent); */
statMsg.Status = msge->exceptionType;
statMsg.Event = msge->reportEvent; /* Error Code */
msgQSend(pMsgesToHost,(char*) &statMsg,sizeof(statMsg),
WAIT_FOREVER, MSG_PRI_NORMAL);
break;
case SOFT_ERROR:
#ifdef INSTRUMENT
wvEvent(EVENT_PHDLR_SOFTERROR,NULL,NULL);
#endif
update_acqstate( ACQ_IDLE );
DPRINT2(0,"SOFT_ERROR: doneCode: %d, errorCode: %d\n",
msge->exceptionType,msge->reportEvent);
/* errLogRet(LOGIT,debugInfo,
"phandler: Soft Error: %d", msge->reportEvent); */
statMsg.Status = msge->exceptionType;
statMsg.Event = msge->reportEvent; /* Error Code */
msgQSend(pMsgesToHost,(char*) &statMsg,sizeof(statMsg),
WAIT_FOREVER, MSG_PRI_NORMAL);
break;
case EXP_ABORTED:
#ifdef INSTRUMENT
wvEvent(EVENT_PHDLR_EXPABORTED,NULL,NULL);
#endif
stmItrpDisable(pTheStmObject, STM_ALLITRPS);
DPRINT(0,"Exp. Aborted");
case HARD_ERROR:
#ifdef INSTRUMENT
wvEvent(EVENT_PHDLR_HARDERROR,NULL,NULL);
#endif
DPRINT1(0,"HARD_ERROR: doneCode: %d, errorCode: %d\n", msge->reportEvent);
AbortExp(msge);
fifoCloseLog(pTheFifoObject);
DPRINT(0,"Done");
break;
case INTERACTIVE_ABORT:
#ifdef INSTRUMENT
wvEvent(EVENT_PHDLR_HARDERROR,NULL,NULL);
#endif
DPRINT1(0,"INTERACTIVE_ABORT: doneCode: %d, errorCode: %d\n", msge->reportEvent);
AbortExp(msge);
fifoCloseLog(pTheFifoObject);
DPRINT(0,"Done");
break;
case EXP_HALTED:
#ifdef INSTRUMENT
wvEvent(EVENT_PHDLR_EXPHALTED,NULL,NULL);
#endif
stmItrpDisable(pTheStmObject, STM_ALLITRPS);
statMsg.Status = msge->exceptionType;
statMsg.Event = msge->reportEvent; /* Error Code */
msgQSend(pMsgesToHost,(char*) &statMsg,sizeof(statMsg),
WAIT_FOREVER, MSG_PRI_NORMAL);
errLogRet(LOGIT,debugInfo,
"phandler: Exp. Halted: %d", msge->reportEvent);
/*
Based on the premise the user now has achieve the S/N
or whatever from data that has already been obtained
therefore there is no need to wait for any data to
be acquired. I.E. Halt Experiment with extreme prejudice!
*/
/* reprogram HSlines, ap registers to safe state */
reset2SafeState( msge->exceptionType );
resetSystem(); /* reset fifo, disable intrps, reset tasks & buffers */
update_acqstate( ACQ_IDLE );
DPRINT2(0,"stmHaltCode: doneCode: %d, errorCode: %d\n",
msge->exceptionType,msge->reportEvent);
stmHaltCode(pTheStmObject,(int) msge->exceptionType,
(int) msge->reportEvent);
DPRINT(0,"EXP_HALTED: lower priority below upLinker\n");
taskPrioritySet(pHandlerTid,(UPLINKER_TASK_PRIORITY+1));
taskPrioritySet(pHandlerTid,pHandlerPriority);
DPRINT(0,"wait4DowninkerReady");
wait4DownLinkerReady(); /* let downlinker become ready, then delete any left over buffers */
resetNameBufs(); /* free all named buffers */
stmInitial(pTheStmObject, 1, 1024, pUpLinkMsgQ, 0);
clrDwnLkAbort();
wait4SystemReady(); /* pend till all activities are complete */
DPRINT(0,"enableInterrupts");
enableInterrupts();
/* now inform Expproc System is Ready */
statMsg.Status = SYSTEM_READY; /* Console Ready */
statMsg.Event = 0; /* Error Code */
msgQSend(pMsgesToHost,(char*) &statMsg,sizeof(statMsg),
WAIT_FOREVER, MSG_PRI_NORMAL);
update_acqstate( ACQ_IDLE );
getstatblock();
if (pTheTuneObject != NULL)
semGive( pTheTuneObject->pSemAccessFIFO );
break;
case STOP_CMPLT:
/* the monitor set the SA_Criteria value,
when the upLinker obtained a FID that meet this
Criteria the upLinker sent this msge here and
then blocked itself
Our job is to
1. Foward the Stopped msge to Host
2. reset hardware
3. put hardware into a safe state
4. call stmSA, clears upLinker msgQ, send SA msge
5. reset SA_Criteria back to Zero
6. give the semaphore to restart upLinker
7. reset update task
8. reset parser task
9. Free the buffers
10. Re-enable Interrupts
*/
#ifdef INSTRUMENT
wvEvent(EVENT_PHDLR_STOPCMPLT,NULL,NULL);
#endif
statMsg.Status = msge->exceptionType;
statMsg.Event = msge->reportEvent; /* Error Code */
msgQSend(pMsgesToHost,(char*) &statMsg,sizeof(statMsg),
WAIT_FOREVER, MSG_PRI_NORMAL);
errLogRet(LOGIT,debugInfo,
"phandler: Exp. Stopped: %d", msge->reportEvent);
/* reprogram HSlines, ap registers to safe state */
reset2SafeState( msge->exceptionType );
resetSystem(); /* reset fifo, disable intrps, reset tasks & buffers */
DPRINT2(0,"stmHaltCode: doneCode: %d, errorCode: %d\n",
msge->exceptionType,msge->reportEvent);
clearIntrpMsgQ(pTheStmObject);
semGive(pSemSAStop); /* release the UpLinker */
stmHaltCode(pTheStmObject,(int) msge->exceptionType,
(int) msge->reportEvent);
/* DPRINT(0,"stmSA"); stmSA(pTheStmObject); */
DPRINT(0,"STOP_CMPLT: lower priority below upLinker\n");
taskPrioritySet(pHandlerTid,(UPLINKER_TASK_PRIORITY+1));
taskPrioritySet(pHandlerTid,pHandlerPriority);
SA_Criteria = 0;
SA_Mod = 0L;
DPRINT(0,"wait4DowninkerReady");
wait4DownLinkerReady(); /* let downlinker become ready, then delete any left over buffers */
resetNameBufs(); /* free all named buffers */
stmInitial(pTheStmObject, 1, 1024, pUpLinkMsgQ, 0);
clrDwnLkAbort();
wait4SystemReady(); /* pend till all activities are complete */
DPRINT(0,"enableInterrupts");
enableInterrupts();
/* now inform Expproc System is Ready */
statMsg.Status = SYSTEM_READY; /* Console Ready */
statMsg.Event = 0; /* Error Code */
msgQSend(pMsgesToHost,(char*) &statMsg,sizeof(statMsg),
WAIT_FOREVER, MSG_PRI_NORMAL);
update_acqstate( ACQ_IDLE );
getstatblock();
if (pTheTuneObject != NULL)
semGive( pTheTuneObject->pSemAccessFIFO );
break;
case LOST_CONN:
#ifdef INSTRUMENT
wvEvent(EVENT_PHDLR_LOSTCONN,NULL,NULL);
#endif
errLogRet(LOGIT,debugInfo,
"phandler: Host Closed Connection to Console: %d", msge->reportEvent);
update_acqstate( ACQ_IDLE );
stmItrpDisable(pTheStmObject, STM_ALLITRPS);
storeConsoleDebug( SYSTEM_ABORT );
/* reprogram HSlines, ap registers to safe state */
reset2SafeState( msge->exceptionType );
resetSystem(); /* reset fifo, disable intrps, reset tasks & buffers */
stmReset(pTheStmObject);
taskDelay(sysClkRateGet()/3);
resetNameBufs(); /* free all named buffers */
enableInterrupts();
if (pTheTuneObject != NULL)
semGive( pTheTuneObject->pSemAccessFIFO );
taskSpawn("tRestart",50,0,2048,systemConRestart,NULL,
2,3,4,5,6,7,8,9,10);
clrDwnLkAbort();
break;
case ALLOC_ERROR:
#ifdef INSTRUMENT
wvEvent(EVENT_PHDLR_ALLOCERROR,NULL,NULL);
#endif
errLogRet(LOGIT,debugInfo,
"phandler: Memory Allocation Error: %d", msge->reportEvent);
update_acqstate( ACQ_IDLE );
statMsg.Status = HARD_ERROR; /* HARD_ERROR */
statMsg.Event = msge->reportEvent; /* Error Code */
msgQSend(pMsgesToHost,(char*) &statMsg,sizeof(statMsg),
WAIT_FOREVER, MSG_PRI_URGENT);
/* report HARD_ERROR to Recvproc */
DPRINT2(0,"stmHaltCode: doneCode: %d, errorCode: %d\n",
HARD_ERROR,msge->reportEvent);
stmHaltCode(pTheStmObject,(int) HARD_ERROR,
(int) msge->reportEvent);
/* reprogram HSlines, ap registers to safe state */
reset2SafeState( msge->exceptionType );
resetSystem(); /* reset fifo, disable intrps, reset tasks & buffers */
#ifdef XXXX
statMsg.Status = WARNING_MSG;
statMsg.Event = WARNINGS + MEM_ALLOC_ERR; /* Error Code */
msgQSend(pMsgesToHost,(char*) &statMsg,sizeof(statMsg),
WAIT_FOREVER, MSG_PRI_NORMAL);
#endif
resetNameBufs(); /* free all named buffers */
stmInitial(pTheStmObject, 1, 1024, pUpLinkMsgQ, 0);
clrDwnLkAbort();
DPRINT(0,"enableInterrupts");
enableInterrupts();
/* now inform Expproc System is Ready */
statMsg.Status = SYSTEM_READY; /* Console Ready */
statMsg.Event = 0; /* Error Code */
msgQSend(pMsgesToHost,(char*) &statMsg,sizeof(statMsg),
WAIT_FOREVER, MSG_PRI_NORMAL);
getstatblock();
if (pTheTuneObject != NULL)
semGive( pTheTuneObject->pSemAccessFIFO );
break;
case WATCHDOG:
#ifdef INSTRUMENT
wvEvent(EVENT_PHDLR_WATCHDOG,NULL,NULL);
#endif
/* Giv'm a bone */
errLogRet(LOGIT,debugInfo,
"phandler: Watch Dog: %d", msge->reportEvent);
break;
default:
/* Who Cares */
errLogRet(LOGIT,debugInfo,
"phandler: Invalid Exception Type: %d, Event: %d",
msge->exceptionType, msge->reportEvent);
break;
}
/*
nMsg2Read = msgQNumMsgs(pMsgesToPHandlr);
DPRINT1(-1,"Message in Q: %d\n",nMsg2Read);
*/
while ( (bytes = msgQReceive(pMsgesToPHandlr, (char*) &msge, sizeof( EXCEPTION_MSGE ), NO_WAIT)) != ERROR )
{
DPRINT1(0,"Read %d bytes from Phandler msgQ, (Bogus Errors at this point)\n",bytes);
}
}
static void
reset2SafeState( int why ) /* argument is the type of exception */
{
int pTmpId, TmpPrior;
int tuneactive = 0;
DPRINT(1,"reset2SafeState");
DPRINT(1,"stopAPint");
pcsAbortSort(); /* parallel channel sort to stop and return to APint() */
abortAPint(); /* like stopAPint() but also cause the Parser to suspend itself */
/* stopAPint(); */
DPRINT(1,"stop downLinker");
setDwnLkAbort(); /* like stop downLinker and set to dump further download to bit bucket */
DPRINT(1,"reset2SafeState");
DPRINT(0,"fifoSetNoStuff\n");
fifoSetNoStuff(pTheFifoObject); /* stop the stuffer in it's tracks */
DPRINT(0,"Disable STM Intrps");
stmItrpDisable(pTheStmObject, STM_ALLITRPS);
/* reset fifo Object not to use parallel channels */
fifoClearPChanId(pTheFifoObject);
DPRINT(0,"fifoReset");
/* Keep the MTS gradient amp disabled whenever possible! */
gpaTuneSet(pTheAutoObject, SET_GPAENABLE, GPA_DISABLE_DELAY);
/* if an interactive abort do not reset the apbus, thus preventing the
all amplifier from going to Pulse Mode, thus amps that are in CW
will stay that way. This is/was a lockdisplay/shimming issue.
Where exiting lock display set all the amps to Pulse Mode or blanked!,
then one shimmed and obtain a certain lock level. After su command
then amps would go back to CW thus injecting noise and lowing the
lock level, If use wht directly to shimming they could neer re-attain
the lock level they had before. But when enter and exit lock display
the level would jump back up. Thus causing no end of
confusion....
Thus for INTERACTIVE_ABORT the reset apbus bit is left out when reseting the FIFO.
Oooops, but wait, we found an exception (of course), when exiting qtune the
reset of the apbus reset all the tune relays back to noraml, now of course
this does not happen thus leaving the console in tuning mode. Thus we added the
following test isTuneActive() and if it is then a full reset including the apbus
is done.
*/
tuneactive = isTuneActive();
/* DPRINT1(-3,"Is Tune active: %d\n",tuneactive); */
if ((why != INTERACTIVE_ABORT) || (tuneactive == 1))
fifoReset(pTheFifoObject, RESETFIFOBRD); /* this now also clear the Fifo Buffer & restart the Stuffer */
else
fifoReset(pTheFifoObject, RESETFIFO | RESETSTATEMACH | RESETTAGFIFO | RESETAPRDBKFIFO ); /* no apbus reset */
/* set initial value of parallel channel free buffer pointer to null */
clearParallelFreeBufs();
DPRINT(0,"Stuff FIFO DIRECTLY with Safe State & Run fifo");
fifoLoadHsl(pTheFifoObject, STD_HS_LINES, pTheFifoObject->SafeHSLines);
fifoLoadHsl(pTheFifoObject, EXT_HS_LINES, pTheFifoObject->SafeHSLinesExt);
/* Each SafeState Code is actually two long words */
if (numSafeStatCodes > 0)
{
/* WARNING: Does not pend for FF Almost Full, BEWARE !! */
/* Should only be used in phandler's reset2SafeState() */
fifoStuffCode(pTheFifoObject, pSafeStateCodes, numSafeStatCodes);
fifoStuffCode(pTheFifoObject, pTurnOffSshaCodes, numTurnOffSshaCodes);
fifoStuffCode(pTheFifoObject, pHaltOpCodes, numHaltOpCodes);
DPRINT(1,"Ready to start FIFO in reset to safe state\n" );
fifoStart(pTheFifoObject);
/* fifoWait4Stop(pTheFifoObject); /* use BusyWait don't what any other lower priority tasks to run ! */
fifoBusyWait4Stop(pTheFifoObject); /* use BusyWait don't what any other lower priority tasks to run ! */
DPRINT(1,"FIFO wait for stop completes in reset to safe state\n" );
}
activate_ssha();
DPRINT(0,"getnGiveShimMutex\n");
/* allow any pending serial Shim commands to finish */
getnGiveShimMutex();
DPRINT(0,"getnGiveVTMutex\n");
/* allow any pending serial VT commands to finish */
getnGiveVTMutex();
/* Now Bump Priority of DownLiner so that it can Dump
the remaining Data that SendProc wants to send it */
/* If we lost the connection to the host computer, the downlinker is
is not going to get any more data; nor should this task (problem
handler) wait for the downlinker to become ready. April 1997 */
DPRINT(0,"dlbFreeAllNotLoading Dyn");
dlbFreeAllNotLoading(pDlbDynBufs);
DPRINT(0,"dlbFreeAllNotLoading Fix");
dlbFreeAllNotLoading(pDlbFixBufs);
if (why != LOST_CONN)
{
pTmpId = taskNameToId("tDownLink");
taskPriorityGet(pTmpId,&TmpPrior);
taskPrioritySet(pTmpId,(pHandlerPriority-1));
/* downLinker has now A. ran and is suspended,
B. Done and in READY state or
C. still waiting in a read of a socket
*/
/* start wdog timeout of 20 seconds */
wdStart(pHandlerWdTimeout,sysClkRateGet() * 20, pHandlerWdISR, 0);
/* if it is busy and not suspend then wait till
/* it is Ready or Suspended, or Time-Out */
while (downLinkerIsActive() && !taskIsSuspended(pTmpId) && !pHandlerTimeout)
taskDelay(1); /* wait one tick , 16msec */
wdCancel(pHandlerWdTimeout);
if (taskIsSuspended(pTmpId))
{
taskResume(pTmpId);
wait4DownLinkerReady();
}
taskPrioritySet(pTmpId,TmpPrior);
DPRINT(0,"downlinker resynchronized\n");
}
DPRINT(0,"dlbFreeAll Dyn");
dlbFreeAll(pDlbDynBufs);
DPRINT(0,"dlbFreeAll Fix");
dlbFreeAll(pDlbFixBufs);
/*
Now Bump Priority of Parser so that it can Finish Up
We don't have to worry as much about the state of the parser
since it will completely restarted very soon.
*/
pTmpId = taskNameToId("tParser");
taskPriorityGet(pTmpId,&TmpPrior);
taskPrioritySet(pTmpId,(pHandlerPriority-1));
if (taskIsSuspended(pTmpId))
{
taskResume(pTmpId);
wait4ParserReady();
}
taskPrioritySet(pTmpId,TmpPrior);
resetAPint();
DPRINT(0,"A-code parser resynchronized\n");
/* Parser might of made a buffer ready to stuff, so better clear it just incase */
if (why != INTERACTIVE_ABORT)
fifoReset(pTheFifoObject, RESETFIFOBRD); /* this now also clear the Fifo Buffer & restart the Stuffer */
else
fifoReset(pTheFifoObject, RESETFIFO | RESETSTATEMACH | RESETTAGFIFO | RESETAPRDBKFIFO ); /* no apbus reset */
return;
}
