void DbPvPut::get() { if(DbPvDebug::getLevel()>0) printf("dbPvPut::get()\n"); { Lock lock(dataMutex); dbScanLock(dbChannelRecord(dbPv->getDbChannel())); bitSet->clear(); Status status = dbUtil->get( channelPutRequester, propertyMask, dbPv->getDbChannel(), pvStructure, bitSet, 0); dbScanUnlock(dbChannelRecord(dbPv->getDbChannel())); if(firstTime) { firstTime = false; bitSet->set(pvStructure->getFieldOffset()); } } channelPutRequester->getDone( status, getPtrSelf(), pvStructure, bitSet); }
void DbPvPut::put(PVStructurePtr const &pvStructure, BitSetPtr const & bitSet) { if (DbPvDebug::getLevel() > 0) printf("dbPvPut::put()\n"); this->pvStructure = pvStructure; this->bitSet = bitSet; if (block && process) { dbProcessNotify(pNotify.get()); return; } Lock lock(dataMutex); PVFieldPtr pvField = pvStructure.get()->getPVFields()[0]; if (propertyMask & dbUtil->dbPutBit) { status = dbUtil->putField( channelPutRequester, propertyMask, dbPv->getDbChannel(), pvField); } else { dbScanLock(dbChannelRecord(dbPv->getDbChannel())); status = dbUtil->put( channelPutRequester, propertyMask, dbPv->getDbChannel(), pvField); if (process) dbProcess(dbChannelRecord(dbPv->getDbChannel())); dbScanUnlock(dbChannelRecord(dbPv->getDbChannel())); } lock.unlock(); channelPutRequester->putDone(status, getPtrSelf()); }
static db_field_log* filter(void* pvt, dbChannel *chan, db_field_log *pfl) { epicsTimeStamp now; epicsTimeGetCurrent(&now); /* If string or array, must make a copy (to ensure coherence between time and data) */ if (pfl->type == dbfl_type_rec) { dbScanLock(dbChannelRecord(chan)); dbChannelMakeArrayCopy(pvt, pfl, chan); dbScanUnlock(dbChannelRecord(chan)); } pfl->time = now; return pfl; }
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 notifyCallback(CALLBACK *pcallback) { processNotify *ppn = NULL; dbCommon *precord; notifyPvt *pnotifyPvt; callbackGetUser(ppn,pcallback); pnotifyPvt = (notifyPvt *) ppn->pnotifyPvt; precord = dbChannelRecord(ppn->chan); dbScanLock(precord); epicsMutexMustLock(pnotifyGlobal->lock); assert(precord->ppnr); assert(pnotifyPvt->state == notifyRestartCallbackRequested || pnotifyPvt->state == notifyUserCallbackRequested); assert(ellCount(&pnotifyPvt->waitList) == 0); if (pnotifyPvt->cancelWait) { if (pnotifyPvt->state == notifyRestartCallbackRequested) { restartCheck(precord->ppnr); } epicsEventSignal(pnotifyPvt->cancelEvent); epicsMutexUnlock(pnotifyGlobal->lock); dbScanUnlock(precord); return; } if(pnotifyPvt->state == notifyRestartCallbackRequested) { processNotifyCommon(ppn, precord); return; } /* All done. Clean up and call userCallback */ pnotifyPvt->state = notifyUserCallbackActive; assert(precord->ppn!=ppn); callDone(precord, ppn); }
void dbNotifyCancel(processNotify *ppn) { dbCommon *precord = dbChannelRecord(ppn->chan); notifyState state; notifyPvt *pnotifyPvt; dbScanLock(precord); epicsMutexMustLock(pnotifyGlobal->lock); ppn->status = notifyCanceled; pnotifyPvt = (notifyPvt *) ppn->pnotifyPvt; if (!pnotifyPvt || pnotifyPvt->state == notifyNotActive) { epicsMutexUnlock(pnotifyGlobal->lock); dbScanUnlock(precord); return; } state = pnotifyPvt->state; switch (state) { case notifyUserCallbackRequested: case notifyRestartCallbackRequested: case notifyUserCallbackActive: /* Callback is scheduled or active, wait for it to complete */ pnotifyPvt->cancelWait = 1; epicsMutexUnlock(pnotifyGlobal->lock); dbScanUnlock(precord); epicsEventWait(pnotifyPvt->cancelEvent); epicsMutexMustLock(pnotifyGlobal->lock); notifyCleanup(ppn); epicsMutexUnlock(pnotifyGlobal->lock); return; case notifyNotActive: break; case notifyWaitForRestart: assert(precord->ppn); assert(precord->ppn!=ppn); ellSafeDelete(&precord->ppnr->restartList,&ppn->restartNode); break; case notifyRestartInProgress: case notifyProcessInProgress: { /*Take all records out of wait list */ processNotifyRecord *ppnrWait; while ((ppnrWait = (processNotifyRecord *) ellFirst(&pnotifyPvt->waitList))) { ellSafeDelete(&pnotifyPvt->waitList, &ppnrWait->waitNode); restartCheck(ppnrWait); } } if (precord->ppn == ppn) restartCheck(precord->ppnr); break; default: printf("dbNotify: illegal state for notifyCallback\n"); } pnotifyPvt->state = notifyNotActive; notifyCleanup(ppn); epicsMutexUnlock(pnotifyGlobal->lock); dbScanUnlock(precord); }
static void doneCallback(processNotify *ppn) { tpnInfo *ptpnInfo = (tpnInfo *) ppn->usrPvt; notifyStatus status = ppn->status; const char *pname = dbChannelRecord(ppn->chan)->name; if (status == 0) printf("tpnCallback '%s': Success\n", pname); else printf("tpnCallback '%s': Notify status %d\n", pname, (int)status); epicsEventSignal(ptpnInfo->callbackDone); }
static void doneCallback(processNotify *ppn) { notifyStatus status = ppn->status; tpnInfo *ptpnInfo = (tpnInfo *) ppn->usrPvt; const char *pname = dbChannelRecord(ppn->chan)->name; if (status == 0) printf("dbtpnCallback: success record=%s\n", pname); else printf("%s dbtpnCallback processNotify.status %d\n", pname, (int) status); epicsEventSignal(ptpnInfo->callbackDone); }
int gft(const char *pname) { char tgf_buffer[MAX_ELEMS*MAX_STRING_SIZE + sizeof(struct dbr_ctrl_double)]; struct dbChannel *chan; struct dbCommon *precord; long elements; short type; int i; chan = dbChannel_create(pname); if (!chan) { printf("Channel couldn't be created\n"); return 1; } precord = dbChannelRecord(chan); elements = dbChannelElements(chan); type = dbChannelExportCAType(chan); printf(" Record Name: %s\n", precord->name); printf("Record Address: 0x%p\n", precord); printf(" Export Type: %d\n", type); printf(" Field Address: 0x%p\n", dbChannelField(chan)); printf(" Field Size: %d\n", dbChannelFieldSize(chan)); printf(" No Elements: %ld\n", elements); if (elements > MAX_ELEMS) elements = MAX_ELEMS; for (i = 0; i <= LAST_BUFFER_TYPE; i++) { if (type == 0) { if ((i != DBR_STRING) && (i != DBR_STS_STRING) && (i != DBR_TIME_STRING) && (i != DBR_GR_STRING) && (i != DBR_CTRL_STRING)) continue; } if (dbChannel_get(chan, i, tgf_buffer, elements, NULL) < 0) printf("\t%s Failed\n", dbr_text[i]); else ca_dump_dbr(i, elements, tgf_buffer); } dbChannelDelete(chan); return 0; }
void dbChannelMakeArrayCopy(void *pvt, db_field_log *pfl, dbChannel *chan) { void *p; struct dbCommon *prec = dbChannelRecord(chan); if (pfl->type != dbfl_type_rec) return; pfl->type = dbfl_type_ref; pfl->stat = prec->stat; pfl->sevr = prec->sevr; pfl->time = prec->time; pfl->field_type = chan->addr.field_type; pfl->no_elements = chan->addr.no_elements; pfl->field_size = chan->addr.field_size; pfl->u.r.dtor = freeArray; pfl->u.r.pvt = pvt; if (pfl->field_type == DBF_STRING && pfl->no_elements == 1) { p = freeListCalloc(dbchStringFreeList); } else { p = calloc(pfl->no_elements, pfl->field_size); } if (p) dbGet(&chan->addr, mapDBFToDBR[pfl->field_type], p, NULL, &pfl->no_elements, NULL); pfl->u.r.field = p; }
/* * TPF * Test put field */ int pft(const char *pname, const char *pvalue) { struct dbChannel *chan; struct dbCommon *precord; long elements; short type; char buffer[500]; short shortvalue; long longvalue; float floatvalue; unsigned char charvalue; double doublevalue; chan = dbChannel_create(pname); if (!chan) { printf("Channel couldn't be created\n"); return 1; } precord = dbChannelRecord(chan); elements = dbChannelElements(chan); type = dbChannelExportCAType(chan); printf(" Record Name: %s\n", precord->name); printf("Record Address: 0x%p\n", precord); printf(" Export Type: %d\n", type); printf(" Field Address: 0x%p\n", dbChannelField(chan)); printf(" Field Size: %d\n", dbChannelFieldSize(chan)); printf(" No Elements: %ld\n", elements); if (dbChannel_put(chan, DBR_STRING,pvalue, 1) < 0) printf("\n\t failed "); if (dbChannel_get(chan, DBR_STRING,buffer, 1, NULL) < 0) printf("\n\tfailed"); else ca_dump_dbr(DBR_STRING,1, buffer); if (type <= DBF_STRING || type == DBF_ENUM) return 0; if (sscanf(pvalue, "%hd", &shortvalue) == 1) { if (dbChannel_put(chan, DBR_SHORT,&shortvalue, 1) < 0) printf("\n\t SHORT failed "); if (dbChannel_get(chan, DBR_SHORT,buffer, 1, NULL) < 0) printf("\n\t SHORT GET failed"); else ca_dump_dbr(DBR_SHORT,1, buffer); } if (sscanf(pvalue, "%ld", &longvalue) == 1) { if (dbChannel_put(chan, DBR_LONG,&longvalue, 1) < 0) printf("\n\t LONG failed "); if (dbChannel_get(chan, DBR_LONG,buffer, 1, NULL) < 0) printf("\n\t LONG GET failed"); else ca_dump_dbr(DBR_LONG,1, buffer); } if (epicsScanFloat(pvalue, &floatvalue) == 1) { if (dbChannel_put(chan, DBR_FLOAT,&floatvalue, 1) < 0) printf("\n\t FLOAT failed "); if (dbChannel_get(chan, DBR_FLOAT,buffer, 1, NULL) < 0) printf("\n\t FLOAT GET failed"); else ca_dump_dbr(DBR_FLOAT,1, buffer); } if (epicsScanFloat(pvalue, &floatvalue) == 1) { doublevalue = floatvalue; if (dbChannel_put(chan, DBR_DOUBLE,&doublevalue, 1) < 0) printf("\n\t DOUBLE failed "); if (dbChannel_get(chan, DBR_DOUBLE,buffer, 1, NULL) < 0) printf("\n\t DOUBLE GET failed"); else ca_dump_dbr(DBR_DOUBLE,1, buffer); } if (sscanf(pvalue, "%hd", &shortvalue) == 1) { charvalue = (unsigned char) shortvalue; if (dbChannel_put(chan, DBR_CHAR,&charvalue, 1) < 0) printf("\n\t CHAR failed "); if (dbChannel_get(chan, DBR_CHAR,buffer, 1, NULL) < 0) printf("\n\t CHAR GET failed"); else ca_dump_dbr(DBR_CHAR,1, buffer); } if (sscanf(pvalue, "%hd", &shortvalue) == 1) { if (dbChannel_put(chan, DBR_ENUM,&shortvalue, 1) < 0) printf("\n\t ENUM failed "); if (dbChannel_get(chan, DBR_ENUM,buffer, 1, NULL) < 0) printf("\n\t ENUM GET failed"); else ca_dump_dbr(DBR_ENUM,1, buffer); } printf("\n"); dbChannelDelete(chan); return (0); }
int dbNotifyDump(void) { epicsMutexLockStatus lockStatus; dbRecordType *pdbRecordType; processNotify *ppnRestart; processNotifyRecord *ppnr; 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)) { dbRecordNode *pdbRecordNode; for (pdbRecordNode = (dbRecordNode *) ellFirst(&pdbRecordType->recList); pdbRecordNode; pdbRecordNode = (dbRecordNode *) ellNext(&pdbRecordNode->node)) { dbCommon *precord = pdbRecordNode->precord; processNotify *ppn; notifyPvt *pnotifyPvt; if (!precord->name[0] || pdbRecordNode->flags & DBRN_FLAGS_ISALIAS) continue; ppn = precord->ppn; if (!ppn || !precord->ppnr) continue; if (dbChannelRecord(precord->ppn->chan) != precord) continue; pnotifyPvt = (notifyPvt *) ppn->pnotifyPvt; printf("%s state %d ppn %p\n waitList\n", precord->name, pnotifyPvt->state, (void*) ppn); ppnr = (processNotifyRecord *) ellFirst(&pnotifyPvt->waitList); while (ppnr) { printf(" %s pact %d\n", ppnr->precord->name, ppnr->precord->pact); ppnr = (processNotifyRecord *) ellNext(&ppnr->waitNode.node); } ppnr = precord->ppnr; if (ppnr) { ppnRestart = (processNotify *)ellFirst( &precord->ppnr->restartList); if (ppnRestart) printf("%s restartList\n", precord->name); while (ppnRestart) { printf(" %s\n", dbChannelRecord(ppnRestart->chan)->name); ppnRestart = (processNotify *) ellNext( &ppnRestart->restartNode.node); } } } } if (lockStatus == epicsMutexLockOK) epicsMutexUnlock(pnotifyGlobal->lock); return 0; }
/* Performs the work of the public db_get_field API, but also returns the number * of elements actually copied to the buffer. The caller is responsible for * zeroing the remaining part of the buffer. */ int dbChannel_get_count( struct dbChannel *chan, int buffer_type, void *pbuffer, long *nRequest, void *pfl) { long status; long options; long i; long zero = 0; /* The order of the DBR* elements in the "newSt" structures below is * very important and must correspond to the order of processing * in the dbAccess.c dbGet() and getOptions() routines. */ dbScanLock(dbChannelRecord(chan)); switch(buffer_type) { case(oldDBR_STRING): status = dbChannelGet(chan, DBR_STRING, pbuffer, &zero, nRequest, pfl); break; /* case(oldDBR_INT): */ case(oldDBR_SHORT): status = dbChannelGet(chan, DBR_SHORT, pbuffer, &zero, nRequest, pfl); break; case(oldDBR_FLOAT): status = dbChannelGet(chan, DBR_FLOAT, pbuffer, &zero, nRequest, pfl); break; case(oldDBR_ENUM): status = dbChannelGet(chan, DBR_ENUM, pbuffer, &zero, nRequest, pfl); break; case(oldDBR_CHAR): status = dbChannelGet(chan, DBR_CHAR, pbuffer, &zero, nRequest, pfl); break; case(oldDBR_LONG): status = dbChannelGet(chan, DBR_LONG, pbuffer, &zero, nRequest, pfl); break; case(oldDBR_DOUBLE): status = dbChannelGet(chan, DBR_DOUBLE, pbuffer, &zero, nRequest, pfl); break; case(oldDBR_STS_STRING): case(oldDBR_GR_STRING): case(oldDBR_CTRL_STRING): { struct dbr_sts_string *pold = (struct dbr_sts_string *)pbuffer; struct { DBRstatus } newSt; options = DBR_STATUS; status = dbChannelGet(chan, DBR_STRING, &newSt, &options, &zero, pfl); pold->status = newSt.status; pold->severity = newSt.severity; status = dbChannelGet(chan, DBR_STRING, pold->value, &zero, nRequest, pfl); } break; /* case(oldDBR_STS_INT): */ case(oldDBR_STS_SHORT): { struct dbr_sts_int *pold = (struct dbr_sts_int *)pbuffer; struct { DBRstatus } newSt; options = DBR_STATUS; status = dbChannelGet(chan, DBR_SHORT, &newSt, &options, &zero, pfl); pold->status = newSt.status; pold->severity = newSt.severity; status = dbChannelGet(chan, DBR_SHORT, &pold->value, &zero, nRequest, pfl); } break; case(oldDBR_STS_FLOAT): { struct dbr_sts_float *pold = (struct dbr_sts_float *)pbuffer; struct { DBRstatus } newSt; options = DBR_STATUS; status = dbChannelGet(chan, DBR_FLOAT, &newSt, &options, &zero, pfl); pold->status = newSt.status; pold->severity = newSt.severity; status = dbChannelGet(chan, DBR_FLOAT, &pold->value, &zero, nRequest, pfl); } break; case(oldDBR_STS_ENUM): { struct dbr_sts_enum *pold = (struct dbr_sts_enum *)pbuffer; struct { DBRstatus } newSt; options = DBR_STATUS; status = dbChannelGet(chan, DBR_ENUM, &newSt, &options, &zero, pfl); pold->status = newSt.status; pold->severity = newSt.severity; status = dbChannelGet(chan, DBR_ENUM, &pold->value, &zero, nRequest, pfl); } break; case(oldDBR_STS_CHAR): { struct dbr_sts_char *pold = (struct dbr_sts_char *)pbuffer; struct { DBRstatus } newSt; options = DBR_STATUS; status = dbChannelGet(chan, DBR_UCHAR, &newSt, &options, &zero, pfl); pold->status = newSt.status; pold->severity = newSt.severity; status = dbChannelGet(chan, DBR_UCHAR, &pold->value, &zero, nRequest, pfl); } break; case(oldDBR_STS_LONG): { struct dbr_sts_long *pold = (struct dbr_sts_long *)pbuffer; struct { DBRstatus } newSt; options = DBR_STATUS; status = dbChannelGet(chan, DBR_LONG, &newSt, &options, &zero, pfl); pold->status = newSt.status; pold->severity = newSt.severity; status = dbChannelGet(chan, DBR_LONG, &pold->value, &zero, nRequest, pfl); } break; case(oldDBR_STS_DOUBLE): { struct dbr_sts_double *pold = (struct dbr_sts_double *)pbuffer; struct { DBRstatus } newSt; options = DBR_STATUS; status = dbChannelGet(chan, DBR_DOUBLE, &newSt, &options, &zero, pfl); pold->status = newSt.status; pold->severity = newSt.severity; options = 0; status = dbChannelGet(chan, DBR_DOUBLE, &pold->value, &options, nRequest, pfl); } break; case(oldDBR_TIME_STRING): { struct dbr_time_string *pold = (struct dbr_time_string *)pbuffer; struct { DBRstatus DBRtime } newSt; options = DBR_STATUS | DBR_TIME; status = dbChannelGet(chan, DBR_STRING, &newSt, &options, &zero, pfl); pold->status = newSt.status; pold->severity = newSt.severity; pold->stamp = newSt.time; /* structure copy */ options = 0; status = dbChannelGet(chan, DBR_STRING, pold->value, &options, nRequest, pfl); } break; /* case(oldDBR_TIME_INT): */ case(oldDBR_TIME_SHORT): { struct dbr_time_short *pold = (struct dbr_time_short *)pbuffer; struct { DBRstatus DBRtime } newSt; options = DBR_STATUS | DBR_TIME; status = dbChannelGet(chan, DBR_SHORT, &newSt, &options, &zero, pfl); pold->status = newSt.status; pold->severity = newSt.severity; pold->stamp = newSt.time; /* structure copy */ options = 0; status = dbChannelGet(chan, DBR_SHORT, &pold->value, &options, nRequest, pfl); } break; case(oldDBR_TIME_FLOAT): { struct dbr_time_float *pold = (struct dbr_time_float *)pbuffer; struct { DBRstatus DBRtime } newSt; options = DBR_STATUS | DBR_TIME; status = dbChannelGet(chan, DBR_FLOAT, &newSt, &options, &zero, pfl); pold->status = newSt.status; pold->severity = newSt.severity; pold->stamp = newSt.time; /* structure copy */ options = 0; status = dbChannelGet(chan, DBR_FLOAT, &pold->value, &options, nRequest, pfl); } break; case(oldDBR_TIME_ENUM): { struct dbr_time_enum *pold = (struct dbr_time_enum *)pbuffer; struct { DBRstatus DBRtime } newSt; options = DBR_STATUS | DBR_TIME; status = dbChannelGet(chan, DBR_ENUM, &newSt, &options, &zero, pfl); pold->status = newSt.status; pold->severity = newSt.severity; pold->stamp = newSt.time; /* structure copy */ options = 0; status = dbChannelGet(chan, DBR_ENUM, &pold->value, &options, nRequest, pfl); } break; case(oldDBR_TIME_CHAR): { struct dbr_time_char *pold = (struct dbr_time_char *)pbuffer; struct { DBRstatus DBRtime } newSt; options = DBR_STATUS | DBR_TIME; status = dbChannelGet(chan, DBR_CHAR, &newSt, &options, &zero, pfl); pold->status = newSt.status; pold->severity = newSt.severity; pold->stamp = newSt.time; /* structure copy */ options = 0; status = dbChannelGet(chan, DBR_CHAR, &pold->value, &options, nRequest, pfl); } break; case(oldDBR_TIME_LONG): { struct dbr_time_long *pold = (struct dbr_time_long *)pbuffer; struct { DBRstatus DBRtime } newSt; options = DBR_STATUS | DBR_TIME; status = dbChannelGet(chan, DBR_LONG, &newSt, &options, &zero, pfl); pold->status = newSt.status; pold->severity = newSt.severity; pold->stamp = newSt.time; /* structure copy */ options = 0; status = dbChannelGet(chan, DBR_LONG, &pold->value, &options, nRequest, pfl); } break; case(oldDBR_TIME_DOUBLE): { struct dbr_time_double *pold = (struct dbr_time_double *)pbuffer; struct { DBRstatus DBRtime } newSt; options = DBR_STATUS | DBR_TIME; status = dbChannelGet(chan, DBR_DOUBLE, &newSt, &options, &zero, pfl); pold->status = newSt.status; pold->severity = newSt.severity; pold->stamp = newSt.time; /* structure copy */ options = 0; status = dbChannelGet(chan, DBR_DOUBLE, &pold->value, &options, nRequest, pfl); } break; /* case(oldDBR_GR_STRING): NOT IMPLEMENTED - use DBR_STS_STRING */ /* case(oldDBR_GR_INT): */ case(oldDBR_GR_SHORT): { struct dbr_gr_int *pold = (struct dbr_gr_int *)pbuffer; struct { DBRstatus DBRunits DBRgrLong DBRalLong } newSt; options = DBR_STATUS | DBR_UNITS | DBR_GR_LONG | DBR_AL_LONG; status = dbChannelGet(chan, DBR_SHORT, &newSt, &options, &zero, pfl); pold->status = newSt.status; pold->severity = newSt.severity; strncpy(pold->units, newSt.units, MAX_UNITS_SIZE); pold->units[MAX_UNITS_SIZE-1] = '\0'; pold->upper_disp_limit = newSt.upper_disp_limit; pold->lower_disp_limit = newSt.lower_disp_limit; pold->upper_alarm_limit = newSt.upper_alarm_limit; pold->upper_warning_limit = newSt.upper_warning_limit; pold->lower_warning_limit = newSt.lower_warning_limit; pold->lower_alarm_limit = newSt.lower_alarm_limit; options = 0; status = dbChannelGet(chan, DBR_SHORT, &pold->value, &options, nRequest, pfl); } break; case(oldDBR_GR_FLOAT): { struct dbr_gr_float *pold = (struct dbr_gr_float *)pbuffer; struct { DBRstatus DBRunits DBRprecision DBRgrDouble DBRalDouble } newSt; options = DBR_STATUS | DBR_UNITS | DBR_PRECISION | DBR_GR_DOUBLE | DBR_AL_DOUBLE; status = dbChannelGet(chan, DBR_FLOAT, &newSt, &options, &zero, pfl); pold->status = newSt.status; pold->severity = newSt.severity; pold->precision = (dbr_short_t) newSt.precision.dp; strncpy(pold->units, newSt.units, MAX_UNITS_SIZE); pold->units[MAX_UNITS_SIZE-1] = '\0'; pold->upper_disp_limit = epicsConvertDoubleToFloat(newSt.upper_disp_limit); pold->lower_disp_limit = epicsConvertDoubleToFloat(newSt.lower_disp_limit); pold->upper_alarm_limit = epicsConvertDoubleToFloat(newSt.upper_alarm_limit); pold->lower_alarm_limit = epicsConvertDoubleToFloat(newSt.lower_alarm_limit); pold->upper_warning_limit = epicsConvertDoubleToFloat(newSt.upper_warning_limit); pold->lower_warning_limit = epicsConvertDoubleToFloat(newSt.lower_warning_limit); options = 0; status = dbChannelGet(chan, DBR_FLOAT, &pold->value, &options, nRequest, pfl); } break; /* case(oldDBR_GR_ENUM): see oldDBR_CTRL_ENUM */ case(oldDBR_GR_CHAR): { struct dbr_gr_char *pold = (struct dbr_gr_char *)pbuffer; struct { DBRstatus DBRunits DBRgrLong DBRalLong } newSt; options = DBR_STATUS | DBR_UNITS | DBR_GR_LONG | DBR_AL_LONG; status = dbChannelGet(chan, DBR_UCHAR, &newSt, &options, &zero, pfl); pold->status = newSt.status; pold->severity = newSt.severity; strncpy(pold->units, newSt.units, MAX_UNITS_SIZE); pold->units[MAX_UNITS_SIZE-1] = '\0'; pold->upper_disp_limit = newSt.upper_disp_limit; pold->lower_disp_limit = newSt.lower_disp_limit; pold->upper_alarm_limit = newSt.upper_alarm_limit; pold->upper_warning_limit = newSt.upper_warning_limit; pold->lower_warning_limit = newSt.lower_warning_limit; pold->lower_alarm_limit = newSt.lower_alarm_limit; options = 0; status = dbChannelGet(chan, DBR_UCHAR, &pold->value, &options, nRequest, pfl); } break; case(oldDBR_GR_LONG): { struct dbr_gr_long *pold = (struct dbr_gr_long *)pbuffer; struct { DBRstatus DBRunits DBRgrLong DBRalLong } newSt; options = DBR_STATUS | DBR_UNITS | DBR_GR_LONG | DBR_AL_LONG; status = dbChannelGet(chan, DBR_LONG, &newSt, &options, &zero, pfl); pold->status = newSt.status; pold->severity = newSt.severity; strncpy(pold->units, newSt.units, MAX_UNITS_SIZE); pold->units[MAX_UNITS_SIZE-1] = '\0'; pold->upper_disp_limit = newSt.upper_disp_limit; pold->lower_disp_limit = newSt.lower_disp_limit; pold->upper_alarm_limit = newSt.upper_alarm_limit; pold->upper_warning_limit = newSt.upper_warning_limit; pold->lower_warning_limit = newSt.lower_warning_limit; pold->lower_alarm_limit = newSt.lower_alarm_limit; options = 0; status = dbChannelGet(chan, DBR_LONG, &pold->value, &options, nRequest, pfl); } break; case(oldDBR_GR_DOUBLE): { struct dbr_gr_double *pold = (struct dbr_gr_double *)pbuffer; struct { DBRstatus DBRunits DBRprecision DBRgrDouble DBRalDouble } newSt; options = DBR_STATUS | DBR_UNITS | DBR_PRECISION | DBR_GR_DOUBLE | DBR_AL_DOUBLE; status = dbChannelGet(chan, DBR_DOUBLE, &newSt, &options, &zero, pfl); pold->status = newSt.status; pold->severity = newSt.severity; pold->precision = (dbr_short_t) newSt.precision.dp; strncpy(pold->units, newSt.units, MAX_UNITS_SIZE); pold->units[MAX_UNITS_SIZE-1] = '\0'; pold->upper_disp_limit = newSt.upper_disp_limit; pold->lower_disp_limit = newSt.lower_disp_limit; pold->upper_alarm_limit = newSt.upper_alarm_limit; pold->upper_warning_limit = newSt.upper_warning_limit; pold->lower_warning_limit = newSt.lower_warning_limit; pold->lower_alarm_limit = newSt.lower_alarm_limit; options = 0; status = dbChannelGet(chan, DBR_DOUBLE, &pold->value, &options, nRequest, pfl); } break; /* case(oldDBR_CTRL_INT): */ case(oldDBR_CTRL_SHORT): { struct dbr_ctrl_int *pold = (struct dbr_ctrl_int *)pbuffer; struct { DBRstatus DBRunits DBRgrLong DBRctrlLong DBRalLong } newSt; options = DBR_STATUS | DBR_UNITS | DBR_GR_LONG | DBR_CTRL_LONG | DBR_AL_LONG; status = dbChannelGet(chan, DBR_SHORT, &newSt, &options, &zero, pfl); pold->status = newSt.status; pold->severity = newSt.severity; strncpy(pold->units, newSt.units, MAX_UNITS_SIZE); pold->units[MAX_UNITS_SIZE-1] = '\0'; pold->upper_disp_limit = newSt.upper_disp_limit; pold->lower_disp_limit = newSt.lower_disp_limit; pold->upper_alarm_limit = newSt.upper_alarm_limit; pold->upper_warning_limit = newSt.upper_warning_limit; pold->lower_warning_limit = newSt.lower_warning_limit; pold->lower_alarm_limit = newSt.lower_alarm_limit; pold->upper_ctrl_limit = newSt.upper_ctrl_limit; pold->lower_ctrl_limit = newSt.lower_ctrl_limit; options = 0; status = dbChannelGet(chan, DBR_SHORT, &pold->value, &options, nRequest, pfl); } break; case(oldDBR_CTRL_FLOAT): { struct dbr_ctrl_float *pold = (struct dbr_ctrl_float *)pbuffer; struct { DBRstatus DBRunits DBRprecision DBRgrDouble DBRctrlDouble DBRalDouble } newSt; options = DBR_STATUS | DBR_UNITS | DBR_PRECISION | DBR_GR_DOUBLE | DBR_CTRL_DOUBLE | DBR_AL_DOUBLE; status = dbChannelGet(chan, DBR_FLOAT, &newSt, &options, &zero, pfl); pold->status = newSt.status; pold->severity = newSt.severity; pold->precision = (dbr_short_t) newSt.precision.dp; strncpy(pold->units, newSt.units, MAX_UNITS_SIZE); pold->units[MAX_UNITS_SIZE-1] = '\0'; pold->upper_disp_limit = epicsConvertDoubleToFloat(newSt.upper_disp_limit); pold->lower_disp_limit = epicsConvertDoubleToFloat(newSt.lower_disp_limit); pold->upper_alarm_limit = epicsConvertDoubleToFloat(newSt.upper_alarm_limit); pold->lower_alarm_limit = epicsConvertDoubleToFloat(newSt.lower_alarm_limit); pold->upper_warning_limit = epicsConvertDoubleToFloat(newSt.upper_warning_limit); pold->lower_warning_limit = epicsConvertDoubleToFloat(newSt.lower_warning_limit); pold->upper_ctrl_limit = epicsConvertDoubleToFloat(newSt.upper_ctrl_limit); pold->lower_ctrl_limit = epicsConvertDoubleToFloat(newSt.lower_ctrl_limit); options = 0; status = dbChannelGet(chan, DBR_FLOAT, &pold->value, &options, nRequest, pfl); } break; case(oldDBR_GR_ENUM): case(oldDBR_CTRL_ENUM): { struct dbr_ctrl_enum *pold = (struct dbr_ctrl_enum *)pbuffer; struct { DBRstatus DBRenumStrs } newSt; short no_str; memset(pold, '\0', sizeof(struct dbr_ctrl_enum)); /* first get status and severity */ options = DBR_STATUS | DBR_ENUM_STRS; status = dbChannelGet(chan, DBR_ENUM, &newSt, &options, &zero, pfl); pold->status = newSt.status; pold->severity = newSt.severity; no_str = newSt.no_str; if (no_str>16) no_str=16; pold->no_str = no_str; for (i = 0; i < no_str; i++) strncpy(pold->strs[i], newSt.strs[i], sizeof(pold->strs[i])); /*now get values*/ options = 0; status = dbChannelGet(chan, DBR_ENUM, &pold->value, &options, nRequest, pfl); } break; case(oldDBR_CTRL_CHAR): { struct dbr_ctrl_char *pold = (struct dbr_ctrl_char *)pbuffer; struct { DBRstatus DBRunits DBRgrLong DBRctrlLong DBRalLong } newSt; options = DBR_STATUS | DBR_UNITS | DBR_GR_LONG | DBR_CTRL_LONG | DBR_AL_LONG; status = dbChannelGet(chan, DBR_UCHAR, &newSt, &options, &zero, pfl); pold->status = newSt.status; pold->severity = newSt.severity; strncpy(pold->units, newSt.units, MAX_UNITS_SIZE); pold->units[MAX_UNITS_SIZE-1] = '\0'; pold->upper_disp_limit = newSt.upper_disp_limit; pold->lower_disp_limit = newSt.lower_disp_limit; pold->upper_alarm_limit = newSt.upper_alarm_limit; pold->upper_warning_limit = newSt.upper_warning_limit; pold->lower_warning_limit = newSt.lower_warning_limit; pold->lower_alarm_limit = newSt.lower_alarm_limit; pold->upper_ctrl_limit = newSt.upper_ctrl_limit; pold->lower_ctrl_limit = newSt.lower_ctrl_limit; options = 0; status = dbChannelGet(chan, DBR_UCHAR, &pold->value, &options, nRequest, pfl); } break; case(oldDBR_CTRL_LONG): { struct dbr_ctrl_long *pold = (struct dbr_ctrl_long *)pbuffer; struct { DBRstatus DBRunits DBRgrLong DBRctrlLong DBRalLong } newSt; options = DBR_STATUS | DBR_UNITS | DBR_GR_LONG | DBR_CTRL_LONG | DBR_AL_LONG; status = dbChannelGet(chan, DBR_LONG, &newSt, &options, &zero, pfl); pold->status = newSt.status; pold->severity = newSt.severity; strncpy(pold->units, newSt.units, MAX_UNITS_SIZE); pold->units[MAX_UNITS_SIZE-1] = '\0'; pold->upper_disp_limit = newSt.upper_disp_limit; pold->lower_disp_limit = newSt.lower_disp_limit; pold->upper_alarm_limit = newSt.upper_alarm_limit; pold->upper_warning_limit = newSt.upper_warning_limit; pold->lower_warning_limit = newSt.lower_warning_limit; pold->lower_alarm_limit = newSt.lower_alarm_limit; pold->upper_ctrl_limit = newSt.upper_ctrl_limit; pold->lower_ctrl_limit = newSt.lower_ctrl_limit; options = 0; status = dbChannelGet(chan, DBR_LONG, &pold->value, &options, nRequest, pfl); } break; case(oldDBR_CTRL_DOUBLE): { struct dbr_ctrl_double *pold = (struct dbr_ctrl_double *)pbuffer; struct { DBRstatus DBRunits DBRprecision DBRgrDouble DBRctrlDouble DBRalDouble } newSt; options = DBR_STATUS | DBR_UNITS | DBR_PRECISION | DBR_GR_DOUBLE | DBR_CTRL_DOUBLE | DBR_AL_DOUBLE; status = dbChannelGet(chan, DBR_DOUBLE, &newSt, &options, &zero, pfl); pold->status = newSt.status; pold->severity = newSt.severity; pold->precision = (dbr_short_t) newSt.precision.dp; strncpy(pold->units, newSt.units, MAX_UNITS_SIZE); pold->units[MAX_UNITS_SIZE-1] = '\0'; pold->upper_disp_limit = newSt.upper_disp_limit; pold->lower_disp_limit = newSt.lower_disp_limit; pold->upper_alarm_limit = newSt.upper_alarm_limit; pold->upper_warning_limit = newSt.upper_warning_limit; pold->lower_warning_limit = newSt.lower_warning_limit; pold->lower_alarm_limit = newSt.lower_alarm_limit; pold->upper_ctrl_limit = newSt.upper_ctrl_limit; pold->lower_ctrl_limit = newSt.lower_ctrl_limit; options = 0; status = dbChannelGet(chan, DBR_DOUBLE, &pold->value, &options, nRequest, pfl); } break; case(oldDBR_STSACK_STRING): { struct dbr_stsack_string *pold = (struct dbr_stsack_string *)pbuffer; struct { DBRstatus } newSt; options = DBR_STATUS; status = dbChannelGet(chan, DBR_STRING, &newSt, &options, &zero, pfl); pold->status = newSt.status; pold->severity = newSt.severity; pold->ackt = newSt.ackt; pold->acks = newSt.acks; options = 0; status = dbChannelGet(chan, DBR_STRING, pold->value, &options, nRequest, pfl); } break; case(oldDBR_CLASS_NAME): { DBENTRY dbEntry; char *name = 0; char *pto = (char *)pbuffer; if (!pdbbase) { status = S_db_notFound; break; } dbInitEntry(pdbbase, &dbEntry); status = dbFindRecord(&dbEntry, dbChannelRecord(chan)->name); if (!status) name = dbGetRecordTypeName(&dbEntry); dbFinishEntry(&dbEntry); if (status) break; if (!name) { status = S_dbLib_recordTypeNotFound; break; } pto[MAX_STRING_SIZE-1] = 0; strncpy(pto, name, MAX_STRING_SIZE-1); } break; default: status = -1; break; } dbScanUnlock(dbChannelRecord(chan)); if (status) return -1; return 0; }