Merge lp:~epics-core/epics-base/server-side-plugins into lp:~epics-core/epics-base/3.15

[mdavidsaver]

This branch takes the changes from

lp:~ralph-lange/epics-base/server-side-plugins

And updates them to the current 3.15 branch. So when reviewing the changes please check also for unintentionally reverted changes from the 3.15 branch.

[Andrew Johnson (anj)]

I've moved the filter plugins to src/std, which build Ok now, and am making some changes to the filter tests. I've copied the xRecord.dbd file and dbChannelTest.db into the filter/test directory rather than try to use them from some remote directory. Successfully loading the .dbd and .db files should not be counted as tests, they are pre-conditions of the actual tests to be able to run, so if they fail the test code should call call testAbort().

Is chfPluginTest.t supposed to produce these warnings?
  chfPluginTest.t ..... 1/1755
  Plugin buggy: provided storage (2 bytes) for i is too small for long (4)
  Plugin buggy: provided storage (2 bytes) for d is too small for double (8)
  Plugin buggy: provided storage (2 bytes) for s is too small for string (>= 4)
  Plugin buggy: provided storage (2 bytes) for c is too small for enum (4)
  chfPluginTest.t ..... ok

All the tests pass on linux-x86, but when I run them on 64-bit Linux chfPluginTest.t fails lots of tests and then core-dumps. I also get the following warning from arrTest and a similar core-dump:
  Plugin arr: provided storage (4 bytes) for s is too small for long (8)
Looking more deeply, the code inside chfPlugin.c is using long data types when it should be using epicsInt32. I'm working on fixing this, but it might take some time.

[lp:~epics-core/epics-base/server-side-plugins]

12360. By Andrew Johnson on 2012-06-21

Moved filter plugins, fixed portability issues.

The filter plugins are now in src/std/filters
and their tests in the test subdirectory.

Various portability issues found and fixed:
 * Variable declarations after statements in a block
 * Code assuming that epicsInt32 = long
 * // comments in C files

Removed a number of tests that weren't really tests;
preconditions for future tests that don't actually check
the code being tested should call testAbort() if the
condition fails, which tells the test harness that you
meant to die at that point.

Split up lots of very long source lines.

Probably made a few other changes that I forget about now.

=== modified file '.bzrignore'
--- .bzrignore	2009-12-23 21:06:44 +0000
+++ .bzrignore	2012-06-21 20:42:45 +0000
@@ -6,3 +6,6 @@
 ./include
 ./templates
 **/O.*
+./.cproject
+./.project
+./.settings
 
=== modified file 'configure/RULES.Db'
--- configure/RULES.Db	2012-05-29 21:44:49 +0000
+++ configure/RULES.Db	2012-06-21 20:42:45 +0000
@@ -397,12 +397,12 @@
 
 %_registerRecordDeviceDriver.cpp: $(COMMON_DIR)/%.dbd 
 	@$(RM) $@ $*.tmp
-	$(REGISTERRECORDDEVICEDRIVER) $< $(basename $@) $(IOC_INST_TOP) > $*.tmp
+	$(REGISTERRECORDDEVICEDRIVER) $(DBDFLAGS) $< $(basename $@) $(IOC_INST_TOP) > $*.tmp
 	$(MV) $*.tmp $@
 
 %_registerRecordDeviceDriver.cpp: %.dbd 
 	@$(RM) $@ $*.tmp
-	$(REGISTERRECORDDEVICEDRIVER) $< $(basename $@) $(IOC_INST_TOP) > $*.tmp
+	$(REGISTERRECORDDEVICEDRIVER) $(DBDFLAGS) $< $(basename $@) $(IOC_INST_TOP) > $*.tmp
 	$(MV) $*.tmp $@
 
 .PRECIOUS: %_registerRecordDeviceDriver.cpp
 
=== modified file 'src/Makefile'
--- src/Makefile	2012-03-14 20:27:40 +0000
+++ src/Makefile	2012-06-21 20:42:45 +0000
@@ -69,6 +69,10 @@
 DIRS += std
 std_DEPEND_DIRS = ioc libCom/RTEMS
 
+DIRS += std/filters/test
+std/filters/test_DEPEND_DIRS = std
+
+
 
 include $(TOP)/configure/RULES_DIRS
 
 
=== modified file 'src/ioc/as/asDbLib.c'
--- src/ioc/as/asDbLib.c	2012-05-03 17:19:34 +0000
+++ src/ioc/as/asDbLib.c	2012-06-21 20:42:45 +0000
@@ -6,7 +6,7 @@
 *     Operator of Los Alamos National Laboratory.
 * EPICS BASE Versions 3.13.7
 * and higher are distributed subject to a Software License Agreement found
-* in file LICENSE that is included with this distribution. 
+* in file LICENSE that is included with this distribution.
 \*************************************************************************/
 /* Author:  Marty Kraimer Date:    02-11-94*/
 
@@ -27,7 +27,7 @@
 #include "caeventmask.h"
 #include "callback.h"
 #include "dbStaticLib.h"
-#include "dbAddr.h"
+#include "dbChannel.h"
 #include "dbAccess.h"
 #include "db_field_log.h"
 #include "dbEvent.h"
@@ -40,7 +40,7 @@
 static char	*psubstitutions=NULL;
 static epicsThreadId	asInitTheadId=0;
 static int	firstTime = TRUE;
-
 
+
 static long asDbAddRecords(void)
 {
     DBENTRY	dbentry;
@@ -98,7 +98,7 @@
     }
     return(0);
 }
-
 
+
 static void asSpcAsCallback(struct dbCommon *precord)
 {
     asChangeGroup(&precord->asp, precord->asg);
@@ -109,7 +109,7 @@
     int *firstTime = (int *)arg;
     *firstTime = FALSE;
 }
-    
+
 static long asInitCommon(void)
 {
     long	status;
@@ -117,7 +117,7 @@
     int		wasFirstTime = firstTime;
     static epicsThreadOnceId asInitCommonOnceFlag = EPICS_THREAD_ONCE_INIT;
 
-    
+
     epicsThreadOnce(&asInitCommonOnceFlag,asInitCommonOnce,(void *)&firstTime);
     if(wasFirstTime) {
         if(!pacf) return(0); /*access security will NEVER be turned on*/
@@ -148,7 +148,7 @@
 {
     return(asInitCommon());
 }
-
 
+
 static void wdCallback(void *arg)
 {
     ASDBCALLBACK *pcallback = (ASDBCALLBACK *)arg;
@@ -195,23 +195,15 @@
     }
     return(0);
 }
-
 
-int epicsShareAPI asDbGetAsl(void *paddress)
+
+int epicsShareAPI asDbGetAsl(struct dbChannel *chan)
 {
-    DBADDR	*paddr = paddress;
-    dbFldDes	*pflddes;
-
-    pflddes = paddr->pfldDes;
-    return((int)pflddes->as_level);
+    return dbChannelFldDes(chan)->as_level;
 }
 
-void * epicsShareAPI asDbGetMemberPvt(void *paddress)
+void * epicsShareAPI asDbGetMemberPvt(struct dbChannel *chan)
 {
-    DBADDR	*paddr = paddress;
-    dbCommon	*precord;
-
-    precord = paddr->precord;
-    return((void *)precord->asp);
+    return dbChannelRecord(chan)->asp;
 }
 
 static void astacCallback(ASCLIENTPVT clientPvt,asClientStatus status)
@@ -259,7 +251,7 @@
     }
     return(0);
 }
-
 
+
 static void myMemberCallback(ASMEMBERPVT memPvt,FILE *fp)
 {
     dbCommon	*precord;
 
=== modified file 'src/ioc/as/asDbLib.h'
--- src/ioc/as/asDbLib.h	2010-10-05 19:27:37 +0000
+++ src/ioc/as/asDbLib.h	2012-06-21 20:42:45 +0000
@@ -5,12 +5,12 @@
 *     Operator of Los Alamos National Laboratory.
 * EPICS BASE Versions 3.13.7
 * and higher are distributed subject to a Software License Agreement found
-* in file LICENSE that is included with this distribution. 
+* in file LICENSE that is included with this distribution.
 \*************************************************************************/
 /* share/epicsH/dbAsLib.h	*/
 /*  $Revision-Id$ */
 /* Author:  Marty Kraimer Date:    02-23-94*/
-
 
+
 #ifndef INCdbAsLibh
 #define INCdbAsLibh
 
@@ -22,6 +22,8 @@
     long	status;
 } ASDBCALLBACK;
 
+struct dbChannel;
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -30,8 +32,8 @@
 epicsShareFunc int epicsShareAPI asSetSubstitutions(const char *substitutions);
 epicsShareFunc int epicsShareAPI asInit(void);
 epicsShareFunc int epicsShareAPI asInitAsyn(ASDBCALLBACK *pcallback);
-epicsShareFunc int epicsShareAPI asDbGetAsl( void *paddr);
-epicsShareFunc void *  epicsShareAPI asDbGetMemberPvt( void *paddr);
+epicsShareFunc int epicsShareAPI asDbGetAsl(struct dbChannel *chan);
+epicsShareFunc void * epicsShareAPI asDbGetMemberPvt(struct dbChannel *chan);
 epicsShareFunc int epicsShareAPI asdbdump(void);
 epicsShareFunc int epicsShareAPI asdbdumpFP(FILE *fp);
 epicsShareFunc int epicsShareAPI aspuag(const char *uagname);
 
=== modified file 'src/ioc/db/Makefile'
--- src/ioc/db/Makefile	2011-11-14 23:38:36 +0000
+++ src/ioc/db/Makefile	2012-06-21 20:42:45 +0000
@@ -17,9 +17,12 @@
 INC += dbCa.h
 INC += dbAddr.h
 INC += dbBkpt.h
+INC += dbChannel.h
 INC += dbConvert.h
 INC += dbConvertFast.h
+INC += dbExtractArray.h
 INC += dbEvent.h
+INC += dbLink.h
 INC += dbLock.h
 INC += dbNotify.h
 INC += dbScan.h
@@ -30,6 +33,8 @@
 INC += initHooks.h
 INC += recGbl.h
 INC += dbIocRegister.h
+INC += chfPlugin.h
+INC += dbState.h
 INC += db_access_routines.h
 INC += db_convert.h
 
@@ -50,11 +55,15 @@
 DBDINC += $(basename $(menuGlobal_DBD))
 DBDINC += dbCommon
 
+
 dbCore_SRCS += dbLock.c
 dbCore_SRCS += dbAccess.c
 dbCore_SRCS += dbBkpt.c
+dbCore_SRCS += dbChannel.c
 dbCore_SRCS += dbConvert.c
 dbCore_SRCS += dbFastLinkConv.c
+dbCore_SRCS += dbExtractArray.c
+dbCore_SRCS += dbLink.c
 dbCore_SRCS += dbNotify.c
 dbCore_SRCS += dbScan.c
 dbCore_SRCS += dbEvent.c
@@ -74,4 +83,6 @@
 dbCore_SRCS += dbContextReadNotifyCache.cpp
 dbCore_SRCS += templateInstances.cpp
 dbCore_SRCS += dbIocRegister.c
+dbCore_SRCS += chfPlugin.c
+dbCore_SRCS += dbState.c
 
 
=== added file 'src/ioc/db/chfPlugin.c'
--- src/ioc/db/chfPlugin.c	1970-01-01 00:00:00 +0000
+++ src/ioc/db/chfPlugin.c	2012-06-21 20:42:45 +0000
@@ -0,0 +1,649 @@
+/*************************************************************************\
+* Copyright (c) 2010 Brookhaven National Laboratory.
+* Copyright (c) 2010 Helmholtz-Zentrum Berlin
+*     fuer Materialien und Energie GmbH.
+* EPICS BASE is distributed subject to a Software License Agreement found
+* in file LICENSE that is included with this distribution.
+\*************************************************************************/
+
+/*
+ *  Author: Ralph Lange <[e-mail]>
+ */
+
+/* Based on the linkoptions utility by Michael Davidsaver (BNL) */
+
+#include <stdlib.h>
+#include <errno.h>
+#include <string.h>
+#include <limits.h>
+#include <math.h>
+
+#include <dbDefs.h>
+#include <dbStaticLib.h>
+#include <epicsTypes.h>
+#include <epicsStdio.h>
+#include <epicsString.h>
+#include <errlog.h>
+#include <shareLib.h>
+
+#define epicsExportSharedSymbols
+#include "chfPlugin.h"
+
+#ifndef HUGE_VALF
+#  define HUGE_VALF HUGE_VAL
+#endif
+#ifndef HUGE_VALL
+#  define HUGE_VALL (-(HUGE_VAL))
+#endif
+
+/*
+ * Data for a chfPlugin
+ */
+typedef struct chfPlugin {
+    const chfPluginArgDef *opts;
+    size_t nopts;
+    epicsUInt32 *required;
+    const chfPluginIf *pif;
+} chfPlugin;
+
+/*
+ * Parser state data for a chfFilter (chfPlugin instance)
+ */
+typedef struct chfFilter {
+    const chfPlugin *plugin;
+    epicsUInt32 *found;
+    void *puser;
+    epicsInt16 nextParam;
+} chfFilter;
+
+/* Data types we get from the parser */
+typedef enum chfPluginType {
+    chfPluginTypeBool,
+    chfPluginTypeInt,
+    chfPluginTypeDouble,
+    chfPluginTypeString
+} chfPluginType;
+
+/*
+ * Convert the (long) integer value 'val' to the type named in 'opt->optType'
+ * and store the result at 'user + opt->offset'.
+ */
+static int store_integer_value(const chfPluginArgDef *opt, void *user, long val)
+{
+    epicsInt32 *ival;
+    int *eval;
+    const chfPluginEnumType *emap;
+    double *dval;
+    char *sval;
+    char buff[22];              /* 2^64 = 1.8e+19, so 20 digits plus sign max */
+
+/*    printf("Got an integer for %s (type %d): %ld\n", opt->name, opt->optType, val); */
+
+    if (!opt->convert && opt->optType != chfPluginArgInt32) {
+        return -1;
+    }
+
+    switch (opt->optType) {
+    case chfPluginArgInt32:
+        ival = (epicsInt32 *) ((char *)user + opt->offset);
+        *ival = val;
+        break;
+    case chfPluginArgBoolean:
+        eval = (int*) ((char*)user + opt->offset);
+        *eval = !!val;
+        break;
+    case chfPluginArgDouble:
+        dval = (double*) ((char*)user + opt->offset);
+        *dval = (double) val;
+        break;
+    case chfPluginArgString:
+        sval = ((char*)user + opt->offset);
+        sprintf(buff, "%ld", val);
+        if (strlen(buff) > opt->size-1) {
+            return -1;
+        }
+        strncpy(sval, buff, opt->size-1);
+        sval[opt->size-1]='\0';
+        break;
+    case chfPluginArgEnum:
+        eval = (int*) ((char*)user + opt->offset);
+        for (emap = opt->enums; emap && emap->name; emap++) {
+            if (val == emap->value) {
+                *eval = val;
+                break;
+            }
+        }
+        if (!emap || !emap->name) {
+            return -1;
+        }
+        break;
+    case chfPluginArgInvalid:
+        return -1;
+    }
+    return 0;
+}
+
+/*
+ * Convert the (int) boolean value 'val' to the type named in 'opt->optType'
+ * and store the result at 'user + opt->offset'.
+ */
+static int store_boolean_value(const chfPluginArgDef *opt, void *user, int val)
+{
+    epicsInt32 *ival;
+    int *eval;
+    double *dval;
+    char *sval;
+
+/*    printf("Got a boolean for %s (type %d): %d\n", opt->name, opt->optType, val); */
+
+    if (!opt->convert && opt->optType != chfPluginArgBoolean) {
+        return -1;
+    }
+
+    switch (opt->optType) {
+    case chfPluginArgInt32:
+        ival = (epicsInt32 *) ((char*)user + opt->offset);
+        *ival = val;
+        break;
+    case chfPluginArgBoolean:
+        eval = (int*) ((char*)user + opt->offset);
+        *eval = val;
+        break;
+    case chfPluginArgDouble:
+        dval = (double*) ((char*)user + opt->offset);
+        *dval = val ? 1. : 0.;
+        break;
+    case chfPluginArgString:
+        sval = ((char*)user + opt->offset);
+        if ((val ? 4 : 5) > opt->size-1) {
+            return -1;
+        }
+        strncpy(sval, (val ? "true" : "false"), opt->size-1);
+        sval[opt->size-1]='\0';
+        break;
+    case chfPluginArgEnum:
+    case chfPluginArgInvalid:
+        return -1;
+    }
+    return 0;
+}
+
+/*
+ * Convert the double value 'val' to the type named in 'opt->optType'
+ * and store the result at 'user + opt->offset'.
+ */
+static int store_double_value(const chfPluginArgDef *opt, void *user, double val)
+{
+    epicsInt32 *ival;
+    int *eval;
+    double *dval;
+    char *sval;
+    int i;
+
+/*
+    printf("Got a double for %s (type %d, convert: %s): %g\n",
+           opt->name, opt->optType, opt->convert?"yes":"no", val);
+*/
+    if (!opt->convert && opt->optType != chfPluginArgDouble) {
+        return -1;
+    }
+
+    switch (opt->optType) {
+    case chfPluginArgInt32:
+#if (LONG_MAX > 0x7fffffff)
+        if (val < -0x80000000L || val > 0x7fffffff) {
+            return -1;
+        }
+#endif
+        ival = (epicsInt32 *) ((char*)user + opt->offset);
+        *ival = val;
+        break;
+    case chfPluginArgBoolean:
+        eval = (int*) ((char*)user + opt->offset);
+        *eval = (val != 0.) ? 1 : 0;
+        break;
+    case chfPluginArgDouble:
+        dval = (double*) ((char*)user + opt->offset);
+        *dval = val;
+        break;
+    case chfPluginArgString:
+        sval = ((char*)user + opt->offset);
+        if (opt->size <= 8) {       /* Play it safe: 3 exp + 2 sign + 'e' + '.' */
+            return -1;
+        }
+        i = epicsSnprintf(sval, opt->size, "%.*g", (int) opt->size - 7, val);
+        if (i >= opt->size) {
+            return -1;
+        }
+        break;
+    case chfPluginArgEnum:
+    case chfPluginArgInvalid:
+        return -1;
+    }
+    return 0;
+}
+
+/*
+ * Convert the (char*) string value 'val' to the type named in 'opt->optType'
+ * and store the result at 'user + opt->offset'.
+ */
+static int store_string_value(const chfPluginArgDef *opt, void *user, const char *val, size_t len)
+{
+    epicsInt32 *ival;
+    long lval;
+    int *eval;
+    const chfPluginEnumType *emap;
+    double *dval;
+    char *sval;
+    char *end;
+    int i;
+
+/*    printf("Got a string for %s (type %d): %.*s\n", opt->name, opt->optType, len, val); */
+
+    if (!opt->convert && opt->optType != chfPluginArgString && opt->optType != chfPluginArgEnum) {
+        return -1;
+    }
+
+    switch (opt->optType) {
+    case chfPluginArgInt32:
+        lval = strtol(val, &end, 0);
+        /* test for the myriad error conditions which strtol may use */
+        if (lval == LONG_MAX || lval == LONG_MIN
+#if (LONG_MAX > 0x7fffffff)
+            || lval < -0x80000000L || lval > 0x7fffffff
+#endif
+            || end == val) {
+            return -1;
+        }
+        ival = (epicsInt32 *) ((char*)user + opt->offset);
+        *ival = lval;
+        break;
+    case chfPluginArgBoolean:
+        eval = (int*) ((char*)user + opt->offset);
+        if (epicsStrnCaseCmp(val, "true", len) == 0) {
+            *eval = 1;
+        } else if (epicsStrnCaseCmp(val, "false", len) == 0) {
+            *eval = 0;
+        } else {
+            i = strtol(val, &end, 0);
+            if (i > INT_MAX || i < INT_MIN || end == val) {
+                return -1;
+            }
+            *eval = !!i;
+        }
+        break;
+    case chfPluginArgDouble:
+        dval = (double*) ((char*)user + opt->offset);
+        *dval = strtod(val, &end);
+        /* Indicates errors in the same manner as strtol */
+        if (*dval==HUGE_VALF||*dval==HUGE_VALL||end==val )
+        {
+            return -1;
+        }
+        break;
+    case chfPluginArgString:
+        i = opt->size-1 < len ? opt->size-1 : len;
+        sval = ((char*)user + opt->offset);
+        strncpy(sval, val, i);
+        sval[i] = '\0';
+        break;
+    case chfPluginArgEnum:
+        eval = (int*) ((char*)user + opt->offset);
+        for (emap = opt->enums; emap && emap->name; emap++) {
+            if (strncmp(emap->name, val, len) == 0) {
+                *eval = emap->value;
+                break;
+            }
+        }
+        if( !emap || !emap->name ) {
+            return -1;
+        }
+        break;
+    case chfPluginArgInvalid:
+        return -1;
+    }
+    return 0;
+}
+
+static void freeInstanceData(chfFilter *f)
+{
+    free(f->found);  /* FIXME: Use a free-list */
+    free(f);         /* FIXME: Use a free-list */
+}
+
+/*
+ * chFilterIf callbacks
+ */
+
+/* First entry point when a new filter instance is created.
+ * All per-instance allocations happen here.
+ */
+static parse_result parse_start(chFilter *filter)
+{
+    chfPlugin *p = (chfPlugin*) filter->plug->puser;
+    chfFilter *f;
+
+    /* Filter context */
+    /* FIXME: Use a free-list */
+    f = calloc(1, sizeof(chfFilter));
+    if (!f) {
+        fprintf(stderr,"chfFilterCtx calloc failed\n");
+        goto errfctx;
+    }
+    f->nextParam = -1;
+
+    /* Bit array to find missing required keys */
+    /* FIXME: Use a free-list */
+    f->found = calloc( (p->nopts/32)+1, sizeof(epicsUInt32) );
+    if (!f->found) {
+        fprintf(stderr,"chfConfigParseStart: bit array calloc failed\n");
+        goto errbitarray;
+    }
+
+    /* Call the plugin to allocate its structure, it returns NULL on error */
+    if (p->pif->allocPvt) {
+        if ((f->puser = p->pif->allocPvt()) == NULL)
+            goto errplugin;
+    }
+
+    filter->puser = (void*) f;
+
+    return parse_continue;
+
+    errplugin:
+    free(f->found);  /* FIXME: Use a free-list */
+    errbitarray:
+    free(f);         /* FIXME: Use a free-list */
+    errfctx:
+    return parse_stop;
+}
+
+static void parse_abort(chFilter *filter) {
+    chfPlugin *p = (chfPlugin*) filter->plug->puser;
+    chfFilter *f = (chfFilter*) filter->puser;
+
+    /* Call the plugin to tell it we're aborting */
+    if (p->pif->parse_error) p->pif->parse_error(f->puser);
+    if (p->pif->freePvt) p->pif->freePvt(f->puser);
+    freeInstanceData(f);
+}
+
+static parse_result parse_end(chFilter *filter)
+{
+    chfPlugin *p = (chfPlugin*) filter->plug->puser;
+    chfFilter *f = (chfFilter*) filter->puser;
+    int i;
+
+    /* Check if all required arguments were supplied */
+    for(i = 0; i < (p->nopts/32)+1; i++) {
+        if ((f->found[i] & p->required[i]) != p->required[i]) {
+            if (p->pif->parse_error) p->pif->parse_error(f->puser);
+            if (p->pif->freePvt) p->pif->freePvt(f->puser);
+            freeInstanceData(f);
+            return parse_stop;
+        }
+    }
+
+    /* Call the plugin to tell it we're done */
+    if (p->pif->parse_ok) {
+        if (p->pif->parse_ok(f->puser)) {
+            if (p->pif->freePvt) p->pif->freePvt(f->puser);
+            freeInstanceData(f);
+            return parse_stop;
+        }
+    }
+
+    return parse_continue;
+}
+
+static parse_result parse_boolean(chFilter *filter, int boolVal)
+{
+    const chfPluginArgDef *opts = ((chfPlugin*)filter->plug->puser)->opts;
+    chfFilter *f =  (chfFilter*)filter->puser;
+
+    if (f->nextParam < 0 || store_boolean_value(&opts[f->nextParam], f->puser, boolVal)) {
+        return parse_stop;
+    } else {
+        return parse_continue;
+    }
+}
+
+static parse_result parse_integer(chFilter *filter, long integerVal)
+{
+    const chfPluginArgDef *opts = ((chfPlugin*)filter->plug->puser)->opts;
+    chfFilter *f =  (chfFilter*)filter->puser;
+
+    if (f->nextParam < 0 || store_integer_value(&opts[f->nextParam], f->puser, integerVal)) {
+        return parse_stop;
+    } else {
+        return parse_continue;
+    }
+}
+
+static parse_result parse_double(chFilter *filter, double doubleVal)
+{
+    const chfPluginArgDef *opts = ((chfPlugin*)filter->plug->puser)->opts;
+    chfFilter *f =  (chfFilter*)filter->puser;
+
+    if (f->nextParam < 0 || store_double_value(&opts[f->nextParam], f->puser, doubleVal)) {
+        return parse_stop;
+    } else {
+        return parse_continue;
+    }
+}
+
+static parse_result parse_string(chFilter *filter, const char *stringVal, size_t stringLen)
+{
+    const chfPluginArgDef *opts = ((chfPlugin*)filter->plug->puser)->opts;
+    chfFilter *f = (chfFilter*)filter->puser;
+
+    if (f->nextParam < 0 || store_string_value(&opts[f->nextParam], f->puser, stringVal, stringLen)) {
+        return parse_stop;
+    } else {
+        return parse_continue;
+    }
+}
+
+static parse_result parse_start_map(chFilter *filter)
+{
+    return parse_continue;
+}
+
+static parse_result parse_map_key(chFilter *filter, const char *key, size_t stringLen)
+{
+    const chfPluginArgDef *cur;
+    const chfPluginArgDef *opts = ((chfPlugin*)filter->plug->puser)->opts;
+    chfFilter *f =  (chfFilter*)filter->puser;
+    int i;
+
+    f->nextParam = -1;
+    for(cur = opts, i = 0; cur && cur->name; cur++, i++) {
+        if (strncmp(key, cur->name, stringLen) == 0) {
+            f->nextParam = i;
+            break;
+        }
+    }
+    if (f->nextParam == -1) {
+        return parse_stop;
+    }
+
+    f->found[i/32] |= 1<<(i%32);
+    return parse_continue;
+}
+
+static parse_result parse_end_map(chFilter *filter)
+{
+    return parse_continue;
+}
+
+static long channel_open(chFilter *filter)
+{
+    chfPlugin *p = (chfPlugin*) filter->plug->puser;
+    chfFilter *f = (chfFilter*) filter->puser;
+
+    if (p->pif->channel_open) return p->pif->channel_open(filter->chan, f->puser);
+    else return 0;
+}
+
+static void channel_register_pre(chFilter *filter,
+                                 chPostEventFunc **cb_out, void **arg_out, db_field_log *probe)
+{
+    chfPlugin *p = (chfPlugin*) filter->plug->puser;
+    chfFilter *f = (chfFilter*) filter->puser;
+
+    if (p->pif->channelRegisterPre)
+        p->pif->channelRegisterPre(filter->chan, f->puser, cb_out, arg_out, probe);
+}
+
+static void channel_register_post(chFilter *filter,
+                                  chPostEventFunc **cb_out, void **arg_out, db_field_log *probe)
+{
+    chfPlugin *p = (chfPlugin*) filter->plug->puser;
+    chfFilter *f = (chfFilter*) filter->puser;
+
+    if (p->pif->channelRegisterPost)
+        p->pif->channelRegisterPost(filter->chan, f->puser, cb_out, arg_out, probe);
+}
+
+static void channel_report(chFilter *filter, int level, const unsigned short indent)
+{
+    chfPlugin *p = (chfPlugin*) filter->plug->puser;
+    chfFilter *f = (chfFilter*) filter->puser;
+
+    if (p->pif->channel_report)
+        p->pif->channel_report(filter->chan, f->puser, level, indent);
+}
+
+static void channel_close(chFilter *filter)
+{
+    chfPlugin *p = (chfPlugin*) filter->plug->puser;
+    chfFilter *f =  (chfFilter*) filter->puser;
+
+    if (p->pif->channel_close) p->pif->channel_close(filter->chan, f->puser);
+    if (p->pif->freePvt) p->pif->freePvt(f->puser);
+    free(f->found);  /* FIXME: Use a free-list */
+    free(f);         /* FIXME: Use a free-list */
+}
+
+/*
+ * chFilterIf for the wrapper
+ * we just support a simple one-level map, and no arrays
+ */
+static chFilterIf wrapper_fif = {
+    parse_start,
+    parse_abort,
+    parse_end,
+
+    NULL, /* parse_null, */
+    parse_boolean,
+    parse_integer,
+    parse_double,
+    parse_string,
+
+    parse_start_map,
+    parse_map_key,
+    parse_end_map,
+
+    NULL, /* parse_start_array, */
+    NULL, /* parse_end_array, */
+
+    channel_open,
+    channel_register_pre,
+    channel_register_post,
+    channel_report,
+    channel_close
+};
+
+const char* chfPluginEnumString(const chfPluginEnumType *emap, int i, const char* def)
+{
+    for(; emap && emap->name; emap++) {
+        if ( i == emap->value ) {
+            return emap->name;
+        }
+    }
+    return def;
+}
+
+int chfPluginRegister(const char* key, const chfPluginIf *pif, const chfPluginArgDef* opts)
+{
+    chfPlugin *p;
+    size_t i;
+    const chfPluginArgDef *cur;
+    epicsUInt32 *reqd;
+
+    /* Check and count options */
+    for (i = 0, cur = opts; cur && cur->name; i++, cur++) {
+        switch(cur->optType) {
+        case chfPluginArgInt32:
+            if (cur->size < sizeof(epicsInt32)) {
+                errlogPrintf("Plugin %s: provided storage (%d bytes) for %s is too small for epicsInt32 (%lu)\n",
+                             key, cur->size, cur->name,
+                             (unsigned long) sizeof(epicsInt32));
+                return -1;
+            }
+            break;
+        case chfPluginArgBoolean:
+            if (cur->size < 1) {
+                errlogPrintf("Plugin %s: provided storage (%d bytes) for %s is too small for boolean (%lu)\n",
+                             key, cur->size, cur->name,
+                             (unsigned long) sizeof(char));
+                return -1;
+            }
+            break;
+        case chfPluginArgDouble:
+            if (cur->size < sizeof(double)) {
+                errlogPrintf("Plugin %s: provided storage (%d bytes) for %s is too small for double (%lu)\n",
+                             key, cur->size, cur->name,
+                             (unsigned long) sizeof(double));
+                return -1;
+            }
+            break;
+        case chfPluginArgString:
+            if (cur->size < sizeof(char*)) {
+                  /* Catch if someone has given us a char* instead of a char[]
+                   * Also means that char buffers must be >=4.
+                   */
+                errlogPrintf("Plugin %s: provided storage (%d bytes) for %s is too small for string (>= %lu)\n",
+                             key, cur->size, cur->name,
+                             (unsigned long) sizeof(char*));
+                return -1;
+            }
+            break;
+        case chfPluginArgEnum:
+            if (cur->size < sizeof(int)) {
+                errlogPrintf("Plugin %s: provided storage (%d bytes) for %s is too small for enum (%lu)\n",
+                             key, cur->size, cur->name,
+                             (unsigned long) sizeof(int));
+                return -1;
+            }
+            break;
+        case chfPluginArgInvalid:
+            errlogPrintf("Plugin %s: storage type for %s is not defined\n",
+                         key, cur->name);
+            return -1;
+            break;
+        }
+    }
+
+    /* Bit array used to find missing required keys */
+    reqd = dbCalloc((i/32)+1, sizeof(epicsUInt32));
+    if (!reqd) {
+        fprintf(stderr,"Plugin %s: bit array calloc failed\n", key);
+        return -1;
+    }
+
+    for (i = 0, cur = opts; cur && cur->name; i++, cur++) {
+        if (cur->required) reqd[i/32] |= 1 << (i%32);
+    }
+
+    /* Plugin data */
+    p = dbCalloc(1, sizeof(chfPlugin));
+    p->pif = pif;
+    p->opts = opts;
+    p->nopts = i;
+    p->required = reqd;
+
+    dbRegisterFilter(key, &wrapper_fif, p);
+
+    return 0;
+}
 
