char * serialize_config(EC_CONFIG * cfg)
{
/* serialize PDO mapping */
int scount = 1024*1024;
char * sbuf = calloc(scount, sizeof(char));
strncat(sbuf, "<entries>\n", scount-strlen(sbuf)-1);
ELLNODE * node;
for(node = ellFirst(&cfg->devices); node; node = ellNext(node))
{
EC_DEVICE * device = (EC_DEVICE *)node;
ELLNODE * node1;
for(node1 = ellFirst(&device->pdo_entry_mappings); node1; node1 = ellNext(node1))
{
EC_PDO_ENTRY_MAPPING * mp = (EC_PDO_ENTRY_MAPPING *)node1;
assert( mp->pdo_entry );
char line[1024];
assert(device->position != -1);
snprintf(line, sizeof(line), "<entry device_position=\"%d\" "
"pdo_index=\"0x%x\" index=\"0x%x\" sub_index=\"0x%x\" "
"offset=\"%d\" bit=\"%d\" />\n",
device->position, mp->pdo_entry->parent->index,
mp->index, mp->sub_index, mp->offset,
mp->bit_position);
strncat(sbuf, line, scount-strlen(sbuf)-1);
}
}
strncat(sbuf, "</entries>\n", scount-strlen(sbuf)-1);
return sbuf;
}
/* auto Run function */
static void devNI6123_BO_AUTO_RUN(ST_execParam *pParam)
{
ST_MASTER *pMaster = get_master();
ST_STD_device *pSTDdev = (ST_STD_device*) ellFirst(pMaster->pList_DeviceTask);
ST_NI6123 *pNI6123 = NULL;
kLog (K_TRACE, "[devNI6123_BO_AUTO_RUN] auto_run(%f)\n", pParam->setValue);
if( pMaster->StatusAdmin & TASK_WAIT_FOR_TRIGGER ||
pMaster->StatusAdmin & TASK_IN_PROGRESS ) {
kLog (K_ERR, "System is running! (0x%x)\n", pMaster->StatusAdmin);
notify_error (1, "System is running! (0x%x)\n", pMaster->StatusAdmin);
return;
}
if(pParam->setValue) {
if( !(pMaster->StatusAdmin & TASK_SYSTEM_IDLE) ) {
kLog (K_ERR, "System is busy! (0x%x)\n", pMaster->StatusAdmin);
notify_error (1, "System is busy! (0x%x)\n", pMaster->StatusAdmin);
return;
}
#if 0
char strBuf[24];
float stopT1;
/* remove this function because ECH has not LTU, so We donot use the DBproc_get function */
if( pSTDdev->ST_Base.opMode == OPMODE_REMOTE ){
DBproc_get (PV_LTU_TIG_T0_STR, strBuf); //Get T0 from LTU
DBproc_put (PV_START_TIG_T0_STR, strBuf); //Set T0 from LTU
sscanf(strBuf, "%f", &stopT1);
stopT1 = pNI6123->sample_time - stopT1;
sprintf(strBuf,"%f",stopT1);
DBproc_put (PV_STOP_TIG_T1_STR, strBuf); //Set T0 from LTU
}
#endif
while(pSTDdev) {
pSTDdev->StatusDev |= TASK_STANDBY;
pNI6123 = pSTDdev->pUser;
pNI6123->auto_run_flag = 1;
pSTDdev = (ST_STD_device*) ellNext(&pSTDdev->node);
}
}
else if(!pParam->setValue) {
while(pSTDdev) {
pNI6123 = pSTDdev->pUser;
pNI6123->auto_run_flag = 0;
pSTDdev = (ST_STD_device*) ellNext(&pSTDdev->node);
}
pMaster->n8EscapeWhile = 0;
epicsThreadSleep(3.0);
pMaster->n8EscapeWhile = 1;
admin_all_taskStatus_reset();
scanIoRequest(pMaster->ioScanPvt_status);
}
notify_refresh_master_status();
}
/*
* read configuration sent by scanner and populate "config" in
* ENGINE_USER structure
*/
static int init_unpack(ENGINE_USER * usr, char * buffer, int size)
{
EC_CONFIG * cfg = usr->config;
int ofs = 0;
int tag = unpack_int(buffer, &ofs);
assert(tag == MSG_CONFIG);
int scanner_config_size = unpack_int(buffer, &ofs);
read_config(buffer + ofs, scanner_config_size, cfg);
ofs += scanner_config_size;
int mapping_config_size = unpack_int(buffer, &ofs);
parseEntriesFromBuffer(buffer + ofs, mapping_config_size, cfg);
ELLNODE * node;
for(node = ellFirst(&cfg->devices); node; node = ellNext(node))
{
EC_DEVICE * device = (EC_DEVICE *)node;
printf("%s\n", device->name);
ELLNODE * node1;
for(node1 = ellFirst(&device->pdo_entry_mappings); node1; node1 = ellNext(node1))
{
EC_PDO_ENTRY_MAPPING * mapping = (EC_PDO_ENTRY_MAPPING *)node1;
if(strcmp(mapping->pdo_entry->name, mapping->pdo_entry->parent->name) == 0)
{
printf(" %s\n", mapping->pdo_entry->name);
}
else
{
printf(" %s %s\n", mapping->pdo_entry->parent->name, mapping->pdo_entry->name);
}
}
}
return 0;
}
void show(CONTEXT * ctx)
{
printf("== show == \n");
printf("device types %d\n", ctx->config->device_types.count);
ELLNODE * node;
for(node = ellFirst(&ctx->config->device_types); node; node = ellNext(node))
{
EC_DEVICE_TYPE * device_type =
(EC_DEVICE_TYPE *)node;
printf("name %s, ", device_type->name);
printf(" (vendor %x, product %x, revision %d) ",
device_type->vendor_id, device_type->product_id,
device_type->revision_id);
printf("sync managers %d\n", device_type->sync_managers.count);
}
printf("device instances %d\n", ctx->config->devices.count);
for(node = ellFirst(&ctx->config->devices); node; node = ellNext(node))
{
EC_DEVICE * device = (EC_DEVICE *)node;
printf("name %s position %d\n", device->name, device->position);
printf("simulation specs %d\n", device->simspecs.count);
ELLNODE * node1 = ellFirst(&device->simspecs);
for (;node1; node1 = ellNext(node1) )
{
st_simspec * simspec = (st_simspec *) node1;
printf("simspec signal_no %d type %d bit_length %d\n",
simspec->signal_no, simspec->type, simspec->bit_length);
}
}
}
/* print list of stopped records, and breakpoints set in locksets */
long epicsShareAPI dbstat(void)
{
struct LS_LIST *pnode;
struct BP_LIST *pbl;
struct EP_LIST *pqe;
epicsTimeStamp time;
epicsMutexMustLock(bkpt_stack_sem);
epicsTimeGetCurrent(&time);
/*
* Traverse list, reporting stopped records
*/
pnode = (struct LS_LIST *) ellFirst(&lset_stack);
while (pnode != NULL) {
if (pnode->precord != NULL) {
printf("LSet: %lu Stopped at: %-28.28s #B: %5.5d T: %p\n",
pnode->l_num, pnode->precord->name, ellCount(&pnode->bp_list), pnode->taskid);
/* for each entrypoint detected, print out entrypoint statistics */
pqe = (struct EP_LIST *) ellFirst(&pnode->ep_queue);
while (pqe != NULL) {
double diff = epicsTimeDiffInSeconds(&time,&pqe->time);
if (diff) {
printf(" Entrypoint: %-28.28s #C: %5.5lu C/S: %7.1f\n",
pqe->entrypoint->name, pqe->count,diff);
}
pqe = (struct EP_LIST *) ellNext((ELLNODE *)pqe);
}
}
else {
printf("LSet: %lu #B: %5.5d T: %p\n",
pnode->l_num, ellCount(&pnode->bp_list), pnode->taskid);
}
/*
* Print out breakpoints set in the lock set
*/
pbl = (struct BP_LIST *) ellFirst(&pnode->bp_list);
while (pbl != NULL) {
printf(" Breakpoint: %-28.28s", pbl->precord->name);
/* display auto print flag */
if (pbl->precord->bkpt & BKPT_PRINT_MASK)
printf(" (ap)\n");
else
printf("\n");
pbl = (struct BP_LIST *) ellNext((ELLNODE *)pbl);
}
pnode = (struct LS_LIST *) ellNext((ELLNODE *)pnode);
}
epicsMutexUnlock(bkpt_stack_sem);
return(0);
}
int epicsShareAPI dbNotifyDump(void)
{
epicsMutexLockStatus lockStatus;
dbRecordType *pdbRecordType;
dbRecordNode *pdbRecordNode;
dbCommon *precord;
putNotify *ppn;
putNotify *ppnRestart;
putNotifyRecord *ppnrWait;
int itry;
for(itry=0; itry<100; itry++) {
lockStatus = epicsMutexTryLock(pnotifyGlobal->lock);
if(lockStatus==epicsMutexLockOK) break;
epicsThreadSleep(.05);
}
for(pdbRecordType = (dbRecordType *)ellFirst(&pdbbase->recordTypeList);
pdbRecordType;
pdbRecordType = (dbRecordType *)ellNext(&pdbRecordType->node)) {
for (pdbRecordNode=(dbRecordNode *)ellFirst(&pdbRecordType->recList);
pdbRecordNode;
pdbRecordNode = (dbRecordNode *)ellNext(&pdbRecordNode->node)) {
putNotifyPvt *pputNotifyPvt;
precord = pdbRecordNode->precord;
if (!precord->name[0] ||
pdbRecordNode->flags & DBRN_FLAGS_ISALIAS)
continue;
if(!precord->ppn) continue;
if(!precord->ppnr) continue;
if(precord->ppn->paddr->precord != precord) continue;
ppn = precord->ppn;
pputNotifyPvt = (putNotifyPvt *)ppn->pputNotifyPvt;
printf("%s state %d ppn %p\n waitList\n",
precord->name,pputNotifyPvt->state,(void*)ppn);
ppnrWait = (putNotifyRecord *)ellFirst(&pputNotifyPvt->waitList);
while(ppnrWait) {
printf(" %s pact %d\n",
ppnrWait->precord->name,ppnrWait->precord->pact);
ppnrWait = (putNotifyRecord *)ellNext(&ppnrWait->waitNode.node);
}
printf(" restartList\n");
ppnRestart = (putNotify *)ellFirst(&precord->ppnr->restartList);
while(ppnRestart) {
printf(" %p\n", (void *)ppnRestart);
ppnRestart = (putNotify *)ellNext(&ppnRestart->restartNode.node);
}
}
}
if(lockStatus==epicsMutexLockOK) epicsMutexUnlock(pnotifyGlobal->lock);
return(0);
}
bufRxManager::~bufRxManager()
{
ELLNODE *node, *next;
SCOPED_LOCK(guard);
for(node=ellFirst(&freebufs), next=node ? ellNext(node):NULL;
node;
node=next, next=next ? ellNext(next) : NULL)
{
buffer *b=CONTAINER(node, buffer, node);
free(b);
}
}
void taskwdAnyRemove(void *key)
{
struct mNode *pm;
struct aNode *pa;
taskwdInit();
epicsMutexMustLock(mLock);
pm = (struct mNode *)ellFirst(&mList);
while (pm) {
if (pm->funcs == &anyFuncs) {
pa = (struct aNode *)pm->usr;
if (pa->key == key) {
ellDelete(&mList, (void *)pm);
freeNode((union twdNode *)pa);
freeNode((union twdNode *)pm);
epicsMutexUnlock(mLock);
return;
}
}
pm = (struct mNode *)ellNext(&pm->node);
}
epicsMutexUnlock(mLock);
errlogPrintf("taskwdAnyRemove: Unregistered key %p\n", key);
}
void taskwdInsert(epicsThreadId tid, TASKWDFUNC callback, void *usr)
{
struct tNode *pt;
struct mNode *pm;
taskwdInit();
if (tid == 0)
tid = epicsThreadGetIdSelf();
pt = &allocNode()->t;
pt->tid = tid;
pt->callback = callback;
pt->usr = usr;
pt->suspended = FALSE;
epicsMutexMustLock(mLock);
pm = (struct mNode *)ellFirst(&mList);
while (pm) {
if (pm->funcs->insert) {
pm->funcs->insert(pm->usr, tid);
}
pm = (struct mNode *)ellNext(&pm->node);
}
epicsMutexUnlock(mLock);
epicsMutexMustLock(tLock);
ellAdd(&tList, (void *)pt);
epicsMutexUnlock(tLock);
}
void signalStatusUpdate(Port *pport)
{
if( interruptAccept)
{
ELLLIST *pclientList;
interruptNode *pnode;
asynInt32Interrupt *pInt32;
epicsInt32 int32Value;
pasynManager->interruptStart
(pport->asynStdInterfaces.int32InterruptPvt, &pclientList);
pnode = (interruptNode *)ellFirst(pclientList);
while(pnode != NULL)
{
pInt32 = (asynInt32Interrupt *) pnode->drvPvt;
if( pInt32->pasynUser->reason == 2)
{
int32Value = pport->error;
pInt32->callback(pInt32->userPvt, pInt32->pasynUser,
int32Value);
break;
}
pnode = (interruptNode *)ellNext(&pnode->node);
}
pasynManager->interruptEnd(pport->asynStdInterfaces.int32InterruptPvt);
}
}
void epicsThreadPoolReport(epicsThreadPool *pool, FILE *fd)
{
ELLNODE *cur;
epicsMutexMustLock(pool->guard);
fprintf(fd, "Thread Pool with %u/%u threads\n"
" running %d jobs with %u threads\n",
pool->threadsRunning,
pool->conf.maxThreads,
ellCount(&pool->jobs),
pool->threadsAreAwake);
if (pool->pauseadd)
fprintf(fd, " Inhibit queueing\n");
if (pool->pauserun)
fprintf(fd, " Pause workers\n");
if (pool->shutdown)
fprintf(fd, " Shutdown in progress\n");
for (cur = ellFirst(&pool->jobs); cur; cur = ellNext(cur)) {
epicsJob *job = CONTAINER(cur, epicsJob, jobnode);
fprintf(fd, " job %p func: %p, arg: %p ",
job, job->func,
job->arg);
if (job->queued)
fprintf(fd, "Queued ");
if (job->running)
fprintf(fd, "Running ");
if (job->freewhendone)
fprintf(fd, "Free ");
fprintf(fd, "\n");
}
epicsMutexUnlock(pool->guard);
}
static void devAdmin_AO_T1(ST_execParam *pParam)
{
ST_ADMIN *pAdminCfg = drvAdmin_get_AdminPtr();
struct dbCommon *precord = pParam->precord;
ST_STD_device *pSTDdev = (ST_STD_device*) ellFirst(pAdminCfg->pList_DeviceTask);
if( pAdminCfg->StatusAdmin & TASK_ARM_ENABLED )
{
epicsPrintf("ERROR! System armed! please check again. (0x%x)\n", pAdminCfg->StatusAdmin);
return;
}
if( pParam->n32Arg0 >= SIZE_CNT_MULTI_TRIG ) {
epicsPrintf("ERROR! Timing section not valid(%d).\n", pParam->n32Arg0);
return;
}
pAdminCfg->ST_Base.dT1[pParam->n32Arg0]= (double)pParam->setValue;
while(pSTDdev) {
pSTDdev = (ST_STD_device*) ellNext(&pSTDdev->node);
}
epicsPrintf("T1 (%lf): Sec. %d, %s %s (%s)\n", pAdminCfg->ST_Base.dT1[pParam->n32Arg0], pParam->n32Arg0,
pAdminCfg->taskName, precord->name, epicsThreadGetNameSelf());
}
static void drvMK80S_scanTask(int param)
{
kuDebug (kuTRACE, "[drvMK80S_scanTask] ... \n");
drvMK80SConfig* pdrvMK80SConfig = NULL;
double drvMK80S_scanInterval;
while(!pdrvMK80S_ellList || ellCount(pdrvMK80S_ellList) <1) {
epicsThreadSleep(1.);
}
while(1) {
pdrvMK80SConfig = (drvMK80SConfig*) ellFirst(pdrvMK80S_ellList);
drvMK80S_scanInterval = pdrvMK80SConfig->scanInterval;
do {
if(drvMK80S_scanInterval > pdrvMK80SConfig->scanInterval) {
drvMK80S_scanInterval = pdrvMK80SConfig->scanInterval;
}
if(!pdrvMK80SConfig->cbCount) {
pdrvMK80SConfig->cbCount++;
kuDebug (kuDEBUG, "[drvMK80S_scanTask] pasynManager->queueRequest() \n");
pasynManager->queueRequest(pdrvMK80SConfig->pasynMK80SUser, asynQueuePriorityLow, pdrvMK80SConfig->cbTimeout);
}
pdrvMK80SConfig = (drvMK80SConfig*) ellNext(&pdrvMK80SConfig->node);
} while(pdrvMK80SConfig);
epicsThreadSleep(drvMK80S_scanInterval);
}
kuDebug (kuCRI, "[drvMK80S_scanTask] end ...\n");
}
/*
* devCombineAdjacentBlocks()
*/
static long devCombineAdjacentBlocks(
ELLLIST *pRangeList,
rangeItem *pRange)
{
rangeItem *pBefore;
rangeItem *pAfter;
pBefore = (rangeItem *) ellPrevious (&pRange->node);
pAfter = (rangeItem *) ellNext (&pRange->node);
/*
* combine adjacent blocks
*/
if (pBefore) {
if (pBefore->end == pRange->begin-1) {
epicsMutexMustLock(addrListLock);
pRange->begin = pBefore->begin;
ellDelete (pRangeList, &pBefore->node);
epicsMutexUnlock(addrListLock);
free ((void *)pBefore);
}
}
if (pAfter) {
if (pAfter->begin == pRange->end+1) {
epicsMutexMustLock(addrListLock);
pRange->end = pAfter->end;
ellDelete (pRangeList, &pAfter->node);
epicsMutexUnlock(addrListLock);
free((void *)pAfter);
}
}
return SUCCESS;
}
/*
* devListAddressMap()
*/
static long devListAddressMap(ELLLIST *pRangeList)
{
rangeItem *pri;
int i;
long s;
if (!devLibInitFlag) {
s = devLibInit ();
if (s) {
return s;
}
}
epicsMutexMustLock(addrListLock);
for (i=0; i<NELEMENTS(addrAlloc); i++) {
pri = (rangeItem *) ellFirst(&pRangeList[i]);
if (pri) {
printf ("%s Address Map\n", epicsAddressTypeName[i]);
}
while (pri) {
printf ("\t0X%0*lX - 0X%0*lX physical base %p %s\n",
addrHexDig[i],
(unsigned long) pri->begin,
addrHexDig[i],
(unsigned long) pri->end,
pri->pPhysical,
pri->pOwnerName);
pri = (rangeItem *) ellNext (&pri->node);
}
}
epicsMutexUnlock(addrListLock);
return SUCCESS;
}
void epicsShareAPI gphFreeMem(gphPvt *pgphPvt)
{
ELLLIST **paplist;
int h;
/* Caller must ensure that no other thread is using *pvt */
if (pgphPvt == NULL) return;
paplist = pgphPvt->paplist;
for (h = 0; h < pgphPvt->size; h++) {
ELLLIST *plist = paplist[h];
GPHENTRY *pgphNode;
GPHENTRY *next;
if (plist == NULL) continue;
pgphNode = (GPHENTRY *) ellFirst(plist);
while (pgphNode) {
next = (GPHENTRY *) ellNext((ELLNODE*)pgphNode);
ellDelete(plist, (ELLNODE*)pgphNode);
free(pgphNode);
pgphNode = next;
}
free(paplist[h]);
}
epicsMutexDestroy(pgphPvt->lock);
free(paplist);
free(pgphPvt);
}
static void devNI6123_AO_DAQ_MAX_VOLT(ST_execParam *pParam)
{
ST_MASTER *pMaster = get_master();
ST_STD_device *pSTDdev = (ST_STD_device*) ellFirst(pMaster->pList_DeviceTask);
ST_NI6123 *pNI6123 = NULL;
kLog (K_DATA,"[devNI6123_AO_DAQ_MAX_VOLT] minVolt(%f)\n", pParam->setValue);
while(pSTDdev) {
if (pSTDdev->StatusDev & TASK_ARM_ENABLED) {
kLog (K_DATA,"[devNI6123_AO_DAQ_MAX_VOLT] %s: System is armed! \n", pSTDdev->taskName);
notify_error (1, "System is armed!", pSTDdev->taskName );
}
else {
pNI6123 = pSTDdev->pUser;
pNI6123->maxVal = pParam->setValue;
scanIoRequest(pSTDdev->ioScanPvt_userCall);
kLog (K_DATA,"[devNI6123_AO_DAQ_MAX_VOLT] task(%s) maxVolt(%.f)\n",
pSTDdev->taskName, pNI6123->maxVal);
}
pSTDdev = (ST_STD_device*) ellNext(&pSTDdev->node);
}
}
static void devNI6123_AO_DAQ_SAMPLEING_RATE(ST_execParam *pParam)
{
ST_MASTER *pMaster = get_master();
ST_STD_device *pSTDdev = (ST_STD_device*) ellFirst(pMaster->pList_DeviceTask);
ST_NI6123 *pNI6123 = NULL;
kLog (K_DATA,"[devNI6123_AO_DAQ_SAMPLEING_RATE] sampleRate(%f)\n", pParam->setValue);
while(pSTDdev) {
if (pSTDdev->StatusDev & TASK_ARM_ENABLED) {
kLog (K_DATA,"[devNI6123_AO_DAQ_SAMPLEING_RATE] %s: System is armed! \n", pSTDdev->taskName);
notify_error (1, "System is armed!", pSTDdev->taskName );
}
else {
pNI6123 = pSTDdev->pUser;
if(pParam->setValue > pNI6123->sample_rateLimit){
/* Device Sampling Rate Limit Cut if User is over Sampling Rate Setting. */
pParam->setValue = pNI6123->sample_rateLimit;
} else if(pParam->setValue <= 0){
pParam->setValue = 1;
}
pNI6123->sample_rate = pParam->setValue;
scanIoRequest(pSTDdev->ioScanPvt_userCall);
kLog (K_DATA,"[devNI6123_AO_DAQ_SAMPLEING_RATE] task(%s) sampleRate(%.f)\n",
pSTDdev->taskName, pNI6123->sample_rate);
}
pSTDdev = (ST_STD_device*) ellNext(&pSTDdev->node);
}
}
static
int fill_cache(epicsUInt16 dev,epicsUInt16 vend)
{
ELLNODE *cur;
const dev_vend_entry *current;
dev_vend_entry *next;
for(cur=ellFirst(&dev_vend_cache); cur; cur=ellNext(cur)){
current=CONTAINER(cur,const dev_vend_entry,node);
/* If one device is found then all must be in cache */
if( current->device==dev && current->vendor==vend )
return 0;
}
next=malloc(sizeof(dev_vend_entry));
if(!next)
return S_dev_noMemory;
next->device=dev;
next->vendor=vend;
if( sharedDevPCIFind(dev,vend,&devices) ){
free(next);
return S_dev_addressNotFound;
}
/* Prepend */
ellInsert(&dev_vend_cache, NULL, &next->node);
return 0;
}
static asynStatus float64Write(void *pvt,asynUser *pasynUser,
epicsFloat64 value)
{
drvPvt *pdrvPvt = (drvPvt *)pvt;
int addr;
asynStatus status;
ELLLIST *pclientList;
interruptNode *pnode;
asynFloat64Interrupt *pinterrupt;
status = getAddr(pdrvPvt,pasynUser,&addr,0);
if(status!=asynSuccess) return status;
epicsMutexMustLock(pdrvPvt->lock);
pdrvPvt->interruptDelay = value;
epicsMutexUnlock(pdrvPvt->lock);
epicsEventSignal(pdrvPvt->waitWork);
asynPrint(pasynUser,ASYN_TRACEIO_DRIVER,
"%s addr %d write %f\n",pdrvPvt->portName,addr,value);
pasynManager->interruptStart(pdrvPvt->asynFloat64Pvt, &pclientList);
pnode = (interruptNode *)ellFirst(pclientList);
while (pnode) {
pinterrupt = pnode->drvPvt;
if(addr==pinterrupt->addr && pinterrupt->pasynUser->reason==1) {
pinterrupt->callback(pinterrupt->userPvt,pinterrupt->pasynUser,value);
break;
}
pnode = (interruptNode *)ellNext(&pnode->node);
}
pasynManager->interruptEnd(pdrvPvt->asynFloat64Pvt);
return asynSuccess;
}
epicsShareFunc void taskwdShow(int level)
{
struct tNode *pt;
int mCount, fCount, tCount;
char tName[40];
epicsMutexMustLock(mLock);
mCount = ellCount(&mList);
epicsMutexUnlock(mLock);
epicsMutexMustLock(fLock);
fCount = ellCount(&fList);
epicsMutexUnlock(fLock);
epicsMutexMustLock(tLock);
tCount = ellCount(&tList);
printf("%d monitors, %d threads registered, %d free nodes\n",
mCount, tCount, fCount);
if (level) {
printf("%16.16s %9s %12s %12s %12s\n",
"THREAD NAME", "STATE", "EPICS TID", "CALLBACK", "USR ARG");
pt = (struct tNode *)ellFirst(&tList);
while (pt != NULL) {
epicsThreadGetName(pt->tid, tName, sizeof(tName));
printf("%16.16s %9s %12p %12p %12p\n",
tName, pt->suspended ? "Suspended" : "Ok ",
(void *)pt->tid, (void *)pt->callback, pt->usr);
pt = (struct tNode *)ellNext(&pt->node);
}
}
epicsMutexUnlock(tLock);
}
static char *dbOpenFile(DBBASE *pdbbase,const char *filename,FILE **fp)
{
ELLLIST *ppathList = (ELLLIST *)pdbbase->pathPvt;
dbPathNode *pdbPathNode;
char *fullfilename;
*fp = 0;
if (!filename) return 0;
if (!ppathList || ellCount(ppathList) == 0 ||
strchr(filename, '/') || strchr(filename, '\\')) {
*fp = fopen(filename, "r");
if (*fp && makeDbdDepends)
fprintf(stdout, "%s:%s \n", makeDbdDepends, filename);
return 0;
}
pdbPathNode = (dbPathNode *)ellFirst(ppathList);
while (pdbPathNode) {
fullfilename = dbMalloc(strlen(pdbPathNode->directory) +
strlen(filename) + 2);
strcpy(fullfilename, pdbPathNode->directory);
strcat(fullfilename, "/");
strcat(fullfilename, filename);
*fp = fopen(fullfilename, "r");
if (*fp && makeDbdDepends)
fprintf(stdout, "%s:%s \n", makeDbdDepends, fullfilename);
free((void *)fullfilename);
if (*fp) return pdbPathNode->directory;
pdbPathNode = (dbPathNode *)ellNext(&pdbPathNode->node);
}
return 0;
}
void epicsShareAPI gphDumpFP(FILE *fp, gphPvt *pgphPvt)
{
unsigned int empty = 0;
ELLLIST **paplist;
int h;
if (pgphPvt == NULL) return;
printf("Hash table has %d buckets", pgphPvt->size);
paplist = pgphPvt->paplist;
for (h = 0; h < pgphPvt->size; h++) {
ELLLIST *plist = paplist[h];
GPHENTRY *pgphNode;
int i = 0;
if (plist == NULL) {
empty++;
continue;
}
pgphNode = (GPHENTRY *) ellFirst(plist);
fprintf(fp, "\n [%3d] %3d ", h, ellCount(plist));
while (pgphNode) {
if (!(++i % 3))
fprintf(fp, "\n ");
fprintf(fp, " %s %p", pgphNode->name, pgphNode->pvtid);
pgphNode = (GPHENTRY *) ellNext((ELLNODE*)pgphNode);
}
}
fprintf(fp, "\n%u buckets empty.\n", empty);
}
static void devNI6123_AO_BEAM_PLUSE(ST_execParam *pParam)
{
ST_MASTER *pMaster = get_master();
ST_STD_device *pSTDdev = (ST_STD_device*) ellFirst(pMaster->pList_DeviceTask);
ST_NI6123 *pNI6123 = NULL;
kLog (K_TRACE, "[devNI6123_AO_BEAM_PLUSE] beam_pulse(%f)\n", pParam->setValue);
while(pSTDdev) {
if (pSTDdev->StatusDev & TASK_ARM_ENABLED) {
kLog (K_ERR, "[devNI6123_AO_BEAM_PLUSE] %s: System is armed! \n", pSTDdev->taskName);
notify_error (1, "System is armed!", pSTDdev->taskName );
}
else {
pNI6123 = pSTDdev->pUser;
pNI6123->beam_pulse = pParam->setValue;
scanIoRequest(pSTDdev->ioScanPvt_userCall);
kLog (K_DEBUG, "[devNI6123_AO_BEAM_PLUSE] task(%s) pulse(%.f)\n",
pSTDdev->taskName, pNI6123->beam_pulse);
}
pSTDdev = (ST_STD_device*) ellNext(&pSTDdev->node);
}
}
epicsShareFunc void epicsShareAPI epicsThreadShow(epicsThreadId showThread, unsigned int level)
{
epicsThreadOSD *pthreadInfo;
int status;
int found = 0;
epicsThreadInit();
if(!showThread) {
showThreadInfo(0,level);
return;
}
status = mutexLock(&listLock);
checkStatusQuit(status,"pthread_mutex_lock","epicsThreadShowAll");
pthreadInfo=(epicsThreadOSD *)ellFirst(&pthreadList);
while(pthreadInfo) {
if (((epicsThreadId)pthreadInfo == showThread)
|| ((epicsThreadId)pthreadInfo->tid == showThread)) {
found = 1;
showThreadInfo(pthreadInfo,level);
}
pthreadInfo=(epicsThreadOSD *)ellNext(&pthreadInfo->node);
}
status = pthread_mutex_unlock(&listLock);
checkStatusQuit(status,"pthread_mutex_unlock","epicsThreadShowAll");
if (!found)
printf("Thread %#lx (%lu) not found.\n", (unsigned long)showThread, (unsigned long)showThread);
}
GPHENTRY * epicsShareAPI gphFind(gphPvt *pgphPvt, const char *name, void *pvtid)
{
ELLLIST **paplist;
ELLLIST *gphlist;
GPHENTRY *pgphNode;
int hash;
if (pgphPvt == NULL) return NULL;
paplist = pgphPvt->paplist;
hash = epicsMemHash((char *)&pvtid, sizeof(void *), 0);
hash = epicsStrHash(name, hash) & pgphPvt->mask;
epicsMutexMustLock(pgphPvt->lock);
gphlist = paplist[hash];
if (gphlist == NULL) {
pgphNode = NULL;
} else {
pgphNode = (GPHENTRY *) ellFirst(gphlist);
}
while (pgphNode) {
if (pvtid == pgphNode->pvtid &&
strcmp(name, pgphNode->name) == 0) break;
pgphNode = (GPHENTRY *) ellNext((ELLNODE *)pgphNode);
}
epicsMutexUnlock(pgphPvt->lock);
return pgphNode;
}
/*
* devInsertAddress()
*/
static void devInsertAddress(
ELLLIST *pRangeList,
rangeItem *pNewRange)
{
rangeItem *pBefore;
rangeItem *pAfter;
epicsMutexMustLock(addrListLock);
pAfter = (rangeItem *) ellFirst (pRangeList);
while (pAfter) {
if (pNewRange->end < pAfter->begin) {
break;
}
pAfter = (rangeItem *) ellNext (&pAfter->node);
}
if (pAfter) {
pBefore = (rangeItem *) ellPrevious (&pAfter->node);
ellInsert (pRangeList, &pBefore->node, &pNewRange->node);
}
else {
ellAdd (pRangeList, &pNewRange->node);
}
epicsMutexUnlock(addrListLock);
}
static long drvEC1_ANT_io_report (int level)
{
ST_STD_device *pSTDdev;
ST_MASTER *pMaster = get_master();
if(!pMaster) return 0;
if(ellCount(pMaster->pList_DeviceTask)) {
pSTDdev = (ST_STD_device*) ellFirst (pMaster->pList_DeviceTask);
}
else {
epicsPrintf("Task not found\n");
return 0;
}
epicsPrintf("Totoal %d task(s) found\n",ellCount(pMaster->pList_DeviceTask));
if(level<1) return 0;
while (pSTDdev) {
if (level>2) {
epicsPrintf(" Sampling Rate: %d/sec\n", pSTDdev->ST_Base.nSamplingRate );
}
if (level>3) {
epicsPrintf(" status of Buffer-Pool (reused-counter/number of data/buffer pointer)\n");
epicsPrintf(" ");
epicsPrintf("\n");
}
pSTDdev = (ST_STD_device*) ellNext(&pSTDdev->node);
}
return 0;
}
int drvM6802_set_DAQclear(drvM6802_taskConfig *ptaskConfig)
{
drvM6802_taskConfig *ptaskAll = NULL;
if( (ptaskConfig->taskStatus & TASK_ADC_STARTED) )
{
ptaskAll = (drvM6802_taskConfig*) ellFirst(pdrvM6802Config->ptaskList);
while(ptaskAll)
{
ozSetArmReset(ptaskAll);
/* epicsThreadSleep(0.1); */
ptaskAll = (drvM6802_taskConfig*) ellNext(&ptaskAll->node);
}
ptaskConfig->taskStatus &= ~TASK_ADC_STARTED;
ptaskConfig->taskStatus |= TASK_ADC_STOPED;
} else {
epicsPrintf("\n>>> ozStopADC : DAQ not started! \n");
return ERROR;
}
return OK;
}
void
bufRxManager::received(CALLBACK* cb)
{
void *vptr;
callbackGetUser(vptr,cb);
bufRxManager &self=*static_cast<bufRxManager*>(vptr);
SCOPED_LOCK2(self.guard, G);
while(true) {
ELLNODE *node=ellGet(&self.usedbufs);
if (!node)
break;
buffer *buf=CONTAINER(node, buffer, node);
G.unlock();
for(ELLNODE *cur=ellFirst(&self.dispatch); cur; cur=ellNext(cur)) {
listener *action=CONTAINER(cur, listener, node);
(action->fn)(action->fnarg, 0, buf->used, buf->data);
}
G.lock();
ellAdd(&self.freebufs, &buf->node);
};
}
