static void errlogInitPvt(void *arg) { struct initArgs *pconfig = (struct initArgs *) arg; epicsThreadId tid; pvtData.errlogInitFailed = TRUE; pvtData.buffersize = pconfig->bufsize; pvtData.maxMsgSize = pconfig->maxMsgSize; pvtData.msgNeeded = adjustToWorstCaseAlignment(pvtData.maxMsgSize + sizeof(msgNode)); ellInit(&pvtData.listenerList); ellInit(&pvtData.msgQueue); pvtData.toConsole = TRUE; pvtData.console = stderr; pvtData.waitForWork = epicsEventMustCreate(epicsEventEmpty); pvtData.listenerLock = epicsMutexMustCreate(); pvtData.msgQueueLock = epicsMutexMustCreate(); pvtData.waitForFlush = epicsEventMustCreate(epicsEventEmpty); pvtData.flush = epicsEventMustCreate(epicsEventEmpty); pvtData.flushLock = epicsMutexMustCreate(); pvtData.waitForExit = epicsEventMustCreate(epicsEventEmpty); pvtData.pbuffer = callocMustSucceed(1, pvtData.buffersize, "errlogInitPvt"); errSymBld(); /* Better not to do this lazily... */ tid = epicsThreadCreate("errlog", epicsThreadPriorityLow, epicsThreadGetStackSize(epicsThreadStackSmall), (EPICSTHREADFUNC)errlogThread, 0); if (tid) { pvtData.errlogInitFailed = FALSE; } }
void ell_check(){ EllCurve ecc; BigNum bnA, bnB, bnPrime, bnQ, bnPX, bnPY, bnQX, bnQY, bnD; strtodigitn( "0000000000000000000000000000000000000000000000000000000000000007", bnA, MAX_SIZE ); strtodigitn( "5FBFF498AA938CE739B8E022FBAFEF40563F6E6A3472FC2A514C0CE9DAE23B7E", bnB, MAX_SIZE ); strtodigitn( "8000000000000000000000000000000000000000000000000000000000000431", bnPrime, MAX_SIZE ); strtodigitn( "8000000000000000000000000000000150FE8A1892976154C59CFC193ACCF5B3", bnQ, MAX_SIZE ); strtodigitn( "0000000000000000000000000000000000000000000000000000000000000002", bnPX, MAX_SIZE ); strtodigitn( "8E2A8A0E65147D4BD6316030E16D19C85C97F0A9CA267122B96ABBCEA7E8FC8", bnPY, MAX_SIZE ); strtodigitn( "7A929ADE789BB9BE10ED359DD39A72C11B60961F49397EEE1D19CE9891EC3B28", bnD, MAX_SIZE ); ellCurveInit( ecc, bnA, bnB, bnPrime ); EllPoint epP, epQ, epRes; ellInit( epP, bnPX, bnPY, ecc ); ellInit( epQ, ecc ); ellMul( epRes, bnQ, epP, ecc ); //std::cout << epRes << std::endl; if ( ellIsZero(epRes) ) std::cout << "Test Valid" << std::endl; else std::cout << "Test is NOT Valid" << std::endl; ellMul( epRes, bnD, epP, ecc ); strtodigitn( "7F2B49E270DB6D90D8595BEC458B50C58585BA1D4E9B788F6689DBD8E56FD80B", bnQX, MAX_SIZE ); strtodigitn( "26F1B489D6701DD185C8413A977B3CBBAF64D1C593D26627DFFB101A87FF77DA", bnQY, MAX_SIZE ); ellInit( epQ, bnQX, bnQY, ecc ); if ( ellIsEqual( epQ, epRes ) ) std::cout << "Test Valid" << std::endl; else std::cout << "Test is NOT Valid" << std::endl; };
static void generalTime_InitOnce(void *dummy) { ellInit(>Pvt.timeProviders); gtPvt.timeListLock = epicsMutexMustCreate(); ellInit(>Pvt.eventProviders); gtPvt.eventListLock = epicsMutexMustCreate(); }
static void inputConstruct(void **ppvt) { inputData *pinputData; pinputData = calloc(1,sizeof(inputData)); ellInit(&pinputData->inputFileList); ellInit(&pinputData->pathList); *ppvt = pinputData; }
void dbNotifyAdd(dbCommon *pfrom, dbCommon *pto) { processNotify *ppn = pfrom->ppn; notifyPvt *pnotifyPvt; if (pto->pact) return; /*if active it will not be processed*/ epicsMutexMustLock(pnotifyGlobal->lock); if (!pto->ppnr) {/* make sure record has a processNotifyRecord*/ pto->ppnr = dbCalloc(1, sizeof(processNotifyRecord)); pto->ppnr->precord = pto; ellInit(&pto->ppnr->restartList); } assert(ppn); pnotifyPvt = (notifyPvt *) ppn->pnotifyPvt; if (!pto->ppn && (pnotifyPvt->state == notifyProcessInProgress) && (pto != dbChannelRecord(ppn->chan))) { notifyPvt *pnotifyPvt; pto->ppn = pfrom->ppn; pnotifyPvt = (notifyPvt *) pfrom->ppn->pnotifyPvt; ellSafeAdd(&pnotifyPvt->waitList, &pto->ppnr->waitNode); } epicsMutexUnlock(pnotifyGlobal->lock); }
void dbProcessNotify(processNotify *ppn) { struct dbChannel *chan = ppn->chan; dbCommon *precord = dbChannelRecord(chan); short dbfType = dbChannelFieldType(chan); notifyPvt *pnotifyPvt; /* Must handle DBF_XXXLINKs as special case. * Only dbPutField will change link fields. * Also the record is not processed as a result */ ppn->status = notifyOK; ppn->wasProcessed = 0; if (dbfType>=DBF_INLINK && dbfType<=DBF_FWDLINK) { if (ppn->requestType == putProcessRequest || ppn->requestType == putProcessGetRequest) { /* Check if puts disabled */ if (precord->disp && (dbChannelField(ppn->chan) != (void *) &precord->disp)) { ppn->putCallback(ppn, putDisabledType); } else { ppn->putCallback(ppn, putFieldType); } } if (ppn->requestType == processGetRequest || ppn->requestType == putProcessGetRequest) { ppn->getCallback(ppn, getFieldType); } ppn->doneCallback(ppn); return; } dbScanLock(precord); epicsMutexMustLock(pnotifyGlobal->lock); pnotifyPvt = (notifyPvt *) ppn->pnotifyPvt; if (pnotifyPvt && (pnotifyPvt->magic != MAGIC)) { printf("dbPutNotify:pnotifyPvt was not initialized\n"); pnotifyPvt = 0; } if (pnotifyPvt) { assert(pnotifyPvt->state == notifyUserCallbackActive); pnotifyPvt->userCallbackWait = 1; epicsMutexUnlock(pnotifyGlobal->lock); dbScanUnlock(precord); epicsEventWait(pnotifyPvt->userCallbackEvent); dbScanLock(precord); epicsMutexMustLock(pnotifyGlobal->lock); notifyCleanup(ppn); } pnotifyPvt = (notifyPvt *) ppn->pnotifyPvt; assert(!pnotifyPvt); notifyInit(ppn); pnotifyPvt = (notifyPvt *) ppn->pnotifyPvt; if (!precord->ppnr) { /* make sure record has a processNotifyRecord*/ precord->ppnr = dbCalloc(1, sizeof(processNotifyRecord)); precord->ppnr->precord = precord; ellInit(&precord->ppnr->restartList); } processNotifyCommon(ppn, precord); }
static void notifyInit(processNotify *ppn) { notifyPvt *pnotifyPvt; pnotifyPvt = (notifyPvt *) ellFirst(&pnotifyGlobal->freeList); if (pnotifyPvt) { ellDelete(&pnotifyGlobal->freeList, &pnotifyPvt->node); } else { pnotifyPvt = dbCalloc(1,sizeof(notifyPvt)); pnotifyPvt->cancelEvent = epicsEventCreate(epicsEventEmpty); pnotifyPvt->userCallbackEvent = epicsEventCreate(epicsEventEmpty); pnotifyPvt->magic = MAGIC; pnotifyPvt->state = notifyNotActive; } pnotifyPvt->state = notifyNotActive; callbackSetCallback(notifyCallback,&pnotifyPvt->callback); callbackSetUser(ppn,&pnotifyPvt->callback); callbackSetPriority(priorityLow,&pnotifyPvt->callback); ellInit(&pnotifyPvt->waitList); ppn->status = notifyOK; ppn->wasProcessed = 0; pnotifyPvt->state = notifyNotActive; pnotifyPvt->cancelWait = pnotifyPvt->userCallbackWait = 0; ppn->pnotifyPvt = pnotifyPvt; }
static void doInitRecord0(dbRecordType *pdbRecordType, dbCommon *precord, void *user) { struct rset *prset = pdbRecordType->prset; devSup *pdevSup; if (!prset) return; /* unlikely */ precord->rset = prset; precord->rdes = pdbRecordType; precord->mlok = epicsMutexMustCreate(); ellInit(&precord->mlis); /* Reset the process active field */ precord->pact = FALSE; /* Initial UDF severity */ if (precord->udf && precord->stat == UDF_ALARM) precord->sevr = precord->udfs; /* Init DSET NOTE that result may be NULL */ pdevSup = dbDTYPtoDevSup(pdbRecordType, precord->dtyp); precord->dset = pdevSup ? pdevSup->pdset : NULL; if (prset->init_record) prset->init_record(precord, 0); }
motorSimController::motorSimController(const char *portName, int numAxes, int priority, int stackSize) : asynMotorController(portName, numAxes, NUM_SIM_CONTROLLER_PARAMS, asynInt32Mask | asynFloat64Mask, asynInt32Mask | asynFloat64Mask, ASYN_CANBLOCK | ASYN_MULTIDEVICE, 1, // autoconnect priority, stackSize) { int axis; motorSimControllerNode *pNode; if (!motorSimControllerListInitialized) { motorSimControllerListInitialized = 1; ellInit(&motorSimControllerList); } // We should make sure this portName is not already in the list */ pNode = (motorSimControllerNode*) calloc(1, sizeof(motorSimControllerNode)); pNode->portName = epicsStrDup(portName); pNode->pController = this; ellAdd(&motorSimControllerList, (ELLNODE *)pNode); if (numAxes < 1 ) numAxes = 1; numAxes_ = numAxes; this->movesDeferred_ = 0; for (axis=0; axis<numAxes; axis++) { new motorSimAxis(this, axis, DEFAULT_LOW_LIMIT, DEFAULT_HI_LIMIT, DEFAULT_HOME, DEFAULT_START); setDoubleParam(axis, this->motorPosition_, DEFAULT_START); } this->motorThread_ = epicsThreadCreate("motorSimThread", epicsThreadPriorityLow, epicsThreadGetStackSize(epicsThreadStackMedium), (EPICSTHREADFUNC) motorSimTaskC, (void *) this); }
static long configMenuList_init(aSubRecord *pasub) { ELLLIST *configMenuList; configMenuList = calloc(1, sizeof(ELLLIST)); pasub->dpvt = configMenuList; ellInit(configMenuList); return(0); }
void ecAsynRegistrar(void) { ellInit(&sampler_configs); iocshRegister(&InitFuncDef,InitCallFunc); iocshRegister(&SamplerFuncDef,SamplerCallFunc); iocshRegister(&showPdoFuncDef,showPdoCallFunc); }
/* * Driver initialisation at IOC startup (ecAsynInit) * * path - location of Unix Domain Socket, must match the scanner's * max_message - maximum size of messages between scanner and ioc * This must be able to accommodate the configuration * of the chain that is transferred from the scanner to * the ioc. */ static void makePorts(char * path, int max_message) { ENGINE_USER * usr = (ENGINE_USER *)callocMustSucceed (1, sizeof(ENGINE_USER), "can't allocate socket engine private data"); ellInit(&usr->ports); usr->master = new ecMaster((char *)"MASTER0"); ellAdd(&usr->ports, &usr->master->node); usr->config_ready = rtMessageQueueCreate(1, sizeof(int)); // TODO - no assert for runtime errors, so what should we use to throw? assert(usr->config_ready != NULL); usr->config = (EC_CONFIG *)callocMustSucceed (1, sizeof(EC_CONFIG), "can't allocate chain config lists"); usr->writeq = rtMessageQueueCreate(1, max_message); assert(usr->writeq != NULL); ENGINE * engine = new_engine(max_message); engine->path = strdup(path); engine->connect = client_connect; engine->on_connect = receive_config_on_connect; engine->send_message = ioc_send; engine->receive_message = ioc_receive; engine->usr = usr; engine_start(engine); new_timer(1000000000, usr->writeq, 0, MSG_HEARTBEAT); int ack; rtMessageQueueReceive(usr->config_ready, &ack, sizeof(int)); }
/* epicsShareFunc int drvSNMPConnInit(const char *version, const char *hostaddr, const char *username, const char *authpass, const char*privpass) */ epicsShareFunc int drvSNMPConnInit(char *version, char *hostaddr, char *username, char *authpass, char*privpass) { printf("------------------------------------------------\n"); printf("degug line\n"); printf("------------------------------------------------\n"); printf("version: %s, hostaddr: %s, username: %s, authpass: %s, privpass: %s\n", version, hostaddr, username, authpass, privpass); printf("------------------------------------------------\n"); snmpinfo = (SNMP_INFO *)malloc(sizeof(SNMP_INFO)); strcpy(&snmpinfo->version, version); strcpy(&snmpinfo->hostaddr, hostaddr); strcpy(&snmpinfo->username, username); strcpy(&snmpinfo->authpass, authpass); strcpy(&snmpinfo->privpass, privpass); strcpy(&snmpinfo->msg,"Test Message"); gsnmpInfo = snmpinfo; memcpy(gsnmpInfo, snmpinfo, sizeof(SNMP_INFO)); printf("version: %s, hostaddr: %s, username: %s, authpass: %s, privpass: %s\n", snmpinfo->version, snmpinfo->hostaddr, snmpinfo->username, snmpinfo->authpass, snmpinfo->privpass); ellInit(&devSNMPList); epicsThreadCreate("drvSNMPConnInit", epicsThreadPriorityHigh, epicsThreadGetStackSize(epicsThreadStackSmall), (EPICSTHREADFUNC)devSNMPScanThread,NULL); return 0; };
void epicsShareAPI dbPutNotifyInit(void) { if(pnotifyGlobal) return; pnotifyGlobal = dbCalloc(1,sizeof(notifyGlobal)); pnotifyGlobal->lock = epicsMutexMustCreate(); ellInit(&pnotifyGlobal->freeList); }
static void initPeriodic(void) { dbMenu *pmenu = dbFindMenu(pdbbase, "menuScan"); double quantum = epicsThreadSleepQuantum(); int i; if (!pmenu) { errlogPrintf("initPeriodic: menuScan not present\n"); return; } nPeriodic = pmenu->nChoice - SCAN_1ST_PERIODIC; papPeriodic = dbCalloc(nPeriodic, sizeof(periodic_scan_list*)); periodicTaskId = dbCalloc(nPeriodic, sizeof(void *)); for (i = 0; i < nPeriodic; i++) { periodic_scan_list *ppsl = dbCalloc(1, sizeof(periodic_scan_list)); const char *choice = pmenu->papChoiceValue[i + SCAN_1ST_PERIODIC]; double number; char *unit; int status = epicsParseDouble(choice, &number, &unit); ppsl->scan_list.lock = epicsMutexMustCreate(); ellInit(&ppsl->scan_list.list); ppsl->name = choice; if (status || number == 0) { errlogPrintf("initPeriodic: Bad menuScan choice '%s'\n", choice); ppsl->period = i; } else if (!*unit || !epicsStrCaseCmp(unit, "second") || !epicsStrCaseCmp(unit, "seconds")) { ppsl->period = number; } else if (!epicsStrCaseCmp(unit, "minute") || !epicsStrCaseCmp(unit, "minutes")) { ppsl->period = number * 60; } else if (!epicsStrCaseCmp(unit, "hour") || !epicsStrCaseCmp(unit, "hours")) { ppsl->period = number * 60 * 60; } else if (!epicsStrCaseCmp(unit, "Hz") || !epicsStrCaseCmp(unit, "Hertz")) { ppsl->period = 1 / number; } else { errlogPrintf("initPeriodic: Bad menuScan choice '%s'\n", choice); ppsl->period = i; } number = ppsl->period / quantum; if ((ppsl->period < 2 * quantum) || (number / floor(number) > 1.1)) { errlogPrintf("initPeriodic: Scan rate '%s' is not achievable.\n", choice); } ppsl->scanCtl = ctlPause; ppsl->loopEvent = epicsEventMustCreate(epicsEventEmpty); papPeriodic[i] = ppsl; } }
static exitPvt * createExitPvt(void) { exitPvt * pep = calloc ( 1, sizeof ( * pep ) ); if ( pep ) { ellInit ( &pep->list ); } return pep; }
/*internal methods */ static void gpibInit(void) { if(pgpibBase) return; pgpibBase = callocMustSucceed(1,sizeof(gpibPvt),"gpibInit"); ellInit(&pgpibBase->gpibPvtList); pgpibBase->timerQueue = epicsTimerQueueAllocate( 1,epicsThreadPriorityScanLow); }
static drvM6802_taskConfig* make_taskConfig(char *taskName, uint16 vme_addr) { static uint16 boardcnt = 1; drvM6802_taskConfig *ptaskConfig = NULL; char task_name[60]; int i; strcpy(task_name, taskName); ptaskConfig = (drvM6802_taskConfig*) malloc(sizeof(drvM6802_taskConfig)); if(!ptaskConfig) return ptaskConfig; ptaskConfig->BoardID = boardcnt; ptaskConfig->vme_addr = vme_addr; strcpy(ptaskConfig->taskName, task_name); ptaskConfig->taskLock = epicsMutexCreate(); ptaskConfig->bufferLock = epicsMutexCreate(); scanIoInit(&ptaskConfig->ioScanPvt); /* ptaskConfig->masterMode = 0; */ ptaskConfig->masterMode = ( ptaskConfig->BoardID == 1 ) ? 1 : 0; ptaskConfig->samplingRate = INIT_SAMPLING; ptaskConfig->appSampleRate = INIT_SAMPLING; ptaskConfig->channelMask = INIT_CH_MASK; ptaskConfig->clockSource = (ptaskConfig->BoardID == 1) ? 0 : 1; /* default 0 : internal clock , 1: external*/ /* ptaskConfig->msgFPDP = 0; */ ptaskConfig->cnt_DMAcallback = 0; ptaskConfig->nTrigPolarity = INIT_TRIG_POLARITY; /* ptaskConfig->pcallback = (CALLBACK*) taskCallback; */ ptaskConfig->fT0 = 1.; ptaskConfig->fT1 = 2.; boardcnt++; ptaskConfig->pcontrolThreadConfig = NULL; ptaskConfig->pfpdpThreadConfig = NULL; for( i=0; i< 16 ; i++) ptaskConfig->register_m6802[i] = DUMMY_DATA; ptaskConfig->adjTime_smplRate_Usec = 0.; ptaskConfig->adjTime_Gain_Usec = 0.; ptaskConfig->adjCount_smplRate = 0; ptaskConfig->adjCount_Gain = 0; ptaskConfig->pchannelConfig = (ELLLIST*) malloc(sizeof(ELLLIST)); if(!ptaskConfig->pchannelConfig) return NULL; else ellInit(ptaskConfig->pchannelConfig); ptaskConfig->taskStatus = TASK_NOT_INIT; return ptaskConfig; }
void testHarness(void) { epicsThreadOnce(&onceFlag, testOnce, NULL); epicsAtExit(harnessExit, NULL); Harness = 1; Programs = 0; Tests = 0; ellInit(&faults); epicsTimeGetCurrent(&started); }
bufRxManager::bufRxManager(const std::string& n, unsigned int qdepth, unsigned int bsize) :dataBufRx(n) ,guard() ,onerror(defaulterr) ,onerror_arg(NULL) ,m_bsize(bsize ? bsize : 2048) { ellInit(&dispatch); ellInit(&freebufs); ellInit(&usedbufs); CBINIT(&received_cb, priorityMedium, &bufRxManager::received, this); for(unsigned int i=0; i<qdepth; i++) { buffer *t=(buffer*)callocMustSucceed(1, sizeof(buffer)-1+m_bsize, "bufRxManager buffer"); ellAdd(&freebufs, &t->node); } }
void epicsShareAPI dbPutNotify(putNotify *ppn) { dbCommon *precord = ppn->paddr->precord; short dbfType = ppn->paddr->field_type; long status=0; putNotifyPvt *pputNotifyPvt; assert(precord); /*check for putField disabled*/ if(precord->disp) { if((void *)(&precord->disp) != ppn->paddr->pfield) { ppn->status = putNotifyPutDisabled; (*ppn->userCallback)(ppn); return; } } /* Must handle DBF_XXXLINKs as special case. * Only dbPutField will change link fields. * Also the record is not processed as a result */ if(dbfType>=DBF_INLINK && dbfType<=DBF_FWDLINK) { status=dbPutField(ppn->paddr,ppn->dbrType,ppn->pbuffer,ppn->nRequest); ppn->status = (status==0) ? putNotifyOK : putNotifyError; (*ppn->userCallback)(ppn); return; } dbScanLock(precord); epicsMutexMustLock(pnotifyGlobal->lock); pputNotifyPvt = (putNotifyPvt *)ppn->pputNotifyPvt; if(pputNotifyPvt && (pputNotifyPvt->magic!=MAGIC)) { printf("dbPutNotify:pputNotifyPvt was not initialized\n"); pputNotifyPvt = 0; } if(pputNotifyPvt) { assert(pputNotifyPvt->state==putNotifyUserCallbackActive); pputNotifyPvt->userCallbackWait = 1; epicsMutexUnlock(pnotifyGlobal->lock); dbScanUnlock(precord); epicsEventWait(pputNotifyPvt->userCallbackEvent); dbScanLock(precord); epicsMutexMustLock(pnotifyGlobal->lock); putNotifyCleanup(ppn); } pputNotifyPvt = (putNotifyPvt *)ppn->pputNotifyPvt; assert(!pputNotifyPvt); putNotifyInit(ppn); pputNotifyPvt = (putNotifyPvt *)ppn->pputNotifyPvt; if(!precord->ppnr) {/* make sure record has a putNotifyRecord*/ precord->ppnr = dbCalloc(1,sizeof(putNotifyRecord)); precord->ppnr->precord = precord; ellInit(&precord->ppnr->restartList); } putNotifyCommon(ppn,precord); }
/* * devLibInit() */ static long devLibInit (void) { rangeItem *pRange; int i; if(devLibInitFlag) return(SUCCESS); if(!pdevLibVME) { epicsPrintf ("pdevLibVME is NULL\n"); return S_dev_internal; } if (NELEMENTS(addrAlloc) != NELEMENTS(addrFree)) { return S_dev_internal; } addrListLock = epicsMutexMustCreate(); epicsMutexMustLock(addrListLock); for (i=0; i<NELEMENTS(addrAlloc); i++) { ellInit (&addrAlloc[i]); ellInit (&addrFree[i]); } for (i=0; i<NELEMENTS(addrAlloc); i++) { pRange = (rangeItem *) malloc (sizeof(*pRange)); if (!pRange) { return S_dev_noMemory; } pRange->pOwnerName = "<Vacant>"; pRange->pPhysical = NULL; pRange->begin = 0; pRange->end = addrLast[i]; ellAdd (&addrFree[i], &pRange->node); } epicsMutexUnlock(addrListLock); devLibInitFlag = TRUE; return pdevLibVME->pDevInit(); }
static int make_drvConfig(uint16 vme_addr) { /* static int cnt = 0; epicsPrintf(">>>>> call make_drvConfig cnt : %d\n", cnt); cnt++; */ /* just call only once */ if(pdrvM6802Config) return 0; /* epicsPrintf(">>>>> %d\n", cnt); */ pdrvM6802Config = (drvM6802Config*) malloc(sizeof(drvM6802Config)); if(!pdrvM6802Config) return 1; pdrvBufferConfig = (drvBufferConfig*) malloc(sizeof(drvBufferConfig)); if(!pdrvBufferConfig) return 1; pdrvM6802Config->openBus = 0; if( ozInitDevice( vme_addr ) == ERROR ) return 0; else epicsPrintf("\n>>> make_drvConfig(0x%04X) : ozInitDevice .... OK\n", vme_addr); pdrvM6802Config->openBus = 1; pdrvM6802Config->ptaskList = (ELLLIST*) malloc(sizeof(ELLLIST)); if(!pdrvM6802Config->ptaskList) return 1; else ellInit(pdrvM6802Config->ptaskList); pdrvBufferConfig->pbufferList = (ELLLIST*) malloc(sizeof(ELLLIST)); if(!pdrvBufferConfig->pbufferList) return 1; else ellInit(pdrvBufferConfig->pbufferList); return 0; }
bool addToList(const char *portName, PMCVController *drv) { if (!PMCVListInitialized) { PMCVListInitialized = 1; ellInit(&PMCVList); } else if (findByPortName(portName) != NULL) { fprintf(stderr, "ERROR: Re-using portName=%s\n", portName); return false; } PMCVNode *pNode = (PMCVNode*)calloc(1, sizeof(PMCVNode)); pNode->portName = epicsStrDup(portName); pNode->pController = drv; ellAdd(&PMCVList, (ELLNODE*)pNode); return true; }
epicsShareFunc epicsMessageQueueId epicsShareAPI epicsMessageQueueCreate( unsigned int capacity, unsigned int maxMessageSize) { epicsMessageQueueId pmsg; unsigned int slotBytes, slotLongs; assert(capacity != 0); pmsg = (epicsMessageQueueId)callocMustSucceed(1, sizeof(*pmsg), "epicsMessageQueueCreate"); pmsg->capacity = capacity; pmsg->maxMessageSize = maxMessageSize; slotLongs = 1 + ((maxMessageSize + sizeof(unsigned long) - 1) / sizeof(unsigned long)); slotBytes = slotLongs * sizeof(unsigned long); pmsg->buf = (unsigned long *)callocMustSucceed(pmsg->capacity, slotBytes, "epicsMessageQueueCreate"); pmsg->inPtr = pmsg->outPtr = pmsg->firstMessageSlot = (char *)&pmsg->buf[0]; pmsg->lastMessageSlot = (char *)&pmsg->buf[(capacity - 1) * slotLongs]; pmsg->full = false; pmsg->slotSize = slotBytes; pmsg->mutex = epicsMutexMustCreate(); ellInit(&pmsg->sendQueue); ellInit(&pmsg->receiveQueue); ellInit(&pmsg->eventFreeList); return pmsg; }
static void dbRecordtypeHead(char *name) { dbRecordType *pdbRecordType; GPHENTRY *pgphentry; pgphentry = gphFind(pdbbase->pgpHash,name,&pdbbase->recordTypeList); if(pgphentry) { duplicate = TRUE; return; } pdbRecordType = dbCalloc(1,sizeof(dbRecordType)); pdbRecordType->name = epicsStrDup(name); if (pdbbase->loadCdefs) ellInit(&pdbRecordType->cdefList); if(ellCount(&tempList)) yyerrorAbort("dbRecordtypeHead tempList not empty"); allocTemp(pdbRecordType); }
void scanIoInit(IOSCANPVT *pioscanpvt) { ioscan_head *piosh = dbCalloc(1, sizeof(ioscan_head)); int prio; ioscanInit(); for (prio = 0; prio < NUM_CALLBACK_PRIORITIES; prio++) { io_scan_list *piosl = &piosh->iosl[prio]; callbackSetCallback(ioscanCallback, &piosl->callback); callbackSetPriority(prio, &piosl->callback); callbackSetUser(piosh, &piosl->callback); ellInit(&piosl->scan_list.list); piosl->scan_list.lock = epicsMutexMustCreate(); } epicsMutexMustLock(ioscan_lock); piosh->next = pioscan_list; pioscan_list = piosh; epicsMutexUnlock(ioscan_lock); *pioscanpvt = piosh; }
static void twdInitOnce(void *arg) { epicsThreadId tid; tLock = epicsMutexMustCreate(); mLock = epicsMutexMustCreate(); fLock = epicsMutexMustCreate(); ellInit(&fList); VALGRIND_CREATE_MEMPOOL(&fList, 0, 0); twdCtl = twdctlRun; loopEvent = epicsEventMustCreate(epicsEventEmpty); exitEvent = epicsEventMustCreate(epicsEventEmpty); tid = epicsThreadCreate("taskwd", epicsThreadPriorityLow, epicsThreadGetStackSize(epicsThreadStackSmall), twdTask, NULL); if (tid == 0) cantProceed("Failed to spawn task watchdog thread\n"); epicsAtExit(twdShutdown, NULL); }
GPHENTRY * epicsShareAPI gphAdd(gphPvt *pgphPvt, const char *name, void *pvtid) { ELLLIST **paplist; ELLLIST *plist; 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); plist = paplist[hash]; if (plist == NULL) { plist = callocMustSucceed(1, sizeof(ELLLIST), "gphAdd"); ellInit(plist); paplist[hash] = plist; } pgphNode = (GPHENTRY *) ellFirst(plist); while (pgphNode) { if (pvtid == pgphNode->pvtid && strcmp(name, pgphNode->name) == 0) { epicsMutexUnlock(pgphPvt->lock); return NULL; } pgphNode = (GPHENTRY *) ellNext((ELLNODE *)pgphNode); } pgphNode = callocMustSucceed(1, sizeof(GPHENTRY), "gphAdd"); pgphNode->name = name; pgphNode->pvtid = pvtid; ellAdd(plist, (ELLNODE *)pgphNode); epicsMutexUnlock(pgphPvt->lock); return (pgphNode); }
static void substituteOpen(void **ppvt,char *substitutionName) { subInfo *psubInfo; subFile *psubFile; FILE *fp; psubInfo = calloc(1,sizeof(subInfo)); *ppvt = (void *)psubInfo; psubFile = calloc(1,sizeof(subFile)); psubInfo->psubFile = psubFile; ellInit(&psubInfo->patternList); fp = fopen(substitutionName,"r"); if(!fp) { fprintf(stderr,"Could not open %s\n",substitutionName); exit(1); } psubFile->substitutionName = substitutionName; psubFile->fp = fp; psubFile->lineNum = 0; psubFile->inputBuffer[0] = 0; psubFile->pnextChar = &psubFile->inputBuffer[0]; subGetNextToken(psubFile); return; }