=== added file 'src/ioc/db/chfPlugin.h'
--- src/ioc/db/chfPlugin.h	1970-01-01 00:00:00 +0000
+++ src/ioc/db/chfPlugin.h	2012-06-21 20:42:45 +0000
@@ -0,0 +1,280 @@
+/*************************************************************************\
+* Copyright (c) 2010 Brookhaven National Laboratory.
+* Copyright (c) 2010 Helmholtz-Zentrum Berlin
+*     fuer Materialien und Energie GmbH.
+* EPICS BASE is distributed subject to a Software License Agreement found
+* in file LICENSE that is included with this distribution.
+\*************************************************************************/
+
+/*
+ *  Author: Ralph Lange <[e-mail]>
+ */
+
+/* Based on the linkoptions utility by Michael Davidsaver (BNL) */
+
+#ifndef CHFPLUGIN_H
+#define CHFPLUGIN_H
+
+#include <shareLib.h>
+#include <dbDefs.h>
+#include <epicsTypes.h>
+#include <dbChannel.h>
+
+struct db_field_log;
+
+/** @file chfPlugin.h
+ * @brief Channel filter simplified plugins.
+ *
+ * Utility layer to allow an easier (reduced) interface for
+ * channel filter plugins.
+ *
+ * Parsing the configuration arguments of a channel filter plugin
+ * is done according to an argument description table provided by the plugin.
+ * The parser stores the results directly into a user supplied structure
+ * after appropriate type conversion.
+ *
+ * To specify the arguments, a chfPluginArgDef table must be defined
+ * for the user structure. This table has to be specified when the plugin registers.
+ *
+ * The plugin is responsible to register an init function using
+ * epicsExportRegistrar() and the accompanying registrar() directive in the dbd,
+ * and call chfPluginRegister() from within the init function.
+ *
+ * For example:
+ *
+ * typedef struct myStruct {
+ *   ... other stuff
+ *   epicsUInt32 ival;
+ *   double      dval;
+ *   epicsUInt32 ival2;
+ *   int         enumval;
+ *   char       strval[20];
+ * } myStruct;
+ *
+ * static const
+ * chfPluginEnumType colorEnum[] = { {"Red",1}, {"Green",2}, {"Blue",3}, {NULL,0} };
+ *
+ * static const
+ * chfPluginDef myStructDef[] = {
+ *   chfInt32 (myStruct, ival,    "Integer" , 0, 0),
+ *   chfInt32 (myStruct, ival2,   "Second"  , 1, 0),
+ *   chfDouble(myStruct, dval,    "Double"  , 1, 0),
+ *   chfString(myStruct, strval , "String"  , 1, 0),
+ *   chfEnum  (myStruct, enumval, "Color"   , 1, 0, colorEnum),
+ *   chfPluginEnd
+ * };
+ *
+ * Note: The 4th argument specifies the parameter to be required (1) or optional (0),
+ *       the 5th whether converting to the required type is allowed (1), or
+ *       type mismatches are an error (0).
+ *
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** @brief Channel filter simplified plugin interface.
+ *
+ * The routines in this structure must be implemented by each filter plugin.
+ */
+typedef struct chfPluginIf {
+
+    /* Memory management */
+    /** @brief Allocate private resources.
+     *
+     * <em>Called before parsing starts.</em>
+     * The plugin should allocate its per-instance structures,
+     * returning a pointer to them or NULL requesting an abort of the operation.
+     *
+     * allocPvt may be set to NULL, if no resource allocation is needed.
+     *
+     * @return Pointer to private structure, NULL if operation is to be aborted.
+     */
+    void * (* allocPvt) (void);
+
+    /** @brief Free private resources.
+     *
+     * <em>Called as part of abort or shutdown.</em>
+     * The plugin should release any resources allocated for this filter;
+     * no further calls through this interface will be made.
+     *
+     * freePvt may be set to NULL, if no resources need to be released.
+     *
+     * @param pvt Pointer to private structure.
+     */
+    void (* freePvt) (void *pvt);
+
+    /* Parameter parsing results */
+    /** @brief A parsing error occurred.
+     *
+     * <em>Called after parsing failed with an error.</em>
+     *
+     * @param pvt Pointer to private structure.
+     */
+    void (* parse_error) (void *pvt);
+
+    /** @brief Configuration has been parsed successfully.
+     *
+     * <em>Called after parsing has finished ok.</em>
+     * The plugin may check the validity of the parsed data,
+     * returning -1 to request an abort of the operation.
+     *
+     * @param pvt Pointer to private structure.
+     * @return 0 for success, -1 if operation is to be aborted.
+     */
+    int (* parse_ok) (void *pvt);
+
+    /* Channel operations */
+    /** @brief Open channel.
+     *
+     * <em>Called as part of the channel connection setup.</em>
+     *
+     * @param chan dbChannel for which the connection is being made.
+     * @param pvt Pointer to private structure.
+     * @return 0 for success, -1 if operation is to be aborted.
+     */
+    long (* channel_open) (dbChannel *chan, void *pvt);
+
+    /** @brief Register callbacks for pre-event-queue operation.
+     *
+     * <em>Called as part of the channel connection setup.</em>
+     *
+     * This function is called to establish the stack of plugins that an event
+     * is passed through between the database and the event queue.
+     *
+     * The plugin must set pe_out to point to its own post-event callback in order
+     * to be called when a data update is sent from the database towards the
+     * event queue.
+     *
+     * The plugin may find out the type of data it will receive by looking at 'probe'.
+     * If the plugin will change the data type and/or size, it must update 'probe'
+     * accordingly.
+     *
+     * @param chan dbChannel for which the connection is being made.
+     * @param pvt Pointer to private structure.
+     * @param cb_out Pointer to this plugin's post-event callback (NULL to bypass
+     *        this plugin).
+     * @param arg_out Argument that must be supplied when calling
+     *        this plugin's post-event callback.
+     */
+    void (* channelRegisterPre) (dbChannel *chan, void *pvt,
+                                 chPostEventFunc **cb_out, void **arg_out,
+                                 db_field_log *probe);
+
+    /** @brief Register callbacks for post-event-queue operation.
+     *
+     * <em>Called as part of the channel connection setup.</em>
+     *
+     * This function is called to establish the stack of plugins that an event
+     * is passed through between the event queue and the final user (CA server or
+     * database access).
+     *
+     * The plugin must set pe_out to point to its own post-event callback in order
+     * to be called when a data update is sent from the event queue towards the
+     * final user.
+     *
+     * The plugin may find out the type of data it will receive by looking at 'probe'.
+     * If the plugin will change the data type and/or size, it must update 'probe'
+     * accordingly.
+     *
+     * @param chan dbChannel for which the connection is being made.
+     * @param pvt Pointer to private structure.
+     * @param cb_out Pointer to this plugin's post-event callback (NULL to bypass
+     *        this plugin).
+     * @param arg_out Argument that must be supplied when calling
+     *        this plugin's post-event callback.
+     */
+    void (* channelRegisterPost) (dbChannel *chan, void *pvt,
+                                  chPostEventFunc **cb_out, void **arg_out,
+                                  db_field_log *probe);
+
+    /** @brief Channel report request.
+     *
+     * <em>Called as part of show... routines.</em>
+     *
+     * @param chan dbChannel for which the report is requested.
+     * @param pvt Pointer to private structure.
+     * @param level Interest level.
+     * @param indent Number of spaces to print before each output line.
+     */
+    void (* channel_report) (dbChannel *chan, void *pvt, int level, const unsigned short indent);
+
+    /* FIXME: More filter routines here ... */
+
+    /** @brief Channel close request.
+     *
+     * <em>Called as part of connection shutdown.</em>
+     * @param chan dbChannel for which the connection is being shut down.
+     * @param pvt Pointer to private structure.
+     */
+    void (* channel_close) (dbChannel *chan, void *pvt);
+
+} chfPluginIf;
+
+typedef enum chfPluginArg {
+    chfPluginArgInvalid=0,
+    chfPluginArgBoolean,
+    chfPluginArgInt32,
+    chfPluginArgDouble,
+    chfPluginArgString,
+    chfPluginArgEnum
+} chfPluginArg;
+
+typedef struct chfPluginEnumType {
+    const char *name;
+    const int value;
+} chfPluginEnumType;
+
+typedef struct chfPluginArgDef {
+    const char * name;
+    chfPluginArg optType;
+    unsigned int required:1;
+    unsigned int convert:1;
+    epicsUInt32 offset;
+    epicsUInt32 size;
+    const chfPluginEnumType *enums;
+} chfPluginArgDef;
+
+#define chfInt32(Struct, Member, Name, Req, Conv) \
+{Name, chfPluginArgInt32, Req, Conv, OFFSET(Struct, Member), sizeof( ((Struct*)0)->Member ), NULL}
+
+#define chfBoolean(Struct, Member, Name, Req, Conv) \
+{Name, chfPluginArgBoolean, Req, Conv, OFFSET(Struct, Member), sizeof( ((Struct*)0)->Member ), NULL}
+
+#define chfDouble(Struct, Member, Name, Req, Conv) \
+{Name, chfPluginArgDouble, Req, Conv, OFFSET(Struct, Member), sizeof( ((Struct*)0)->Member ), NULL}
+
+#define chfString(Struct, Member, Name, Req, Conv) \
+{Name, chfPluginArgString, Req, Conv, OFFSET(Struct, Member), sizeof( ((Struct*)0)->Member ), NULL}
+
+#define chfEnum(Struct, Member, Name, Req, Conv, Enums) \
+{Name, chfPluginArgEnum, Req, Conv, OFFSET(Struct, Member), sizeof( ((Struct*)0)->Member ), Enums}
+
+#define chfPluginArgEnd {0}
+
+/* Extra output when parsing and converting */
+#define CHFPLUGINDEBUG 1
+
+/** @brief Return the string associated with Enum index 'i'.
+ *
+ * @param Enums A null-terminated array of string/integer pairs.
+ * @param i An Enum index.
+ * @param def String to be returned when 'i' isn't a valid Enum index.
+ * @return The string associated with 'i'.
+ */
+epicsShareFunc const char* chfPluginEnumString(const chfPluginEnumType *Enums, int i, const char* def);
+
+/** @brief Register a plugin.
+ *
+ * @param key The plugin name key that clients will use.
+ * @param pif Pointer to the plugin's interface.
+ * @param opts Pointer to the configuration argument description table.
+ */
+epicsShareFunc int chfPluginRegister(const char* key, const chfPluginIf *pif, const chfPluginArgDef* opts);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // CHFPLUGIN_H
 
=== modified file 'src/ioc/db/dbAccess.c'
--- src/ioc/db/dbAccess.c	2012-02-20 16:01:04 +0000
+++ src/ioc/db/dbAccess.c	2012-06-21 20:42:45 +0000
@@ -1,21 +1,22 @@
 /*************************************************************************\
+* Copyright (c) 2010 Brookhaven National Laboratory.
+* Copyright (c) 2010 Helmholtz-Zentrum Berlin
+*     fuer Materialien und Energie GmbH.
 * Copyright (c) 2002 The University of Chicago, 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 Versions 3.13.7
-* and higher are distributed subject to a Software License Agreement found
-* in file LICENSE that is included with this distribution. 
+* EPICS BASE is distributed subject to a Software License Agreement found
+* in file LICENSE that is included with this distribution.
 \*************************************************************************/
-/* dbAccess.c */
-/* $Revision-Id$ */
+
 /*
  *      Original Author: Bob Dalesio
  *      Current Author:  Marty Kraimer
- *      Date:            11-7-90
-*/
+ *                       Andrew Johnson <[e-mail]>
+ *                       Ralph Lange <[e-mail]>
+ */
 
-
 
 #include <stddef.h>
 #include <stdlib.h>
 #include <stdarg.h>
@@ -46,6 +47,7 @@
 #include "dbAddr.h"
 #include "callback.h"
 #include "dbScan.h"
+#include "dbLink.h"
 #include "dbLock.h"
 #include "dbEvent.h"
 #include "dbConvert.h"
@@ -89,17 +91,6 @@
 
 /* The following is to handle SPC_AS */
 static SPC_ASCALLBACK spcAsCallback = 0;
-
 
-static void inherit_severity(const struct pv_link *ppv_link,
-    dbCommon *pdest, epicsEnum16 stat, epicsEnum16 sevr)
-{
-    switch(ppv_link->pvlMask&pvlOptMsMode) {
-        case pvlOptNMS: break;
-        case pvlOptMSI: if (sevr < INVALID_ALARM) break;
-        case pvlOptMS:  recGblSetSevr(pdest,LINK_ALARM,sevr); break;
-        case pvlOptMSS: recGblSetSevr(pdest,stat,sevr); break;
-    }
-}
 
 void epicsShareAPI dbSpcAsRegisterCallback(SPC_ASCALLBACK func)
 {
@@ -113,7 +104,7 @@
     dbCommon 	*precord = paddr->precord;
     long	status=0;
     long	special=paddr->special;
-	
+
     prset = dbGetRset(paddr);
     if(special<100) { /*global processing*/
 	if((special==SPC_NOMOD) && (pass==0)) {
@@ -139,7 +130,7 @@
     }
     return(0);
 }
-
 
+
 static void get_enum_strs(DBADDR *paddr, char **ppbuffer,
 	struct rset *prset,long	*options)
 {
@@ -199,7 +190,7 @@
 	*ppbuffer = ((char *)*ppbuffer) + dbr_enumStrs_size;
 	return;
 }
-
 
+
 static void get_graphics(DBADDR *paddr, char **ppbuffer,
 	struct rset *prset,long	*options)
 {
@@ -239,7 +230,7 @@
 	}
 	return;
 }
-
 
+
 static void get_control(DBADDR *paddr, char **ppbuffer,
 	struct rset *prset,long	*options)
 {
@@ -279,7 +270,7 @@
 	}
 	return;
 }
-
 
