496 lines
15 KiB
C
496 lines
15 KiB
C
/*************************************************************************\
|
||
* Copyright (c) 2006 UChicago Argonne LLC, as Operator of Argonne
|
||
* National Laboratory.
|
||
* Copyright (c) 2002 The Regents of the University of California, as
|
||
* Operator of Los Alamos National Laboratory.
|
||
* EPICS BASE is distributed subject to a Software License Agreement found
|
||
* in file LICENSE that is included with this distribution.
|
||
\*************************************************************************/
|
||
/* iocInit.c ioc initialization */
|
||
/* $Id$ */
|
||
/* Author: Marty Kraimer Date: 06-01-91 */
|
||
|
||
|
||
#include <stddef.h>
|
||
#include <stdlib.h>
|
||
#include <stdarg.h>
|
||
#include <stdio.h>
|
||
#include <string.h>
|
||
#include <errno.h>
|
||
|
||
#include "dbDefs.h"
|
||
#include "epicsThread.h"
|
||
#include "epicsPrint.h"
|
||
#include "ellLib.h"
|
||
#include "dbDefs.h"
|
||
#include "dbBase.h"
|
||
#include "caeventmask.h"
|
||
#include "dbAddr.h"
|
||
#include "dbBkpt.h"
|
||
#include "dbFldTypes.h"
|
||
#include "link.h"
|
||
#include "dbLock.h"
|
||
#include "dbAccess.h"
|
||
#include "recGbl.h"
|
||
#include "dbNotify.h"
|
||
#include "dbCa.h"
|
||
#include "dbScan.h"
|
||
#include "taskwd.h"
|
||
#include "callback.h"
|
||
#include "dbCommon.h"
|
||
#include "dbLock.h"
|
||
#include "devSup.h"
|
||
#include "drvSup.h"
|
||
#include "registryRecordType.h"
|
||
#include "registryDeviceSupport.h"
|
||
#include "registryDriverSupport.h"
|
||
#include "errMdef.h"
|
||
#include "recSup.h"
|
||
#include "envDefs.h"
|
||
#include "rsrv.h"
|
||
epicsShareFunc int epicsShareAPI asInit (void);
|
||
#include "dbStaticLib.h"
|
||
#include "db_access_routines.h"
|
||
#include "initHooks.h"
|
||
#include "epicsExit.h"
|
||
#include "epicsSignal.h"
|
||
|
||
#define epicsExportSharedSymbols
|
||
#include "epicsRelease.h"
|
||
#include "iocInit.h"
|
||
|
||
static enum {
|
||
iocVirgin, iocBuilding, iocBuilt, iocRunning, iocPaused, iocStopped
|
||
} iocState = iocVirgin;
|
||
|
||
/* define forward references*/
|
||
static void initDrvSup(void);
|
||
static void initRecSup(void);
|
||
static void initDevSup(void);
|
||
static void finishDevSup(void);
|
||
static void initDatabase(void);
|
||
static void initialProcess(void);
|
||
static void exitDatabase(void *dummy);
|
||
|
||
|
||
/*
|
||
* Initialize EPICS on the IOC.
|
||
*/
|
||
int iocInit(void)
|
||
{
|
||
return iocBuild() || iocRun();
|
||
}
|
||
|
||
int iocBuild(void)
|
||
{
|
||
if (iocState != iocVirgin) {
|
||
errlogPrintf("iocBuild: IOC can only be initialized once\n");
|
||
return -1;
|
||
}
|
||
|
||
if (!epicsThreadIsOkToBlock()) {
|
||
epicsThreadSetOkToBlock(1);
|
||
}
|
||
|
||
errlogPrintf("Starting iocInit\n");
|
||
if (!pdbbase) {
|
||
errlogPrintf("iocBuild: Aborting, no database loaded!\n");
|
||
return -1;
|
||
}
|
||
epicsSignalInstallSigHupIgnore();
|
||
initHooks(initHookAtBeginning);
|
||
|
||
coreRelease();
|
||
/* After this point, further calls to iocInit() are disallowed. */
|
||
iocState = iocBuilding;
|
||
|
||
taskwdInit();
|
||
callbackInit();
|
||
initHooks(initHookAfterCallbackInit);
|
||
|
||
dbCaLinkInit();
|
||
initHooks(initHookAfterCaLinkInit);
|
||
|
||
initDrvSup();
|
||
initHooks(initHookAfterInitDrvSup);
|
||
|
||
initRecSup();
|
||
initHooks(initHookAfterInitRecSup);
|
||
|
||
initDevSup();
|
||
initHooks(initHookAfterInitDevSup);
|
||
|
||
initDatabase();
|
||
dbLockInitRecords(pdbbase);
|
||
dbBkptInit();
|
||
initHooks(initHookAfterInitDatabase);
|
||
|
||
finishDevSup();
|
||
initHooks(initHookAfterFinishDevSup);
|
||
|
||
scanInit();
|
||
if (asInit()) {
|
||
errlogPrintf("iocBuild: asInit Failed.\n");
|
||
return -1;
|
||
}
|
||
dbPutNotifyInit();
|
||
epicsThreadSleep(.5);
|
||
initHooks(initHookAfterScanInit);
|
||
|
||
initialProcess();
|
||
initHooks(initHookAfterInitialProcess);
|
||
|
||
/* Start CA server threads */
|
||
rsrv_init();
|
||
|
||
iocState = iocBuilt;
|
||
return 0;
|
||
}
|
||
|
||
int iocRun(void)
|
||
{
|
||
if (iocState != iocPaused && iocState != iocBuilt) {
|
||
errlogPrintf("iocRun: IOC not paused\n");
|
||
return -1;
|
||
}
|
||
|
||
/* Enable scan tasks and some driver support functions. */
|
||
scanRun();
|
||
dbCaRun();
|
||
interruptAccept = TRUE;
|
||
if (iocState == iocBuilt)
|
||
initHooks(initHookAfterInterruptAccept);
|
||
|
||
rsrv_run();
|
||
if (iocState == iocBuilt)
|
||
initHooks(initHookAtEnd);
|
||
|
||
errlogPrintf("iocRun: %s\n", iocState == iocBuilt ?
|
||
"All initialization complete" :
|
||
"IOC restarted");
|
||
iocState = iocRunning;
|
||
return 0;
|
||
}
|
||
|
||
int iocPause(void)
|
||
{
|
||
if (iocState != iocRunning) {
|
||
errlogPrintf("iocPause: IOC not running\n");
|
||
return -1;
|
||
}
|
||
|
||
rsrv_pause();
|
||
interruptAccept = FALSE;
|
||
dbCaPause();
|
||
scanPause();
|
||
iocState = iocPaused;
|
||
|
||
errlogPrintf("iocPause: IOC suspended\n");
|
||
return 0;
|
||
}
|
||
|
||
|
||
static void initDrvSup(void) /* Locate all driver support entry tables */
|
||
{
|
||
drvSup *pdrvSup;
|
||
struct drvet *pdrvet;
|
||
|
||
for (pdrvSup = (drvSup *)ellFirst(&pdbbase->drvList); pdrvSup;
|
||
pdrvSup = (drvSup *)ellNext(&pdrvSup->node)) {
|
||
pdrvet = registryDriverSupportFind(pdrvSup->name);
|
||
if (!pdrvet) {
|
||
errlogPrintf("iocInit: driver %s not found\n", pdrvSup->name);
|
||
continue;
|
||
}
|
||
pdrvSup->pdrvet = pdrvet;
|
||
/*
|
||
* If an initialization routine is defined (not NULL),
|
||
* for the driver support call it.
|
||
*/
|
||
if (pdrvet->init) {
|
||
pdrvet->init();
|
||
}
|
||
}
|
||
}
|
||
|
||
static void initRecSup(void)
|
||
{
|
||
dbRecordType *pdbRecordType;
|
||
recordTypeLocation *precordTypeLocation;
|
||
struct rset *prset;
|
||
|
||
for (pdbRecordType = (dbRecordType *)ellFirst(&pdbbase->recordTypeList);
|
||
pdbRecordType;
|
||
pdbRecordType = (dbRecordType *)ellNext(&pdbRecordType->node)) {
|
||
precordTypeLocation = registryRecordTypeFind(pdbRecordType->name);
|
||
if (!precordTypeLocation) {
|
||
errlogPrintf("iocInit record support for %s not found\n",
|
||
pdbRecordType->name);
|
||
continue;
|
||
}
|
||
prset = precordTypeLocation->prset;
|
||
pdbRecordType->prset = prset;
|
||
if (prset->init) {
|
||
prset->init();
|
||
}
|
||
}
|
||
}
|
||
|
||
static long do_nothing(struct dbCommon *precord) { return 0; }
|
||
|
||
/* Dummy DSXT used for soft device supports */
|
||
struct dsxt devSoft_DSXT = {
|
||
do_nothing,
|
||
do_nothing
|
||
};
|
||
|
||
static devSup *pthisDevSup = NULL;
|
||
|
||
static void initDevSup(void)
|
||
{
|
||
dbRecordType *pdbRecordType;
|
||
struct dset *pdset;
|
||
|
||
for (pdbRecordType = (dbRecordType *)ellFirst(&pdbbase->recordTypeList);
|
||
pdbRecordType;
|
||
pdbRecordType = (dbRecordType *)ellNext(&pdbRecordType->node)) {
|
||
for (pthisDevSup = (devSup *)ellFirst(&pdbRecordType->devList);
|
||
pthisDevSup;
|
||
pthisDevSup = (devSup *)ellNext(&pthisDevSup->node)) {
|
||
pdset = registryDeviceSupportFind(pthisDevSup->name);
|
||
if (!pdset) {
|
||
errlogPrintf("device support %s not found\n",pthisDevSup->name);
|
||
continue;
|
||
}
|
||
if (pthisDevSup->link_type == CONSTANT)
|
||
pthisDevSup->pdsxt = &devSoft_DSXT;
|
||
pthisDevSup->pdset = pdset;
|
||
if (pdset->init) {
|
||
pdset->init(0);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
epicsShareFunc void devExtend(dsxt *pdsxt)
|
||
{
|
||
if (!pthisDevSup)
|
||
errlogPrintf("devExtend() called outside of initDevSup()\n");
|
||
else {
|
||
pthisDevSup->pdsxt = pdsxt;
|
||
}
|
||
}
|
||
|
||
static void finishDevSup(void)
|
||
{
|
||
dbRecordType *pdbRecordType;
|
||
struct dset *pdset;
|
||
|
||
for (pdbRecordType = (dbRecordType *)ellFirst(&pdbbase->recordTypeList);
|
||
pdbRecordType;
|
||
pdbRecordType = (dbRecordType *)ellNext(&pdbRecordType->node)) {
|
||
for (pthisDevSup = (devSup *)ellFirst(&pdbRecordType->devList);
|
||
pthisDevSup;
|
||
pthisDevSup = (devSup *)ellNext(&pthisDevSup->node)) {
|
||
pdset = pthisDevSup->pdset;
|
||
if (pdset && pdset->init) {
|
||
pdset->init(1);
|
||
}
|
||
}
|
||
|
||
}
|
||
}
|
||
|
||
static void initDatabase(void)
|
||
{
|
||
dbRecordType *pdbRecordType;
|
||
dbFldDes *pdbFldDes;
|
||
dbRecordNode *pdbRecordNode;
|
||
devSup *pdevSup;
|
||
struct rset *prset;
|
||
struct dset *pdset;
|
||
dbCommon *precord;
|
||
DBADDR dbaddr;
|
||
DBLINK *plink;
|
||
int j;
|
||
|
||
for (pdbRecordType = (dbRecordType *)ellFirst(&pdbbase->recordTypeList);
|
||
pdbRecordType;
|
||
pdbRecordType = (dbRecordType *)ellNext(&pdbRecordType->node)) {
|
||
prset = pdbRecordType->prset;
|
||
for (pdbRecordNode = (dbRecordNode *)ellFirst(&pdbRecordType->recList);
|
||
pdbRecordNode;
|
||
pdbRecordNode = (dbRecordNode *)ellNext(&pdbRecordNode->node)) {
|
||
if (!prset) break;
|
||
|
||
/* Find pointer to record instance */
|
||
precord = pdbRecordNode->precord;
|
||
if (!precord->name[0]) continue;
|
||
|
||
precord->rset = prset;
|
||
precord->rdes = pdbRecordType;
|
||
precord->mlok = epicsMutexMustCreate();
|
||
ellInit(&precord->mlis);
|
||
|
||
/* Reset the process active field */
|
||
precord->pact = FALSE;
|
||
|
||
/* Init DSET NOTE that result may be NULL */
|
||
pdevSup = dbDTYPtoDevSup(pdbRecordType, precord->dtyp);
|
||
pdset = pdevSup ? pdevSup->pdset : NULL;
|
||
precord->dset = pdset;
|
||
if (prset->init_record) {
|
||
prset->init_record(precord, 0);
|
||
}
|
||
}
|
||
}
|
||
|
||
/* Second pass to resolve links */
|
||
for (pdbRecordType = (dbRecordType *)ellFirst(&pdbbase->recordTypeList);
|
||
pdbRecordType;
|
||
pdbRecordType = (dbRecordType *)ellNext(&pdbRecordType->node)) {
|
||
prset = pdbRecordType->prset;
|
||
for (pdbRecordNode=(dbRecordNode *)ellFirst(&pdbRecordType->recList);
|
||
pdbRecordNode;
|
||
pdbRecordNode = (dbRecordNode *)ellNext(&pdbRecordNode->node)) {
|
||
precord = pdbRecordNode->precord;
|
||
if (!precord->name[0]) continue;
|
||
/* Convert all PV_LINKs to DB_LINKs or CA_LINKs */
|
||
/* For all the links in the record type... */
|
||
for (j = 0; j < pdbRecordType->no_links; j++) {
|
||
pdbFldDes = pdbRecordType->papFldDes[pdbRecordType->link_ind[j]];
|
||
plink = (DBLINK *)((char *)precord + pdbFldDes->offset);
|
||
if (plink->type == PV_LINK) {
|
||
if (plink == &precord->tsel) recGblTSELwasModified(plink);
|
||
if (!(plink->value.pv_link.pvlMask&(pvlOptCA|pvlOptCP|pvlOptCPP))
|
||
&& (dbNameToAddr(plink->value.pv_link.pvname,&dbaddr)==0)) {
|
||
DBADDR *pdbAddr;
|
||
|
||
plink->type = DB_LINK;
|
||
pdbAddr = dbCalloc(1,sizeof(struct dbAddr));
|
||
*pdbAddr = dbaddr; /*structure copy*/;
|
||
plink->value.pv_link.pvt = pdbAddr;
|
||
} else {/*It is a CA link*/
|
||
char *pperiod;
|
||
|
||
if (pdbFldDes->field_type==DBF_INLINK) {
|
||
plink->value.pv_link.pvlMask |= pvlOptInpNative;
|
||
}
|
||
dbCaAddLink(plink);
|
||
if (pdbFldDes->field_type==DBF_FWDLINK) {
|
||
pperiod = strrchr(plink->value.pv_link.pvname,'.');
|
||
if (pperiod && strstr(pperiod,"PROC")) {
|
||
plink->value.pv_link.pvlMask |= pvlOptFWD;
|
||
} else {
|
||
errlogPrintf("%s.FLNK is a Channel Access Link "
|
||
" but does not access field PROC\n",
|
||
precord->name);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
pdevSup = dbDTYPtoDevSup(pdbRecordType, precord->dtyp);
|
||
if (pdevSup) {
|
||
struct dsxt *pdsxt = pdevSup->pdsxt;
|
||
if (pdsxt && pdsxt->add_record) {
|
||
pdsxt->add_record(precord);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
/* Call record support init_record routine - Second pass */
|
||
for (pdbRecordType = (dbRecordType *)ellFirst(&pdbbase->recordTypeList);
|
||
pdbRecordType;
|
||
pdbRecordType = (dbRecordType *)ellNext(&pdbRecordType->node)) {
|
||
prset = pdbRecordType->prset;
|
||
for (pdbRecordNode=(dbRecordNode *)ellFirst(&pdbRecordType->recList);
|
||
pdbRecordNode;
|
||
pdbRecordNode = (dbRecordNode *)ellNext(&pdbRecordNode->node)) {
|
||
if (!prset) break;
|
||
|
||
/* Find pointer to record instance */
|
||
precord = pdbRecordNode->precord;
|
||
if (!precord->name[0]) continue;
|
||
precord->rset = prset;
|
||
if (prset->init_record) {
|
||
prset->init_record(precord, 1);
|
||
}
|
||
}
|
||
}
|
||
epicsAtExit(exitDatabase, NULL);
|
||
return;
|
||
}
|
||
|
||
/*
|
||
* Process database records at initialization if
|
||
* their pini (process at init) field is set.
|
||
*/
|
||
static void initialProcess(void)
|
||
{
|
||
dbRecordType *pdbRecordType;
|
||
dbRecordNode *pdbRecordNode;
|
||
dbCommon *precord;
|
||
|
||
for (pdbRecordType = (dbRecordType *)ellFirst(&pdbbase->recordTypeList);
|
||
pdbRecordType;
|
||
pdbRecordType = (dbRecordType *)ellNext(&pdbRecordType->node)) {
|
||
for (pdbRecordNode = (dbRecordNode *)ellFirst(&pdbRecordType->recList);
|
||
pdbRecordNode;
|
||
pdbRecordNode = (dbRecordNode *)ellNext(&pdbRecordNode->node)) {
|
||
precord = pdbRecordNode->precord;
|
||
if (!precord->name[0]) continue;
|
||
if (precord->pini) {
|
||
dbProcess(precord);
|
||
}
|
||
}
|
||
}
|
||
return;
|
||
}
|
||
|
||
|
||
static void exitDatabase(void *dummy)
|
||
{
|
||
dbRecordType *pdbRecordType;
|
||
struct rset *prset;
|
||
dbRecordNode *pdbRecordNode;
|
||
dbCommon *precord;
|
||
dbFldDes *pdbFldDes;
|
||
devSup *pdevSup;
|
||
struct dsxt *pdsxt;
|
||
DBLINK *plink;
|
||
int j;
|
||
|
||
scanPause();
|
||
interruptAccept = FALSE;
|
||
|
||
for (pdbRecordType = (dbRecordType *)ellFirst(&pdbbase->recordTypeList);
|
||
pdbRecordType;
|
||
pdbRecordType = (dbRecordType *)ellNext(&pdbRecordType->node)) {
|
||
prset = pdbRecordType->prset;
|
||
for (pdbRecordNode=(dbRecordNode *)ellFirst(&pdbRecordType->recList);
|
||
pdbRecordNode;
|
||
pdbRecordNode = (dbRecordNode *)ellNext(&pdbRecordNode->node)) {
|
||
precord = pdbRecordNode->precord;
|
||
if (!precord->name[0]) continue;
|
||
/* For all the links in the record type... */
|
||
for (j = 0; j < pdbRecordType->no_links; j++) {
|
||
pdbFldDes = pdbRecordType->papFldDes[pdbRecordType->link_ind[j]];
|
||
plink = (DBLINK *)((char *)precord + pdbFldDes->offset);
|
||
if (plink->type == CA_LINK) {
|
||
dbCaRemoveLink(plink);
|
||
}
|
||
}
|
||
if (precord->dset &&
|
||
(pdevSup = dbDSETtoDevSup(pdbRecordType, precord->dset)) &&
|
||
(pdsxt = pdevSup->pdsxt) &&
|
||
pdsxt->del_record) {
|
||
pdsxt->del_record(precord);
|
||
}
|
||
}
|
||
}
|
||
|
||
iocState = iocStopped;
|
||
}
|