817 lines
25 KiB
C
817 lines
25 KiB
C
/* iocInit.c ioc initialization */
|
||
/* share/src/db $Id$ */
|
||
/*
|
||
* Author: Marty Kraimer
|
||
* Date: 06-01-91
|
||
*
|
||
* Experimental Physics and Industrial Control System (EPICS)
|
||
*
|
||
* Copyright 1991, the Regents of the University of California,
|
||
* and the University of Chicago Board of Governors.
|
||
*
|
||
* This software was produced under U.S. Government contracts:
|
||
* (W-7405-ENG-36) at the Los Alamos National Laboratory,
|
||
* and (W-31-109-ENG-38) at Argonne National Laboratory.
|
||
*
|
||
* Initial development by:
|
||
* The Controls and Automation Group (AT-8)
|
||
* Ground Test Accelerator
|
||
* Accelerator Technology Division
|
||
* Los Alamos National Laboratory
|
||
*
|
||
* Co-developed with
|
||
* The Controls and Computing Group
|
||
* Accelerator Systems Division
|
||
* Advanced Photon Source
|
||
* Argonne National Laboratory
|
||
*
|
||
* Modification Log:
|
||
* -----------------
|
||
* .01 07-20-91 rac print release data; set env params
|
||
* .02 08-06-91 mrk parm string length test changed to warning
|
||
* .03 08-09-91 joh added ioc log client init
|
||
* .04 09-10-91 joh moved VME stuff from here to initVme()
|
||
* .05 09-10-91 joh printf() -> logMsg()
|
||
* .06 09-10-91 joh print message only on failure
|
||
* .07 08-30-91 rcz completed .02 fix
|
||
* .08 10-10-91 rcz changed getResources to accomodate EPICS_
|
||
* parameters in a structure (first try)
|
||
* .09 12-02-91 mrk Added finishDevSup
|
||
* .10 02-10-92 jba Changed error messages
|
||
* .11 02-28-92 jba ANSI C changes
|
||
* .12 03-26-92 mrk changed test if(status) to if(rtnval)
|
||
* .13 04-17-92 rcz changed sdrLoad to dbRead
|
||
* .14 04-17-92 mrk Added wait before interruptAccept
|
||
* .15 05-17-92 rcz moved sdrSum stuff to dbReadWrite.c
|
||
* .16 05-19-92 mrk Changes for internal database structure changes
|
||
* .17 06-16-92 jba Added prset test to call of init_record second time loop
|
||
* .18 07-31-92 rcz moved database loading to function dbLoad
|
||
*
|
||
*/
|
||
|
||
#include <vxWorks.h>
|
||
#include <types.h>
|
||
#include <memLib.h>
|
||
#include <lstLib.h>
|
||
#include <sysLib.h>
|
||
#include <symLib.h>
|
||
#include <sysSymTbl.h> /* for sysSymTbl*/
|
||
#include <a_out.h> /* for N_TEXT */
|
||
#include <stdarg.h>
|
||
#include <stdioLib.h>
|
||
#include <string.h>
|
||
#include <logLib.h>
|
||
|
||
#include <sdrHeader.h>
|
||
#include <fast_lock.h>
|
||
#include <choice.h>
|
||
#include <dbDefs.h>
|
||
#include <dbAccess.h>
|
||
#include <dbScan.h>
|
||
#include <taskwd.h>
|
||
#include <callback.h>
|
||
#include <dbCommon.h>
|
||
#include <dbBase.h>
|
||
#include <dbFldTypes.h>
|
||
#include <dbRecDes.h>
|
||
#include <dbRecType.h>
|
||
#include <dbRecords.h>
|
||
#include <devSup.h>
|
||
#include <drvSup.h>
|
||
#include <errMdef.h>
|
||
#include <recSup.h>
|
||
#include <envDefs.h>
|
||
#include <dbManipulate.h>
|
||
/*This module will declare and initilize module_type variables*/
|
||
#define MODULE_TYPES_INIT 1
|
||
#include <module_types.h>
|
||
|
||
static initialized=FALSE;
|
||
|
||
/* The following is for use by interrupt routines */
|
||
int interruptAccept=FALSE;
|
||
extern short wakeup_init; /*old IO_EVENT_SCAN*/
|
||
|
||
struct dbBase *pdbBase=NULL;
|
||
|
||
/* added for Channel Access Links */
|
||
long dbCommonInit();
|
||
|
||
/* define forward references*/
|
||
extern long dbRead();
|
||
long initDrvSup();
|
||
long initRecSup();
|
||
long initDevSup();
|
||
long finishDevSup();
|
||
long initDatabase();
|
||
long addToSet();
|
||
long initialProcess();
|
||
long getResources();
|
||
|
||
int iocInit(pResourceFilename)
|
||
char * pResourceFilename;
|
||
{
|
||
long status;
|
||
char name[40];
|
||
long rtnval;
|
||
void (*pdbUserExit)();
|
||
SYM_TYPE type;
|
||
|
||
if(initialized) {
|
||
logMsg("iocInit can only be called once\n");
|
||
return(-1);
|
||
}
|
||
coreRelease();
|
||
epicsSetEnvParams();
|
||
|
||
if (!pdbBase) {
|
||
logMsg("iocInit aborting because No database loaded by dbLoad\n");
|
||
return(-1);
|
||
}
|
||
status=getResources(pResourceFilename);
|
||
if(status!=0) {
|
||
logMsg("iocInit aborting because getResources failed\n");
|
||
return(-1);
|
||
}
|
||
status = iocLogInit();
|
||
if(status!=0){
|
||
logMsg("iocInit Failed to Initialize Ioc Log Client \n");
|
||
}
|
||
initialized = TRUE;
|
||
taskwdInit();
|
||
|
||
/* added for Channel Access Links */
|
||
dbCaLinkInit((int) 1);
|
||
|
||
if(initDrvSup()!=0) logMsg("iocInit: Drivers Failed during Initialization\n");
|
||
if(initRecSup()!=0) logMsg("iocInit: Record Support Failed during Initialization\n");
|
||
if(initDevSup()!=0) logMsg("iocInit: Device Support Failed during Initialization\n");
|
||
ts_init();
|
||
if(initDatabase()!=0) logMsg("iocInit: Database Failed during Initialization\n");
|
||
/* added for Channel Access Links */
|
||
dbCaLinkInit((int) 2);
|
||
|
||
if(finishDevSup()!=0) logMsg("iocInit: Device Support Failed during Finalization\n");
|
||
|
||
/* if user exit exists call it */
|
||
strcpy(name,"_");
|
||
strcat(name,"dbUserExit");
|
||
rtnval = symFindByName(sysSymTbl,name,(void *)&pdbUserExit,&type);
|
||
if(rtnval==OK && (type&N_TEXT!=0)) {
|
||
(*pdbUserExit)();
|
||
logMsg("User Exit was called\n");
|
||
}
|
||
callbackInit();
|
||
scanInit();
|
||
/* wait 1/2 second to make sure all tasks are started*/
|
||
(void)taskDelay(sysClkRateGet()/2);
|
||
interruptAccept=TRUE;
|
||
wakeup_init=TRUE; /*old IO_EVENT_SCAN*/
|
||
if(initialProcess()!=0) logMsg("iocInit: initialProcess Failed\n");
|
||
rsrv_init();
|
||
logMsg("iocInit: All initialization complete\n");
|
||
|
||
return(0);
|
||
}
|
||
|
||
static long initDrvSup() /* Locate all driver support entry tables */
|
||
{
|
||
char *pname;
|
||
char name[40];
|
||
int i;
|
||
SYM_TYPE type;
|
||
char message[100];
|
||
long status=0;
|
||
long rtnval;
|
||
STATUS vxstatus;
|
||
struct drvSup *pdrvSup;
|
||
|
||
if(!(pdrvSup=pdbBase->pdrvSup)) {
|
||
status = S_drv_noDrvSup;
|
||
errMessage(status,"No device drivers are defined");
|
||
return(status);
|
||
}
|
||
for(i=0; i< (pdrvSup->number); i++) {
|
||
if(!(pname = pdrvSup->papDrvName[i])) continue;
|
||
strcpy(name,"_");
|
||
strcat(name,pname);
|
||
vxstatus = symFindByName(sysSymTbl,name,(void *)&(pdrvSup->papDrvet[i]),&type);
|
||
if( vxstatus!=OK || ( type&N_TEXT == 0) ) {
|
||
strcpy(message,"driver entry table not found for ");
|
||
strcat(message,pname);
|
||
status = S_drv_noDrvet;
|
||
errMessage(status,message);
|
||
continue;
|
||
}
|
||
if(!(pdrvSup->papDrvet[i]->init)) continue;
|
||
rtnval = (*(pdrvSup->papDrvet[i]->init))();
|
||
if(status==0) status = rtnval;
|
||
}
|
||
return(status);
|
||
}
|
||
|
||
static long initRecSup()
|
||
{
|
||
char name[40];
|
||
int i;
|
||
SYM_TYPE type;
|
||
char message[100];
|
||
long status=0;
|
||
long rtnval;
|
||
STATUS vxstatus;
|
||
int nbytes;
|
||
struct recType *precType;
|
||
struct recSup *precSup;
|
||
|
||
if(!(precType=pdbBase->precType)) {
|
||
status = S_rectype_noRecs;
|
||
errMessage(status,"No record types defined");
|
||
return(status);
|
||
}
|
||
nbytes = sizeof(struct recSup) + precType->number*sizeof(void *);
|
||
if(!(precSup = calloc(1,nbytes))) {
|
||
errMessage(0,"Could not allocate structures for record support");
|
||
return(-1);
|
||
}
|
||
pdbBase->precSup = precSup;
|
||
precSup->number = precType->number;
|
||
precSup->papRset = (void *)((long)precSup + (long)sizeof(struct recSup));
|
||
for(i=0; i< (precSup->number); i++) {
|
||
if(precType->papName[i] == NULL)continue;
|
||
strcpy(name,"_");
|
||
strcat(name,precType->papName[i]);
|
||
strcat(name,"RSET");
|
||
vxstatus = symFindByName(sysSymTbl,name,
|
||
(void *)(&precSup->papRset[i]),&type);
|
||
if( vxstatus!=OK || ( type&N_TEXT == 0) ) {
|
||
strcpy(message,"record support entry table not found for ");
|
||
strcat(message,name);
|
||
status = S_rec_noRSET;
|
||
errMessage(status,message);
|
||
continue;
|
||
}
|
||
if(!(precSup->papRset[i]->init)) continue;
|
||
else {
|
||
rtnval = (*(precSup->papRset[i]->init))();
|
||
if(status==0) status = rtnval;
|
||
}
|
||
}
|
||
|
||
return(status);
|
||
}
|
||
|
||
static long initDevSup() /* Locate all device support entry tables */
|
||
{
|
||
char *pname;
|
||
char name[40];
|
||
int i,j;
|
||
SYM_TYPE type;
|
||
char message[100];
|
||
long status=0;
|
||
long rtnval;
|
||
STATUS vxstatus;
|
||
struct recDevSup *precDevSup;
|
||
struct devSup *pdevSup;
|
||
|
||
if(!(precDevSup=pdbBase->precDevSup)) {
|
||
status = S_dev_noDevSup;
|
||
errMessage(status,"No device support is defined");
|
||
return(status);
|
||
}
|
||
for(i=0; i< (precDevSup->number); i++) {
|
||
if((pdevSup = precDevSup->papDevSup[i]) == NULL) continue;
|
||
for(j=0; j < (pdevSup->number); j++) {
|
||
if(!(pname = pdevSup->papDsetName[j])) continue;
|
||
strcpy(name,"_");
|
||
strcat(name,pname);
|
||
vxstatus = (long)symFindByName(sysSymTbl,name,
|
||
(void *)&(pdevSup->papDset[j]),&type);
|
||
if( vxstatus!=OK || ( type&N_TEXT == 0) ) {
|
||
pdevSup->papDset[j]=NULL;
|
||
strcpy(message,"device support entry table not found for ");
|
||
strcat(message,pname);
|
||
status = S_dev_noDSET;
|
||
errMessage(status,message);
|
||
continue;
|
||
}
|
||
if(!(pdevSup->papDset[j]->init)) continue;
|
||
rtnval = (*(pdevSup->papDset[j]->init))(0);
|
||
if(status==0) status = rtnval;
|
||
}
|
||
}
|
||
return(status);
|
||
}
|
||
|
||
static long finishDevSup()
|
||
{
|
||
int i,j;
|
||
struct recDevSup *precDevSup;
|
||
struct devSup *pdevSup;
|
||
|
||
if(!(precDevSup=pdbBase->precDevSup)) return(0);
|
||
for(i=0; i< (precDevSup->number); i++) {
|
||
if((pdevSup = precDevSup->papDevSup[i]) == NULL) continue;
|
||
for(j=0; j < (pdevSup->number); j++) {
|
||
if(!(pdevSup->papDset[j])) continue;
|
||
if(!(pdevSup->papDset[j]->init)) continue;
|
||
(*(pdevSup->papDset[j]->init))(1);
|
||
}
|
||
|
||
}
|
||
return(0);
|
||
}
|
||
|
||
|
||
static long initDatabase()
|
||
{
|
||
char name[PVNAME_SZ+FLDNAME_SZ+2];
|
||
short i,j;
|
||
char message[120];
|
||
long status=0;
|
||
long rtnval=0;
|
||
short nset=0;
|
||
short lookAhead;
|
||
struct recLoc *precLoc;
|
||
struct rset *prset;
|
||
struct recDes *precDes;
|
||
struct recTypDes *precTypDes;
|
||
struct recHeader *precHeader;
|
||
RECNODE *precNode;
|
||
struct fldDes *pfldDes;
|
||
struct dbCommon *precord;
|
||
struct dbAddr dbAddr;
|
||
struct link *plink;
|
||
struct devSup *pdevSup;
|
||
struct recSup *precSup;
|
||
struct recType *precType;
|
||
|
||
if(!(precType=pdbBase->precType)) return(0);
|
||
if(!(precSup=pdbBase->precSup)) return(0);
|
||
if(!(precHeader = pdbBase->precHeader)) {
|
||
status = S_record_noRecords;
|
||
errMessage(status,"No database records are defined");
|
||
return(status);
|
||
}
|
||
if(!(precDes = pdbBase->precDes)) {
|
||
status = S_record_noRecords;
|
||
errMessage(status,"Database record descriptions were not defined");
|
||
return(status);
|
||
}
|
||
for(i=0; i< (precHeader->number); i++) {
|
||
if(!(precLoc = precHeader->papRecLoc[i]))continue;
|
||
if(!(prset=GET_PRSET(precSup,i))) {
|
||
strcpy(name,precType->papName[i]);
|
||
strcat(name,"RSET");
|
||
strcpy(message,"record support entry table not found for ");
|
||
strcat(message,name);
|
||
status = S_rec_noRSET;
|
||
errMessage(status,message);
|
||
continue;
|
||
}
|
||
precTypDes = precDes->papRecTypDes[i];
|
||
pdevSup = GET_PDEVSUP(pdbBase->precDevSup,i);
|
||
for(precNode=(RECNODE *)lstFirst(precLoc->preclist);
|
||
precNode; precNode = (RECNODE *)lstNext(&precNode->next)) {
|
||
precord = precNode->precord;
|
||
/* If NAME is null then skip this record*/
|
||
if(!(precord->name[0])) continue;
|
||
/*initialize fields rset*/
|
||
(struct rset *)(precord->rset) = prset;
|
||
/* initialize mlok and mlis*/
|
||
FASTLOCKINIT(&precord->mlok);
|
||
lstInit(&(precord->mlis));
|
||
precord->pact=FALSE;
|
||
/* set lset=0 See determine lock set below*/
|
||
precord->lset = 0;
|
||
/* Init DSET NOTE that result may be NULL*/
|
||
precord->dset=(struct dset *)GET_PDSET(pdevSup,precord->dtyp);
|
||
/* call record support init_record routine - First pass */
|
||
rtnval = dbCommonInit(precord,0);
|
||
if(!(precSup->papRset[i]->init_record)) continue;
|
||
rtnval = (*(precSup->papRset[i]->init_record))(precord,0);
|
||
if(status==0) status = rtnval;
|
||
}
|
||
}
|
||
/* Second pass to resolve links*/
|
||
for(i=0; i< (precHeader->number); i++) {
|
||
if(!(precLoc = precHeader->papRecLoc[i]))continue;
|
||
precTypDes = precDes->papRecTypDes[i];
|
||
for(precNode=(RECNODE *)lstFirst(precLoc->preclist);
|
||
precNode; precNode = (RECNODE *)lstNext(&precNode->next)) {
|
||
precord = precNode->precord;
|
||
/* If NAME is null then skip this record*/
|
||
if(!(precord->name[0])) continue;
|
||
/* Convert all PV_LINKs to DB_LINKs or CA_LINKs*/
|
||
for(j=0; j<precTypDes->no_links; j++) {
|
||
pfldDes = precTypDes->papFldDes[precTypDes->link_ind[j]];
|
||
plink = (struct link *)((char *)precord + pfldDes->offset);
|
||
if(plink->type == PV_LINK) {
|
||
strncpy(name,plink->value.pv_link.pvname,PVNAME_SZ);
|
||
name[PVNAME_SZ]=0;
|
||
strcat(name,".");
|
||
strncat(name,plink->value.pv_link.fldname,FLDNAME_SZ);
|
||
if(dbNameToAddr(name,&dbAddr) == 0) {
|
||
/* show that refered to record has link. */
|
||
/* See determine lock set below.*/
|
||
if( pfldDes->field_type!=DBF_INLINK
|
||
|| plink->value.pv_link.process_passive
|
||
|| dbAddr.no_elements>1 )
|
||
((struct dbCommon *)(dbAddr.precord))->lset= -1;
|
||
plink->type = DB_LINK;
|
||
plink->value.db_link.pdbAddr =
|
||
calloc(1,sizeof(struct dbAddr));
|
||
*((struct dbAddr *)(plink->value.db_link.pdbAddr))=dbAddr;
|
||
}
|
||
else {
|
||
/* not a local pvar ... assuming a CA_LINK */
|
||
/* only supporting NPP, Input MS/NMS, and */
|
||
/* Output NMS links ... checking here. */
|
||
|
||
if (plink->value.db_link.process_passive
|
||
|| (pfldDes->field_type == DBF_OUTLINK
|
||
&& plink->value.db_link.maximize_sevr))
|
||
{
|
||
/* link PP and/or Outlink MS ... */
|
||
/* neither supported under CA_LINKs */
|
||
strncpy(message,precord->name,PVNAME_SZ);
|
||
message[PVNAME_SZ]=0;
|
||
strcat(message,".");
|
||
strncat(message,pfldDes->fldname,FLDNAME_SZ);
|
||
strcat(message,": link process variable =");
|
||
strcat(message,name);
|
||
strcat(message," not found");
|
||
status = S_db_notFound;
|
||
errMessage(status,message);
|
||
if(rtnval==OK) rtnval=status;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
/* Call init_record for second time */
|
||
for(i=0; i< (precHeader->number); i++) {
|
||
if(!(precLoc = precHeader->papRecLoc[i]))continue;
|
||
if(!(prset=GET_PRSET(precSup,i))) continue;
|
||
precTypDes = precDes->papRecTypDes[i];
|
||
for(precNode=(RECNODE *)lstFirst(precLoc->preclist);
|
||
precNode; precNode = (RECNODE *)lstNext(&precNode->next)) {
|
||
precord = precNode->precord;
|
||
/* If NAME is null then skip this record*/
|
||
if(!(precord->name[0])) continue;
|
||
rtnval = dbCommonInit(precord,1);
|
||
if(status==0) status = rtnval;
|
||
/* call record support init_record routine - Second pass */
|
||
if(!(precSup->papRset[i]->init_record)) continue;
|
||
rtnval = (*(precSup->papRset[i]->init_record))(precord,1);
|
||
if(status==0) status = rtnval;
|
||
}
|
||
}
|
||
|
||
/* Now determine lock sets*/
|
||
/* When each record is examined lset has one of the following values
|
||
* -1 Record is not in a set and at least one following record refers
|
||
* to this record unless INLINK && no_elements<=1 && !process_passive
|
||
* 0 record is not in a set and no following records refer to it.
|
||
* >0 Record is already in a set
|
||
*/
|
||
for(i=0; i<precHeader->number; i++) {
|
||
if(!(precLoc = precHeader->papRecLoc[i]))continue;
|
||
precTypDes = precDes->papRecTypDes[i];
|
||
for(precNode=(RECNODE *)lstFirst(precLoc->preclist);
|
||
precNode; precNode = (RECNODE *)lstNext(&precNode->next)) {
|
||
precord = precNode->precord;
|
||
/* If NAME is null then skip this record*/
|
||
if(!(precord->name[0])) continue;
|
||
if(precord->lset > 0) continue; /*already in a lock set */
|
||
lookAhead = ( (precord->lset == -1) ? TRUE : FALSE);
|
||
nset++;
|
||
rtnval = addToSet(precord,i,lookAhead,i,precNode,nset);
|
||
if(status==0) status=rtnval;
|
||
if(rtnval) return(status); /*I really mean rtnval*/
|
||
}
|
||
}
|
||
dbScanLockInit(nset);
|
||
return(status);
|
||
}
|
||
|
||
static long addToSet(precord,record_type,lookAhead,i,prootNode,lset)
|
||
struct dbCommon *precord; /* record being added to lock set*/
|
||
short record_type; /* record being added to lock set*/
|
||
short lookAhead; /*should following records be checked*/
|
||
short i; /*record before 1st following: index into papRecLoc*/
|
||
RECNODE *prootNode; /*precNode before 1st following */
|
||
short lset; /* current lock set */
|
||
{
|
||
short k,in;
|
||
long status;
|
||
struct fldDes *pfldDes;
|
||
struct link *plink;
|
||
struct recTypDes *precTypDes;
|
||
struct recHeader *precHeader;
|
||
struct recDes *precDes;
|
||
struct recLoc *precLoc;
|
||
RECNODE *precNode;
|
||
|
||
if(!(precDes = pdbBase->precDes)) return(0);
|
||
if(precord->lset > 0) {
|
||
status = S_db_lsetLogic;
|
||
errMessage(status,"Logic Error in iocInit(addToSet)");
|
||
return(status);
|
||
}
|
||
precord->lset = lset;
|
||
/* add all DB_LINKs in this record to the set */
|
||
/* unless not process_passive or no_elements>1*/
|
||
precTypDes = precDes->papRecTypDes[record_type];
|
||
for(k=0; k<precTypDes->no_links; k++) {
|
||
struct dbAddr *pdbAddr;
|
||
struct dbCommon *pk;
|
||
|
||
pfldDes = precTypDes->papFldDes[precTypDes->link_ind[k]];
|
||
plink = (struct link *)((char *)precord + pfldDes->offset);
|
||
if(plink->type != DB_LINK) continue;
|
||
pdbAddr = (struct dbAddr *)(plink->value.db_link.pdbAddr);
|
||
if( pfldDes->field_type==DBF_INLINK
|
||
&& !(plink->value.db_link.process_passive)
|
||
&& pdbAddr->no_elements<=1) continue;
|
||
pk = (struct dbCommon *)(pdbAddr->precord);
|
||
if(pk->lset > 0){
|
||
if(pk->lset == lset) continue; /*already in lock set*/
|
||
status = S_db_lsetLogic;
|
||
errMessage(status,"Logic Error in iocInit(addToSet)");
|
||
return(status);
|
||
}
|
||
status = addToSet(pk,pdbAddr->record_type,TRUE,i,prootNode,lset);
|
||
if(status) return(status);
|
||
}
|
||
/* Now look for all later records that refer to this record*/
|
||
/* unless not process_passive or no_elements>1*/
|
||
/* remember that all earlier records already have lock set determined*/
|
||
if(!lookAhead) return(0);
|
||
precNode = (RECNODE *)lstNext(&prootNode->next);
|
||
if(!(precHeader = pdbBase->precHeader)) return(0);
|
||
for(in=i; in<precHeader->number; in++) {
|
||
struct dbCommon *pn;
|
||
|
||
if(!(precLoc = precHeader->papRecLoc[in])) continue;
|
||
precTypDes = precDes->papRecTypDes[in];
|
||
if(!precNode) precNode = (RECNODE *)lstFirst(precLoc->preclist);
|
||
while(precNode) {
|
||
pn = precNode->precord;
|
||
/* If NAME is null then skip this record*/
|
||
if(!(pn->name[0])) continue;
|
||
for(k=0; k<precTypDes->no_links; k++) {
|
||
struct dbAddr *pdbAddr;
|
||
struct dbCommon *pk;
|
||
|
||
pfldDes = precTypDes->papFldDes[precTypDes->link_ind[k]];
|
||
plink = (struct link *)((char *)pn + pfldDes->offset);
|
||
if(plink->type != DB_LINK) continue;
|
||
pdbAddr = (struct dbAddr *)(plink->value.db_link.pdbAddr);
|
||
if( pfldDes->field_type==DBF_INLINK
|
||
&& !(plink->value.db_link.process_passive)
|
||
&& pdbAddr->no_elements<=1 ) continue;
|
||
pk = (struct dbCommon *)(pdbAddr->precord);
|
||
if(pk != precord) continue;
|
||
if(pn->lset > 0) {
|
||
if(pn->lset == lset) continue;
|
||
status = S_db_lsetLogic;
|
||
errMessage(status,"Logic Error in iocInit(addToSet)");
|
||
return(status);
|
||
}
|
||
status = addToSet(pn,in,TRUE,i,prootNode,lset);
|
||
if(status) return(status);
|
||
}
|
||
precNode = (RECNODE *)lstNext(&precNode->next);
|
||
}
|
||
precNode = NULL;
|
||
}
|
||
return(0);
|
||
}
|
||
|
||
static long initialProcess()
|
||
{
|
||
short i;
|
||
struct recHeader *precHeader;
|
||
struct recLoc *precLoc;
|
||
RECNODE *precNode;
|
||
struct dbCommon *precord;
|
||
|
||
if(!(precHeader = pdbBase->precHeader)) return(0);
|
||
for(i=0; i< (precHeader->number); i++) {
|
||
if(!(precLoc = precHeader->papRecLoc[i]))continue;
|
||
for(precNode=(RECNODE *)lstFirst(precLoc->preclist);
|
||
precNode; precNode = (RECNODE *)lstNext(&precNode->next)) {
|
||
precord = precNode->precord;
|
||
/* If NAME is null then skip this record*/
|
||
if(!(precord->name[0])) continue;
|
||
if(!precord->pini) continue;
|
||
(void)dbProcess(precord);
|
||
}
|
||
}
|
||
return(0);
|
||
}
|
||
|
||
#define MAX 128
|
||
#define SAME 0
|
||
static char *cvt_str[] = {
|
||
"DBF_STRING",
|
||
"DBF_SHORT",
|
||
"DBF_LONG",
|
||
"DBF_FLOAT",
|
||
"DBF_DOUBLE"
|
||
};
|
||
#define CVT_COUNT (sizeof(cvt_str) / sizeof(char*))
|
||
static long getResources(fname) /* Resource Definition File interpreter */
|
||
char *fname;
|
||
{
|
||
FILE *fp;
|
||
int len;
|
||
int len2;
|
||
int lineNum = 0;
|
||
int i = 0;
|
||
int found = 0;
|
||
int cvType = 0;
|
||
int epicsFlag;
|
||
char buff[MAX + 1];
|
||
char name[40];
|
||
char s1[MAX];
|
||
char s2[MAX];
|
||
char s3[MAX];
|
||
char message[100];
|
||
long rtnval = 0;
|
||
UTINY type;
|
||
char *pSymAddr;
|
||
short n_short;
|
||
long n_long;
|
||
float n_float;
|
||
double n_double;
|
||
if (!fname) return (0);
|
||
if ((fp = fopen(fname, "r")) == 0) {
|
||
errMessage(-1L, "getResources: No such Resource file");
|
||
return (-1);
|
||
}
|
||
while ( fgets( buff, MAX, fp) != NULL) {
|
||
len = strlen(buff);
|
||
lineNum++;
|
||
if (len < 2)
|
||
goto CLEAR;
|
||
if (len >= MAX) {
|
||
sprintf(message,
|
||
"getResources: Line too long - line=%d", lineNum);
|
||
errMessage(-1L, message);
|
||
return (-1);
|
||
}
|
||
for (i = 0; i < len; i++) {
|
||
if (buff[i] == '!') {
|
||
goto CLEAR;
|
||
}
|
||
}
|
||
/* extract the 3 fields as strings */
|
||
if ((sscanf(buff, "%s %s %s", s1, s2, s3)) != 3) {
|
||
sprintf(message,
|
||
"getResources: Not enough fields - line=%d", lineNum);
|
||
errMessage(-1L, message);
|
||
return (-1);
|
||
}
|
||
found = 0;
|
||
len2 = strlen(s2);
|
||
for (i = 0; i < CVT_COUNT; i++) {
|
||
|
||
|
||
if ((strncmp(s2, cvt_str[i], len2)) == SAME) {
|
||
found = 1;
|
||
cvType = i;
|
||
break;
|
||
}
|
||
}
|
||
if (!found) {
|
||
sprintf(message,
|
||
"getResources: Field 2 not defined - line=%d", lineNum);
|
||
errMessage(-1L, message);
|
||
return (-1);
|
||
}
|
||
strcpy(name, "_");
|
||
strcat(name, s1);
|
||
rtnval = symFindByName(sysSymTbl, name, &pSymAddr, &type);
|
||
if (rtnval != OK || (type & N_TEXT == 0)) {
|
||
sprintf(message,
|
||
"getResources: Symbol name not found - line=%d", lineNum);
|
||
errMessage(-1L, message);
|
||
return (-1);
|
||
}
|
||
if ( (strncmp(s1,"EPICS_",6)) == SAME)
|
||
epicsFlag = 1;
|
||
else
|
||
epicsFlag = 0;
|
||
|
||
switch (cvType) {
|
||
case 0: /* DBF_STRING */
|
||
len = strlen(s3);
|
||
len2 = 20;
|
||
if (len >= len2) {
|
||
sprintf(message,
|
||
"getResources: Warning, string might exceed previous reserved space - line=%d",
|
||
lineNum);
|
||
errMessage(-1L, message);
|
||
}
|
||
if ( epicsFlag )
|
||
strncpy(pSymAddr+sizeof(void *), s3, len + 1);
|
||
else
|
||
strncpy(pSymAddr, s3, len + 1);
|
||
break;
|
||
case 1: /* DBF_SHORT */
|
||
if ((sscanf(s3, "%hd", &n_short)) != 1) {
|
||
sprintf(message,
|
||
"getResources: conversion failed - line=%d", lineNum);
|
||
errMessage(-1L, message);
|
||
return (-1);
|
||
}
|
||
if ( epicsFlag ) {
|
||
sprintf(message,
|
||
"getResources: EPICS_ type DBF_SHORT not supported - line =%d",
|
||
lineNum);
|
||
errMessage(-1L, message);
|
||
}
|
||
else
|
||
*(short *) pSymAddr = n_short;
|
||
|
||
break;
|
||
case 2: /* DBF_LONG */
|
||
if ((sscanf(s3, "%ld", &n_long)) != 1) {
|
||
sprintf(message,
|
||
"getResources: conversion failed - line=%d", lineNum);
|
||
errMessage(-1L, message);
|
||
return (-1);
|
||
}
|
||
if ( epicsFlag ) {
|
||
sprintf(message,
|
||
"getResources: EPICS_ type DBF_LONG not supported - line= %d",
|
||
lineNum);
|
||
errMessage(-1L, message);
|
||
}
|
||
else
|
||
*(long *) pSymAddr = n_long;
|
||
break;
|
||
case 3: /* DBF_FLOAT */
|
||
if ((sscanf(s3, "%e", &n_float)) != 1) {
|
||
sprintf(message,
|
||
"getResources: conversion failed - line=%d", lineNum);
|
||
errMessage(-1L, message);
|
||
return (-1);
|
||
}
|
||
if ( epicsFlag ) {
|
||
sprintf(message,
|
||
"getResources: EPICS_ type DBF_FLOAT not supported - line =%d",
|
||
lineNum);
|
||
errMessage(-1L, message);
|
||
}
|
||
else
|
||
*(float *) pSymAddr = n_float;
|
||
|
||
break;
|
||
case 4: /* DBF_DOUBLE */
|
||
if ((sscanf(s3, "%le", &n_double)) != 1) {
|
||
sprintf(message,
|
||
"getResources: conversion failed - line=%d", lineNum);
|
||
errMessage(-1L, message);
|
||
return (-1);
|
||
}
|
||
if ( epicsFlag ) {
|
||
sprintf(message,
|
||
"getResources: EPICS_ type DBF_DOUBLE not supported - line=%d",
|
||
lineNum);
|
||
errMessage(-1L, message);
|
||
}
|
||
else
|
||
*(double *) pSymAddr = n_double;
|
||
|
||
break;
|
||
default:
|
||
sprintf(message,
|
||
"getResources: switch default reached - line=%d", lineNum);
|
||
errMessage(-1L, message);
|
||
return (-1);
|
||
break;
|
||
}
|
||
CLEAR: memset(buff, '\0', MAX);
|
||
memset(s1, '\0', MAX);
|
||
memset(s2, '\0', MAX);
|
||
memset(s3, '\0', MAX);
|
||
}
|
||
fclose(fp);
|
||
return (0);
|
||
}
|
||
|
||
long dbLoad(pfilename)
|
||
char * pfilename;
|
||
{
|
||
long status;
|
||
status=dbRead(&pdbBase, pfilename);
|
||
if(status!=0) {
|
||
logMsg("dbLoad aborting because dbRead failed\n");
|
||
return(-1);
|
||
}
|
||
return (0);
|
||
}
|