+
 static void get_alarm(DBADDR *paddr, char **ppbuffer,
 	struct rset *prset,long	*options)
 {
@@ -324,35 +315,44 @@
 	}
 	return;
 }
-
 
-static void getOptions(DBADDR *paddr,char **poriginal,long *options,void *pflin)
+
+/*
+ * This code relies on *poriginal being aligned and all increments done by the
+ * blocks only changing the buffer pointer in a way that does not break alignment.
+ */
+static void getOptions(DBADDR *paddr, char **poriginal, long *options,
+        void *pflin)
 {
 	db_field_log	*pfl= (db_field_log *)pflin;
 	struct rset	*prset;
-	short		field_type=paddr->field_type;
+        short		field_type;
 	dbCommon	*pcommon;
 	char		*pbuffer = *poriginal;
 
+        if (!pfl || pfl->type == dbfl_type_rec)
+            field_type = paddr->field_type;
+        else
+            field_type = pfl->field_type;
 	prset=dbGetRset(paddr);
 	/* Process options */
 	pcommon = paddr->precord;
 	if( (*options) & DBR_STATUS ) {
 	    unsigned short *pushort = (unsigned short *)pbuffer;
 
-	    if(pfl!=NULL) {
-		*pushort++ = pfl->stat;
-		*pushort++ = pfl->sevr;
-	    } else {
-		*pushort++ = pcommon->stat;
-		*pushort++ = pcommon->sevr;
-	    }
+            if (!pfl || pfl->type == dbfl_type_rec) {
+                *pushort++ = pcommon->stat;
+                *pushort++ = pcommon->sevr;
+            } else {
+                *pushort++ = pfl->stat;
+                *pushort++ = pfl->sevr;
+            }
 	    *pushort++ = pcommon->acks;
 	    *pushort++ = pcommon->ackt;
 	    pbuffer = (char *)pushort;
 	}
 	if( (*options) & DBR_UNITS ) {
 	    memset(pbuffer,'\0',dbr_units_size);
-	    if( prset && prset->get_units ){ 
+	    if( prset && prset->get_units ){
 		(*prset->get_units)(paddr, pbuffer);
 		pbuffer[DB_UNITS_SIZE-1] = '\0';
 	    } else {
@@ -363,7 +363,7 @@
 	if( (*options) & DBR_PRECISION ) {
 	    memset(pbuffer, '\0', dbr_precision_size);
 	    if((field_type==DBF_FLOAT || field_type==DBF_DOUBLE)
-	    &&  prset && prset->get_precision ){ 
+	    &&  prset && prset->get_precision ){
 		(*prset->get_precision)(paddr,pbuffer);
 	    } else {
 		*options ^= DBR_PRECISION; /*Turn off DBR_PRECISION*/
@@ -373,12 +373,12 @@
 	if( (*options) & DBR_TIME ) {
 	    epicsUInt32 *ptime = (epicsUInt32 *)pbuffer;
 
-	    if(pfl!=NULL) {
-		*ptime++ = pfl->time.secPastEpoch;
-		*ptime++ = pfl->time.nsec;
-	    } else {
-		*ptime++ = pcommon->time.secPastEpoch;
-		*ptime++ = pcommon->time.nsec;
+            if (!pfl || pfl->type == dbfl_type_rec) {
+                *ptime++ = pcommon->time.secPastEpoch;
+                *ptime++ = pcommon->time.nsec;
+            } else {
+                *ptime++ = pfl->time.secPastEpoch;
+                *ptime++ = pfl->time.nsec;
 	    }
 	    pbuffer = (char *)ptime;
 	}
@@ -392,7 +392,7 @@
 	    get_alarm(paddr, &pbuffer, prset, options);
 	*poriginal = pbuffer;
 }
-
 
+
 struct rset * epicsShareAPI dbGetRset(const struct dbAddr *paddr)
 {
 	struct dbFldDes *pfldDes = paddr->pfldDes;
@@ -419,10 +419,10 @@
 
 int epicsShareAPI dbIsValueField(const struct dbFldDes *pdbFldDes)
 {
-    if(pdbFldDes->pdbRecordType->indvalFlddes == pdbFldDes->indRecordType)
-	return(TRUE);
+    if (pdbFldDes->pdbRecordType->indvalFlddes == pdbFldDes->indRecordType)
+        return TRUE;
     else
-	return(FALSE);
+        return FALSE;
 }
 
 int epicsShareAPI dbGetFieldIndex(const struct dbAddr *paddr)
@@ -430,50 +430,6 @@
     return paddr->pfldDes->indRecordType;
 }
 
-long epicsShareAPI dbGetNelements(const struct link *plink,long *nelements)
-{
-    switch(plink->type) {
-    case CONSTANT:
-	*nelements = 0;
-	return(0);
-    case DB_LINK: {
-	    DBADDR *paddr = (DBADDR *)plink->value.pv_link.pvt;
-	    *nelements = paddr->no_elements;
-	    return(0);
-	}
-    case CA_LINK:
-	return(dbCaGetNelements(plink,nelements));
-    default:
-	break;
-    }
-    return(S_db_badField);
-}
-
-int epicsShareAPI dbIsLinkConnected(const struct link *plink)
-{
-    switch(plink->type) {
-	case DB_LINK: return(TRUE);
-	case CA_LINK: return(dbCaIsLinkConnected(plink));
-	default: break;
-    }
-    return(FALSE);
-}
-
-int epicsShareAPI dbGetLinkDBFtype(const struct link *plink)
-{
-    switch(plink->type) {
-	case DB_LINK: 
-	{
-	    DBADDR *paddr = (DBADDR *)plink->value.pv_link.pvt;
-
-	    return((int)paddr->field_type);
-	}
-	case CA_LINK: return(dbCaGetLinkDBFtype(plink));
-	default: break;
-    }
-    return(-1);
-}
-
 
 /*
  *  Process a record if its scan field is passive.
  *     Will notify if processing is complete by callback.
@@ -481,50 +437,15 @@
  */
 long epicsShareAPI dbScanPassive(dbCommon *pfrom, dbCommon *pto)
 {
-    long status;
-	
     /* if not passive just return success */
-    if(pto->scan != 0) return(0);
-
-    if(pfrom && pfrom->ppn) dbNotifyAdd(pfrom,pto);
-    status = dbProcess(pto);
-    return(status);
-}
-
-/*KLUDGE: Following needed so that dbPutLink to PROC field works correctly*/
-long epicsShareAPI dbScanLink(dbCommon *pfrom, dbCommon *pto)
-{
-    long		status;
-    unsigned char	pact;
-
-    if(pfrom && pfrom->ppn) dbNotifyAdd(pfrom,pto);
-    pact = pfrom->pact;
-    pfrom->pact = TRUE;
-    status = dbProcess(pto);
-    pfrom->pact = pact;
-    return(status);
-}
-
-void epicsShareAPI dbScanFwdLink(struct link *plink)
-{
-    dbCommon		*precord;
-    struct pv_link      *pvlink;
-    short               fwdLinkValue;
-
-    if(plink->type!=DB_LINK && plink->type!=CA_LINK) return;
-    pvlink = &plink->value.pv_link;
-    precord = pvlink->precord;
-    if(plink->type==DB_LINK) {
-        dbAddr *paddr = (dbAddr *)plink->value.pv_link.pvt;
-        dbScanPassive(precord,paddr->precord);
-        return;
-    }
-    if(!(pvlink->pvlMask & pvlOptFWD)) return;
-    fwdLinkValue = 1;
-    dbCaPutLink(plink,DBR_SHORT,&fwdLinkValue,1);
-    return;
-}
-
 
+    if (pto->scan != 0)
+        return 0;
+
+    if (pfrom && pfrom->ppn)
+        dbNotifyAdd(pfrom,pto);
+    return dbProcess(pto);
+}
+
 /*
  *   Process the record.
  *     1.  Check for breakpoints.
@@ -536,121 +457,127 @@
  */
 long epicsShareAPI dbProcess(dbCommon *precord)
 {
-	struct rset	*prset = precord->rset;
-	dbRecordType	*pdbRecordType = precord->rdes;
-	unsigned char	tpro=precord->tpro;
-	long		status = 0;
-        int             *ptrace;
-	int		set_trace=FALSE;
-	dbFldDes	*pdbFldDes;
-        int             callNotifyCompletion = FALSE;
-
-        ptrace = dbLockSetAddrTrace(precord);
+    struct rset *prset = precord->rset;
+    dbRecordType *pdbRecordType = precord->rdes;
+    unsigned char tpro = precord->tpro;
+    long status = 0;
+    int *ptrace;
+    int	set_trace = FALSE;
+    dbFldDes *pdbFldDes;
+    int callNotifyCompletion = FALSE;
+
+    ptrace = dbLockSetAddrTrace(precord);
+    /*
+     *  Note that it is likely that if any changes are made
+     *   to dbProcess() corresponding changes will have to
+     *   be made in the breakpoint handler.
+     */
+
+    /* see if there are any stopped records or breakpoints */
+    if (lset_stack_count != 0) {
         /*
-         *  Note that it is likely that if any changes are made
-         *   to dbProcess() corresponding changes will have to
-         *   be made in the breakpoint handler.
+         *  Check to see if the record should be processed
+         *   and activate breakpoint accordingly.  If this
+         *   function call returns non-zero, skip record
+         *   support and fall out of dbProcess().  This is
+         *   done so that a dbContTask() can be spawned to
+         *   take over record processing for the lock set
+         *   containing a breakpoint.
          */
- 
-        /* see if there are any stopped records or breakpoints */
-        if (lset_stack_count != 0) {
-           /*
-            *  Check to see if the record should be processed
-            *   and activate breakpoint accordingly.  If this
-            *   function call returns non-zero, skip record
-            *   support and fall out of dbProcess().  This is
-            *   done so that a dbContTask() can be spawned to
-            *   take over record processing for the lock set
-            *   containing a breakpoint.
-            */
-            if (dbBkpt(precord))
-                goto all_done;
-        }
-    
-	/* check for trace processing*/
-	if (tpro) {
-                if(*ptrace==0) {
-                        *ptrace = 1;
-			set_trace = TRUE;
-		}
-	}
-
-	/* If already active dont process */
-	if (precord->pact) {
-		unsigned short	monitor_mask;
-
-		if (*ptrace) printf("%s: Active %s\n",
-                        epicsThreadGetNameSelf(), precord->name);
-		/* raise scan alarm after MAX_LOCK times */
-		if (precord->stat==SCAN_ALARM) goto all_done;
-		if (precord->lcnt++ !=MAX_LOCK) goto all_done;
-		if (precord->sevr>=INVALID_ALARM) goto all_done;
-		recGblSetSevr(precord, SCAN_ALARM, INVALID_ALARM);
-		monitor_mask = recGblResetAlarms(precord);
-		monitor_mask |= DBE_VALUE|DBE_LOG;
-		pdbFldDes = pdbRecordType->papFldDes[pdbRecordType->indvalFlddes];
-		db_post_events(precord,
-			(void *)(((char *)precord) + pdbFldDes->offset),
-			monitor_mask);
-		goto all_done;
-	}
-        else precord->lcnt = 0;
-
-       /*
-        *  Check the record disable link.  A record will not be
-        *    processed if the value retrieved through this link
-        *    is equal to constant set in the record's disv field.
-        */
-        status = dbGetLink(&(precord->sdis),DBR_SHORT,&(precord->disa),0,0);
-
-	/* if disabled check disable alarm severity and return success */
-	if (precord->disa == precord->disv) {
-		if(*ptrace) printf("%s: Disabled %s\n",
-                        epicsThreadGetNameSelf(), precord->name);
-		/*take care of caching and notifyCompletion*/
-		precord->rpro = FALSE;
-		precord->putf = FALSE;
-                callNotifyCompletion = TRUE;
-		/* raise disable alarm */
-		if (precord->stat==DISABLE_ALARM) goto all_done;
-		precord->sevr = precord->diss;
-		precord->stat = DISABLE_ALARM;
-		precord->nsev = 0;
-		precord->nsta = 0;
-		db_post_events(precord, &precord->stat, DBE_VALUE);
-		db_post_events(precord, &precord->sevr, DBE_VALUE);
-		pdbFldDes = pdbRecordType->papFldDes[pdbRecordType->indvalFlddes];
-		db_post_events(precord,
-			(void *)(((char *)precord) + pdbFldDes->offset),
-			DBE_VALUE|DBE_ALARM);
-		goto all_done;
-	}
-
-	/* locate record processing routine */
-        /* put this in iocInit() !!! */
-	if (!(prset=precord->rset) || !(prset->process)) {
-                callNotifyCompletion = TRUE;
-		precord->pact=1;/*set pact TRUE so error is issued only once*/
-		recGblRecordError(S_db_noRSET, (void *)precord, "dbProcess");
-		status = S_db_noRSET;
-		if (*ptrace) printf("%s: No RSET for %s\n",
-				epicsThreadGetNameSelf(), precord->name);
-		goto all_done;
-	}
-	if(*ptrace) printf("%s: Process %s\n",
-			epicsThreadGetNameSelf(), precord->name);
-	/* process record */
-	status = (*prset->process)(precord);
-        /* Print record's fields if PRINT_MASK set in breakpoint field */
-        if (lset_stack_count != 0) {
-                dbPrint(precord);
-        }
+        if (dbBkpt(precord))
+            goto all_done;
+    }
+
+    /* check for trace processing*/
+    if (tpro) {
+        if(*ptrace==0) {
+            *ptrace = 1;
+            set_trace = TRUE;
+        }
+    }
+
+    /* If already active dont process */
+    if (precord->pact) {
+        unsigned short	monitor_mask;
+
+        if (*ptrace)
+            printf("%s: Active %s\n",
+                    epicsThreadGetNameSelf(), precord->name);
+        /* raise scan alarm after MAX_LOCK times */
+        if (precord->stat==SCAN_ALARM) goto all_done;
+        if (precord->lcnt++ !=MAX_LOCK) goto all_done;
+        if (precord->sevr>=INVALID_ALARM) goto all_done;
+        recGblSetSevr(precord, SCAN_ALARM, INVALID_ALARM);
+        monitor_mask = recGblResetAlarms(precord);
+        monitor_mask |= DBE_VALUE|DBE_LOG;
+        pdbFldDes = pdbRecordType->papFldDes[pdbRecordType->indvalFlddes];
+        db_post_events(precord,
+                (void *)(((char *)precord) + pdbFldDes->offset),
+                monitor_mask);
+        goto all_done;
+    }
+    else precord->lcnt = 0;
+
+    /*
+     *  Check the record disable link.  A record will not be
+     *    processed if the value retrieved through this link
+     *    is equal to constant set in the record's disv field.
+     */
+    status = dbGetLink(&precord->sdis, DBR_SHORT, &precord->disa, 0, 0);
+
+    /* if disabled check disable alarm severity and return success */
+    if (precord->disa == precord->disv) {
+        if(*ptrace)
+            printf("%s: Disabled %s\n",
+                    epicsThreadGetNameSelf(), precord->name);
+
+        /*take care of caching and notifyCompletion*/
+        precord->rpro = FALSE;
+        precord->putf = FALSE;
+        callNotifyCompletion = TRUE;
+
+        /* raise disable alarm */
+        if (precord->stat==DISABLE_ALARM) goto all_done;
+        precord->sevr = precord->diss;
+        precord->stat = DISABLE_ALARM;
+        precord->nsev = 0;
+        precord->nsta = 0;
+        db_post_events(precord, &precord->stat, DBE_VALUE);
+        db_post_events(precord, &precord->sevr, DBE_VALUE);
+        pdbFldDes = pdbRecordType->papFldDes[pdbRecordType->indvalFlddes];
+        db_post_events(precord,
+                (void *)(((char *)precord) + pdbFldDes->offset),
+                DBE_VALUE|DBE_ALARM);
+        goto all_done;
+    }
+
+    /* locate record processing routine */
+    /* FIXME: put this in iocInit() !!! */
+    if (!(prset=precord->rset) || !(prset->process)) {
+        callNotifyCompletion = TRUE;
+        precord->pact=1;/*set pact TRUE so error is issued only once*/
+        recGblRecordError(S_db_noRSET, (void *)precord, "dbProcess");
+        status = S_db_noRSET;
+        if (*ptrace)
+            printf("%s: No RSET for %s\n",
+                    epicsThreadGetNameSelf(), precord->name);
+        goto all_done;
+    }
+    if(*ptrace)
+        printf("%s: Process %s\n",
+                epicsThreadGetNameSelf(), precord->name);
+    /* process record */
+    status = (*prset->process)(precord);
+    /* Print record's fields if PRINT_MASK set in breakpoint field */
+    if (lset_stack_count != 0) {
+        dbPrint(precord);
+    }
 all_done:
-	if (set_trace) *ptrace = 0;
-	if(callNotifyCompletion && precord->ppn) dbNotifyCompletion(precord);
-	return(status);
+    if (set_trace) *ptrace = 0;
+    if(callNotifyCompletion && precord->ppn) dbNotifyCompletion(precord);
+    return(status);
 }
-
 
+
 /*
  *  Fill out a database structure (*paddr) for
  *    a record given by the name "pname."
@@ -726,59 +653,7 @@
     dbFinishEntry(&dbEntry);
     return status;
 }
-
 
-/* JOH 10-19-04 */
-static char * dbCopyInNameComponentOfPV (
-    char * pBuf, unsigned bufLen, const char * pComponent )
-{
-    unsigned compLen = strlen ( pComponent );
-    if ( compLen < bufLen ) {
-        strcpy ( pBuf, pComponent );
-        return pBuf + compLen;
-    }
-    else {
-        unsigned reducedSize = bufLen - 1u;
-        strncpy ( pBuf, pComponent, reducedSize );
-        pBuf[reducedSize] = '\0';
-        return pBuf + reducedSize;
-    }
-}
-/*
- *  Copies PV name into pBuf of length bufLen
- *
- *    Returns the number of bytes written to pBuf
- *      not including null termination.
- *  JOH 10-19-04 
- */
-unsigned dbNameOfPV (
-    const dbAddr * paddr, char * pBuf, unsigned bufLen )
-{
-    dbFldDes * pfldDes = paddr->pfldDes;
-    char * pBufTmp = pBuf;
-    if ( bufLen == 0u ) {
-        return 0u;
-    }
-    pBufTmp = dbCopyInNameComponentOfPV ( 
-        pBufTmp, bufLen, paddr->precord->name );
-    pBufTmp = dbCopyInNameComponentOfPV ( 
-        pBufTmp, bufLen - ( pBufTmp - pBuf ), "." );
-    pBufTmp = dbCopyInNameComponentOfPV ( 
-        pBufTmp, bufLen - ( pBufTmp - pBuf ), pfldDes->name );
-    return pBufTmp - pBuf;
-}
-/*
- *    Returns the number of bytes in the PV name
- *      not including null termination.
- *    JOH 10-19-04 
- */
-unsigned dbNameSizeOfPV ( const dbAddr * paddr )
-{
-    unsigned recNameLen = strlen ( paddr->precord->name );
-    dbFldDes * pfldDes = paddr->pfldDes;
-    unsigned fieldNameLen = strlen ( pfldDes->name );
-    return recNameLen + fieldNameLen + 1;
-}
-
 
+
 long epicsShareAPI dbValueSize(short dbr_type)
 {
     /* sizes for value associated with each DBR request type */
@@ -826,222 +701,117 @@
     return dbReadDatabase(&pdbbase, file, 0, subs);
 }
 
-
 
-long epicsShareAPI dbGetLinkValue(struct link *plink, short dbrType,
-    void *pbuffer, long *poptions, long *pnRequest)
-{
-    long status = 0;
-
-    if (plink->type == CONSTANT) {
-        if (poptions) *poptions = 0;
-        if (pnRequest) *pnRequest = 0;
-    } else if (plink->type == DB_LINK) {
-        struct pv_link *ppv_link = &(plink->value.pv_link);
-        DBADDR         *paddr = ppv_link->pvt;
-        dbCommon       *precord = plink->value.pv_link.precord;
-
-        /* scan passive records with links that are process passive  */
-        if (ppv_link->pvlMask&pvlOptPP) {
-            dbCommon *pfrom = paddr->precord;
-            unsigned char pact;
-
-            pact = precord->pact;
-            precord->pact = TRUE;
-            status = dbScanPassive(precord,pfrom);
-            precord->pact = pact;
-            if (status) return status;
-        }
-        if(precord!= paddr->precord) {
-            inherit_severity(ppv_link,precord,paddr->precord->stat,paddr->precord->sevr);
-        }
-
-        if (ppv_link->getCvt && ppv_link->lastGetdbrType == dbrType) {
-            status = ppv_link->getCvt(paddr->pfield, pbuffer, paddr);
-        } else {
-            unsigned short dbfType = paddr->field_type;
-            long       no_elements = paddr->no_elements;
-
-            if (dbrType < 0 || dbrType > DBR_ENUM ||
-                dbfType > DBF_DEVICE) {
-                status = S_db_badDbrtype;
-                recGblRecordError(status, precord, "GetLinkValue Failed");
-                recGblSetSevr(precord, LINK_ALARM, INVALID_ALARM);
-                return status;
-            }
-            /*  attempt to make a fast link */
-            if ((!poptions || *poptions == 0) &&
-                no_elements == 1 &&
-                (!pnRequest || *pnRequest == 1) &&
-                paddr->special != SPC_ATTRIBUTE) {
-                ppv_link->getCvt = dbFastGetConvertRoutine[dbfType][dbrType];
-                status = ppv_link->getCvt(paddr->pfield, pbuffer, paddr);
-            } else {
-                ppv_link->getCvt = 0;
-                status = dbGet(paddr, dbrType, pbuffer, poptions, pnRequest, NULL);
-            }
-        }
-        ppv_link->lastGetdbrType = dbrType;
-        if (status) {
-            recGblRecordError(status, precord, "dbGetLinkValue");
-            recGblSetSevr(precord, LINK_ALARM, INVALID_ALARM);
-        }
-    } else if (plink->type == CA_LINK) {
-        struct dbCommon *precord = plink->value.pv_link.precord;
-        const struct pv_link *pcalink = &plink->value.pv_link;
-        epicsEnum16 sevr, stat;
-
-        status=dbCaGetLink(plink,dbrType,pbuffer,&stat,&sevr,pnRequest);
-        if (status) {
-            recGblSetSevr(precord, LINK_ALARM, INVALID_ALARM);
-        } else {
-            inherit_severity(pcalink,precord,stat,sevr);
-        }
-        if (poptions) *poptions = 0;
-    } else {
-        cantProceed("dbGetLinkValue: Illegal link type");
-    }
-    return status;
-}
-
 
-long epicsShareAPI dbPutLinkValue(struct link *plink, short dbrType,
-    const void *pbuffer, long nRequest)
-{
-    long status = 0;
-
-    if (plink->type == DB_LINK) {
-        struct dbCommon *psource = plink->value.pv_link.precord;
-        struct pv_link *ppv_link = &plink->value.pv_link;
-        DBADDR *paddr = (DBADDR *)ppv_link->pvt;
-        dbCommon *pdest = paddr->precord;
-
-        status = dbPut(paddr, dbrType, pbuffer, nRequest);
-        inherit_severity(ppv_link,pdest,psource->nsta,psource->nsev);
-        if (status) return status;
-
-        if (paddr->pfield == (void *)&pdest->proc ||
-            (ppv_link->pvlMask & pvlOptPP && pdest->scan == 0)) {
-            /*if dbPutField caused asyn record to process */
-            /* ask for reprocessing*/
-            if (pdest->putf) {
-                pdest->rpro = TRUE;
-            } else { /* otherwise ask for the record to be processed*/
-                status = dbScanLink(psource, pdest);
-            }
-        }
-        if (status)
-            recGblSetSevr(psource, LINK_ALARM, INVALID_ALARM);
-    } else if (plink->type == CA_LINK) {
-        struct dbCommon *psource = plink->value.pv_link.precord;
-
-        status = dbCaPutLink(plink, dbrType, pbuffer, nRequest);
-        if (status < 0)
-            recGblSetSevr(psource, LINK_ALARM, INVALID_ALARM);
-    } else {
-        cantProceed("dbPutLinkValue: Illegal link type");
-    }
-    return status;
-}
-
 
+
+static long getLinkValue(DBADDR *paddr, short dbrType,
+    char *pbuf, long *nRequest)
+{
+    dbCommon *precord = paddr->precord;
+    dbFldDes *pfldDes = paddr->pfldDes;
+    int maxlen;
+    DBENTRY dbEntry;
+    long status;
+
+    switch (dbrType) {
+    case DBR_STRING:
+        maxlen = MAX_STRING_SIZE - 1;
+        if (nRequest && *nRequest > 1) *nRequest = 1;
+        break;
+
+    case DBR_CHAR:
+    case DBR_UCHAR:
+            if (nRequest && *nRequest > 0) {
+            maxlen = *nRequest - 1;
+            break;
+        }
+        /* else fall through ... */
+    default:
+        return S_db_badDbrtype;
+    }
+
+    dbInitEntry(pdbbase, &dbEntry);
+    status = dbFindRecord(&dbEntry, precord->name);
+    if (!status) status = dbFindField(&dbEntry, pfldDes->name);
+    if (!status) {
+        char *rtnString = dbGetString(&dbEntry);
+
+        strncpy(pbuf, rtnString, --maxlen);
+        pbuf[maxlen] = 0;
+    }
+    dbFinishEntry(&dbEntry);
+    return status;
+}
+
+static long getAttrValue(DBADDR *paddr, short dbrType,
+        char *pbuf, long *nRequest)
+{
+    int maxlen;
+
+    if (!paddr->pfield) return S_db_badField;
+
+    switch (dbrType) {
+    case DBR_STRING:
+        maxlen = MAX_STRING_SIZE - 1;
+        if (nRequest && *nRequest > 1) *nRequest = 1;
+        break;
+
+    case DBR_CHAR:
+    case DBR_UCHAR:
+            if (nRequest && *nRequest > 0) {
+            maxlen = *nRequest - 1;
+            break;
+        }
+        /* else fall through ... */
+    default:
+        return S_db_badDbrtype;
+    }
+
+    strncpy(pbuf, paddr->pfield, --maxlen);
+    pbuf[maxlen] = 0;
+    return 0;
+}
+
 long epicsShareAPI dbGetField(DBADDR *paddr,short dbrType,
     void *pbuffer, long *options, long *nRequest, void *pflin)
 {
-    short dbfType = paddr->field_type;
     dbCommon *precord = paddr->precord;
     long status = 0;
 
     dbScanLock(precord);
-    if (dbfType >= DBF_INLINK && dbfType <= DBF_FWDLINK) {
-        DBENTRY dbEntry;
-        dbFldDes *pfldDes = paddr->pfldDes;
-        char *rtnString;
-        char *pbuf = (char *)pbuffer;
-        int maxlen;
-
-        if (options && (*options))
-            getOptions(paddr, &pbuf, options, pflin);
-        if (nRequest && *nRequest == 0) goto done;
-
-        switch (dbrType) {
-        case DBR_STRING:
-            maxlen = MAX_STRING_SIZE - 1;
-            if (nRequest && *nRequest > 1) *nRequest = 1;
-            break;
-
-        case DBR_CHAR:
-        case DBR_UCHAR:
-            if (nRequest && *nRequest > 0) {
-                maxlen = *nRequest - 1;
-                break;
-            }
-            /* else fall through ... */
-        default:
-            status = S_db_badDbrtype;
-            goto done;
-        }
-
-        dbInitEntry(pdbbase, &dbEntry);
-        status = dbFindRecord(&dbEntry, precord->name);
-        if (!status) status = dbFindField(&dbEntry, pfldDes->name);
-        if (!status) {
-            rtnString = dbGetString(&dbEntry);
-            strncpy(pbuf, rtnString, maxlen);
-            pbuf[maxlen] = 0;
-        }
-        dbFinishEntry(&dbEntry);
-    } else {
-        status = dbGet(paddr, dbrType, pbuffer, options, nRequest, pflin);
-    }
-done:
+    status = dbGet(paddr, dbrType, pbuffer, options, nRequest, pflin);
     dbScanUnlock(precord);
     return status;
 }
-
 
+
 long epicsShareAPI dbGet(DBADDR *paddr, short dbrType,
     void *pbuffer, long *options, long *nRequest, void *pflin)
 {
+    char *pbuf = pbuffer;
     db_field_log *pfl = (db_field_log *)pflin;
-    short field_type  = paddr->field_type;
-    long no_elements  = paddr->no_elements;
+    short field_type;
+    long no_elements;
     long offset;
     struct rset *prset;
     long status = 0;
 
-    if (options && *options) {
-        char *pbuf = pbuffer;
-
+    if (options && *options)
         getOptions(paddr, &pbuf, options, pflin);
-        pbuffer = pbuf;
-    }
-    if (nRequest && *nRequest == 0) return 0;
-
-    if (paddr->special == SPC_ATTRIBUTE) {
-        char *pbuf = pbuffer;
-        int maxlen;
-
-        if (!paddr->pfield) return S_db_badField;
-
-        switch (dbrType) {
-        case DBR_STRING:
-            maxlen = MAX_STRING_SIZE - 1;
-            if (nRequest && *nRequest > 1) *nRequest = 1;
-            break;
-
-        case DBR_CHAR:
-        case DBR_UCHAR:
-            if (nRequest && *nRequest > 0) {
-                maxlen = *nRequest - 1;
-                break;
-            }
-            /* else fall through ... */
-        default:
-            return S_db_badDbrtype;
-        }
-
-        strncpy(pbuf, (char *)paddr->pfield, maxlen);
-        pbuf[maxlen] = 0;
+    if (nRequest && *nRequest == 0)
         return 0;
+
+    if (!pfl || pfl->type == dbfl_type_rec) {
+        field_type  = paddr->field_type;
+        no_elements = paddr->no_elements;
+    } else {
+        field_type  = pfl->field_type;
+        no_elements = pfl->no_elements;
     }
 
+    if (field_type >= DBF_INLINK && field_type <= DBF_FWDLINK)
+        return getLinkValue(paddr, dbrType, pbuf, nRequest);
+
+    if (paddr->special == SPC_ATTRIBUTE)
+        return getAttrValue(paddr, dbrType, pbuf, nRequest);
+
     /* Check for valid request */
     if (INVALID_DB_REQ(dbrType) || field_type > DBF_DEVICE) {
         char message[80];
@@ -1052,7 +822,8 @@
     }
 
     /* check for array */
-    if (paddr->special == SPC_DBADDR &&
+    if ((!pfl || pfl->type == dbfl_type_rec) &&
+        paddr->special == SPC_DBADDR &&
         no_elements > 1 &&
         (prset = dbGetRset(paddr)) &&
         prset->get_array_info) {
@@ -1062,15 +833,20 @@
 
     if (offset == 0 && (!nRequest || no_elements == 1)) {
         if (nRequest) *nRequest = 1;
-        if (pfl != NULL) {
+        if (!pfl || pfl->type == dbfl_type_rec) {
+            status = dbFastGetConvertRoutine[field_type][dbrType]
+                (paddr->pfield, pbuffer, paddr);
+        } else {
             DBADDR localAddr = *paddr; /* Structure copy */
-
-            localAddr.pfield = (char *)&pfl->field;
+            localAddr.field_type = pfl->field_type;
+            localAddr.field_size = pfl->field_size;
+            localAddr.no_elements = pfl->no_elements;
+            if (pfl->type == dbfl_type_val)
+                localAddr.pfield = (char *) &pfl->u.v.field;
+            else
+                localAddr.pfield = (char *)  pfl->u.r.field;
             status = dbFastGetConvertRoutine[field_type][dbrType]
                 (localAddr.pfield, pbuffer, &localAddr);
-        } else {
-            status = dbFastGetConvertRoutine[field_type][dbrType]
-                (paddr->pfield, pbuffer, paddr);
         }
     } else {
         long n;
@@ -1094,18 +870,23 @@
         /* convert database field  and place it in the buffer */
         if (n <= 0) {
             ;/*do nothing*/
-        } else if (pfl) {
+        } else if (!pfl || pfl->type == dbfl_type_rec) {
+            status = convert(paddr, pbuffer, n, no_elements, offset);
+        } else {
             DBADDR localAddr = *paddr; /* Structure copy */
-
-            localAddr.pfield = (char *)&pfl->field;
+            localAddr.field_type = pfl->field_type;
+            localAddr.field_size = pfl->field_size;
+            localAddr.no_elements = pfl->no_elements;
+            if (pfl->type == dbfl_type_val)
+                localAddr.pfield = (char *) &pfl->u.v.field;
+            else
+                localAddr.pfield = (char *)  pfl->u.r.field;
             status = convert(&localAddr, pbuffer, n, no_elements, offset);
-        } else {
-            status = convert(paddr, pbuffer, n, no_elements, offset);
         }
     }
     return status;
 }
-
 
+
 devSup* epicsShareAPI dbDTYPtoDevSup(dbRecordType *prdes, int dtyp) {
     return (devSup *)ellNth(&prdes->devList, dtyp+1);
 }
@@ -1125,10 +906,9 @@
     dbCommon    *precord = paddr->precord;
     dbFldDes    *pfldDes = paddr->pfldDes;
     long        special = paddr->special;
-    DBLINK      *plink = (DBLINK *)paddr->pfield;
+    struct link *plink = (struct link *)paddr->pfield;
     const char  *pstring = (const char *)pbuffer;
     DBENTRY     dbEntry;
-    DBADDR      dbaddr;
     struct dsxt *old_dsxt = NULL;
     struct dset *new_dset = NULL;
     struct dsxt *new_dsxt = NULL;
@@ -1199,21 +979,8 @@
 
     switch (plink->type) { /* Old link type */
     case DB_LINK:
-        free(plink->value.pv_link.pvt);
-        plink->value.pv_link.pvt = 0;
-        plink->type = PV_LINK;
-        plink->value.pv_link.getCvt = 0;
-        plink->value.pv_link.pvlMask = 0;
-        plink->value.pv_link.lastGetdbrType = 0;
-        dbLockSetSplit(precord);
-        break;
-
     case CA_LINK:
-        dbCaRemoveLink(plink);
-        plink->type = PV_LINK;
-        plink->value.pv_link.getCvt = 0;
-        plink->value.pv_link.pvlMask = 0;
-        plink->value.pv_link.lastGetdbrType = 0;
+    	dbRemoveLink(plink);
         break;
 
     case CONSTANT:
@@ -1260,35 +1027,7 @@
 
     switch (plink->type) { /* New link type */
     case PV_LINK:
-        if (plink == &precord->tsel)
-            recGblTSELwasModified(plink);
-        plink->value.pv_link.precord = precord;
-
-        if (!(plink->value.pv_link.pvlMask & (pvlOptCA|pvlOptCP|pvlOptCPP)) &&
-            (dbNameToAddr(plink->value.pv_link.pvname, &dbaddr) == 0)) {
-            /* It's a DB link */
-            DBADDR      *pdbAddr;
-
-            plink->type = DB_LINK;
-            pdbAddr = dbMalloc(sizeof(struct dbAddr));
-            *pdbAddr = dbaddr; /* NB: structure copy */;
-            plink->value.pv_link.pvt = pdbAddr;
-            dbLockSetRecordLock(pdbAddr->precord);
-            dbLockSetMerge(precord, pdbAddr->precord);
-        } else { /* Make it a CA link */
-            char        *pperiod;
-
-            plink->type = CA_LINK;
-            if (pfldDes->field_type == DBF_INLINK) {
-                plink->value.pv_link.pvlMask |= pvlOptInpNative;
-            }
-            dbCaAddLink(plink);
-            if (pfldDes->field_type == DBF_FWDLINK) {
-                pperiod = strrchr(plink->value.pv_link.pvname, '.');
-                if (pperiod && strstr(pperiod, "PROC"))
-                    plink->value.pv_link.pvlMask |= pvlOptFWD;
-            }
-        }
+        dbAddLink(precord, plink, pfldDes->field_type);
         break;
 
     case CONSTANT:
@@ -1316,7 +1055,7 @@
     }
 postScanEvent:
     if (scan != precord->scan)
-        db_post_events(precord, &precord->scan, DBE_VALUE|DBE_LOG);
+        db_post_events(precord, &precord->scan, DBE_VALUE | DBE_LOG);
 unlock:
     dbLockSetGblUnlock();
 finish:
@@ -1337,8 +1076,7 @@
         return S_db_noMod;
 
     /*check for putField disabled*/
-    if (precord->disp &&
-        (void *)(&precord->disp) != paddr->pfield)
+    if (precord->disp && paddr->pfield != &precord->disp)
         return S_db_putDisabled;
 
     if (dbfType >= DBF_INLINK && dbfType <= DBF_FWDLINK)
@@ -1347,7 +1085,7 @@
     dbScanLock(precord);
     status = dbPut(paddr, dbrType, pbuffer, nRequest);
     if (status == 0) {
-        if (paddr->pfield == (void *)&precord->proc ||
+        if (paddr->pfield == &precord->proc ||
             (pfldDes->process_passive &&
              precord->scan == 0 &&
              dbrType < DBR_PUT_ACKT)) {
@@ -1366,16 +1104,18 @@
     dbScanUnlock(precord);
     return status;
 }
-
 
-static long putAckt(DBADDR *paddr, const unsigned short *pbuffer, long nRequest,
+
+static long putAckt(DBADDR *paddr, const void *pbuffer, long nRequest,
     long no_elements, long offset)
 {
     dbCommon *precord = paddr->precord;
+    const unsigned short *ptrans = pbuffer;
 
-    if (*pbuffer == precord->ackt) return 0;
-    precord->ackt = *pbuffer;
+    if (*ptrans == precord->ackt) return 0;
+    precord->ackt = *ptrans;
     db_post_events(precord, &precord->ackt, DBE_VALUE | DBE_ALARM);
-    if (!precord->ackt && precord->acks > precord->sevr) {
+    if (!precord->ackt &&
+        precord->acks > precord->sevr) {
         precord->acks = precord->sevr;
         db_post_events(precord, &precord->acks, DBE_VALUE | DBE_ALARM);
     }
@@ -1383,19 +1123,20 @@
     return 0;
 }
 
-static long putAcks(DBADDR *paddr, const unsigned short *pbuffer, long nRequest,
+static long putAcks(DBADDR *paddr, const void *pbuffer, long nRequest,
     long no_elements, long offset)
 {
     dbCommon *precord = paddr->precord;
+    const unsigned short *psev = pbuffer;
 
-    if (*pbuffer >= precord->acks) {
+    if (*psev >= precord->acks) {
         precord->acks = 0;
+        db_post_events(precord, &precord->acks, DBE_VALUE | DBE_ALARM);
         db_post_events(precord, NULL, DBE_ALARM);
-        db_post_events(precord, &precord->acks, DBE_VALUE | DBE_ALARM);
     }
     return 0;
 }
-
 
+
 long epicsShareAPI dbPut(DBADDR *paddr, short dbrType,
     const void *pbuffer, long nRequest)
 {
@@ -1403,17 +1144,17 @@
     short field_type  = paddr->field_type;
     long no_elements  = paddr->no_elements;
     long special      = paddr->special;
-    long offset;
     long status = 0;
     dbFldDes *pfldDes;
     int isValueField;
 
-    if (special == SPC_ATTRIBUTE) return S_db_noMod;
+    if (special == SPC_ATTRIBUTE)
+        return S_db_noMod;
 
     if (dbrType == DBR_PUT_ACKT && field_type <= DBF_DEVICE) {
-        return putAckt(paddr, (unsigned short *)pbuffer, 1, 1, 0);
+        return putAckt(paddr, pbuffer, 1, 1, 0);
     } else if (dbrType == DBR_PUT_ACKS && field_type <= DBF_DEVICE) {
-        return putAcks(paddr, (unsigned short *)pbuffer, 1, 1, 0);
+        return putAcks(paddr, pbuffer, 1, 1, 0);
     } else if (INVALID_DB_REQ(dbrType) || field_type > DBF_DEVICE) {
         char message[80];
 
@@ -1432,6 +1173,7 @@
             paddr->pfield, paddr);
     } else {
         struct rset *prset = dbGetRset(paddr);
+        long offset = 0;
 
         if (paddr->special == SPC_DBADDR &&
             prset && prset->get_array_info) {
@@ -1439,8 +1181,6 @@
 
             status = prset->get_array_info(paddr, &dummy, &offset);
         }
-        else
-            offset = 0;
         if (no_elements < nRequest) nRequest = no_elements;
         status = dbPutConvertRoutine[dbrType][field_type](paddr, pbuffer,
             nRequest, no_elements, offset);
@@ -1471,140 +1211,4 @@
 
     return status;
 }
-
 
-/* various utility routines */
-long epicsShareAPI dbGetControlLimits(
-    const struct link *plink,double *low, double *high)
-{
-    struct buffer {
-        DBRctrlDouble
-        double value;
-    } buffer;
-    DBADDR *paddr;
-    long options = DBR_CTRL_DOUBLE;
-    long number_elements = 0;
-    long status;
-
-    if(plink->type == CA_LINK) return(dbCaGetControlLimits(plink,low,high));
-    if(plink->type !=DB_LINK) return(S_db_notFound);
-    paddr = (DBADDR *)plink->value.pv_link.pvt;
-    status = dbGet(paddr,DBR_DOUBLE,&buffer,&options,&number_elements,0);
-    if(status) return(status);
-    *low = buffer.lower_ctrl_limit;
-    *high = buffer.upper_ctrl_limit;
-    return(0);
-}
-
-long epicsShareAPI dbGetGraphicLimits(
-    const struct link *plink,double *low, double *high)
-{
-    struct buffer {
-        DBRgrDouble
-        double value;
-    } buffer;
-    DBADDR *paddr;
-    long options = DBR_GR_DOUBLE;
-    long number_elements = 0;
-    long status;
-
-    if(plink->type == CA_LINK) return(dbCaGetGraphicLimits(plink,low,high));
-    if(plink->type !=DB_LINK) return(S_db_notFound);
-    paddr = (DBADDR *)plink->value.pv_link.pvt;
-    status = dbGet(paddr,DBR_DOUBLE,&buffer,&options,&number_elements,0);
-    if(status) return(status);
-    *low = buffer.lower_disp_limit;
-    *high = buffer.upper_disp_limit;
-    return(0);
-}
-
 
-long epicsShareAPI dbGetAlarmLimits(const struct link *plink,
-	double *lolo, double *low, double *high, double *hihi)
-{
-    struct buffer {
-        DBRalDouble
-        double value;
-    } buffer;
-    DBADDR *paddr;
-    long options = DBR_AL_DOUBLE;
-    long number_elements = 0;
-    long status;
-
-    if(plink->type == CA_LINK)
-        return(dbCaGetAlarmLimits(plink,lolo,low,high,hihi));
-    if(plink->type !=DB_LINK) return(S_db_notFound);
-    paddr = (DBADDR *)plink->value.pv_link.pvt;
-    status = dbGet(paddr,DBR_DOUBLE,&buffer,&options,&number_elements,0);
-    if(status) return(status);
-    *lolo = buffer.lower_alarm_limit;
-    *low = buffer.lower_warning_limit;
-    *high = buffer.upper_warning_limit;
-    *hihi = buffer.upper_alarm_limit;
-    return(0);
-}
-
-long epicsShareAPI dbGetPrecision(const struct link *plink,short *precision)
-{
-    struct buffer {
-        DBRprecision
-        double value;
-    } buffer;
-    DBADDR *paddr;
-    long options = DBR_PRECISION;
-    long number_elements = 0;
-    long status;
-
-    if(plink->type == CA_LINK) return(dbCaGetPrecision(plink,precision));
-    if(plink->type !=DB_LINK) return(S_db_notFound);
-    paddr = (DBADDR *)plink->value.pv_link.pvt;
-    status = dbGet(paddr,DBR_DOUBLE,&buffer,&options,&number_elements,0);
-    if(status) return(status);
-    *precision = buffer.precision.dp;
-    return(0);
-}
-
 
-long epicsShareAPI dbGetUnits(
-    const struct link *plink,char *units,int unitsSize)
-{
-    struct buffer {
-        DBRunits
-        double value;
-    } buffer;
-    DBADDR *paddr;
-    long options = DBR_UNITS;
-    long number_elements = 0;
-    long status;
-
-    if(plink->type == CA_LINK) return(dbCaGetUnits(plink,units,unitsSize));
-    if(plink->type !=DB_LINK) return(S_db_notFound);
-    paddr = (DBADDR *)plink->value.pv_link.pvt;
-    status = dbGet(paddr,DBR_DOUBLE,&buffer,&options,&number_elements,0);
-    if(status) return(status);
-    strncpy(units,buffer.units,unitsSize);
-    return(0);
-}
-
-long epicsShareAPI dbGetAlarm(const struct link *plink,
-    epicsEnum16 *status,epicsEnum16 *severity)
-{
-    DBADDR *paddr;
-
-    if(plink->type == CA_LINK) return(dbCaGetAlarm(plink,status,severity));
-    if(plink->type !=DB_LINK) return(S_db_notFound);
-    paddr = (DBADDR *)plink->value.pv_link.pvt;
-    if (status) *status = paddr->precord->stat;
-    if (severity) *severity = paddr->precord->sevr;
-    return(0);
-}
-
-long epicsShareAPI dbGetTimeStamp(const struct link *plink,epicsTimeStamp *pstamp)
-{
-    DBADDR *paddr;
-
-    if (plink->type == CA_LINK)
-        return dbCaGetTimeStamp(plink,pstamp);
-    if (plink->type != DB_LINK)
-        return S_db_notFound;
-    paddr = (DBADDR *)plink->value.pv_link.pvt;
-    *pstamp = paddr->precord->time;
-    return 0;
-}
+
 
=== modified file 'src/ioc/db/dbAccess.h'
--- src/ioc/db/dbAccess.h	2002-07-12 21:35:43 +0000
+++ src/ioc/db/dbAccess.h	2012-06-21 20:42:45 +0000
@@ -3,8 +3,7 @@
 *     National Laboratory.
 * Copyright (c) 2002 The Regents of the University of California, as
 *     Operator of Los Alamos National Laboratory.
-* EPICS BASE Versions 3.13.7
-* and higher are distributed subject to a Software License Agreement found
+* EPICS BASE is distributed subject to a Software License Agreement found
 * in file LICENSE that is included with this distribution. 
 \*************************************************************************/
 /* dbAccess.h	*/
@@ -22,6 +21,7 @@
 #include "dbAddr.h"
 #include "dbLock.h"
 #include "dbAccessDefs.h"
+#include "dbLink.h"
 #include "dbCa.h"
 #include "dbCommon.h"
 #include "db_field_log.h"
 
=== modified file 'src/ioc/db/dbAccessDefs.h'
--- src/ioc/db/dbAccessDefs.h	2010-10-05 19:27:37 +0000
+++ src/ioc/db/dbAccessDefs.h	2012-06-21 20:42:45 +0000
@@ -3,9 +3,8 @@
 *     National Laboratory.
 * Copyright (c) 2002 The Regents of the University of California, as
 *     Operator of Los Alamos National Laboratory.
-* EPICS BASE Versions 3.13.7
-* and higher are distributed subject to a Software License Agreement found
-* in file LICENSE that is included with this distribution. 
+* EPICS BASE is distributed subject to a Software License Agreement found
+* in file LICENSE that is included with this distribution.
 \*************************************************************************/
 /* dbAccessDefs.h	*/
 /* $Revision-Id$ */
@@ -20,6 +19,8 @@
 
 #include "epicsTypes.h"
 #include "epicsTime.h"
+#include "dbBase.h"
+#include "dbAddr.h"
 
 #ifdef INCLdb_accessh_epicsExportSharedSymbols
 #   define epicsExportSharedSymbols
@@ -47,7 +48,7 @@
 #define DBR_CTRL_DOUBLE 0x00000100
 #define DBR_AL_LONG     0x00000200
 #define DBR_AL_DOUBLE   0x00000400
-
 
+
 /**********************************************************************
  * The next page contains macros for defining requests.
  * As an example the following defines a buffer to accept an array
@@ -69,7 +70,7 @@
  * options = DBR_STATUS|DBR_TIME;
  * number_elements = 10;
  * rtnval=dbGetField(paddr,DBR_FLOAT,&buffer,&options,&number_elements);
- *	
+ *
  * When dbGetField returns:
  *	rtnval is error status (0 means success)
  *	options has a bit set for each option that was accepted
@@ -97,7 +98,7 @@
  * MYBUFFER *pbuf1;
  * MYBUFFER buf;
  *************************************************************************/
-
 
+
 /* Macros for defining each option */
 #define DBRstatus \
 	epicsUInt16	status;		/* alarm status */\
@@ -143,7 +144,7 @@
         epicsFloat64    upper_warning_limit;\
         epicsFloat64    lower_warning_limit;\
         epicsFloat64    lower_alarm_limit;
-
 
+
 /*  structures for each option type             */
 struct dbr_status       {DBRstatus};
 struct dbr_units        {DBRunits};
@@ -198,25 +199,6 @@
 #define S_db_cntSpwn    (M_dbAccess|63) /*Cannot spawn dbContTask*/
 #define S_db_cntCont    (M_dbAccess|65) /*Cannot resume dbContTask*/
 #define S_db_noMemory   (M_dbAccess|66) /*unable to allocate data structure from pool*/
-
 
-/* Global Database Access Routines*/
-#define dbGetLink(PLNK, DBRTYPE, PBUFFER, OPTIONS, NREQUEST) \
-    ( ( ( (PLNK)->type == CONSTANT ) && \
-        ( (NREQUEST) == 0) &&\
-        ( (OPTIONS) == 0) ) \
-      ? 0 \
-      : dbGetLinkValue((PLNK),(DBRTYPE), \
-        (void *)(PBUFFER), (OPTIONS), (NREQUEST) ) )
-#define dbPutLink(PLNK, DBRTYPE, PBUFFER, NREQUEST) \
-    ( ( (PLNK)->type == CONSTANT) \
-      ? 0 \
-      : dbPutLinkValue( (PLNK), (DBRTYPE), (void *)(PBUFFER), (NREQUEST) ) )
-#define dbGetPdbAddrFromLink(PLNK) \
-    ( ( (PLNK)->type != DB_LINK ) \
-      ? 0 \
-      : ( ( (struct dbAddr *)( (PLNK)->value.pv_link.pvt) ) ) )
-#define dbGetSevr(PLINK,PSEVERITY) \
-    dbGetAlarm((PLINK),NULL,(PSEVERITY))
 
 epicsShareFunc long epicsShareAPI dbPutSpecial(struct dbAddr *paddr,int pass);
 epicsShareFunc struct rset * epicsShareAPI dbGetRset(const struct dbAddr *paddr);
@@ -224,51 +206,24 @@
     const char *recordTypename,const char *name,const char*value);
 epicsShareFunc int epicsShareAPI dbIsValueField(const struct dbFldDes *pdbFldDes);
 epicsShareFunc int epicsShareAPI dbGetFieldIndex(const struct dbAddr *paddr);
-epicsShareFunc long epicsShareAPI dbGetNelements(
-    const struct link *plink,long *nelements);
-epicsShareFunc int epicsShareAPI dbIsLinkConnected(const struct link *plink);
-epicsShareFunc int epicsShareAPI dbGetLinkDBFtype(const struct link *plink);
-epicsShareFunc long epicsShareAPI dbScanLink(
-    struct dbCommon *pfrom, struct dbCommon *pto);
 epicsShareFunc long epicsShareAPI dbScanPassive(
     struct dbCommon *pfrom,struct dbCommon *pto);
-epicsShareFunc void epicsShareAPI dbScanFwdLink(struct link *plink);
 epicsShareFunc long epicsShareAPI dbProcess(struct dbCommon *precord);
 epicsShareFunc long epicsShareAPI dbNameToAddr(
     const char *pname,struct dbAddr *);
 epicsShareFunc devSup* epicsShareAPI dbDTYPtoDevSup(dbRecordType *prdes, int dtyp);
 epicsShareFunc devSup* epicsShareAPI dbDSETtoDevSup(dbRecordType *prdes, struct dset *pdset);
-epicsShareFunc long epicsShareAPI dbGetLinkValue(
-    struct link *,short dbrType,void *pbuffer,long *options,long *nRequest);
 epicsShareFunc long epicsShareAPI dbGetField(
     struct dbAddr *,short dbrType,void *pbuffer,long *options,
     long *nRequest,void *pfl);
 epicsShareFunc long epicsShareAPI dbGet(
     struct dbAddr *,short dbrType,void *pbuffer,long *options,
     long *nRequest,void *pfl);
-epicsShareFunc long epicsShareAPI dbPutLinkValue(
-    struct link *,short dbrType,const void *pbuffer,long nRequest);
 epicsShareFunc long epicsShareAPI dbPutField(
     struct dbAddr *,short dbrType,const void *pbuffer,long nRequest);
 epicsShareFunc long epicsShareAPI dbPut(
     struct dbAddr *,short dbrType,const void *pbuffer,long nRequest);
 
-/* various utility routines */
-epicsShareFunc long epicsShareAPI dbGetControlLimits(
-    const struct link *plink,double *low, double *high);
-epicsShareFunc long epicsShareAPI dbGetGraphicLimits(
-    const struct link *plink,double *low, double *high);
-epicsShareFunc long epicsShareAPI dbGetAlarmLimits(
-    const struct link *plink,double *lolo, double *low, double *high, double *hihi);
-epicsShareFunc long epicsShareAPI dbGetPrecision(
-    const struct link *plink,short *precision);
-epicsShareFunc long epicsShareAPI dbGetUnits(
-    const struct link *plink,char *units,int unitsSize);
-epicsShareFunc long epicsShareAPI dbGetAlarm(
-    const struct link *plink, epicsEnum16 *status,epicsEnum16 *severity);
-epicsShareFunc long epicsShareAPI dbGetTimeStamp(
-    const struct link *plink,epicsTimeStamp *pstamp);
-
 typedef void(*SPC_ASCALLBACK)(struct dbCommon *);
 /*dbSpcAsRegisterCallback called by access security */
 epicsShareFunc void epicsShareAPI dbSpcAsRegisterCallback(SPC_ASCALLBACK func);
 
=== modified file 'src/ioc/db/dbAddr.h'
--- src/ioc/db/dbAddr.h	2008-08-15 18:58:18 +0000
+++ src/ioc/db/dbAddr.h	2012-06-21 20:42:45 +0000
@@ -4,7 +4,7 @@
 * 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. 
+* in file LICENSE that is included with this distribution.
 \*************************************************************************/
 
 #ifndef dbAddrh
@@ -27,7 +27,4 @@
 
 typedef dbAddr DBADDR;
 
-unsigned dbNameOfPV (const dbAddr * paddr, char * pBuf, unsigned bufLen);
-unsigned dbNameSizeOfPV (const dbAddr * paddr);
-
 #endif /* dbAddrh */
 
=== modified file 'src/ioc/db/dbBkpt.c'
--- src/ioc/db/dbBkpt.c	2010-10-05 19:27:37 +0000
+++ src/ioc/db/dbBkpt.c	2012-06-21 20:42:45 +0000
@@ -65,6 +65,7 @@
 #include "dbAddr.h"
 #include "dbAccessDefs.h"
 #include "dbScan.h"
+#include "dbLink.h"
 #include "dbLock.h"
 #include "recGbl.h"
 #include "dbTest.h"
 
=== modified file 'src/ioc/db/dbCAC.h'
--- src/ioc/db/dbCAC.h	2011-06-01 22:22:12 +0000
+++ src/ioc/db/dbCAC.h	2012-06-21 20:42:45 +0000
@@ -5,7 +5,7 @@
 *     Operator of Los Alamos National Laboratory.
 * EPICS BASE Versions 3.13.7
 * and higher are distributed subject to a Software License Agreement found
-* in file LICENSE that is included with this distribution. 
+* in file LICENSE that is included with this distribution.
 \*************************************************************************/
 /*
  *  $Revision-Id$
@@ -49,7 +49,7 @@
 #include "db_access.h"
 #include "dbNotify.h"
 #include "dbEvent.h"
-#include "dbAddr.h"
+#include "dbChannel.h"
 #include "dbLock.h"
 #include "dbCommon.h"
 #include "db_convert.h"
@@ -75,25 +75,25 @@
     virtual ~dbBaseIO() {}
 };
 
-extern "C" void dbSubscriptionEventCallback ( void *pPrivate, struct dbAddr *paddr,
+extern "C" void dbSubscriptionEventCallback ( void *pPrivate, struct dbChannel *dbch,
     int eventsRemaining, struct db_field_log *pfl );
 
-class dbSubscriptionIO : 
-    public tsDLNode < dbSubscriptionIO >, 
+class dbSubscriptionIO :
+    public tsDLNode < dbSubscriptionIO >,
     public dbBaseIO {
 public:
-    dbSubscriptionIO ( 
+    dbSubscriptionIO (
         epicsGuard < epicsMutex > &, epicsMutex &,
-        dbContext &, dbChannelIO &, struct dbAddr &, cacStateNotify &, 
+        dbContext &, dbChannelIO &, struct dbChannel *, cacStateNotify &,
         unsigned type, unsigned long count, unsigned mask, dbEventCtx );
     void destructor ( epicsGuard < epicsMutex > & );
     void unsubscribe ( epicsGuard < epicsMutex > & );
     void channelDeleteException ( epicsGuard < epicsMutex > & );
     void show ( epicsGuard < epicsMutex > &, unsigned level ) const;
     void show ( unsigned level ) const;
-    void * operator new ( size_t size, 
+    void * operator new ( size_t size,
         tsFreeList < dbSubscriptionIO, 256, epicsMutexNOOP > & );
-    epicsPlacementDeleteOperator (( void *, 
+    epicsPlacementDeleteOperator (( void *,
         tsFreeList < dbSubscriptionIO, 256, epicsMutexNOOP > & ))
 private:
     epicsMutex & mutex;
@@ -104,8 +104,8 @@
     unsigned type;
     unsigned id;
     dbSubscriptionIO * isSubscription ();
-    friend void dbSubscriptionEventCallback ( 
-        void * pPrivate, struct dbAddr * paddr,
+    friend void dbSubscriptionEventCallback (
+        void * pPrivate, struct dbChannel * dbch,
         int eventsRemaining, struct db_field_log * pfl );
     dbSubscriptionIO ( const dbSubscriptionIO & );
     dbSubscriptionIO & operator = ( const dbSubscriptionIO & );
@@ -149,8 +149,8 @@
 class dbContextReadNotifyCache  {
 public:
     dbContextReadNotifyCache ( epicsMutex & );
-    void callReadNotify ( epicsGuard < epicsMutex > &, 
-        struct dbAddr & addr, unsigned type, unsigned long count, 
+    void callReadNotify ( epicsGuard < epicsMutex > &,
+        struct dbChannel * dbch, unsigned type, unsigned long count,
             cacReadNotify & notify );
     void show ( epicsGuard < epicsMutex > &, unsigned level ) const;
 private:
@@ -162,29 +162,29 @@
 
 class dbContext : public cacContext {
 public:
-    dbContext ( epicsMutex & cbMutex, epicsMutex & mutex, 
+    dbContext ( epicsMutex & cbMutex, epicsMutex & mutex,
         cacContextNotify & notify );
     virtual ~dbContext ();
     void destroyChannel ( epicsGuard < epicsMutex > &, dbChannelIO & );
-    void callReadNotify ( epicsGuard < epicsMutex > &, 
-            struct dbAddr & addr, unsigned type, unsigned long count, 
+    void callReadNotify ( epicsGuard < epicsMutex > &,
+            struct dbChannel * dbch, unsigned type, unsigned long count,
             cacReadNotify & notify );
-    void callStateNotify ( struct dbAddr &addr, unsigned type, unsigned long count, 
+    void callStateNotify ( struct dbChannel * dbch, unsigned type, unsigned long count,
             const struct db_field_log * pfl, cacStateNotify & notify );
-    void subscribe ( 
+    void subscribe (
             epicsGuard < epicsMutex > &,
-            struct dbAddr & addr, dbChannelIO & chan,
-            unsigned type, unsigned long count, unsigned mask, 
+            struct dbChannel * dbch, dbChannelIO & chan,
+            unsigned type, unsigned long count, unsigned mask,
             cacStateNotify & notify, cacChannel::ioid * pId );
-    void initiatePutNotify ( 
-            epicsGuard < epicsMutex > &, dbChannelIO &, struct dbAddr &, 
-            unsigned type, unsigned long count, const void * pValue, 
-            cacWriteNotify & notify, cacChannel::ioid * pId ); 
+    void initiatePutNotify (
+            epicsGuard < epicsMutex > &, dbChannelIO &, struct dbChannel *,
+            unsigned type, unsigned long count, const void * pValue,
+            cacWriteNotify & notify, cacChannel::ioid * pId );
     void show ( unsigned level ) const;
     void showAllIO ( const dbChannelIO & chan, unsigned level ) const;
-    void destroyAllIO ( 
+    void destroyAllIO (
         epicsGuard < epicsMutex > &, dbChannelIO & chan );
-    void ioCancel ( epicsGuard < epicsMutex > &, 
+    void ioCancel ( epicsGuard < epicsMutex > &,
         dbChannelIO & chan, const cacChannel::ioid &id );
     void ioShow ( epicsGuard < epicsMutex > &,
         const cacChannel::ioid & id, unsigned level ) const;
@@ -202,11 +202,11 @@
     epics_auto_ptr < cacContext > pNetContext;
     char * pStateNotifyCache;
 
-    cacChannel & createChannel ( 
+    cacChannel & createChannel (
         epicsGuard < epicsMutex > &,
-        const char * pChannelName, cacChannelNotify &, 
+        const char * pChannelName, cacChannelNotify &,
         cacChannel::priLev );
-    void flush ( 
+    void flush (
         epicsGuard < epicsMutex > & );
     unsigned circuitCount (
         epicsGuard < epicsMutex > & ) const;
@@ -214,7 +214,7 @@
         epicsGuard < epicsMutex > & ) const;
     unsigned beaconAnomaliesSinceProgramStart (
         epicsGuard < epicsMutex > & ) const;
-    void show ( 
+    void show (
         epicsGuard < epicsMutex > &, unsigned level ) const;
 
     dbContext ( const dbContext & );
@@ -226,17 +226,17 @@
 {
 }
 
-inline dbContextPrivateListOfIO::~dbContextPrivateListOfIO () 
+inline dbContextPrivateListOfIO::~dbContextPrivateListOfIO ()
 {
     assert ( ! this->pBlocker );
 }
 
-inline void dbContext::callReadNotify ( 
-    epicsGuard < epicsMutex > & guard, struct dbAddr &addr, 
+inline void dbContext::callReadNotify (
+    epicsGuard < epicsMutex > & guard, struct dbChannel * dbch,
     unsigned type, unsigned long count, cacReadNotify & notifyIn )
 {
     guard.assertIdenticalMutex ( this-> mutex );
-    this->readNotifyCache.callReadNotify ( guard, addr, type, count, notifyIn );
+    this->readNotifyCache.callReadNotify ( guard, dbch, type, count, notifyIn );
 }
 
 #endif // dbCACh
 
=== modified file 'src/ioc/db/dbCa.c'
--- src/ioc/db/dbCa.c	2012-05-04 18:38:59 +0000
+++ src/ioc/db/dbCa.c	2012-06-21 20:42:45 +0000
@@ -411,6 +411,13 @@
     return pca->isConnected;
 }
 
+void dbCaScanFwdLink(struct link *plink) {
+    short fwdLinkValue = 1;
+
+    if (plink->value.pv_link.pvlMask & pvlOptFWD)
+        dbCaPutLink(plink, DBR_SHORT, &fwdLinkValue, 1);
+}
+
 #define pcaGetCheck \
     assert(plink); \
     if (plink->type != CA_LINK) return -1; \
@@ -639,7 +646,7 @@
 static void eventCallback(struct event_handler_args arg)
 {
     caLink *pca = (caLink *)arg.usr;
-    DBLINK *plink;
+    struct link *plink;
     size_t size;
     dbCommon *precord = 0;
     struct dbr_time_double *pdbr_time_double;
 
=== modified file 'src/ioc/db/dbCa.h'
--- src/ioc/db/dbCa.h	2009-04-29 18:24:25 +0000
+++ src/ioc/db/dbCa.h	2012-06-21 20:42:45 +0000
@@ -40,6 +40,7 @@
 #define dbCaPutLink(plink, dbrType, pbuffer, nRequest) \
     dbCaPutLinkCallback((plink), (dbrType), (pbuffer), (nRequest), 0, 0)
 epicsShareFunc int dbCaIsLinkConnected(const struct link *plink);
+epicsShareFunc void dbCaScanFwdLink(struct link *plink);
 
 /* The following are available after the link is connected*/
 epicsShareFunc long dbCaGetNelements(const struct link *plink,
 
=== added file 'src/ioc/db/dbChannel.c'
--- src/ioc/db/dbChannel.c	1970-01-01 00:00:00 +0000
+++ src/ioc/db/dbChannel.c	2012-06-21 20:42:45 +0000
@@ -0,0 +1,865 @@
+/*************************************************************************\
+* Copyright (c) 2010 UChicago Argonne LLC, as Operator of Argonne
+*     National Laboratory.
+* Copyright (c) 2010 Brookhaven National Laboratory.
+* Copyright (c) 2010 Helmholtz-Zentrum Berlin
+*     fuer Materialien und Energie GmbH.
+* EPICS BASE is distributed subject to a Software License Agreement found
+* in file LICENSE that is included with this distribution.
+\*************************************************************************/
+
+/*
+ *  Author: Andrew Johnson <[e-mail]>
+ *          Ralph Lange <[e-mail]>
+ */
+
+#include <stdio.h>
+#include <string.h>
+
+#include "cantProceed.h"
+#include "dbChannel.h"
+#include "dbCommon.h"
+#include "dbBase.h"
+#include "dbEvent.h"
+#include "link.h"
+#include <freeList.h>
+#include "dbAccessDefs.h"
+#include "dbLock.h"
+#include "dbStaticLib.h"
+#include "epicsAssert.h"
+#include "epicsString.h"
+#include "errlog.h"
+#include "gpHash.h"
+#include "recSup.h"
+#include "special.h"
+#include "yajl_parse.h"
+
+/* The following is defined in db_convert.h */
+extern unsigned short dbDBRnewToDBRold[DBR_ENUM+1];
+
+typedef struct parseContext {
+    dbChannel *chan;
+    chFilter *filter;
+    int depth;
+} parseContext;
+
+#define CALLIF(rtn) !rtn ? parse_stop : rtn
+
+static void *dbchStringFreeList;
+
+void dbChannelInit (void)
+{
+    if (!dbchStringFreeList) {
+        freeListInitPvt(&dbchStringFreeList,
+            sizeof(epicsOldString), 128);
+    }
+}
+
+static void chf_value(parseContext *parser, parse_result *presult)
+{
+    chFilter *filter = parser->filter;
+
+    if (*presult == parse_stop || parser->depth > 0)
+        return;
+
+    parser->filter = NULL;
+    if (filter->plug->fif->parse_end(filter) == parse_continue) {
+        ellAdd(&parser->chan->filters, &filter->list_node);
+    } else {
+        free(filter); /* FIXME: Use free-list */
+        *presult = parse_stop;
+    }
+}
+
+static int chf_null(void * ctx)
+{
+    parseContext *parser = (parseContext *) ctx;
+    chFilter *filter = parser->filter;
+    parse_result result;
+
+    assert(filter);
+    result = CALLIF(filter->plug->fif->parse_null)(filter );
+    chf_value(parser, &result);
+    return result;
+}
+
+static int chf_boolean(void * ctx, int boolVal)
+{
+    parseContext *parser = (parseContext *) ctx;
+    chFilter *filter = parser->filter;
+    parse_result result;
+
+    assert(filter);
+    result = CALLIF(filter->plug->fif->parse_boolean)(filter , boolVal);
+    chf_value(parser, &result);
+    return result;
+}
+
+static int chf_integer(void * ctx, long integerVal)
+{
+    parseContext *parser = (parseContext *) ctx;
+    chFilter *filter = parser->filter;
+    parse_result result;
+
+    assert(filter);
+    result = CALLIF(filter->plug->fif->parse_integer)(filter , integerVal);
+    chf_value(parser, &result);
+    return result;
+}
+
+static int chf_double(void * ctx, double doubleVal)
+{
+    parseContext *parser = (parseContext *) ctx;
+    chFilter *filter = parser->filter;
+    parse_result result;
+
+    assert(filter);
+    result = CALLIF(filter->plug->fif->parse_double)(filter , doubleVal);
+    chf_value(parser, &result);
+    return result;
+}
+
+static int chf_string(void * ctx, const unsigned char * stringVal,
+        unsigned int stringLen)
+{
+    parseContext *parser = (parseContext *) ctx;
+    chFilter *filter = parser->filter;
+    parse_result result;
+
+    assert(filter);
+    result = CALLIF(filter->plug->fif->parse_string)(filter , (const char *) stringVal, stringLen);
+    chf_value(parser, &result);
+    return result;
+}
+
+static int chf_start_map(void * ctx)
+{
+    parseContext *parser = (parseContext *) ctx;
+    chFilter *filter = parser->filter;
+
+    if (!filter) {
+        assert(parser->depth == 0);
+        return parse_continue; /* Opening '{' */
+    }
+
+    ++parser->depth;
+    return CALLIF(filter->plug->fif->parse_start_map)(filter );
+}
+
+static int chf_map_key(void * ctx, const unsigned char * key,
+        unsigned int stringLen)
+{
+    parseContext *parser = (parseContext *) ctx;
+    chFilter *filter = parser->filter;
+    const chFilterPlugin *plug;
+    parse_result result;
+
+    if (filter) {
+        assert(parser->depth > 0);
+        return CALLIF(filter->plug->fif->parse_map_key)(filter , (const char *) key, stringLen);
+    }
+
+    assert(parser->depth == 0);
+    plug = dbFindFilter((const char *) key, stringLen);
+    if (!plug) {
+        printf("dbChannelCreate: Channel filter '%.*s' not found\n", (int) stringLen, key);
+        return parse_stop;
+    }
+
+    /* FIXME: Use a free-list */
+    filter = (chFilter *) callocMustSucceed(1, sizeof(*filter), "Creating dbChannel filter");
+    filter->chan = parser->chan;
+    filter->plug = plug;
+    filter->puser = NULL;
+
+    result = plug->fif->parse_start(filter);
+    if (result == parse_continue) {
+        parser->filter = filter;
+    } else {
+        free(filter); /* FIXME: Use free-list */
+    }
+    return result;
+}
+
+static int chf_end_map(void * ctx)
+{
+    parseContext *parser = (parseContext *) ctx;
+    chFilter *filter = parser->filter;
+    parse_result result;
+
+    if (!filter) {
+        assert(parser->depth == 0);
+        return parse_continue; /* Final closing '}' */
+    }
+
+    assert(parser->depth > 0);
+    result = CALLIF(filter->plug->fif->parse_end_map)(filter );
+
+    --parser->depth;
+    chf_value(parser, &result);
+    return result;
+}
+
+static int chf_start_array(void * ctx)
+{
+    parseContext *parser = (parseContext *) ctx;
+    chFilter *filter = parser->filter;
+
+    assert(filter);
+    ++parser->depth;
+    return CALLIF(filter->plug->fif->parse_start_array)(filter );
+}
+
+static int chf_end_array(void * ctx)
+{
+    parseContext *parser = (parseContext *) ctx;
+    chFilter *filter = parser->filter;
+    parse_result result;
+
+    assert(filter);
+    result = CALLIF(filter->plug->fif->parse_end_array)(filter );
+    --parser->depth;
+    chf_value(parser, &result);
+    return result;
+}
+
+static const yajl_callbacks chf_callbacks =
+    { chf_null, chf_boolean, chf_integer, chf_double, NULL, chf_string,
+      chf_start_map, chf_map_key, chf_end_map, chf_start_array, chf_end_array };
+
+static const yajl_parser_config chf_config =
+    { 0, 1 }; /* allowComments = NO , checkUTF8 = YES */
+
+static void * chf_malloc(void *ctx, unsigned int sz)
+{
+    return malloc(sz); /* FIXME: free-list */
+}
+
+static void * chf_realloc(void *ctx, void *ptr, unsigned int sz)
+{
+    return realloc(ptr, sz); /* FIXME: free-list */
+}
+
+static void chf_free(void *ctx, void *ptr)
+{
+    return free(ptr); /* FIXME: free-list */
+}
+
+static const yajl_alloc_funcs chf_alloc =
+    { chf_malloc, chf_realloc, chf_free };
+
+static long chf_parse(dbChannel *chan, const char **pjson)
+{
+    parseContext parser =
+        { chan, NULL, 0 };
+    yajl_handle yh = yajl_alloc(&chf_callbacks, &chf_config, &chf_alloc, &parser);
+    const char *json = *pjson;
+    size_t jlen = strlen(json);
+    yajl_status ys;
+    long status;
+
+    if (!yh)
+        return S_db_noMemory;
+
+    ys = yajl_parse(yh, (const unsigned char *) json, jlen);
+    if (ys == yajl_status_insufficient_data)
+        ys = yajl_parse_complete(yh);
+
+    switch (ys) {
+    case yajl_status_ok:
+        status = 0;
+        *pjson += yajl_get_bytes_consumed(yh);
+        break;
+
+    case yajl_status_error: {
+        unsigned char *err;
+
+        err = yajl_get_error(yh, 1, (const unsigned char *) json, jlen);
+        printf("dbChannelCreate: %s\n", err);
+        yajl_free_error(yh, err);
+    } /* fall through */
+    default:
+        status = S_db_notFound;
+    }
+
+    if (parser.filter) {
+        assert(status);
+        parser.filter->plug->fif->parse_abort(parser.filter);
+        free(parser.filter); /* FIXME: free-list */
+    }
+    yajl_free(yh);
+    return status;
+}
+
+static long pvNameLookup(DBENTRY *pdbe, const char **ppname)
+{
+    long status;
+
+    dbInitEntry(pdbbase, pdbe);
+
+    status = dbFindRecordPart(pdbe, ppname);
+    if (status)
+        return status;
+
+    if (**ppname == '.')
+        ++*ppname;
+
+    status = dbFindFieldPart(pdbe, ppname);
+    if (status == S_dbLib_fieldNotFound)
+        status = dbGetAttributePart(pdbe, ppname);
+
+    return status;
+}
+
+long dbChannelTest(const char *name)
+{
+    DBENTRY dbEntry;
+    long status;
+
+    if (!name || !*name || !pdbbase)
+        return S_db_notFound;
+
+    status = pvNameLookup(&dbEntry, &name);
+
+    dbFinishEntry(&dbEntry);
+    return status;
+}
+
+#define TRY(Func, Arg) \
+if (Func) { \
+    result = Func Arg; \
+    if (result != parse_continue) goto failure; \
+}
+
+static long parseArrayRange(dbChannel* chan, const char *pname, const char **ppnext) {
+    epicsInt32 start = 0;
+    epicsInt32 end = -1;
+    epicsInt32 incr = 1;
+    epicsInt32 l;
+    char *pnext;
+    short exist;
+    chFilter *filter;
+    const chFilterPlugin *plug;
+    parse_result result;
+    long status = 0;
+
+    /* If no number is present, strtol() returns 0 and sets pnext=pname,
+       else pnext points to the first char after the number */
+    pname++;
+    l = strtol(pname, &pnext, 0);
+    exist = pnext - pname;
+    if (exist) start = l;
+    pname = pnext;
+    if (*pname == ']' && exist) {
+        end = start;
+        goto insertplug;
+    }
+    if (*pname != ':') {
+        status = S_dbLib_fieldNotFound;
+        goto finish;
+    }
+    pname++;
+    l = strtol(pname, &pnext, 0);
+    exist = pnext - pname;
+    pname = pnext;
+    if (*pname == ']') {
+        if (exist) end = l;
+        goto insertplug;
+    }
+    if (exist) incr = l;
+    if (*pname != ':') {
+        status = S_dbLib_fieldNotFound;
+        goto finish;
+    }
+    pname++;
+    l = strtol(pname, &pnext, 0);
+    exist = pnext - pname;
+    if (exist) end = l;
+    pname = pnext;
+    if (*pname != ']') {
+        status = S_dbLib_fieldNotFound;
+        goto finish;
+    }
+
+    insertplug:
+    pname++;
+    *ppnext = pname;
+
+    plug = dbFindFilter("arr", 3);
+    if (!plug) {
+        status = S_dbLib_fieldNotFound;
+        goto finish;
+    }
+
+    /* FIXME: Use a free-list */
+    filter = (chFilter *) callocMustSucceed(1, sizeof(*filter), "Creating 'arr' dbChannel filter");
+    filter->chan = chan;
+    filter->plug = plug;
+    filter->puser = NULL;
+
+    TRY(filter->plug->fif->parse_start, (filter));
+    TRY(filter->plug->fif->parse_start_map, (filter));
+    if (start != 0) {
+        TRY(filter->plug->fif->parse_map_key, (filter, "s", 1));
+        TRY(filter->plug->fif->parse_integer, (filter, start));
+    }
+    if (incr != 1) {
+        TRY(filter->plug->fif->parse_map_key, (filter, "i", 1));
+        TRY(filter->plug->fif->parse_integer, (filter, incr));
+    }
+    if (end != -1) {
+        TRY(filter->plug->fif->parse_map_key, (filter, "e", 1));
+        TRY(filter->plug->fif->parse_integer, (filter, end));
+    }
+    TRY(filter->plug->fif->parse_end_map, (filter));
+    TRY(filter->plug->fif->parse_end, (filter));
+
+    ellAdd(&chan->filters, &filter->list_node);
+    return 0;
+
+    failure:
+    free(filter); /* FIXME: Use free-list */
+    status = S_dbLib_fieldNotFound;
+
+    finish:
+    return status;
+}
+
+/* Stolen from dbAccess.c: */
+static short mapDBFToDBR[DBF_NTYPES] =
+    {
+    /* DBF_STRING   => */DBR_STRING,
+    /* DBF_CHAR     => */DBR_CHAR,
+    /* DBF_UCHAR    => */DBR_UCHAR,
+    /* DBF_SHORT    => */DBR_SHORT,
+    /* DBF_USHORT   => */DBR_USHORT,
+    /* DBF_LONG     => */DBR_LONG,
+    /* DBF_ULONG    => */DBR_ULONG,
+    /* DBF_FLOAT    => */DBR_FLOAT,
+    /* DBF_DOUBLE   => */DBR_DOUBLE,
+    /* DBF_ENUM,    => */DBR_ENUM,
+    /* DBF_MENU,    => */DBR_ENUM,
+    /* DBF_DEVICE   => */DBR_ENUM,
+    /* DBF_INLINK   => */DBR_STRING,
+    /* DBF_OUTLINK  => */DBR_STRING,
+    /* DBF_FWDLINK  => */DBR_STRING,
+    /* DBF_NOACCESS => */DBR_NOACCESS };
+
+dbChannel * dbChannelCreate(const char *name)
+{
+    const char *pname = name;
+    DBENTRY dbEntry;
+    dbChannel *chan = NULL;
+    dbAddr *paddr;
+    dbFldDes *pflddes;
+    long status;
+    short dbfType;
+
+    if (!name || !*name || !pdbbase)
+        return NULL;
+
+    status = pvNameLookup(&dbEntry, &pname);
+    if (status)
+        goto finish;
+
+    /* FIXME: Use free-list */
+    chan = (dbChannel *) callocMustSucceed(1, sizeof(*chan), "dbChannelCreate");
+    chan->name = epicsStrDup(name);  /* FIXME: free-list */
+    ellInit(&chan->filters);
+    ellInit(&chan->pre_chain);
+    ellInit(&chan->post_chain);
+
+    paddr = &chan->addr;
+    pflddes = dbEntry.pflddes;
+    dbfType = pflddes->field_type;
+
+    paddr->precord = dbEntry.precnode->precord;
+    paddr->pfield = dbEntry.pfield;
+    paddr->pfldDes = pflddes;
+    paddr->no_elements = 1;
+    paddr->field_type = dbfType;
+    paddr->field_size = pflddes->size;
+    paddr->special = pflddes->special;
+    paddr->dbr_field_type = mapDBFToDBR[dbfType];
+
+    /* Handle field modifiers */
+    if (*pname) {
+        if (*pname == '$') {
+            /* Some field types can be accessed as char arrays */
+            if (dbfType == DBF_STRING) {
+                paddr->no_elements = pflddes->size;
+                paddr->field_type = DBF_CHAR;
+                paddr->field_size = 1;
+                paddr->dbr_field_type = DBR_CHAR;
+            } else if (dbfType >= DBF_INLINK && dbfType <= DBF_FWDLINK) {
+                /* Clients see a char array, but keep original dbfType */
+                paddr->no_elements = PVNAME_STRINGSZ + 12;
+                paddr->field_size = 1;
+                paddr->dbr_field_type = DBR_CHAR;
+            } else {
+                status = S_dbLib_fieldNotFound;
+                goto finish;
+            }
+            pname++;
+        }
+
+        if (*pname == '[') {
+            status = parseArrayRange(chan, pname, &pname);
+            if (status) goto finish;
+        }
+
+        /* JSON may follow */
+        if (*pname == '{') {
+            status = chf_parse(chan, &pname);
+            if (status) goto finish;
+        }
+
+        /* Make sure there's nothing else */
+        if (*pname) {
+            status = S_dbLib_fieldNotFound;
+            goto finish;
+        }
+    }
+
+    if (paddr->special == SPC_DBADDR) {
+        struct rset *prset = dbGetRset(paddr);
+
+        /* Let record type modify the dbAddr */
+        if (prset && prset->cvt_dbaddr) {
+            status = prset->cvt_dbaddr(paddr);
+            if (status) goto finish;
+        }
+    }
+
+finish:
+    if (status && chan) {
+        dbChannelDelete(chan);
+        chan = NULL;
+    }
+    dbFinishEntry(&dbEntry);
+    return chan;
+}
+
+db_field_log* dbChannelRunPreChain(dbChannel *chan, db_field_log *pLogIn) {
+    chFilter *filter;
+    ELLNODE *node;
+    db_field_log *pLog = pLogIn;
+
+    for (node = ellFirst(&chan->pre_chain); node && pLog; node = ellNext(node)) {
+        filter = CONTAINER(node, chFilter, pre_node);
+        pLog = filter->pre_func(filter->pre_arg, chan, pLog);
+    }
+    return pLog;
+}
+
+db_field_log* dbChannelRunPostChain(dbChannel *chan, db_field_log *pLogIn) {
+    chFilter *filter;
+    ELLNODE *node;
+    db_field_log *pLog = pLogIn;
+
+    for (node = ellFirst(&chan->post_chain); node && pLog; node = ellNext(node)) {
+        filter = CONTAINER(node, chFilter, post_node);
+        pLog = filter->post_func(filter->post_arg, chan, pLog);
+    }
+    return pLog;
+}
+
+long dbChannelOpen(dbChannel *chan)
+{
+    chFilter *filter;
+    chPostEventFunc *func;
+    void *arg;
+    long status;
+    ELLNODE *node;
+    db_field_log probe;
+    db_field_log p;
+
+    for (node = ellFirst(&chan->filters); node; node = ellNext(node)) {
+        filter = CONTAINER(node, chFilter, list_node);
+         /* Call channel_open */
+        status = 0;
+        if (filter->plug->fif->channel_open)
+            status = filter->plug->fif->channel_open(filter);
+        if (status) return status;
+    }
+
+    /* Set up type probe */
+    probe.field_type  = dbChannelFieldType(chan);
+    probe.no_elements = dbChannelElements(chan);
+    probe.field_size  = dbChannelFieldSize(chan);
+    p = probe;
+
+    /*
+     * Build up the pre- and post-event-queue filter chains
+     * Separate loops because the probe must reach the filters in the right order.
+     */
+    for (node = ellFirst(&chan->filters); node; node = ellNext(node)) {
+        filter = CONTAINER(node, chFilter, list_node);
+        func = NULL;
+        arg = NULL;
+        if (filter->plug->fif->channel_register_pre) {
+            filter->plug->fif->channel_register_pre(filter, &func, &arg, &p);
+            if (func) {
+                ellAdd(&chan->pre_chain, &filter->pre_node);
+                filter->pre_func = func;
+                filter->pre_arg  = arg;
+                probe = p;
+            }
+        }
+    }
+    for (node = ellFirst(&chan->filters); node; node = ellNext(node)) {
+        filter = CONTAINER(node, chFilter, list_node);
+        func = NULL;
+        arg = NULL;
+        if (filter->plug->fif->channel_register_post) {
+            filter->plug->fif->channel_register_post(filter, &func, &arg, &p);
+            if (func) {
+                ellAdd(&chan->post_chain, &filter->post_node);
+                filter->post_func = func;
+                filter->post_arg  = arg;
+                probe = p;
+            }
+        }
+    }
+
+    /* Save probe results */
+    chan->final_no_elements  = probe.no_elements;
+    chan->final_field_size   = probe.field_size;
+    chan->final_type         = probe.field_type;
+    chan->dbr_final_type     = dbDBRnewToDBRold[mapDBFToDBR[probe.field_type]];
+
+    return 0;
+}
+
+/* FIXME: For performance we should make these one-liners into macros,
+ * or try to make them inline if all our compilers can do that.
+ */
+const char * dbChannelName(dbChannel *chan)
+{
+    return chan->name;
+}
+
+struct dbCommon * dbChannelRecord(dbChannel *chan)
+{
+    return chan->addr.precord;
+}
+
+struct dbFldDes * dbChannelFldDes(dbChannel *chan)
+{
+    return chan->addr.pfldDes;
+}
+
+long dbChannelElements(dbChannel *chan)
+{
+    return chan->addr.no_elements;
+}
+
+short dbChannelFieldType(dbChannel *chan)
+{
+    return chan->addr.field_type;
+}
+
+short dbChannelExportType(dbChannel *chan)
+{
+    return chan->addr.dbr_field_type;
+}
+
+short dbChannelFieldSize(dbChannel *chan)
+{
+    return chan->addr.field_size;
+}
+
+long dbChannelFinalElements(dbChannel *chan)
+{
+    return chan->final_no_elements;
+}
+
+short dbChannelFinalFieldType(dbChannel *chan)
+{
+    return chan->final_type;
+}
+
+short dbChannelFinalExportType(dbChannel *chan)
+{
+    return chan->dbr_final_type;
+}
+
+short dbChannelFinalFieldSize(dbChannel *chan)
+{
+    return chan->final_field_size;
+}
+
+short dbChannelSpecial(dbChannel *chan)
+{
+    return chan->addr.special;
+}
+
+void * dbChannelField(dbChannel *chan)
+{
+    /* Channel filters do not get to interpose here since there are many
+     * places where the field pointer is compared with the address of a
+     * specific record field, so they can't modify the pointer value.
+     */
+    return chan->addr.pfield;
+}
+
+/* Only use dbChannelGet() if the record is already locked. */
+long dbChannelGet(dbChannel *chan, short type, void *pbuffer,
+        long *options, long *nRequest, void *pfl)
+{
+    /* FIXME: Vector through chan->get() ? */
+    return dbGet(&chan->addr, type, pbuffer, options, nRequest, pfl);
+}
+
+long dbChannelGetField(dbChannel *chan, short dbrType, void *pbuffer,
+        long *options, long *nRequest, void *pfl)
+{
+    dbCommon *precord = chan->addr.precord;
+    long status = 0;
+
+    dbScanLock(precord);
+    status = dbChannelGet(chan, dbrType, pbuffer, options, nRequest, pfl);
+    dbScanUnlock(precord);
+    return status;
+}
+
+/* Only use dbChannelPut() if the record is already locked.
+ * This routine doesn't work on link fields, ignores DISP, and
+ * doesn't trigger record processing on PROC or pp(TRUE).
+ */
+long dbChannelPut(dbChannel *chan, short type, const void *pbuffer,
+        long nRequest)
+{
+    /* FIXME: Vector through chan->put() ? */
+    return dbPut(&chan->addr, type, pbuffer, nRequest);
+}
+
+long dbChannelPutField(dbChannel *chan, short type, const void *pbuffer,
+        long nRequest)
+{
+    /* FIXME: Vector through chan->putField() ? */
+    return dbPutField(&chan->addr, type, pbuffer, nRequest);
+}
+
+void dbChannelShow(dbChannel *chan, int level, const unsigned short indent)
+{
+    long elems = chan->addr.no_elements;
+    long felems = chan->final_no_elements;
+    int count = ellCount(&chan->filters);
+    int pre   = ellCount(&chan->pre_chain);
+    int post  = ellCount(&chan->post_chain);
+
+    printf("%*schannel name: %s\n", indent, "", chan->name);
+    /* FIXME: show field_type as text */
+    printf("%*s  field_type=%d (%dB), %ld element%s, %d filter%s", indent, "",
+           chan->addr.field_type, chan->addr.field_size, elems, elems == 1 ? "" : "s",
+           count, count == 1 ? "" : "s");
+    if (count)
+        printf(" (%d pre eventq, %d post eventq)\n", pre, post);
+    else
+        printf("\n");
+    if (level > 0)
+        dbChannelFilterShow(chan, level - 1, indent + 2);
+    if (count) {
+        /* FIXME: show field_type as text */
+        printf("%*s  final field_type=%d (%dB), %ld element%s\n", indent, "",
+               chan->final_type, chan->final_field_size, felems, felems == 1 ? "" : "s");
+    }
+}
+
+void dbChannelFilterShow(dbChannel *chan, int level, const unsigned short indent)
+{
+    chFilter *filter = (chFilter *) ellFirst(&chan->filters);
+    while (filter) {
+        filter->plug->fif->channel_report(filter, level, indent);
+        filter = (chFilter *) ellNext(&filter->list_node);
+    }
+}
+
+void dbChannelDelete(dbChannel *chan)
+{
+    chFilter *filter;
+
+    /* Close filters in reverse order */
+    while ((filter = (chFilter *) ellPop(&chan->filters))) {
+        filter->plug->fif->channel_close(filter);
+        free(filter);
+    }
+    free((char *) chan->name);   /* FIXME: Use free-list */
+    free(chan); /* FIXME: Use free-list */
+}
+
+static void freeArray(db_field_log *pfl) {
+    if (pfl->field_type == DBF_STRING && pfl->no_elements == 1) {
+        freeListFree(dbchStringFreeList, pfl->u.r.field);
+    } else {
+        free(pfl->u.r.field);
+    }
+}
+
+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;
+}
+
+/* FIXME: Do these belong in a different file? */
+
+void dbRegisterFilter(const char *name, const chFilterIf *fif, void *puser)
+{
+    GPHENTRY *pgph;
+    chFilterPlugin *pfilt;
+
+    if (!pdbbase) {
+        printf("dbRegisterFilter: pdbbase not set!\n");
+        return;
+    }
+
+    pgph = gphFind(pdbbase->pgpHash, name, &pdbbase->filterList);
+    if (pgph)
+        return;
+
+    pfilt = dbCalloc(1, sizeof(chFilterPlugin));
+    pfilt->name = epicsStrDup(name);
+    pfilt->fif = fif;
+    pfilt->puser = puser;
+
+    ellAdd(&pdbbase->filterList, &pfilt->node);
+    pgph = gphAdd(pdbbase->pgpHash, pfilt->name, &pdbbase->filterList);
+    if (!pgph) {
+        free((void *) pfilt->name);
+        free(pfilt);
+        printf("dbRegisterFilter: gphAdd failed\n");
+        return;
+    }
+    pgph->userPvt = pfilt;
+}
+
+const chFilterPlugin * dbFindFilter(const char *name, size_t len)
+{
+    GPHENTRY *pgph = gphFindParse(pdbbase->pgpHash, name, len,
+            &pdbbase->filterList);
+
+    if (!pgph)
+        return NULL;
+    return (chFilterPlugin *) pgph->userPvt;
+}
 
=== added file 'src/ioc/db/dbChannel.h'
--- src/ioc/db/dbChannel.h	1970-01-01 00:00:00 +0000
+++ src/ioc/db/dbChannel.h	2012-06-21 20:42:45 +0000
@@ -0,0 +1,181 @@
+/*************************************************************************\
+* Copyright (c) 2010 UChicago Argonne LLC, as Operator of Argonne
+*     National Laboratory.
+* Copyright (c) 2010 Brookhaven National Laboratory.
+* Copyright (c) 2010 Helmholtz-Zentrum Berlin
+*     fuer Materialien und Energie GmbH.
+* EPICS BASE is distributed subject to a Software License Agreement found
+* in file LICENSE that is included with this distribution.
+\*************************************************************************/
+
+/*
+ *  Author: Andrew Johnson <[e-mail]>
+ *          Ralph Lange <[e-mail]>
+ */
+
+#ifndef INC_dbChannel_H
+#define INC_dbChannel_H
+
+#include "dbDefs.h"
+#include "dbAddr.h"
+#include "ellLib.h"
+#include "epicsTypes.h"
+#include "errMdef.h"
+#include "shareLib.h"
+#include "db_field_log.h"
+#include "dbEvent.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * event subscription
+ */
+typedef struct evSubscrip {
+    ELLNODE                 node;
+    struct dbChannel        *chan;
+    EVENTFUNC               *user_sub;
+    void                    *user_arg;
+    struct event_que        *ev_que;
+    db_field_log            **pLastLog;
+    unsigned long           npend;  /* n times this event is on the queue */
+    unsigned long           nreplace;  /* n times replacing event on the queue */
+    unsigned char           select;
+    char                    useValque;
+    char                    callBackInProgress;
+    char                    enabled;
+} evSubscrip;
+
+typedef struct chFilter chFilter;
+
+/* A dbChannel points to a record field, and can have multiple filters */
+typedef struct dbChannel {
+    const char *name;
+    dbAddr addr;              /* address structure for record/field */
+    long  final_no_elements;  /* final number of elements (arrays) */
+    short final_field_size;   /* final size of element */
+    short final_type;         /* final type of database field */
+    short dbr_final_type;     /* final field type as seen by database request */
+    ELLLIST filters;          /* list of filters as created from JSON */
+    ELLLIST pre_chain;        /* list of filters to be called pre-event-queue */
+    ELLLIST post_chain;       /* list of filters to be called post-event-queue */
+} dbChannel;
+
+/* Prototype for the post event function that is called in filter stacks */
+typedef db_field_log* (chPostEventFunc)(void *pvt, dbChannel *chan, db_field_log *pLog);
+
+/* Return values from chFilterIf->parse_* routines: */
+typedef enum {
+    parse_stop, parse_continue
+} parse_result;
+
+/* These routines must be implemented by each filter plug-in */
+typedef struct chFilterIf {
+    /* Parsing event handlers: */
+    parse_result (* parse_start)(chFilter *filter);
+    /* If parse_start() returns parse_continue for a filter, one of
+     * parse_abort() or parse_end() will later be called for that same
+     * filter.
+     */
+    void (* parse_abort)(chFilter *filter);
+    /* If parse_abort() is called it should release any memory allocated
+     * for this filter; no further parse_...() calls will be made;
+     */
+    parse_result (* parse_end)(chFilter *filter);
+    /* If parse_end() returns parse_stop it should have released any
+     * memory allocated for this filter; no further parse_...() calls will
+     * be made in this case.
+     */
+
+    parse_result (* parse_null)(chFilter *filter);
+    parse_result (* parse_boolean)(chFilter *filter, int boolVal);
+    parse_result (* parse_integer)(chFilter *filter, long integerVal);
+    parse_result (* parse_double)(chFilter *filter, double doubleVal);
+    parse_result (* parse_string)(chFilter *filter, const char *stringVal,
+            size_t stringLen); /* NB: stringVal is not zero-terminated: */
+
+    parse_result (* parse_start_map)(chFilter *filter);
+    parse_result (* parse_map_key)(chFilter *filter, const char *key,
+            size_t stringLen); /* NB: key is not zero-terminated: */
+    parse_result (* parse_end_map)(chFilter *filter);
+
+    parse_result (* parse_start_array)(chFilter *filter);
+    parse_result (* parse_end_array)(chFilter *filter);
+
+    /* Channel operations: */
+    long (* channel_open)(chFilter *filter);
+    void (* channel_register_pre) (chFilter *filter, chPostEventFunc **cb_out, void **arg_out, db_field_log *probe);
+    void (* channel_register_post)(chFilter *filter, chPostEventFunc **cb_out, void **arg_out, db_field_log *probe);
+    void (* channel_report)(chFilter *filter, int level, const unsigned short indent);
+    /* FIXME: More filter routines here ... */
+    void (* channel_close)(chFilter *filter);
+} chFilterIf;
+
+/* A chFilterPlugin holds data for a filter plugin */
+typedef struct chFilterPlugin {
+    ELLNODE node;
+    const char *name;
+    const chFilterIf *fif;
+    void *puser;
+} chFilterPlugin;
+
+/* A chFilter holds data for a single filter instance */
+struct chFilter {
+    ELLNODE list_node;
+    ELLNODE pre_node;
+    ELLNODE post_node;
+    dbChannel *chan;
+    const chFilterPlugin *plug;
+    chPostEventFunc *pre_func;
+    void *pre_arg;
+    chPostEventFunc *post_func;
+    void *post_arg;
+    void *puser;
+};
+
+struct dbCommon;
+struct dbFldDes;
+
+epicsShareFunc void dbChannelInit (void);
+epicsShareFunc long dbChannelTest(const char *name);
+epicsShareFunc dbChannel * dbChannelCreate(const char *name);
+epicsShareFunc long dbChannelOpen(dbChannel *chan);
+epicsShareFunc const char * dbChannelName(dbChannel *chan);
+epicsShareFunc struct dbCommon * dbChannelRecord(dbChannel *chan);
+epicsShareFunc struct dbFldDes * dbChannelFldDes(dbChannel *chan);
+epicsShareFunc long dbChannelElements(dbChannel *chan);
+epicsShareFunc short dbChannelFieldType(dbChannel *chan);
+epicsShareFunc short dbChannelExportType(dbChannel *chan);
+epicsShareFunc short dbChannelFieldSize(dbChannel *chan);
+epicsShareFunc long dbChannelFinalElements(dbChannel *chan);
+epicsShareFunc short dbChannelFinalFieldType(dbChannel *chan);
+epicsShareFunc short dbChannelFinalExportType(dbChannel *chan);
+epicsShareFunc short dbChannelFinalElementSize(dbChannel *chan);
+epicsShareFunc short dbChannelSpecial(dbChannel *chan);
+epicsShareFunc void * dbChannelField(dbChannel *chan);
+epicsShareFunc long dbChannelGet(dbChannel *chan, short type,
+        void *pbuffer, long *options, long *nRequest, void *pfl);
+epicsShareFunc long dbChannelGetField(dbChannel *chan, short type,
+        void *pbuffer, long *options, long *nRequest, void *pfl);
+epicsShareFunc long dbChannelPut(dbChannel *chan, short type,
+        const void *pbuffer, long nRequest);
+epicsShareFunc long dbChannelPutField(dbChannel *chan, short type,
+        const void *pbuffer, long nRequest);
+epicsShareFunc void dbChannelShow(dbChannel *chan, int level,
+        const unsigned short indent);
+epicsShareFunc void dbChannelFilterShow(dbChannel *chan, int level,
+        const unsigned short indent);
+epicsShareFunc void dbChannelDelete(dbChannel *chan);
+
+epicsShareFunc void dbRegisterFilter(const char *key, const chFilterIf *fif, void *puser);
+epicsShareFunc db_field_log* dbChannelRunPreChain(dbChannel *chan, db_field_log *pLogIn);
+epicsShareFunc db_field_log* dbChannelRunPostChain(dbChannel *chan, db_field_log *pLogIn);
+epicsShareFunc const chFilterPlugin * dbFindFilter(const char *key, size_t len);
+epicsShareFunc void dbChannelMakeArrayCopy(void *pvt, db_field_log *pfl, dbChannel *chan);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* INC_dbChannel_H */
 
=== modified file 'src/ioc/db/dbChannelIO.cpp'
--- src/ioc/db/dbChannelIO.cpp	2010-10-05 19:27:37 +0000
+++ src/ioc/db/dbChannelIO.cpp	2012-06-21 20:42:45 +0000
@@ -4,20 +4,20 @@
 * 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. 
+* in file LICENSE that is included with this distribution.
 \*************************************************************************/
 
-/*  
+/*
  *  $Revision-Id$
  *
- *                              
+ *
  *                    L O S  A L A M O S
  *              Los Alamos National Laboratory
  *               Los Alamos, New Mexico 87545
- *                                  
+ *
  *  Copyright, 1986, The Regents of the University of California.
- *                                  
- *           
+ *
+ *
  *	Author Jeffrey O. Hill
  *	[e-mail]
  *	505 665 1831
@@ -40,15 +40,12 @@
 #include "dbChannelIO.h"
 #include "dbPutNotifyBlocker.h"
 
-dbChannelIO::dbChannelIO ( 
-    epicsMutex & mutexIn, cacChannelNotify & notify, 
-    const dbAddr & addrIn, dbContext & serviceIO ) :
-    cacChannel ( notify ), mutex ( mutexIn ), serviceIO ( serviceIO ), 
-    addr ( addrIn )
+dbChannelIO::dbChannelIO (
+    epicsMutex & mutexIn, cacChannelNotify & notify,
+    dbChannel * dbchIn, dbContext & serviceIO ) :
+    cacChannel ( notify ), mutex ( mutexIn ), serviceIO ( serviceIO ),
+    dbch ( dbchIn )
 {
-    unsigned bufLen = dbNameSizeOfPV ( & this->addr ) + 1;
-    this->pNameStr.reset ( new char [ bufLen ] );
-    dbNameOfPV ( & this->addr, this->pNameStr.get (), bufLen );
 }
 
 void dbChannelIO::initiateConnect ( epicsGuard < epicsMutex > & guard )
@@ -57,7 +54,7 @@
     this->notify().connectNotify ( guard );
 }
 
-dbChannelIO::~dbChannelIO () 
+dbChannelIO::~dbChannelIO ()
 {
 }
 
@@ -65,48 +62,49 @@
 {
     guard.assertIdenticalMutex ( this->mutex );
     this->serviceIO.destroyAllIO ( guard, *this );
+    dbChannelDelete ( this->dbch );
     this->~dbChannelIO ();
 }
 
-void dbChannelIO::destroy ( 
+void dbChannelIO::destroy (
     epicsGuard < epicsMutex > & guard )
 {
     guard.assertIdenticalMutex ( this->mutex );
     this->serviceIO.destroyChannel ( guard, *this );
-    // dont access this pointer after above call because
-    // object nolonger exists
+    // don't access this pointer after above call because
+    // object no longer exists
 }
 
-cacChannel::ioStatus dbChannelIO::read ( 
-     epicsGuard < epicsMutex > & guard, unsigned type, 
-     unsigned long count, cacReadNotify & notify, ioid * ) 
+cacChannel::ioStatus dbChannelIO::read (
+     epicsGuard < epicsMutex > & guard, unsigned type,
+     unsigned long count, cacReadNotify & notify, ioid * )
 {
     guard.assertIdenticalMutex ( this->mutex );
-    this->serviceIO.callReadNotify ( guard, this->addr, 
+    this->serviceIO.callReadNotify ( guard, this->dbch,
         type, count, notify );
     return iosSynch;
 }
 
-void dbChannelIO::write ( 
-    epicsGuard < epicsMutex > & guard, unsigned type, 
+void dbChannelIO::write (
+    epicsGuard < epicsMutex > & guard, unsigned type,
     unsigned long count, const void *pValue )
 {
     epicsGuardRelease < epicsMutex > unguard ( guard );
     if ( count > LONG_MAX ) {
         throw outOfBounds();
     }
-    int status = db_put_field ( &this->addr, type, pValue, 
+    int status = dbChannel_put ( this->dbch, type, pValue,
         static_cast <long> (count) );
     if ( status ) {
-        throw std::logic_error ( 
+        throw std::logic_error (
            "db_put_field() completed unsuccessfully" );
     }
 }
 
-cacChannel::ioStatus dbChannelIO::write ( 
-    epicsGuard < epicsMutex > & guard, unsigned type, 
-    unsigned long count, const void * pValue, 
-    cacWriteNotify & notify, ioid * pId ) 
+cacChannel::ioStatus dbChannelIO::write (
+    epicsGuard < epicsMutex > & guard, unsigned type,
+    unsigned long count, const void * pValue,
+    cacWriteNotify & notify, ioid * pId )
 {
     guard.assertIdenticalMutex ( this->mutex );
 
@@ -114,24 +112,24 @@
         throw outOfBounds();
     }
 
-    this->serviceIO.initiatePutNotify ( 
-        guard, *this, this->addr, 
+    this->serviceIO.initiatePutNotify (
+        guard, *this, this->dbch,
         type, count, pValue, notify, pId );
 
     return iosAsynch;
 }
 
-void dbChannelIO::subscribe ( 
-    epicsGuard < epicsMutex > & guard, unsigned type, unsigned long count, 
-    unsigned mask, cacStateNotify & notify, ioid * pId ) 
-{   
+void dbChannelIO::subscribe (
+    epicsGuard < epicsMutex > & guard, unsigned type, unsigned long count,
+    unsigned mask, cacStateNotify & notify, ioid * pId )
+{
     guard.assertIdenticalMutex ( this->mutex );
-    this->serviceIO.subscribe ( 
-        guard, this->addr, *this,
+    this->serviceIO.subscribe (
+        guard, this->dbch, *this,
         type, count, mask, notify, pId );
 }
 
-void dbChannelIO::ioCancel ( 
+void dbChannelIO::ioCancel (
     epicsGuard < epicsMutex > & mutualExclusionGuard,
     const ioid & id )
 {
@@ -139,7 +137,7 @@
     this->serviceIO.ioCancel ( mutualExclusionGuard, *this, id );
 }
 
-void dbChannelIO::ioShow ( 
+void dbChannelIO::ioShow (
     epicsGuard < epicsMutex > & guard,
     const ioid & id, unsigned level ) const
 {
@@ -147,31 +145,35 @@
     this->serviceIO.ioShow ( guard, id, level );
 }
 
-void dbChannelIO::show ( 
+void dbChannelIO::show (
     epicsGuard < epicsMutex > & guard, unsigned level ) const
 {
     guard.assertIdenticalMutex ( this->mutex );
 
-    printf ("channel at %p attached to local database record %s\n", 
-        static_cast <const void *> ( this ), this->addr.precord->name );
+    printf ("channel at %p attached to local database record %s\n",
+        static_cast <const void *> ( this ),
+        dbChannelRecord ( this->dbch ) -> name );
 
     if ( level > 0u ) {
-        printf ( "\ttype %s, element count %li, field at %p\n",
-            dbf_type_to_text ( this->addr.dbr_field_type ), this->addr.no_elements,
-            this->addr.pfield );
-    }
-    if ( level > 1u ) {
-        this->serviceIO.show ( level - 2u );
-        this->serviceIO.showAllIO ( *this, level - 2u );
+        printf ( "        type %s, element count %li, field at %p\n",
+            dbf_type_to_text ( dbChannelExportType ( this->dbch ) ),
+            dbChannelElements ( this->dbch ),
+            dbChannelField ( this->dbch ) );
+        if ( level > 1u ) {
+            dbChannelFilterShow ( this->dbch, level - 2u, 8 );
+            this->serviceIO.show ( level - 2u );
+            this->serviceIO.showAllIO ( *this, level - 2u );
+        }
     }
 }
 
 unsigned long dbChannelIO::nativeElementCount (
-    epicsGuard < epicsMutex > & guard ) const 
+    epicsGuard < epicsMutex > & guard ) const
 {
     guard.assertIdenticalMutex ( this->mutex );
-    if ( this->addr.no_elements >= 0u ) {
-        return static_cast < unsigned long > ( this->addr.no_elements );
+    long elements = dbChannelElements ( this->dbch );
+    if ( elements >= 0u ) {
+        return static_cast < unsigned long > ( elements );
     }
     return 0u;
 }
@@ -181,24 +183,30 @@
     epicsGuard < epicsMutex > & guard ) const throw ()
 {
     guard.assertIdenticalMutex ( this->mutex );
-    return this->pNameStr.get ();
+    return dbChannelName ( this->dbch );
 }
 
 unsigned dbChannelIO::getName (
     epicsGuard < epicsMutex > &,
     char * pBuf, unsigned bufLen ) const throw ()
 {
-    return dbNameOfPV ( & this->addr, pBuf, bufLen );
+    const char *name = dbChannelName ( this->dbch );
+    size_t len = strlen ( name );
+    strncpy ( pBuf, name, bufLen );
+    if (len < bufLen)
+        return len;
+    pBuf[--bufLen] = '\0';
+    return bufLen;
 }
 
 short dbChannelIO::nativeType (
-    epicsGuard < epicsMutex > & guard ) const 
+    epicsGuard < epicsMutex > & guard ) const
 {
     guard.assertIdenticalMutex ( this->mutex );
-    return this->addr.dbr_field_type;
+    return dbChannelExportType( this->dbch );
 }
 
-void * dbChannelIO::operator new ( size_t size, 
+void * dbChannelIO::operator new ( size_t size,
     tsFreeList < dbChannelIO, 256, epicsMutexNOOP > & freeList )
 {
     return freeList.allocate ( size );
@@ -212,7 +220,7 @@
 }
 
 #ifdef CXX_PLACEMENT_DELETE
-void dbChannelIO::operator delete ( void *pCadaver, 
+void dbChannelIO::operator delete ( void *pCadaver,
     tsFreeList < dbChannelIO, 256, epicsMutexNOOP > & freeList )
 {
     freeList.release ( pCadaver );
 
=== modified file 'src/ioc/db/dbChannelIO.h'
--- src/ioc/db/dbChannelIO.h	2010-10-05 19:27:37 +0000
+++ src/ioc/db/dbChannelIO.h	2012-06-21 20:42:45 +0000
@@ -5,7 +5,7 @@
 *     Operator of Los Alamos National Laboratory.
 * EPICS BASE Versions 3.13.7
 * and higher are distributed subject to a Software License Agreement found
-* in file LICENSE that is included with this distribution. 
+* in file LICENSE that is included with this distribution.
 \*************************************************************************/
 
 /*
@@ -44,65 +44,64 @@
 
 class dbChannelIO : public cacChannel, public dbContextPrivateListOfIO {
 public:
-    dbChannelIO ( 
-        epicsMutex &, cacChannelNotify &, 
-        const dbAddr &, dbContext & );
-    void destructor ( 
+    dbChannelIO (
+        epicsMutex &, cacChannelNotify &,
+        dbChannel *, dbContext & );
+    void destructor (
         epicsGuard < epicsMutex > & );
     void destroy (
         epicsGuard < epicsMutex > & mutualExclusionGuard );
-    void callReadNotify ( 
-        epicsGuard < epicsMutex > &, 
-        unsigned type, unsigned long count, 
+    void callReadNotify (
+        epicsGuard < epicsMutex > &,
+        unsigned type, unsigned long count,
         cacReadNotify & notify );
-    void callStateNotify ( 
-        unsigned type, unsigned long count, 
+    void callStateNotify (
+        unsigned type, unsigned long count,
         const struct db_field_log * pfl, cacStateNotify & notify );
-    void show ( 
+    void show (
         epicsGuard < epicsMutex > &, unsigned level ) const;
     unsigned getName (
         epicsGuard < epicsMutex > &,
         char * pBuf, unsigned bufLen ) const throw ();
     const char * pName (
         epicsGuard < epicsMutex > & ) const throw ();
-    void * operator new ( size_t size, 
+    void * operator new ( size_t size,
         tsFreeList < dbChannelIO, 256, epicsMutexNOOP > & );
-    epicsPlacementDeleteOperator (( void *, 
+    epicsPlacementDeleteOperator (( void *,
         tsFreeList < dbChannelIO, 256, epicsMutexNOOP > & ))
 protected:
     ~dbChannelIO ();
 private:
     epicsMutex & mutex;
     dbContext & serviceIO;
-    dbAddr addr;
-    epics_auto_ptr < char, eapt_array > pNameStr;
+    dbChannel * dbch;
 
     void initiateConnect (
         epicsGuard < epicsMutex > & );
-    unsigned requestMessageBytesPending ( 
-        epicsGuard < epicsMutex > & );
-    void flush ( 
-        epicsGuard < epicsMutex > & );
-    ioStatus read ( 
+    unsigned requestMessageBytesPending (
+        epicsGuard < epicsMutex > & );
+    void flush (
+        epicsGuard < epicsMutex > & );
+    ioStatus read (
         epicsGuard < epicsMutex > &,
-        unsigned type, unsigned long count, 
+        unsigned type, unsigned long count,
         cacReadNotify &, ioid * );
-    void write ( 
+    void write (
         epicsGuard < epicsMutex > &,
-        unsigned type, unsigned long count, 
+        unsigned type, unsigned long count,
         const void * pvalue );
-    ioStatus write ( 
+    ioStatus write (
         epicsGuard < epicsMutex > &,
-        unsigned type, unsigned long count, 
+        unsigned type, unsigned long count,
         const void * pvalue, cacWriteNotify &, ioid * );
-    void subscribe ( 
+    void subscribe (
         epicsGuard < epicsMutex > &,
-        unsigned type, unsigned long count, 
+        unsigned type, unsigned long count,
         unsigned mask, cacStateNotify &notify, ioid * );
-    void ioCancel ( 
+    void ioCancel (
         epicsGuard < epicsMutex > & mutualExclusionGuard,
         const ioid & );
-    void ioShow ( 
+    void ioShow (
         epicsGuard < epicsMutex > &,
         const ioid &, unsigned level ) const;
     short nativeType (
@@ -115,18 +114,18 @@
     void operator delete ( void * );
 };
 
-inline void dbChannelIO::callReadNotify ( 
-    epicsGuard < epicsMutex > & guard, unsigned type, unsigned long count, 
+inline void dbChannelIO::callReadNotify (
+    epicsGuard < epicsMutex > & guard, unsigned type, unsigned long count,
     cacReadNotify & notify )
 {
     guard.assertIdenticalMutex ( this->mutex );
-    this->serviceIO.callReadNotify ( guard, this->addr, type, count, notify );
+    this->serviceIO.callReadNotify ( guard, this->dbch, type, count, notify );
 }
 
-inline void dbChannelIO::callStateNotify ( unsigned type, unsigned long count, 
+inline void dbChannelIO::callStateNotify ( unsigned type, unsigned long count,
         const struct db_field_log *pfl, cacStateNotify &notify )
 {
-    this->serviceIO.callStateNotify ( this->addr, type, count, pfl, notify );
+    this->serviceIO.callStateNotify ( this->dbch, type, count, pfl, notify );
 }
 
 
 
=== modified file 'src/ioc/db/dbContext.cpp'
--- src/ioc/db/dbContext.cpp	2010-10-05 19:27:37 +0000
+++ src/ioc/db/dbContext.cpp	2012-06-21 20:42:45 +0000
@@ -4,19 +4,19 @@
 * 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. 
+* in file LICENSE that is included with this distribution.
 \*************************************************************************/
-/*  
+/*
  *  $Revision-Id$
  *
- *                              
+ *
  *                    L O S  A L A M O S
  *              Los Alamos National Laboratory
  *               Los Alamos, New Mexico 87545
- *                                  
+ *
  *  Copyright, 1986, The Regents of the University of California.
- *                                  
- *           
+ *
+ *
  *	Author Jeffrey O. Hill
  *	[e-mail]
  *	505 665 1831
@@ -33,6 +33,7 @@
 #include "epicsEvent.h"
 #include "epicsThread.h"
 #include "errlog.h"
+#include "dbChannel.h"
 
 #define epicsExportSharedSymbols
 #include "db_access_routines.h"
@@ -43,20 +44,20 @@
 class dbService : public cacService {
 public:
     ~dbService () {}
-    cacContext & contextCreate ( 
-        epicsMutex & mutualExclusion, 
-        epicsMutex & callbackControl, 
+    cacContext & contextCreate (
+        epicsMutex & mutualExclusion,
+        epicsMutex & callbackControl,
         cacContextNotify & );
 };
 
 static dbService dbs;
 
-cacContext & dbService::contextCreate ( 
-    epicsMutex & mutualExclusion, 
-    epicsMutex & callbackControl, 
+cacContext & dbService::contextCreate (
+    epicsMutex & mutualExclusion,
+    epicsMutex & callbackControl,
     cacContextNotify & notify )
 {
-    return * new dbContext ( callbackControl, 
+    return * new dbContext ( callbackControl,
         mutualExclusion, notify );
 }
 
@@ -67,9 +68,9 @@
 
 dbBaseIO::dbBaseIO () {}
 
-dbContext::dbContext ( epicsMutex & cbMutexIn, 
+dbContext::dbContext ( epicsMutex & cbMutexIn,
         epicsMutex & mutexIn, cacContextNotify & notifyIn ) :
-    readNotifyCache ( mutexIn ), ctx ( 0 ), 
+    readNotifyCache ( mutexIn ), ctx ( 0 ),
     stateNotifyCacheSize ( 0 ), mutex ( mutexIn ), cbMutex ( cbMutexIn ),
     notify ( notifyIn ), pNetContext ( 0 ), pStateNotifyCache ( 0 )
 {
@@ -84,41 +85,41 @@
 }
 
 cacChannel & dbContext::createChannel ( // X aCC 361
-    epicsGuard < epicsMutex > & guard, const char * pName, 
+    epicsGuard < epicsMutex > & guard, const char * pName,
     cacChannelNotify & notifyIn, cacChannel::priLev priority )
 {
     guard.assertIdenticalMutex ( this->mutex );
 
-    struct dbAddr addr;
-    int status;
-    {
-        // dont know if the database might call a put callback 
-        // while holding its lock ...
-        epicsGuardRelease < epicsMutex > unguard ( guard );
-        status = db_name_to_addr ( pName, & addr );
-    }
-    if ( status ) {
+    dbChannel *dbch = dbChannel_create ( pName );
+    if ( ! dbch ) {
         if ( ! this->pNetContext.get() ) {
             this->pNetContext.reset (
-                & this->notify.createNetworkContext ( 
+                & this->notify.createNetworkContext (
                     this->mutex, this->cbMutex ) );
         }
         return this->pNetContext->createChannel (
                     guard, pName, notifyIn, priority );
     }
-    else if ( ca_preemtive_callback_is_enabled () ) {
-        return * new ( this->dbChannelIOFreeList )
-            dbChannelIO ( this->mutex, notifyIn, addr, *this ); 
-    }
-    else {
-        errlogPrintf ( 
+
+    if ( ! ca_preemtive_callback_is_enabled () ) {
+        dbChannelDelete ( dbch );
+        errlogPrintf (
             "dbContext: preemptive callback required for direct in\n"
             "memory interfacing of CA channels to the DB.\n" );
         throw cacChannel::unsupportedByService ();
     }
+
+    try {
+        return * new ( this->dbChannelIOFreeList )
+            dbChannelIO ( this->mutex, notifyIn, dbch, *this );
+    }
+    catch (...) {
+        dbChannelDelete ( dbch );
+        throw;
+    }
 }
 
-void dbContext::destroyChannel ( 
+void dbContext::destroyChannel (
     epicsGuard < epicsMutex > & guard, dbChannelIO & chan )
 {
     guard.assertIdenticalMutex ( this->mutex );
@@ -134,30 +135,30 @@
     this->dbChannelIOFreeList.release ( & chan );
 }
 
-void dbContext::callStateNotify ( struct dbAddr & addr, 
-        unsigned type, unsigned long count, 
-        const struct db_field_log * pfl, 
+void dbContext::callStateNotify ( struct dbChannel * dbch,
+        unsigned type, unsigned long count,
+        const struct db_field_log * pfl,
         cacStateNotify & notifyIn )
 {
     unsigned long size = dbr_size_n ( type, count );
 
     if ( type > INT_MAX ) {
         epicsGuard < epicsMutex > guard ( this->mutex );
-        notifyIn.exception ( guard, ECA_BADTYPE, 
-            "type code out of range (high side)", 
+        notifyIn.exception ( guard, ECA_BADTYPE,
+            "type code out of range (high side)",
             type, count );
         return;
     }
 
     if ( count > INT_MAX ) {
         epicsGuard < epicsMutex > guard ( this->mutex );
-        notifyIn.exception ( guard, ECA_BADCOUNT, 
+        notifyIn.exception ( guard, ECA_BADCOUNT,
             "element count out of range (high side)",
             type, count);
         return;
     }
 
-    // no need to lock this because state notify is 
+    // no need to lock this because state notify is
     // called from only one event queue consumer thread
     if ( this->stateNotifyCacheSize < size) {
         char * pTmp = new char [size];
@@ -166,14 +167,14 @@
         this->stateNotifyCacheSize = size;
     }
     void *pvfl = (void *) pfl;
-    int status = db_get_field ( &addr, static_cast <int> ( type ), 
+    int status = dbChannel_get ( dbch, static_cast <int> ( type ),
                     this->pStateNotifyCache, static_cast <int> ( count ), pvfl );
     if ( status ) {
         epicsGuard < epicsMutex > guard ( this->mutex );
-        notifyIn.exception ( guard, ECA_GETFAIL, 
-            "db_get_field() completed unsuccessfuly", type, count );
+        notifyIn.exception ( guard, ECA_GETFAIL,
+            "dbChannel_get() completed unsuccessfully", type, count );
     }
-    else { 
+    else {
         epicsGuard < epicsMutex > guard ( this->mutex );
         notifyIn.current ( guard, type, count, this->pStateNotifyCache );
     }
@@ -185,10 +186,10 @@
     assert ( status == ECA_NORMAL );
 }
 
-void dbContext::subscribe ( 
+void dbContext::subscribe (
     epicsGuard < epicsMutex > & guard,
-    struct dbAddr & addr, dbChannelIO & chan,
-    unsigned type, unsigned long count, unsigned mask, 
+    struct dbChannel * dbch, dbChannelIO & chan,
+    unsigned type, unsigned long count, unsigned mask,
     cacStateNotify & notifyIn, cacChannel::ioid * pId )
 {
     guard.assertIdenticalMutex ( this->mutex );
@@ -214,12 +215,12 @@
 
             unsigned selfPriority = epicsThreadGetPrioritySelf ();
             unsigned above;
-            epicsThreadBooleanStatus tbs = 
+            epicsThreadBooleanStatus tbs =
                 epicsThreadLowestPriorityLevelAbove ( selfPriority, &above );
             if ( tbs != epicsThreadBooleanStatusSuccess ) {
                 above = selfPriority;
             }
-            int status = db_start_events ( tmpctx, "CAC-event", 
+            int status = db_start_events ( tmpctx, "CAC-event",
                 cacAttachClientCtx, ca_current_context (), above );
             if ( status ) {
                 db_close_events ( tmpctx );
@@ -227,7 +228,7 @@
             }
         }
         if ( this->ctx ) {
-            // another thread tried to simultaneously setup 
+            // another thread tried to simultaneously setup
             // the event system
             db_close_events ( tmpctx );
         }
@@ -237,9 +238,9 @@
     }
 
     dbSubscriptionIO & subscr =
-        * new ( this->dbSubscriptionIOFreeList ) 
-        dbSubscriptionIO ( guard, this->mutex, *this, chan, 
-            addr, notifyIn, type, count, mask, this->ctx );
+        * new ( this->dbSubscriptionIOFreeList )
+        dbSubscriptionIO ( guard, this->mutex, *this, chan,
+            dbch, notifyIn, type, count, mask, this->ctx );
     chan.dbContextPrivateListOfIO::eventq.add ( subscr );
     this->ioTable.idAssignAdd ( subscr );
 
@@ -248,27 +249,27 @@
     }
 }
 
-void dbContext::initiatePutNotify ( 
+void dbContext::initiatePutNotify (
     epicsGuard < epicsMutex > & guard,
-    dbChannelIO & chan, struct dbAddr & addr, 
-    unsigned type, unsigned long count, const void * pValue, 
+    dbChannelIO & chan, struct dbChannel * dbch,
+    unsigned type, unsigned long count, const void * pValue,
     cacWriteNotify & notifyIn, cacChannel::ioid * pId )
 {
     guard.assertIdenticalMutex ( this->mutex );
     if ( ! chan.dbContextPrivateListOfIO::pBlocker ) {
-        chan.dbContextPrivateListOfIO::pBlocker = 
-            new ( this->dbPutNotifyBlockerFreeList ) 
+        chan.dbContextPrivateListOfIO::pBlocker =
+            new ( this->dbPutNotifyBlockerFreeList )
                 dbPutNotifyBlocker ( this->mutex );
         this->ioTable.idAssignAdd ( *chan.dbContextPrivateListOfIO::pBlocker );
     }
-    chan.dbContextPrivateListOfIO::pBlocker->initiatePutNotify ( 
-        guard, notifyIn, addr, type, count, pValue );
+    chan.dbContextPrivateListOfIO::pBlocker->initiatePutNotify (
+        guard, notifyIn, dbch, type, count, pValue );
     if ( pId ) {
         *pId = chan.dbContextPrivateListOfIO::pBlocker->getId ();
     }
 }
 
-void dbContext::destroyAllIO ( 
+void dbContext::destroyAllIO (
     epicsGuard < epicsMutex > & guard, dbChannelIO & chan )
 {
     guard.assertIdenticalMutex ( this->mutex );
@@ -284,7 +285,7 @@
     }
 
     while ( ( pIO = tmp.get() ) ) {
-        // This prevents a db event callback from coming 
+        // This prevents a db event callback from coming
         // through after the notify IO is deleted
         pIO->unsubscribe ( guard );
         // If they call ioCancel() here it will be ignored
@@ -301,8 +302,8 @@
     }
 }
 
-void dbContext::ioCancel ( 
-    epicsGuard < epicsMutex > & guard, dbChannelIO & chan, 
+void dbContext::ioCancel (
+    epicsGuard < epicsMutex > & guard, dbChannelIO & chan,
     const cacChannel::ioid &id )
 {
     guard.assertIdenticalMutex ( this->mutex );
@@ -325,8 +326,8 @@
     }
 }
 
-void dbContext::ioShow ( 
-    epicsGuard < epicsMutex > & guard, const cacChannel::ioid &id, 
+void dbContext::ioShow (
+    epicsGuard < epicsMutex > & guard, const cacChannel::ioid &id,
     unsigned level ) const
 {
     guard.assertIdenticalMutex ( this->mutex );
@@ -339,7 +340,7 @@
 void dbContext::showAllIO ( const dbChannelIO & chan, unsigned level ) const
 {
     epicsGuard < epicsMutex > guard ( this->mutex );
-    tsDLIterConst < dbSubscriptionIO > pItem = 
+    tsDLIterConst < dbSubscriptionIO > pItem =
         chan.dbContextPrivateListOfIO::eventq.firstIter ();
     while ( pItem.valid () ) {
         pItem->show ( guard, level );
@@ -356,14 +357,14 @@
     this->show ( guard, level );
 }
 
-void dbContext::show ( 
+void dbContext::show (
     epicsGuard < epicsMutex > & guard, unsigned level ) const
 {
     guard.assertIdenticalMutex ( this->mutex );
-    printf ( "dbContext at %p\n", 
+    printf ( "dbContext at %p\n",
         static_cast <const void *> ( this ) );
     if ( level > 0u ) {
-        printf ( "\tevent call back cache location %p, and its size %lu\n", 
+        printf ( "\tevent call back cache location %p, and its size %lu\n",
             static_cast <void *> ( this->pStateNotifyCache ), this->stateNotifyCacheSize );
         this->readNotifyCache.show ( guard, level - 1 );
     }
@@ -375,7 +376,7 @@
     }
 }
 
-void dbContext::flush ( 
+void dbContext::flush (
     epicsGuard < epicsMutex > & guard )
 {
     guard.assertIdenticalMutex ( this->mutex );
 
=== modified file 'src/ioc/db/dbContextReadNotifyCache.cpp'
--- src/ioc/db/dbContextReadNotifyCache.cpp	2010-10-05 19:27:37 +0000
+++ src/ioc/db/dbContextReadNotifyCache.cpp	2012-06-21 20:42:45 +0000
@@ -5,7 +5,7 @@
 *     Operator of Los Alamos National Laboratory.
 * EPICS BASE Versions 3.13.7
 * and higher are distributed subject to a Software License Agreement found
-* in file LICENSE that is included with this distribution. 
+* in file LICENSE that is included with this distribution.
 \*************************************************************************/
 
 /*
@@ -30,11 +30,11 @@
 
 class privateAutoDestroyPtr {
 public:
-    privateAutoDestroyPtr ( 
+    privateAutoDestroyPtr (
         dbContextReadNotifyCacheAllocator & allocator, unsigned long size ) :
         _allocator ( allocator ), _p ( allocator.alloc ( size ) ) {}
     ~privateAutoDestroyPtr () { _allocator.free ( _p ); }
-	char * get () const { return _p; }              
+	char * get () const { return _p; }
 private:
     dbContextReadNotifyCacheAllocator & _allocator;
     char * _p;
@@ -43,28 +43,28 @@
 };
 
 // extra effort taken here to not hold the lock when calling the callback
-void dbContextReadNotifyCache::callReadNotify ( 
-    epicsGuard < epicsMutex > & guard, struct dbAddr & addr, 
+void dbContextReadNotifyCache::callReadNotify (
+    epicsGuard < epicsMutex > & guard, struct dbChannel * dbch,
 	unsigned type, unsigned long count, cacReadNotify & notify )
 {
     guard.assertIdenticalMutex ( _mutex );
 
     if ( type > INT_MAX ) {
-        notify.exception ( guard, ECA_BADTYPE, 
-            "type code out of range (high side)", 
+        notify.exception ( guard, ECA_BADTYPE,
+            "type code out of range (high side)",
             type, count );
         return;
     }
 
-    if ( addr.no_elements < 0 ) {
-        notify.exception ( guard, ECA_BADCOUNT, 
+    if ( dbChannelElements(dbch) < 0 ) {
+        notify.exception ( guard, ECA_BADCOUNT,
             "database has negetive element count",
             type, count);
         return;
     }
 
-    if ( count > static_cast < unsigned > ( addr.no_elements ) ) {
-        notify.exception ( guard, ECA_BADCOUNT, 
+    if ( count > static_cast < unsigned long > ( dbChannelElements(dbch) ) ) {
+        notify.exception ( guard, ECA_BADCOUNT,
             "element count out of range (high side)",
             type, count);
         return;
@@ -75,21 +75,21 @@
     int status;
     {
         epicsGuardRelease < epicsMutex > unguard ( guard );
-        status = db_get_field ( &addr, static_cast <int> ( type ), 
-                    ptr.get (), static_cast <int> ( count ), 0 );
+        status = dbChannel_get ( dbch, static_cast <int> ( type ),
+                    ptr.get (), static_cast <long> ( count ), 0 );
     }
     if ( status ) {
-        notify.exception ( guard, ECA_GETFAIL, 
+        notify.exception ( guard, ECA_GETFAIL,
             "db_get_field() completed unsuccessfuly",
             type, count );
     }
-    else { 
-        notify.completion ( 
+    else {
+        notify.completion (
             guard, type, count, ptr.get () );
     }
 }
 
-void dbContextReadNotifyCache::show ( 
+void dbContextReadNotifyCache::show (
     epicsGuard < epicsMutex > & guard, unsigned level ) const
 {
     guard.assertIdenticalMutex ( _mutex );
@@ -155,8 +155,8 @@
             pNext = _pReadNotifyCache->pNext;
             count++;
         }
-        printf ( "\tcount %lu and size %lu\n", 
-            static_cast < unsigned long > ( count ), 
+        printf ( "\tcount %lu and size %lu\n",
+            static_cast < unsigned long > ( count ),
             _readNotifyCacheSize );
     }
 }
 
=== modified file 'src/ioc/db/dbEvent.c'
--- src/ioc/db/dbEvent.c	2011-10-19 18:07:00 +0000
+++ src/ioc/db/dbEvent.c	2012-06-21 20:42:45 +0000
@@ -1,19 +1,20 @@
 /*************************************************************************\
+* Copyright (c) 2010 Brookhaven National Laboratory.
+* Copyright (c) 2010 Helmholtz-Zentrum Berlin
+*     fuer Materialien und Energie GmbH.
 * Copyright (c) 2002 The University of Chicago, 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 Versions 3.13.7
-* and higher are distributed subject to a Software License Agreement found
-* in file LICENSE that is included with this distribution. 
+* EPICS BASE is distributed subject to a Software License Agreement found
+* in file LICENSE that is included with this distribution.
 \*************************************************************************/
-/* dbEvent.c */
-/* $Revision-Id$ */
-/* routines for scheduling events to lower priority tasks via the RT kernel */
+
 /*
- *  Author:     Jeffrey O. Hill 
- *      Date:            4-1-89
-*/
+ *  Author: Jeffrey O. Hill <[e-mail]>
+ *
+ *          Ralph Lange <[e-mail]>
+ */
 
 #include <stddef.h>
 #include <stdlib.h>
@@ -39,6 +40,7 @@
 #include "db_field_log.h"
 #define epicsExportSharedSymbols
 #include "dbAddr.h"
+#include "dbChannel.h"
 #include "dbLock.h"
 #include "dbAccessDefs.h"
 #include "dbEvent.h"
@@ -49,51 +51,33 @@
 #define EVENTQEMPTY     ((struct evSubscrip *)NULL)
 
 /*
- * event subscruiption
- */
-struct evSubscrip {
-    ELLNODE                 node;
-    struct dbAddr           *paddr;
-    EVENTFUNC               *user_sub;
-    void                    *user_arg;
-    struct event_que        *ev_que;
-    db_field_log            *pLastLog;
-    unsigned long           npend;  /* n times this event is on the queue */
-    unsigned long           nreplace;  /* n times replacing event on the queue */
-    unsigned char           select;
-    char                    valque;
-    char                    callBackInProgress;
-    char                    enabled;
-};
-
-/*
  * really a ring buffer
  */
 struct event_que {
     /* lock writers to the ring buffer only */
     /* readers must never slow up writers */
     epicsMutexId            writelock;
-    db_field_log            valque[EVENTQUESIZE];
+    db_field_log            *valque[EVENTQUESIZE];
     struct evSubscrip       *evque[EVENTQUESIZE];
     struct event_que        *nextque;       /* in case que quota exceeded */
     struct event_user       *evUser;        /* event user parent struct */
     unsigned short          putix;
     unsigned short          getix;
     unsigned short          quota;          /* the number of assigned entries*/
-    unsigned short          nDuplicates;    /* N events duplicated on this q */ 
+    unsigned short          nDuplicates;    /* N events duplicated on this q */
     unsigned short          nCanceled;      /* the number of canceled entries */
 };
 
 struct event_user {
     struct event_que    firstque;       /* the first event que */
-    
+
     epicsMutexId        lock;
     epicsEventId        ppendsem;       /* Wait while empty */
     epicsEventId        pflush_sem;     /* wait for flush */
-        
+
     EXTRALABORFUNC      *extralabor_sub;/* off load to event task */
     void                *extralabor_arg;/* parameter to above */
-    
+
     epicsThreadId       taskid;         /* event handler task id */
     struct evSubscrip   *pSuicideEvent; /* event that is deleteing itself */
     unsigned            queovr;         /* event que overflow count */
@@ -114,34 +98,28 @@
 #define RNGINC(OLD)\
 ( (unsigned short) ( (OLD) >= (EVENTQUESIZE-1) ? 0 : (OLD)+1 ) )
 
-#define LOCKEVQUE(EV_QUE)\
-epicsMutexMustLock((EV_QUE)->writelock);
-
-#define UNLOCKEVQUE(EV_QUE)\
-epicsMutexUnlock((EV_QUE)->writelock);
-
-#define LOCKREC(RECPTR)\
-epicsMutexMustLock((RECPTR)->mlok);
-
-#define UNLOCKREC(RECPTR)\
-epicsMutexUnlock((RECPTR)->mlok);
+#define LOCKEVQUE(EV_QUE)   epicsMutexMustLock((EV_QUE)->writelock)
+#define UNLOCKEVQUE(EV_QUE) epicsMutexUnlock((EV_QUE)->writelock)
+#define LOCKREC(RECPTR)     epicsMutexMustLock((RECPTR)->mlok)
+#define UNLOCKREC(RECPTR)   epicsMutexUnlock((RECPTR)->mlok)
 
 static void *dbevEventUserFreeList;
 static void *dbevEventQueueFreeList;
-static void *dbevEventBlockFreeList;
+static void *dbevEventSubscriptionFreeList;
+static void *dbevFieldLogFreeList;
 
 static char *EVENT_PEND_NAME = "eventTask";
 
 static struct evSubscrip canceledEvent;
 
-static unsigned short ringSpace ( const struct event_que *pevq ) 
+static unsigned short ringSpace ( const struct event_que *pevq )
 {
     if ( pevq->evque[pevq->putix] == EVENTQEMPTY ) {
         if ( pevq->getix > pevq->putix ) {
             return ( unsigned short ) ( pevq->getix - pevq->putix );
         }
         else {
-            return ( unsigned short ) ( ( EVENTQUESIZE + pevq->getix ) - pevq->putix ); 
+            return ( unsigned short ) ( ( EVENTQUESIZE + pevq->getix ) - pevq->putix );
         }
     }
     return 0;
@@ -163,7 +141,7 @@
     DBADDR              addr;
     long                status;
     struct evSubscrip   *pevent;
-    dbFldDes 		    *pdbFldDes;
+    dbFldDes            *pdbFldDes;
 
     if ( ! pname ) return DB_EVENT_OK;
     status = dbNameToAddr ( pname, &addr );
@@ -172,7 +150,7 @@
         return DB_EVENT_ERROR;
     }
 
-    LOCKREC ( addr.precord );
+    LOCKREC (addr.precord);
 
     pevent = (struct evSubscrip *) ellFirst ( &addr.precord->mlis );