427 lines
13 KiB
C
427 lines
13 KiB
C
/* dbNotify.c */
|
||
/* base/src/db $Id$ */
|
||
/*
|
||
* Author: Marty Kraimer
|
||
* Date: 03-30-95
|
||
* Extracted from dbLink.c
|
||
*/
|
||
/*****************************************************************
|
||
COPYRIGHT NOTIFICATION
|
||
*****************************************************************
|
||
|
||
(C) COPYRIGHT 1993 UNIVERSITY OF CHICAGO
|
||
|
||
This software was developed under a United States Government license
|
||
described on the COPYRIGHT_UniversityOfChicago file included as part
|
||
of this distribution.
|
||
**********************************************************************/
|
||
|
||
#include <stdlib.h>
|
||
#include <stdarg.h>
|
||
#include <stdio.h>
|
||
#include <string.h>
|
||
#include <limits.h>
|
||
|
||
#include "dbDefs.h"
|
||
#include "ellLib.h"
|
||
#include "epicsAssert.h"
|
||
#include "epicsEvent.h"
|
||
#include "epicsMutex.h"
|
||
#include "epicsThread.h"
|
||
#include "errlog.h"
|
||
#include "errMdef.h"
|
||
#include "dbBase.h"
|
||
#include "dbStaticLib.h"
|
||
#include "dbFldTypes.h"
|
||
#include "link.h"
|
||
#include "dbCommon.h"
|
||
#define epicsExportSharedSymbols
|
||
#include "callback.h"
|
||
#include "dbAddr.h"
|
||
#include "dbScan.h"
|
||
#include "dbLock.h"
|
||
#include "callback.h"
|
||
#include "dbAccessDefs.h"
|
||
#include "recGbl.h"
|
||
#include "dbNotify.h"
|
||
#include "epicsTime.h"
|
||
#include "cantProceed.h"
|
||
|
||
#define STATIC static
|
||
/*structure attached to ppnr field of each record*/
|
||
typedef struct putNotifyRecord {
|
||
ellCheckNode waitNode;
|
||
ELLLIST restartList; /*list of putNotifys to restart*/
|
||
dbCommon *precord;
|
||
}putNotifyRecord;
|
||
|
||
/*putNotify.state values */
|
||
typedef enum {
|
||
putNotifyNotActive,
|
||
putNotifyWaitForRestart,
|
||
putNotifyRestartCallbackRequested,
|
||
putNotifyRestartInProgress,
|
||
putNotifyPutInProgress,
|
||
putNotifyUserCallbackRequested
|
||
}putNotifyState;
|
||
|
||
/* putNotify groups can span locksets if links are dynamically modified*/
|
||
/* Thus a global lock is taken while putNotify fields are accessed */
|
||
STATIC epicsMutexId notifyLock = 0;
|
||
|
||
/*Local routines*/
|
||
STATIC void restartCheck(putNotifyRecord *ppnr);
|
||
STATIC void notifyCallback(CALLBACK *pcallback);
|
||
STATIC void putNotifyPvt(putNotify *ppn,dbCommon *precord);
|
||
|
||
#define ellSafeAdd(list,listnode) \
|
||
{ \
|
||
assert((listnode)->isOnList==0); \
|
||
ellAdd((list),&((listnode)->node)); \
|
||
(listnode)->isOnList=1; \
|
||
}
|
||
|
||
#define ellSafeDelete(list,listnode) \
|
||
{ \
|
||
assert((listnode)->isOnList); \
|
||
ellDelete((list),&((listnode)->node)); \
|
||
(listnode)->isOnList=0; \
|
||
}
|
||
|
||
STATIC void restartCheck(putNotifyRecord *ppnr)
|
||
{
|
||
dbCommon *precord = ppnr->precord;
|
||
putNotify *pfirst;
|
||
|
||
assert(precord->ppn);
|
||
pfirst = (putNotify *)ellFirst(&ppnr->restartList);
|
||
if(!pfirst) {
|
||
precord->ppn = 0;
|
||
return;
|
||
}
|
||
assert(pfirst->state==putNotifyWaitForRestart);
|
||
/* remove pfirst from restartList */
|
||
ellSafeDelete(&ppnr->restartList,&pfirst->restartNode);
|
||
/*make pfirst owner of the record*/
|
||
precord->ppn = pfirst;
|
||
/* request callback for pfirst */
|
||
pfirst->state = putNotifyRestartCallbackRequested;
|
||
callbackRequest(&pfirst->callback);
|
||
}
|
||
|
||
STATIC void putNotifyPvt(putNotify *ppn,dbCommon *precord)
|
||
{
|
||
long status=0;
|
||
dbFldDes *pfldDes=(dbFldDes *)(ppn->paddr->pfldDes);
|
||
|
||
if(precord->ppn && ppn->state!=putNotifyRestartCallbackRequested) {
|
||
/*another putNotify owns the record */
|
||
ppn->state = putNotifyWaitForRestart;
|
||
ellSafeAdd(&precord->ppnr->restartList,&ppn->restartNode);
|
||
epicsMutexUnlock(notifyLock);
|
||
dbScanUnlock(precord);
|
||
return;
|
||
} else if(precord->ppn){
|
||
assert(precord->ppn==ppn);
|
||
assert(ppn->state==putNotifyRestartCallbackRequested);
|
||
}
|
||
if(precord->pact) {
|
||
precord->ppn = ppn;
|
||
ellSafeAdd(&ppn->waitList,&precord->ppnr->waitNode);
|
||
ppn->state = putNotifyRestartInProgress;
|
||
epicsMutexUnlock(notifyLock);
|
||
dbScanUnlock(precord);
|
||
return;
|
||
}
|
||
status=dbPut(ppn->paddr,ppn->dbrType,ppn->pbuffer,ppn->nRequest);
|
||
ppn->status = (status==0) ? putNotifyOK : putNotifyError;
|
||
/* Check to see if dbProcess should not be called */
|
||
if(!status /*dont process if dbPut returned error */
|
||
&&((ppn->paddr->pfield==(void *)&precord->proc) /*If PROC call dbProcess*/
|
||
|| (pfldDes->process_passive && precord->scan==0))) {
|
||
precord->ppn = ppn;
|
||
ellSafeAdd(&ppn->waitList,&precord->ppnr->waitNode);
|
||
ppn->state = putNotifyPutInProgress;
|
||
epicsMutexUnlock(notifyLock);
|
||
dbProcess(precord);
|
||
dbScanUnlock(precord);
|
||
return;
|
||
}
|
||
if(ppn->state==putNotifyRestartCallbackRequested) {
|
||
restartCheck(precord->ppnr);
|
||
}
|
||
ppn->state = putNotifyNotActive;
|
||
assert(precord->ppn!=ppn);
|
||
epicsMutexUnlock(notifyLock);
|
||
dbScanUnlock(precord);
|
||
(*ppn->userCallback)(ppn);
|
||
return;
|
||
}
|
||
|
||
STATIC void notifyCallback(CALLBACK *pcallback)
|
||
{
|
||
putNotify *ppn=NULL;
|
||
dbCommon *precord;
|
||
|
||
callbackGetUser(ppn,pcallback);
|
||
precord = ppn->paddr->precord;
|
||
dbScanLock(precord);
|
||
epicsMutexMustLock(notifyLock);
|
||
assert(precord->ppnr);
|
||
assert(ppn->state==putNotifyRestartCallbackRequested
|
||
|| ppn->state==putNotifyUserCallbackRequested);
|
||
assert(ellCount(&ppn->waitList)==0);
|
||
if(ppn->requestCancel) {
|
||
ppn->status = putNotifyCanceled;
|
||
if(ppn->state==putNotifyRestartCallbackRequested) {
|
||
restartCheck(precord->ppnr);
|
||
}
|
||
ppn->state = putNotifyNotActive;
|
||
epicsMutexUnlock(notifyLock);
|
||
dbScanUnlock(precord);
|
||
assert(ppn->pcancelEvent);
|
||
epicsEventSignal(*ppn->pcancelEvent);
|
||
return;
|
||
}
|
||
if(ppn->state==putNotifyRestartCallbackRequested) {
|
||
putNotifyPvt(ppn,precord);
|
||
return;
|
||
}
|
||
/* All done. Clean up and call userCallback */
|
||
ppn->state = putNotifyNotActive;
|
||
assert(precord->ppn!=ppn);
|
||
epicsMutexUnlock(notifyLock);
|
||
dbScanUnlock(precord);
|
||
(*ppn->userCallback)(ppn);
|
||
}
|
||
|
||
void epicsShareAPI dbPutNotify(putNotify *ppn)
|
||
{
|
||
dbCommon *precord = ppn->paddr->precord;
|
||
short dbfType = ppn->paddr->field_type;
|
||
long status=0;
|
||
|
||
assert(precord);
|
||
/* 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(notifyLock);
|
||
ppn->status = 0;
|
||
ppn->state = putNotifyNotActive;
|
||
ppn->requestCancel = 0;
|
||
callbackSetCallback(notifyCallback,&ppn->callback);
|
||
callbackSetUser(ppn,&ppn->callback);
|
||
callbackSetPriority(priorityLow,&ppn->callback);
|
||
ellInit(&ppn->waitList);
|
||
if(!precord->ppnr) {/* make sure record has a putNotifyRecord*/
|
||
precord->ppnr = dbCalloc(1,sizeof(putNotifyRecord));
|
||
precord->ppnr->precord = precord;
|
||
ellInit(&precord->ppnr->restartList);
|
||
}
|
||
putNotifyPvt(ppn,precord);
|
||
}
|
||
|
||
void epicsShareAPI dbPutNotifyInit(void)
|
||
{
|
||
notifyLock = epicsMutexMustCreate();
|
||
}
|
||
|
||
void epicsShareAPI dbNotifyCancel(putNotify *ppn)
|
||
{
|
||
dbCommon *precord = ppn->paddr->precord;
|
||
putNotifyState state;
|
||
|
||
if(ppn->state==putNotifyNotActive) return;
|
||
assert(precord);
|
||
dbScanLock(precord);
|
||
epicsMutexMustLock(notifyLock);
|
||
state = ppn->state;
|
||
/*If callback is scheduled or active wait for it to complete*/
|
||
if(state==putNotifyUserCallbackRequested
|
||
|| state==putNotifyRestartCallbackRequested) {
|
||
epicsEventId eventId;
|
||
eventId = epicsEventCreate(epicsEventEmpty);
|
||
ppn->pcancelEvent = &eventId;
|
||
ppn->requestCancel = 1;
|
||
epicsMutexUnlock(notifyLock);
|
||
dbScanUnlock(precord);
|
||
epicsEventWait(eventId);
|
||
dbScanLock(precord);
|
||
epicsMutexMustLock(notifyLock);
|
||
ppn->pcancelEvent = 0;
|
||
epicsEventDestroy(eventId);
|
||
state = ppn->state;
|
||
epicsMutexUnlock(notifyLock);
|
||
dbScanUnlock(precord);
|
||
return;
|
||
}
|
||
switch(state) {
|
||
case putNotifyNotActive: break;
|
||
case putNotifyWaitForRestart:
|
||
assert(precord->ppn);
|
||
assert(precord->ppn!=ppn);
|
||
ellSafeDelete(&precord->ppnr->restartList,&ppn->restartNode);
|
||
break;
|
||
case putNotifyRestartInProgress:
|
||
case putNotifyPutInProgress:
|
||
{ /*Take all records out of wait list */
|
||
putNotifyRecord *ppnrWait;
|
||
|
||
while((ppnrWait = (putNotifyRecord *)ellFirst(&ppn->waitList))){
|
||
ellSafeDelete(&ppn->waitList,&ppnrWait->waitNode);
|
||
restartCheck(ppnrWait);
|
||
}
|
||
}
|
||
if(precord->ppn==ppn) restartCheck(precord->ppnr);
|
||
break;
|
||
default:
|
||
printf("dbNotify: illegal state for notifyCallback\n");
|
||
}
|
||
ppn->state = putNotifyNotActive;
|
||
epicsMutexUnlock(notifyLock);
|
||
dbScanUnlock(precord);
|
||
}
|
||
|
||
void epicsShareAPI dbNotifyCompletion(dbCommon *precord)
|
||
{
|
||
putNotify *ppn = precord->ppn;
|
||
|
||
epicsMutexMustLock(notifyLock);
|
||
assert(ppn);
|
||
assert(precord->ppnr);
|
||
if(ppn->state!=putNotifyRestartInProgress
|
||
&& ppn->state!=putNotifyPutInProgress) {
|
||
epicsMutexUnlock(notifyLock);
|
||
return;
|
||
}
|
||
ellSafeDelete(&ppn->waitList,&precord->ppnr->waitNode);
|
||
if((ellCount(&ppn->waitList)!=0)) {
|
||
restartCheck(precord->ppnr);
|
||
} else if(ppn->state == putNotifyPutInProgress) {
|
||
ppn->state = putNotifyUserCallbackRequested;
|
||
restartCheck(precord->ppnr);
|
||
callbackRequest(&ppn->callback);
|
||
} else if(ppn->state == putNotifyRestartInProgress) {
|
||
ppn->state = putNotifyRestartCallbackRequested;
|
||
callbackRequest(&ppn->callback);
|
||
} else {
|
||
cantProceed("dbNotifyCompletion illegal state");
|
||
}
|
||
epicsMutexUnlock(notifyLock);
|
||
}
|
||
|
||
void epicsShareAPI dbNotifyAdd(dbCommon *pfrom, dbCommon *pto)
|
||
{
|
||
putNotify *ppn = pfrom->ppn;
|
||
|
||
if(pto->pact) return; /*if active it will not be processed*/
|
||
epicsMutexMustLock(notifyLock);
|
||
if(!pto->ppnr) {/* make sure record has a putNotifyRecord*/
|
||
pto->ppnr = dbCalloc(1,sizeof(putNotifyRecord));
|
||
pto->ppnr->precord = pto;
|
||
ellInit(&pto->ppnr->restartList);
|
||
}
|
||
assert(ppn);
|
||
if(!(pto->ppn)
|
||
&& (ppn->state==putNotifyPutInProgress)
|
||
&& (pto!=ppn->paddr->precord)) {
|
||
pto->ppn = pfrom->ppn;
|
||
ellSafeAdd(&pfrom->ppn->waitList,&pto->ppnr->waitNode);
|
||
}
|
||
epicsMutexUnlock(notifyLock);
|
||
}
|
||
|
||
STATIC void dbtpnCallback(putNotify *ppn)
|
||
{
|
||
putNotifyStatus status = ppn->status;
|
||
|
||
if(status==putNotifyBlocked)
|
||
printf("dbtpnCallback: blocked record=%s\n",ppn->paddr->precord->name);
|
||
else if(status==0)
|
||
printf("dbtpnCallback: success record=%s\n",ppn->paddr->precord->name);
|
||
else
|
||
errlogPrintf("%s dbtpnCallback putNotify.status %d\n",(int)status);
|
||
free((void *)ppn->paddr);
|
||
free(ppn);
|
||
}
|
||
|
||
long epicsShareAPI dbtpn(char *pname,char *pvalue)
|
||
{
|
||
long status;
|
||
DBADDR *pdbaddr=NULL;
|
||
putNotify *ppn=NULL;
|
||
char *psavevalue;
|
||
int len;
|
||
|
||
len = strlen(pvalue);
|
||
/*allocate space for value immediately following DBADDR*/
|
||
pdbaddr = dbCalloc(1,sizeof(DBADDR) + len+1);
|
||
psavevalue = (char *)(pdbaddr + 1);
|
||
strcpy(psavevalue,pvalue);
|
||
status = dbNameToAddr(pname,pdbaddr);
|
||
if(status) {
|
||
errMessage(status, "dbtpn: dbNameToAddr");
|
||
free((void *)pdbaddr);
|
||
return(-1);
|
||
}
|
||
ppn = dbCalloc(1,sizeof(putNotify));
|
||
ppn->paddr = pdbaddr;
|
||
ppn->pbuffer = psavevalue;
|
||
ppn->nRequest = 1;
|
||
ppn->dbrType = DBR_STRING;
|
||
ppn->userCallback = dbtpnCallback;
|
||
dbPutNotify(ppn);
|
||
return(0);
|
||
}
|
||
|
||
int epicsShareAPI dbNotifyDump(void)
|
||
{
|
||
epicsMutexLockStatus lockStatus;
|
||
dbRecordType *pdbRecordType;
|
||
dbRecordNode *pdbRecordNode;
|
||
dbCommon *precord;
|
||
putNotify *ppn;
|
||
putNotify *ppnRestart;
|
||
putNotifyRecord *ppnrWait;
|
||
|
||
|
||
lockStatus = epicsMutexLockWithTimeout(notifyLock,2.0);
|
||
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->ppn) continue;
|
||
if(!precord->ppnr) continue;
|
||
if(precord->ppn->paddr->precord != precord) continue;
|
||
ppn = precord->ppn;
|
||
printf("%s state %d ppn %p\n waitList\n",
|
||
precord->name,ppn->state,ppn);
|
||
ppnrWait = (putNotifyRecord *)ellFirst(&ppn->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", ppnRestart);
|
||
ppnRestart = (putNotify *)ellNext(&ppnRestart->restartNode.node);
|
||
}
|
||
}
|
||
}
|
||
if(lockStatus==epicsMutexLockOK) epicsMutexUnlock(notifyLock);
|
||
return(0);
|
||
}
|