release notes for 1.2.1

doesn't actually change logic flow, but wasn't intentional.

.ci/travis-build.sh

@@ -1,16 +1,6 @@
 #!/bin/sh
 set -e -x
 
-# set RTEMS to eg. "4.9" or "4.10"
-# requires qemu, bison, flex, texinfo, install-info
-if [ -n "$RTEMS" ]
-then
-  # find local qemu-system-i386
-  echo -n "Using QEMU: "
-  type qemu-system-i386 || echo "Missing qemu"
-  EXTRA=RTEMS_QEMU_FIXUPS=YES
-fi
-
 make -j2 $EXTRA
 
 if [ "$TEST" != "NO" ]

.ci/travis-prepare.sh

@@ -10,24 +10,6 @@ EOF
 install -d "$HOME/.source"
 cd "$HOME/.source"
 
-add_base_module() {
-  MODULE=$1
-  BRANCH=$2
-  ( cd epics-base/modules && \
-  git clone --quiet --depth 5 --branch $MODULE/$BRANCH https://github.com/${REPOBASE:-epics-base}/epics-base.git $MODULE && \
-  cd $MODULE && git log -n1 )
-}
-
-add_gh_module() {
-  MODULE=$1
-  REPOOWNER=$2
-  REPONAME=$3
-  BRANCH=$4
-  ( cd epics-base/modules && \
-  git clone --quiet --depth 5 --branch $BRANCH https://github.com/$REPOOWNER/$REPONAME.git $MODULE && \
-  cd $MODULE && git log -n1 )
-}
-
 add_gh_flat() {
   MODULE=$1
   REPOOWNER=$2
@@ -42,21 +24,11 @@ ${MODULE_UC}=$HOME/.source/$MODULE
 EOF
 }
 
-if [ "$BRBASE" ]
-then
-  git clone --quiet --depth 5 --branch "$BRBASE" https://github.com/${REPOBASE:-epics-base}/epics-base.git epics-base
-  (cd epics-base && git log -n1 )
-  add_gh_flat pvData ${REPOPVD:-epics-base} pvDataCPP ${BRPVD:-master}
-  add_gh_flat pvAccess ${REPOPVA:-epics-base} pvAccessCPP ${BRPVA:-master}
-else
-  git clone --quiet --depth 5 --branch core/"${BRCORE:-master}" https://github.com/${REPOBASE:-epics-base}/epics-base.git epics-base
-  ( cd epics-base && git log -n1 )
-  add_base_module libcom "${BRLIBCOM:-master}"
-  add_base_module ca "${BRCA:-master}"
-  add_base_module database "${BRDATABASE:-master}"
-  add_gh_module pvData ${REPOPVD:-epics-base} pvDataCPP ${BRPVD:-master}
-  add_gh_module pvAccess ${REPOPVA:-epics-base} pvAccessCPP ${BRPVA:-master}
-fi
+# not recursive
+git clone --quiet --depth 5 --branch "$BRBASE" https://github.com/${REPOBASE:-epics-base}/epics-base.git epics-base
+(cd epics-base && git log -n1 )
+add_gh_flat pvData ${REPOPVD:-epics-base} pvDataCPP ${BRPVD:-master}
+add_gh_flat pvAccess ${REPOPVA:-epics-base} pvAccessCPP ${BRPVA:-master}
 
 if [ -e $CURDIR/configure/RELEASE.local ]
 then
@@ -119,35 +91,22 @@ EOF
 if [ -n "$RTEMS" ]
 then
   echo "Cross RTEMS${RTEMS} for pc386"
-  install -d /home/travis/.cache
-  curl -L "https://github.com/mdavidsaver/rsb/releases/download/travis-20160306-2/rtems${RTEMS}-i386-trusty-20190306-2.tar.gz" \
-  | tar -C /home/travis/.cache -xj
+  curl -L "https://github.com/mdavidsaver/rsb/releases/download/20171203-${RTEMS}/i386-rtems${RTEMS}-trusty-20171203-${RTEMS}.tar.bz2" \
+  | tar -C / -xmj
 
   sed -i -e '/^RTEMS_VERSION/d' -e '/^RTEMS_BASE/d' epics-base/configure/os/CONFIG_SITE.Common.RTEMS
   cat << EOF >> epics-base/configure/os/CONFIG_SITE.Common.RTEMS
 RTEMS_VERSION=$RTEMS
-RTEMS_BASE=/home/travis/.cache/rtems${RTEMS}-i386
+RTEMS_BASE=$HOME/.rtems
 EOF
   cat << EOF >> epics-base/configure/CONFIG_SITE
-CROSS_COMPILER_TARGET_ARCHS+=RTEMS-pc386
-EOF
-
-  # find local qemu-system-i386
-  export PATH="$HOME/.cache/qemu/usr/bin:$PATH"
-  echo -n "Using QEMU: "
-  type qemu-system-i386 || echo "Missing qemu"
-  cat <<EOF >> epics-base/configure/CONFIG_SITE
-RTEMS_QEMU_FIXUPS=YES
+CROSS_COMPILER_TARGET_ARCHS += RTEMS-pc386-qemu
 EOF
 fi
 
 make -j2 -C epics-base $EXTRA
-
-if [ "$BRBASE" ]
-then
-  make -j2 -C pvData $EXTRA
-  make -j2 -C pvAccess $EXTRA
-fi
+make -j2 -C pvData $EXTRA
+make -j2 -C pvAccess $EXTRA
 
 find epics-base/include
 find epics-base/lib

.travis.yml

@@ -11,19 +11,20 @@ addons:
     - perl
     - clang
     - g++-mingw-w64-i686
+    - qemu-system-x86
 install:
  - ./.ci/travis-prepare.sh
 script:
  - ./.ci/travis-build.sh
 env:
- - BRCORE=master BRLIBCOM=master BRPVD=master BRPVA=master
- - CMPLR=clang
- - EXTRA="CMD_CXXFLAGS=-std=c++98"
- - EXTRA="CMD_CXXFLAGS=-std=c++11"
- - CMPLR=clang EXTRA="CMD_CXXFLAGS=-std=c++11"
- - WINE=32 TEST=NO STATIC=YES
- - WINE=32 TEST=NO STATIC=NO
- - RTEMS=4.10 TEST=NO
- - RTEMS=4.9 TEST=NO
+ - BRBASE=7.0
+ - BRBASE=7.0 CMPLR=clang
+ - BRBASE=7.0 EXTRA="CMD_CXXFLAGS=-std=c++98"
+ - BRBASE=7.0 EXTRA="CMD_CXXFLAGS=-std=c++11"
+ - BRBASE=7.0 CMPLR=clang EXTRA="CMD_CXXFLAGS=-std=c++11"
+ - BRBASE=7.0 WINE=32 TEST=NO STATIC=YES
+ - BRBASE=7.0 WINE=32 TEST=NO STATIC=NO
+ - BRBASE=7.0 RTEMS=4.10 TEST=NO
+ - BRBASE=7.0 RTEMS=4.9 TEST=NO
  - BRBASE=3.16
  - BRBASE=3.15

Makefile

@@ -7,6 +7,9 @@ DIRS += configure
 DIRS += $(wildcard *App)
 DIRS += $(wildcard iocBoot)
 
+# pdbApp depends on configure for CONFIG_QSRV_VERSION
+pdbApp_DEPEND_DIRS = configure
+
 # iocBoot depends on all *App dirs
 iocBoot_DEPEND_DIRS += $(filter %App,$(DIRS))
 testApp_DEPEND_DIRS += p2pApp pdbApp

README.md

@@ -1,3 +1,5 @@
+See main [documentation](https://epics-base.github.io/pva2pva/) page.
+
 This repository contains two distinct pieces of software.
 
 QSRV
@@ -23,24 +25,22 @@ Dependencies
 ------------
 
 - [epics-base](http://www.aps.anl.gov/epics/) >= 3.15.3
+- and
 - [pvDataCPP](http://epics-pvdata.sourceforge.net/)
 - [pvAccessCPP](http://epics-pvdata.sourceforge.net/)
 
+or bundled with
+
+- [epics-base](http://www.aps.anl.gov/epics/) >= 7.0.1
+
 Building
 --------
 
 To build all dependencies from source:
 
 ```sh
-git clone https://github.com/epics-base/epics-base.git
-git clone https://github.com/epics-base/pvDataCPP.git
-git clone https://github.com/epics-base/pvAccessCPP.git
-git clone https://github.com/mdavidsaver/pva2pva.git
-
+git clone --recursive https://github.com/epics-base/epics-base.git
 make -C epics-base
-make -C pvDataCPP
-make -C pvAccessCPP
-make -C pva2pva
 ```
 
 Running QSRV
@@ -86,15 +86,15 @@ A full list of `info(Q:group` options.
 record(...) {
     info(Q:group, {
         "<group_name>":{
-            +id:"some/NT:1.0",  // top level ID
-            +meta:"FLD",        // map top level alarm/timeStamp
-            +atomic:true,       // whether monitors default to multi-locking atomicity
+            +id:"some/NT:1.0",  # top level ID
+            +meta:"FLD",        # map top level alarm/timeStamp
+            +atomic:true,       # whether monitors default to multi-locking atomicity
             "<field.name>":{
-                +type:"scalar", // controls how map VAL mapped onto <field.name>
+                +type:"scalar", # controls how map VAL mapped onto <field.name>
                 +channel:"VAL",
                 +id:"some/NT:1.0",
-                +trigger:"*",   // "*" or comma seperated list of <field.name>s
-                +putorder:0,    // set for fields where put is allowed, processing done in increasing order
+                +trigger:"*",   # "*" or comma seperated list of <field.name>s
+                +putorder:0,    # set for fields where put is allowed, processing done in increasing order
             }
         }
     })
@@ -109,9 +109,7 @@ At present each pva2pva process can act as a uni-directional proxy,
 presenting a pvAccess server on one interface,
 and a client on other(s).
 
-The file [example.cmd](example.cmd) provides a starting point.
-Adjust *EPICS_PVAS_INTF_ADDR_LIST* and *EPICS_PVA_ADDR_LIST*
-according to the host computer's network configuration.
+The file [loopback.conf](loopback.conf) provides a starting point.
 
 At present there are no safe guard against creating loops
 where a gateway client side connects to its own server side.
@@ -121,5 +119,5 @@ the interface used for the server (either directly, or included in a broadcast d
 
 ```
 cd pva2pva
-./bin/linux-x86_64/pva2pva example.cmd
+./bin/linux-x86_64/pva2pva loopback.conf
 ```

common/pvahelper.h

@@ -74,8 +74,9 @@ struct BaseMonitor : public epics::pvAccess::Monitor
 
     typedef epics::pvAccess::MonitorRequester requester_t;
 
-    mutable epicsMutex lock; // not held during any callback
+    epicsMutex& lock; // not held during any callback
     typedef epicsGuard<epicsMutex> guard_t;
+    typedef epicsGuardRelease<epicsMutex> unguard_t;
 
 private:
     const requester_t::weak_pointer requester;
@@ -90,9 +91,11 @@ private:
     buffer_t inuse, empty;
 
 public:
-    BaseMonitor(const requester_t::weak_pointer& requester,
+    BaseMonitor(epicsMutex& lock,
+                const requester_t::weak_pointer& requester,
                 const epics::pvData::PVStructure::shared_pointer& pvReq)
-        :requester(requester)
+        :lock(lock)
+        ,requester(requester)
         ,inoverflow(false)
         ,running(false)
         ,nbuffers(2)
@@ -104,121 +107,136 @@ public:
 
     //! Must call before first post().  Sets .complete and calls monitorConnect()
     //! @note that value will never by accessed except by post() and requestUpdate()
-    void connect(const epics::pvData::PVStructurePtr& value)
+    void connect(guard_t& guard, const epics::pvData::PVStructurePtr& value)
     {
+        guard.assertIdenticalMutex(lock);
         epics::pvData::StructureConstPtr dtype(value->getStructure());
         epics::pvData::PVDataCreatePtr create(epics::pvData::getPVDataCreate());
         BaseMonitor::shared_pointer self(shared_from_this());
         requester_t::shared_pointer req(requester.lock());
-        {
-            guard_t G(lock);
-            assert(!complete); // can't call twice
 
-            complete = value;
-            empty.resize(nbuffers);
-            for(size_t i=0; i<empty.size(); i++) {
-                empty[i].reset(new epics::pvAccess::MonitorElement(create->createPVStructure(dtype)));
-            }
+        assert(!complete); // can't call twice
+
+        complete = value;
+        empty.resize(nbuffers);
+        for(size_t i=0; i<empty.size(); i++) {
+            empty[i].reset(new epics::pvAccess::MonitorElement(create->createPVStructure(dtype)));
         }
-        epics::pvData::Status sts;
-        if(req)
+
+        if(req) {
+            unguard_t U(guard);
+            epics::pvData::Status sts;
             req->monitorConnect(sts, self, dtype);
+        }
     }
 
     struct no_overflow {};
 
     //! post update if queue not full, if full return false w/o overflow
-    bool post(const epics::pvData::BitSet& updated, no_overflow)
+    bool post(guard_t& guard, const epics::pvData::BitSet& updated, no_overflow)
     {
+        guard.assertIdenticalMutex(lock);
         requester_t::shared_pointer req;
-        {
-            guard_t G(lock);
-            if(!complete || !running) return false;
 
-            changed |= updated;
+        if(!complete || !running) return false;
 
-            if(empty.empty()) return false;
+        changed |= updated;
 
-            if(p_postone())
-                req = requester.lock();
-            inoverflow = false;
+        if(empty.empty()) return false;
+
+        if(p_postone())
+            req = requester.lock();
+        inoverflow = false;
+
+        if(req) {
+            unguard_t U(guard);
+            req->monitorEvent(shared_from_this());
         }
-        if(req) req->monitorEvent(shared_from_this());
         return true;
     }
 
     //! post update of pending changes.  eg. call from requestUpdate()
-    bool post()
+    bool post(guard_t& guard)
     {
+        guard.assertIdenticalMutex(lock);
         bool oflow;
         requester_t::shared_pointer req;
-        {
-            guard_t G(lock);
-            if(!complete || !running) return false;
 
-            if(empty.empty()) {
-                oflow = inoverflow = true;
+        if(!complete || !running) return false;
 
-            } else {
+        if(empty.empty()) {
+            oflow = inoverflow = true;
 
-                if(p_postone())
-                    req = requester.lock();
-                oflow = inoverflow = false;
-            }
+        } else {
+
+            if(p_postone())
+                req = requester.lock();
+            oflow = inoverflow = false;
+        }
+
+        if(req) {
+            unguard_t U(guard);
+            req->monitorEvent(shared_from_this());
         }
-        if(req) req->monitorEvent(shared_from_this());
         return !oflow;
     }
 
     //! post update with changed and overflowed masks (eg. when updates were lost in some upstream queue)
-    bool post(const epics::pvData::BitSet& updated, const epics::pvData::BitSet& overflowed)
+    bool post(guard_t& guard,
+              const epics::pvData::BitSet& updated,
+              const epics::pvData::BitSet& overflowed)
     {
+        guard.assertIdenticalMutex(lock);
         bool oflow;
         requester_t::shared_pointer req;
-        {
-            guard_t G(lock);
-            if(!complete || !running) return false;
 
-            if(empty.empty()) {
-                oflow = inoverflow = true;
-                overflow |= overflowed;
-                overflow.or_and(updated, changed);
-                changed |= updated;
+        if(!complete || !running) return false;
 
-            } else {
+        if(empty.empty()) {
+            oflow = inoverflow = true;
+            overflow |= overflowed;
+            overflow.or_and(updated, changed);
+            changed |= updated;
 
-                changed |= updated;
-                if(p_postone())
-                    req = requester.lock();
-                oflow = inoverflow = false;
-            }
+        } else {
+
+            changed |= updated;
+            if(p_postone())
+                req = requester.lock();
+            oflow = inoverflow = false;
+        }
+
+        if(req) {
+            unguard_t U(guard);
+            req->monitorEvent(shared_from_this());
         }
-        if(req) req->monitorEvent(shared_from_this());
         return !oflow;
     }
 
     //! post update with changed
-    bool post(const epics::pvData::BitSet& updated) {
+    bool post(guard_t& guard, const epics::pvData::BitSet& updated) {
         bool oflow;
         requester_t::shared_pointer req;
-        {
-            guard_t G(lock);
-            if(!complete || !running) return false;
 
-            if(empty.empty()) {
-                oflow = inoverflow = true;
-                overflow.or_and(updated, changed);
-                changed |= updated;
+        if(!complete || !running) return false;
 
-            } else {
+        if(empty.empty()) {
+            oflow = inoverflow = true;
+            overflow.or_and(updated, changed);
+            changed |= updated;
 
-                changed |= updated;
-                if(p_postone())
-                    req = requester.lock();
-                oflow = inoverflow = false;
-            }
+        } else {
+
+            changed |= updated;
+            if(p_postone())
+                req = requester.lock();
+            oflow = inoverflow = false;
+        }
+
+        if(req) {
+            unguard_t U(guard);
+            req->monitorEvent(shared_from_this());
         }
-        if(req) req->monitorEvent(shared_from_this());
         return !oflow;
     }
 
@@ -250,7 +268,7 @@ public:
     virtual void onStop() {}
     //! called when within release() when the opportunity exists to end the overflow condition
     //! May do nothing, or lock and call post()
-    virtual void requestUpdate() {guard_t G(lock); post();}
+    virtual void requestUpdate() {guard_t G(lock); post(G);}
 
     virtual void destroy()
     {

common/sb.h

@@ -0,0 +1,16 @@
+#ifndef SB_H
+#define SB_H
+
+#include <sstream>
+
+// in-line string builder (eg. for exception messages)
+//   throw std::runtime_error(SB()<<"Answer: !"<<42);
+struct SB {
+    std::ostringstream strm;
+    SB() {}
+    operator std::string() const { return strm.str(); }
+    template<typename T>
+    SB& operator<<(T i) { strm<<i; return *this; }
+};
+
+#endif // SB_H

configure/CONFIG_QSRV_VERSION

@@ -1,9 +1,9 @@
 # Module (source) version
 EPICS_QSRV_MAJOR_VERSION = 1
-EPICS_QSRV_MINOR_VERSION = 0
-EPICS_QSRV_MAINTENANCE_VERSION = 0
+EPICS_QSRV_MINOR_VERSION = 2
+EPICS_QSRV_MAINTENANCE_VERSION = 1
 EPICS_QSRV_DEVELOPMENT_FLAG = 0
 
 # ABI version
 EPICS_QSRV_ABI_MAJOR_VERSION = 1
-EPICS_QSRV_ABI_MINOR_VERSION = 0
+EPICS_QSRV_ABI_MINOR_VERSION = 1

configure/CONFIG_SITE

@@ -38,5 +38,8 @@ CHECK_RELEASE = YES
 # we don't actually use 'rset' explicitly, but quiet some warnings
 USR_CPPFLAGS += -DUSE_TYPED_RSET
 
+# we use std::min()/max() and don't want conflicting MSVC defs
+USR_CPPFLAGS_WIN32 += -DNOMINMAX
+
 -include $(TOP)/../CONFIG_SITE.local
 -include $(TOP)/configure/CONFIG_SITE.local

documentation/Doxyfile

@@ -38,7 +38,7 @@ PROJECT_NAME           = pva2pva
 # could be handy for archiving the generated documentation or if some version
 # control system is used.
 
-PROJECT_NUMBER         = 0
+PROJECT_NUMBER         = 1.2.1
 
 # Using the PROJECT_BRIEF tag one can provide an optional one line description
 # for a project that appears at the top of each page and should give viewer a

documentation/mainpage.dox

@@ -1,15 +1,21 @@
 /**
 @mainpage pva2pva Home of QSRV and pvAccess 2 pvAccess gateway
 
+- [Source](https://github.com/epics-base/pva2pva)
 - [Download](https://sourceforge.net/projects/epics-pvdata/files/)
 
 @section qsrv QSRV
 
-QSRV is a network server using the PVAccess protocol which
+@ref qsrv_page is a network server using the PVAccess protocol which
 runs inside an EPICS IOC process and allows clients
 to make requests to access the Process Variables (PVs)
 within.
 
+Documentation of @ref qsrv_config including @ref qsrv_group_def
+and @ref qsrv_link configuration.
+
+- @ref release_notes
+
 @subsection qsrv_build Building
 
 To build the latest from version control

documentation/qsrvpage.dox

@@ -0,0 +1,333 @@
+/**
+@page qsrv_page QSRV
+
+@section qsrv_config QSRV Configuration
+
+By default QSRV exposes all Process Variables (fields of process database records).
+In addition to these "single" PVs are special "group" PVs.
+
+@subsection qsrv_single Single PVs
+
+"single" PVs are the same set of names server by the Channel Access server (RSRV).
+This is all accessible record fields.
+So all data which is accessible via Channel Access is also accessible via PVAccess.
+
+QSRV presents all "single" PVs as Structures conforming to the
+Normative Types NTScalar, NTScalarArray, or NTEnum depending on the native DBF field type.
+
+@subsection qsrv_group_def Group PV definitions
+
+A group is defined using a JSON syntax.
+Groups are defined with respect to a Group Name,
+which is also the PV name.
+So unlike records, the "field" of a group have a different meaning.
+Group field names are _not_ part of the PV name.
+
+A group definition is split among several records.
+For example of a group including two records is:
+
+@code
+record(ai, "rec:X") {
+  info(Q:group, {
+    "grp:name": {
+        "X": {+channel:"VAL"}
+    }
+  })
+}
+record(ai, "rec:Y") {
+  info(Q:group, {
+    "grp:name": {
+        "Y": {+channel:"VAL"}
+    }
+  })
+}
+@endcode
+
+This group, named "grp:name", has two fields "X" and "Y".
+
+@code
+$ pvget grp:name
+grp:name
+structure 
+    epics:nt/NTScalar:1.0 X
+        double value 0
+        alarm_t alarm INVALID DRIVER UDF
+        time_t timeStamp <undefined> 0
+...
+    epics:nt/NTScalar:1.0 Y
+        double value 0
+        alarm_t alarm INVALID DRIVER UDF
+        time_t timeStamp <undefined> 0
+...
+@endcode
+
+@subsection qsrv_group_ref Group PV reference
+
+@code
+record(...) {
+    info(Q:group, {
+        "<group_name>":{
+            +id:"some/NT:1.0",  # top level ID
+            +meta:"FLD",        # map top level alarm/timeStamp
+            +atomic:true,       # whether monitors default to multi-locking atomicity
+            "<field.name>":{
+                +type:"scalar", # controls how map VAL mapped onto <field.name>
+                +channel:"VAL",
+                +id:"some/NT:1.0",
+                +trigger:"*",   # "*" or comma seperated list of <field.name>s
+                +putorder:0,    # set for fields where put is allowed, processing done in increasing order
+            }
+        }
+    })
+}
+@endcode
+
+@subsubsection qsrv_group_map_types Field mapping types
+
+@li "scalar" or ""
+@li "plain"
+@li "any"
+@li "meta"
+@li "proc"
+
+The "scalar" mapping places an NTScalar or NTScalarArray as a sub-structure.
+
+The "plain" mapping ignores all meta-data and places only the "value" as a field.
+The "value" is equivalent to '.value' of the equivalent NTScalar/NTScalarArray as a field.
+
+The "any" mapping places a variant union into which the "value" is placed.
+
+The "meta" mapping ignores the "value" and places only the alarm and time
+meta-data as sub-fields.
+The special group level tag 'meta:""' allows these meta-data fields to be
+placed in the top-level structure.
+
+The "proc" mapping uses neither "value" nor meta-data.
+Instead the target record is processed during a put.
+
+@subsubsection qsrv_group_map_trig Field Update Triggers
+
+The field triggers define how changes to the consitutent field
+are translated into a subscription update to the group.
+
+The most use of these are "" which means that changes to the field
+are ignored, and do not result group update.
+And "*" which results in a group update containing the most recent
+values/meta-data of all fields.
+
+It may be useful to specify a comma seperated list of field names
+so that changes may partially update the group.
+
+@subsection qsrv_stamp QSRV Timestamp Options
+
+QSRV has the ability to perform certain transformations on the timestamp before transporting it.
+The mechanism for configuring this is the "Q:time:tag" info() tag.
+
+@subsubsection qsrv_stamp_nslsb Nano-seconds least significant bits
+
+Setting "Q:time:tag" to a value of "nsec:lsb:#", where # is a number between 0 and 32,
+will split the nanoseconds value stored in the associated record.
+The least significant # bits are stored in the 'timeStamp.userTag' field.
+While the remaining 32-# bits are stored in 'timeStamp.nanoseconds' (without shifting).
+
+For example, in the following situation 20 bits are split off into userTag.
+If the nanoseconds part of the record timestamp is 0x12345678,
+then the PVD structure would include "timeStamp.nanoseconds=0x12300000"
+and "timeStamp.userTag=0x45678".
+
+@code
+record(ai, "...") {
+  info(Q:time:tag, "nsec:lsb:20")
+}
+@endcode
+
+@subsection qsrv_form QSRV Display Form Option
+
+The value of the OPI display form hint ('display.form') can be set set with the "Q:form" info() tag.
+This hint, along with 'display.precision', is used by some OPI clients to control how values are rendered.
+
+The text value of the tag must be one of the following choices.
+
+@li Default
+@li String
+@li Binary
+@li Decimal
+@li Hex
+@li Exponential
+@li Engineering
+
+@code
+record(ai, "...") {
+  info(Q:form, "Default") # implied default
+}
+@endcode
+
+@subsection qsrv_link PVAccess Links
+
+When built against Base >= 3.16.1, support is enabled for PVAccess links,
+which are analogous to Channel Access (CA) links.  However, the syntax
+for PVA links is quite different.
+
+@note The "dbjlr" and "dbpvar" IOC shell command provide information about PVA links in a running IOC.
+
+@warning The PVA Link syntax shown below is provisional and subject to change.
+
+A simple configuration using defaults is
+
+@code
+record(longin, "tgt") {}
+record(longin, "src") {
+    field(INP, {pva:"tgt"})
+}
+@endcode
+
+This is a shorthand for
+
+@code
+record(longin, "tgt") {}
+record(longin, "src") {
+    field(INP, {pva:{pv:"tgt"}})
+}
+@endcode
+
+Some additional keys (beyond "pv") may be used.
+Defaults are shown below:
+
+@code
+record(longin, "tgt") {}
+record(longin, "src") {
+    field(INP, {pva:{
+        pv:"tgt",
+        field:"",   # may be a sub-field
+        local:false,# Require local PV
+        Q:4,        # monitor queue depth
+        pipeline:false, # require that server uses monitor flow control protocol
+        proc:none,  # Request record processing (side-effects).
+        sevr:false, # Maximize severity.
+        time:false, # set record time during getValue
+        monorder:0, # Order of record processing as a result of CP and CPP
+        retry:false,# allow Put while disconnected.
+        always:false,# CP/CPP input link process even when .value field hasn't changed
+        defer:false # Defer put
+    }})
+}
+@endcode
+
+@subsubsection qsrv_link_pv pv: Target PV name
+
+The PV name to search for.
+This is the same name which could be used with 'pvget' or other client tools.
+
+@subsubsection qsrv_link_field field: Structure field name
+
+The name of a sub-field of the remotely provided Structure.
+By default, an empty string "" uses the top-level Structure.
+
+If the top level structure, or a sub-structure is selected, then
+it is expeccted to conform to NTScalar, NTScalarArray, or NTEnum
+to extract value and meta-data.
+
+If the sub-field is an PVScalar or PVScalarArray, then a value
+will be taken from it, but not meta-data will be available.
+
+@todo Ability to traverse through unions and into structure arrays (as with group mappings).
+
+@subsubsection qsrv_link_local local: Require local PV
+
+When true, link will not connect unless the named PV is provided by the local (QSRV) data provider.
+
+@subsubsection qsrv_link_Q Q: Monitor queue depth
+
+Requests a certain monitor queue depth.
+The server may, or may not, take this into consideration when selecting
+a queue depth.
+
+@subsubsection qsrv_link_pipeline pipeline: Monitor flow control
+
+Expect that the server supports PVA monitor flow control.
+If not, then the subscription will stall (ick.)
+
+@subsubsection qsrv_link_proc proc: Request record processing (side-effects)
+
+The meaning of this option depends on the direction of the link.
+
+For output links, this option allows a request for remote processing (side-effects).
+
+@li none (default) - Make no special request.  Uses a server specific default.
+@li false, "NPP" - Request to skip processing.
+@li true, "PP" - Request to force processing.
+@li "CP", "CPP" - For output links, an alias for "PP".
+
+For input links, this option controls whether the record containing
+the PVA link will be processed when subscription events are received.
+
+@li none (default), false, "NPP" - Do not process on subscription updates.
+@li true, "CP" - Always process on subscription updates.
+@li "PP", "CPP" - Process on subscription updates if SCAN=Passive
+
+@subsubsection qsrv_link_sevr sevr: Alarm propagation
+
+This option controls whether reading a value from an input PVA link
+has the addition effect of propagating any alarm via the Maximize
+Severity process.
+
+@li false - Do not maximize severity.
+@li true - Maximize alarm severity
+@li "MSI" - Maximize only if the remote severity is INVALID.
+
+@subsubsection qsrv_link_time time: Time propagation
+
+Somewhat analogous to sevr: applied to timestamp.
+When true, the record TIME field is updated when the link value is read.
+
+@warning TSEL must be set to -2 for time:true to have an effect.
+
+@subsubsection qsrv_link_monorder monorder: Monitor processing order
+
+When multiple record target the same target PV, and request processing
+on subscription updates.  This option allows the order of processing
+to be specified.
+
+Record are processed in increasing order.
+monorder=-1 is processed before monorder=0.
+Both are processed before monorder=1.
+
+@subsubsection qsrv_link_defer defer: Defer put
+
+By default (defer=false) an output link will immediately
+start a PVA Put operation.  defer=true will store the
+new value in an internal cache, but not start a PVA Put.
+
+This option, in combination with field: allows a single
+Put to contain updates to multiple sub-fields.
+
+
+@subsubsection qsrv_link_retry retry: Put while disconnected
+
+Allow a Put operation to be queued while the link is disconnected.
+The Put will be executed when the link becomes connected.
+
+@subsubsection qsrv_link_always always: CP/CPP always process
+
+By default (always:false) a subscription update will only cause a CP input link
+to scan if the structure field (cf. field: option) is marked as changed.
+Set to true to override this, and always process the link.
+
+@subsubsection qsrv_link_sem Link semantics/behavior
+
+This section attempts to answer some questions about how links behave in certain situations.
+
+Links are evaluated in three basic contexts.
+
+@li dbPutLink()/dbScanFwdLink()
+@li dbGetLink() of non-CP link
+@li dbGetLink() during a scan resulting from a CP link.
+
+An input link can bring in a Value as well as meta-data, alarm, time, and display/control info.
+For input links, the PVA link engine attempts to always maintain consistency between Value, alarm, and time.
+However, consistency between these, and the display/control info is only ensured during a CP scan.
+
+
+
+
+*/

documentation/qsrvpage.h

@@ -1,13 +0,0 @@
-/**
-@page qsrv_page QSRV
-
-@section qsrv_config QSRV Configuration
-
-By default QSRV exposes all Process Variables (fields of process database records).
-In addition to these "single" PVs, special "group" PVs.
-
-@subsection qsrv_group_sym Group PV semantics
-
-@subsection qsrv_group_def Group PV definitions
-
-*/

documentation/release_notes.dox

@@ -0,0 +1,44 @@
+/**
+
+@page release_notes Release Notes
+
+Release 1.2.1 (July 2019)
+=========================
+
+- Fixes
+ - Fix unittest: testpvalink.  No functional change.
+
+Release 1.2.0 (Mar 2019)
+========================
+
+- Incompatible changes
+ - The field 'display.format' is replaced with 'display.form' and 'display.precision'.
+   https://github.com/epics-base/pva2pva/issues/19
+- Additions
+ - Use @code info(Q:form, "...") @endcode to set 'display.form'.  See @ref qsrv_form
+- Fixes
+ - Correct handling of 64-bit integer fields.
+ - Install a copy of softIocExit.db for standalone builds
+
+Release 1.1.0 (Nov 2018)
+==========================
+
+- Incompatible changes
+ - Requires pvDataCPP >= 7.1.0
+ - Requires pvAccessCPP >= 6.1.0
+- Removals
+ - Drop the broken ioccircle and ioccircle2 examples.
+- Fixes
+ - Fix QSRV monitor locking causing crash
+ - Fix Windows DLL import/export errors
+ - Correctly handle empty "scalar" case of NELM=1, NORD=0.
+- Additions
+ - QSRV implement channelList() (aka. 'pvlist') with list of record and group names.
+ - @ref qsrv_link type (requires Base >= 3.16.1)
+
+Release 1.0.0 (Dec 2017)
+========================
+
+Initial Release
+
+*/

example.cmd

@@ -1,26 +0,0 @@
-# Bind gateway server side to this interface
-epicsEnvSet("EPICS_PVAS_INTF_ADDR_LIST","10.0.1.200")
-
-# Gateway client side searches here.  Must not include gateway server side interface
-epicsEnvSet("EPICS_PVA_ADDR_LIST", "10.1.1.255")
-# Prevent gateway client from automatically populating the address list,
-# which would include the gateway server side interface
-epicsEnvSet("EPICS_PVA_AUTO_ADDR_LIST","NO")
-
-gwstart()
-
-# PVA variables
-#
-# Server side
-#
-# EPICS_PVAS_INTF_ADDR_LIST - Bind to this interface for both UDP and TCP
-# EPICS_PVAS_SERVER_PORT - default TCP port
-# EPICS_PVAS_BROADCAST_PORT - Listen for searches on this port
-#
-# EPICS_PVA_SERVER_PORT - Unused if EPICS_PVAS_SERVER_PORT set
-#
-# Client side
-#
-# EPICS_PVA_BROADCAST_PORT - Default search port for *ADDR_LIST
-# EPICS_PVA_ADDR_LIST - Space seperated list of search endpoints (bcast or unicast)
-# EPICS_PVA_AUTO_ADDR_LIST - YES/NO whether to populate ADDR_LIST with all local interface bcast addrs

iocBoot/ioccircle/circle.db

@@ -1,66 +0,0 @@
-record(ao, "circle:step") {
-  field(VAL , "1.0")
-  field(DRVL, "0.0")
-  field(DRVH, "359")
-  field(PINI, "YES")
-}
-
-record(ao, "circle:period") {
-  field(VAL , "1.0")
-  field(PINI, "YES")
-  field(OUT , "circle:tick.ODLY NPP")
-}
-
-record(calc, "circle:angle") {
-  field(PINI, "RUNNING") # bootstrap
-  field(INPA, "circle:angle NPP")
-  field(INPB, "circle:step NPP")
-  field(INPD, "360")
-  field(DESC, "Angle")
-  field(EGU , "deg")
-  field(LOLO, "45")
-  field(LOW , "135")
-  field(HIGH, "225")
-  field(HIHI, "315")
-  field(LLSV, "MAJOR")
-  field(LSV , "MINOR")
-  field(HSV , "MINOR")
-  field(HHSV, "MAJOR")
-  field(CALC, "C:=A+B;(C>=D)?C-D:C")
-  field(FLNK, "circle:x")
-  field(PREC, "3")
-  info(pdbGroup0, "circle|angle=VAL")
-  info(pdbGroup1, "line|a=VAL")
-  alias("line:a")
-}
-
-record(calc, "circle:x") {
-  field(INPA, "circle:angle NPP")
-  field(CALC, "cos(A*PI/180)")
-  field(TSEL, "circle:angle.TIME")
-  field(FLNK, "circle:y")
-  field(PREC, "3")
-  info(pdbGroup, "circle|x=VAL")
-}
-
-record(calc, "circle:y") {
-  field(INPA, "circle:angle NPP")
-  field(CALC, "sin(A*PI/180)")
-  field(TSEL, "circle:angle.TIME")
-  field(PREC, "3")
-  field(FLNK, "line:b")
-  info(pdbGroup, "circle|y=VAL")
-  info(pdbTrigger,"circle|y>*")
-}
-
-record(ai, "line:b") {
-  field(INP, "line:a NPP")
-  field(FLNK, "circle:tick")
-  info(pdbGroup, "line|b=VAL")
-  info(pdbTrigger,"line|b>*")
-}
-
-record(calcout, "circle:tick") {
-  field(ODLY, "1.0")
-  field(OUT , "circle:angle.PROC CA") # loop
-}

iocBoot/ioccircle/st.cmd

@@ -1,15 +0,0 @@
-#!../../bin/linux-x86_64-debug/softIocPVA
-
-#epicsEnvSet("EPICS_PVA_ADDR_LIST", "10.5.2.255")
-#epicsEnvSet("EPICS_PVAS_INTF_ADDR_LIST","10.5.2.1")
-#epicsEnvSet("EPICS_PVA_AUTO_ADDR_LIST","NO")
-
-#epicsEnvSet("EPICS_PVA_SERVER_PORT","5085")
-#epicsEnvSet("EPICS_PVA_BROADCAST_PORT","5086")
-#epicsEnvSet("EPICS_CA_SERVER_PORT","5067")
-#epicsEnvSet("EPICS_CA_REPEATER_PORT","5068")
-#epicsEnvSet("EPICS_CA_MAX_ARRAY_BYTES","13000000")
-
-dbLoadRecords("circle.db","")
-
-iocInit()

iocBoot/ioccircle2/Makefile

@@ -1,5 +0,0 @@
-TOP = ../..
-include $(TOP)/configure/CONFIG
-ARCH = linux-x86_64-debug
-TARGETS = envPaths
-include $(TOP)/configure/RULES.ioc

iocBoot/ioccircle2/circle2.db

@@ -1,27 +0,0 @@
-record(calc, "circle2:x") {
-  field(INPA, {pva:"circle.x CP MSI"})
-  field(CALC, "2*A")
-  field(FLNK, "circle2:y")
-  info(pdbGroup, "circle2|x=VAL")
-#  field(TPRO, "1")
-}
-
-record(calc, "circle2:y") {
-  field(INPA, {pva:"circle.y MSI"})
-  field(CALC, "2*A")
-  field(TSEL, "circle2:x.TIME")
-  field(FLNK, "circle2:mag")
-  info(pdbGroup, "circle2|y=VAL")
-#  field(TPRO, "1")
-}
-
-record(calc, "circle2:mag") {
-  field(INPA, "circle2:x NPP MSI")
-  field(INPB, "circle2:y NPP MSI")
-  field(CALC, "SQRT(A*A+B*B)")
-  field(MDEL, "-1")
-  field(TSEL, "circle2:x.TIME")
-  info(pdbGroup, "circle2|mag=VAL")
-  info(pdbTrigger,"circle2|mag>*")
-#  field(TPRO, "1")
-}

iocBoot/ioccircle2/st.cmd

@@ -1,17 +0,0 @@
-#!../../bin/linux-x86_64-debug/softIocPVA
-
-#epicsEnvSet("EPICS_PVA_ADDR_LIST", "10.5.2.255")
-#epicsEnvSet("EPICS_PVAS_INTF_ADDR_LIST","10.5.2.1")
-#epicsEnvSet("EPICS_PVA_AUTO_ADDR_LIST","NO")
-
-#epicsEnvSet("EPICS_PVA_SERVER_PORT","5085")
-#epicsEnvSet("EPICS_PVA_BROADCAST_PORT","5086")
-#epicsEnvSet("EPICS_CA_SERVER_PORT","5067")
-#epicsEnvSet("EPICS_CA_REPEATER_PORT","5068")
-epicsEnvSet("EPICS_CA_MAX_ARRAY_BYTES","13000000")
-
-dbLoadRecords("circle2.db","")
-
-var(pvaLinkDebug, 5)
-
-iocInit()

iocBoot/iocimagedemo/image.db

@@ -1,18 +1,20 @@
 
 
 record(longout, "$(N):ArraySize0_RBV") {
+    field(VAL, "100")
     info(Q:group, {
         "$(N):Array":{
-            "dimension[0].size":{+channel:"VAL", +type:"plain"}
+            "dimension[0].size":{+channel:"VAL", +type:"plain", +putorder:0}
         }
     })
     field(FLNK, "$(N):ArraySize1_RBV")
 }
 
 record(longout, "$(N):ArraySize1_RBV") {
+    field(VAL, "100")
     info(Q:group, {
         "$(N):Array":{
-            "dimension[1].size":{+channel:"VAL", +type:"plain"}
+            "dimension[1].size":{+channel:"VAL", +type:"plain", +putorder:0}
         }
     })
     field(FLNK, "$(N):ArrayData_")
@@ -20,6 +22,7 @@ record(longout, "$(N):ArraySize1_RBV") {
 
 record(aSub, "$(N):ArrayData_") {
     field(SNAM, "QSRV_image_demo")
+    field(PINI, "YES")
     field(FTA, "ULONG")
     field(FTB, "ULONG")
     field(FTVA, "USHORT")
@@ -35,7 +38,9 @@ record(waveform, "$(N):ArrayData") {
     info(Q:group, {
         "$(N):Array":{
             +id:"epics:nt/NTNDArray:1.0",
-            "value":{+type:"any", +channel:"VAL", +trigger:"*"},
+            "value":{+type:"any",
+                     +channel:"VAL",
+                     +trigger:"*"},
             "":{+type:"meta", +channel:"SEVR"}
         }
     })

iocBoot/iocimagedemo/table.db

@@ -35,11 +35,15 @@ record(aao, "$(N)B") {
     field(TPRO, "1")
 }
 
-record(bo, "$(N)Save") {
+record(longout, "$(N)Save") {
+    field(MDEL, "-1") # ensure we always trigger group monitor
     field(TPRO, "1")
     info(Q:group, {
         "$(N)Tbl":{
-            "_save":{+type:"proc", +channel:"VAL", +putorder:2}
+            "_save":{+type:"proc",
+                     +channel:"VAL",
+                     +putorder:2,
+                     +trigger:"*"}
         }
     })
 }

iocBoot/iocpvalink/README

@@ -0,0 +1,5 @@
+IOC for testing PVA links
+
+Primary test is st.cmd.  st2.cmd is run/stopped concurrently
+to test remote connect/disconnect.  st2a.cmd to test type
+change.

iocBoot/iocpvalink/pvalink.db

@@ -0,0 +1,106 @@
+record(ai, "$(P)target") {}
+
+# local input link shorthand
+record(longin, "$(P)inp1") {
+    field(INP , {pva:"$(P)target"})
+    alias("$(P)inp1:alias")
+}
+
+# local input link longhand
+record(longin, "$(P)inp2") {
+    field(INP , {pva:{pv:"$(P)target"}})
+}
+
+# remote input link
+record(longin, "$(P)inp3") {
+    field(INP , {pva:"invalid:pv:name"})
+}
+
+# null like (requires local, but not local)
+record(longin, "$(P)inp4") {
+    field(INP , {pva:{pv:"invalid:pv:name", local:true}})
+}
+
+# local input link w/ CP (process on update)
+record(calc, "$(P)cnt") {
+    field(SCAN, "1 second")
+    field(INPA, "$(P)cnt")
+    field(INPB, "9")
+    field(CALC, "A<B?A+1:0")
+    field(HIGH, "7")
+    field(HSV , "MAJOR")
+}
+record(longin, "$(P)track") {
+    field(INP , {pva:{
+                    pv:"$(P)cnt",
+                    proc:"CP",
+                    sevr:true,
+                    time:true
+                    }})
+    field(TSE, "-2")
+}
+
+# remote input link w/ CP (process on update)
+record(longin, "$(P)track2") {
+    field(INP , {pva:{
+                    pv:"$(P)cnt:rmt",
+                    proc:"CP",
+                    sevr:true,
+                    time:true
+                    }})
+    field(TSE, "-2")
+}
+
+
+# local output link
+record(longout, "$(P)out1") {
+    field(OUT , {pva:{pv:"$(P)out:tgt"}})
+    field(TPRO, "1")
+}
+record(longout, "$(P)out:tgt") {
+    field(TPRO, "1")
+}
+
+# remote output link
+record(longout, "$(P)out2") {
+    field(OUT , {pva:{pv:"$(P)out:rmt"}})
+    field(TPRO, "1")
+}
+
+# remote output link w/ retry (queue put while disconnected)
+record(longout, "$(P)out3") {
+    field(OUT , {pva:{pv:"$(P)out:rmt", retry:true}})
+    field(TPRO, "1")
+    #info(base:lsetDebug, "YES")
+}
+
+
+# output link to waveform
+record(aao, "$(P)out4:wf") {
+    field(FTVL, "DOUBLE")
+    field(NELM, "10")
+    field(OUT , {pva:{pv:"$(P)target:wf"}})
+}
+
+# input link to waveform
+record(aao, "$(P)target:wf") {
+    field(FTVL, "DOUBLE")
+    field(NELM, "10")
+}
+
+record(aai, "$(P)inp5:wf") {
+    field(FTVL, "DOUBLE")
+    field(NELM, "10")
+    field(INP , {pva:{pv:"$(P)target:wf"}})
+}
+
+
+# test forward link
+record(calc, "$(P)fcnt1") {
+    field(CALC, "VAL+1")
+    field(FLNK, {pva:{pv:"$(P)fcnt2"}})
+    info(base:lsetDebug, "YES")
+}
+record(calc, "$(P)fcnt2") {
+    field(CALC, "VAL+1")
+}

iocBoot/iocpvalink/pvalink2.db

@@ -0,0 +1,14 @@
+# use with pvalink.db, run in a second IOC
+
+record(calc, "$(P)cnt:rmt") {
+    field(SCAN, "1 second")
+    field(INPA, "$(P)cnt")
+    field(INPB, "9")
+    field(CALC, "A<B?A+0.1:0")
+    field(HIGH, "7")
+    field(HSV , "MAJOR")
+}
+
+record(longout, "$(P)out:rmt") {
+    field(TPRO, "1")
+}

iocBoot/iocpvalink/pvalink2a.db

@@ -0,0 +1,18 @@
+# use with pvalink.db, run in a second IOC
+#  use instead of pvalink2.db to cause a type change
+
+record(calcout, "$(P)cnt:rmtx") {
+    field(SCAN, "1 second")
+    field(OUT , "$(P)cnt:rmt PP")
+    field(INPA, "$(P)cnt")
+    field(INPB, "9")
+    field(CALC, "A<B?A+1:0")
+    field(HIGH, "7")
+    field(HSV , "MAJOR")
+}
+
+record(longin, "$(P)cnt:rmt") {}
+
+record(stringout, "$(P)out:rmt") {
+    field(TPRO, "1")
+}

iocBoot/iocpvalink/st.cmd

@@ -0,0 +1,5 @@
+#!../../bin/linux-x86_64-debug/softIocPVA
+
+dbLoadRecords("pvalink.db","P=TST:")
+
+iocInit()

iocBoot/iocpvalink/st2.cmd

@@ -0,0 +1,5 @@
+#!../../bin/linux-x86_64-debug/softIocPVA
+
+dbLoadRecords("pvalink2.db","P=TST:")
+
+iocInit()

iocBoot/iocpvalink/st2a.cmd

@@ -0,0 +1,5 @@
+#!../../bin/linux-x86_64-debug/softIocPVA
+
+dbLoadRecords("pvalink2a.db","P=TST:")
+
+iocInit()

loopback.conf

@@ -14,6 +14,7 @@
  */
 {
     "version":1,
+    "readOnly":false,
     "clients":[
         {
             "name":"theclient",
@@ -29,6 +30,8 @@
             "name":"theserver",
             "clients":["theclient"],
             "interface":"127.0.0.1",
+            "addrlist":"127.255.255.255",
+            "autoaddrlist":false,
             "serverport":5075,
             "bcastport":5076
         }

p2pApp/channel.cpp

@@ -1,6 +1,11 @@
 
 #include <epicsAtomic.h>
 
+#include <epicsTimer.h>
+#include <epicsMutex.h>
+#include <epicsGuard.h>
+#include <epicsEndian.h>
+
 #include <pv/iocshelper.h>
 
 #include <pv/pvAccess.h>

p2pApp/gwmain.cpp

@@ -12,6 +12,8 @@
 #include <epicsStdlib.h>
 #include <epicsGetopt.h>
 #include <iocsh.h>
+#include <epicsTimer.h>
+#include <libComRegister.h>
 
 #include <pv/json.h>
 
@@ -22,16 +24,21 @@
 #include <pv/reftrack.h>
 #include <pv/iocreftrack.h>
 #include <pv/iocshelper.h>
+#include <pv/logger.h>
 
 #include "server.h"
+#include "pva2pva.h"
 
 namespace pvd = epics::pvData;
 namespace pva = epics::pvAccess;
 
+extern int p2pReadOnly;
+
 namespace {
 
 pvd::StructureConstPtr schema(pvd::getFieldCreate()->createFieldBuilder()
                               ->add("version", pvd::pvUInt)
+                              ->add("readOnly", pvd::pvBoolean)
                               ->addNestedStructureArray("clients")
                                  ->add("name", pvd::pvString)
                                  ->add("provider", pvd::pvString)
@@ -44,6 +51,8 @@ pvd::StructureConstPtr schema(pvd::getFieldCreate()->createFieldBuilder()
                                  ->add("name", pvd::pvString)
                                  ->addArray("clients", pvd::pvString)
                                  ->add("interface", pvd::pvString)
+                                 ->add("addrlist", pvd::pvString)
+                                 ->add("autoaddrlist", pvd::pvBoolean)
                                  ->add("serverport", pvd::pvUShort)
                                  ->add("bcastport", pvd::pvUShort)
                                  ->add("control_prefix", pvd::pvString)
@@ -61,9 +70,12 @@ void getargs(ServerConfig& arg, int argc, char *argv[])
     int opt;
     bool checkonly = false;
 
-    while( (opt=getopt(argc, argv, "vhiIC"))!=-1)
+    while( (opt=getopt(argc, argv, "qvhiIC"))!=-1)
     {
         switch(opt) {
+        case 'q':
+            arg.debug--;
+            break;
         case 'v':
             arg.debug++;
             break;
@@ -94,6 +106,8 @@ void getargs(ServerConfig& arg, int argc, char *argv[])
     std::ifstream strm(argv[optind]);
     pvd::parseJSON(strm, arg.conf);
 
+    p2pReadOnly = arg.conf->getSubFieldT<pvd::PVScalar>("readOnly")->getAs<pvd::boolean>();
+
     unsigned version = arg.conf->getSubFieldT<pvd::PVUInt>("version")->get();
     if(version==0) {
         std::cerr<<"Warning: config file missing \"version\" key.  Assuming 1\n";
@@ -116,15 +130,19 @@ void getargs(ServerConfig& arg, int argc, char *argv[])
     }
 }
 
-GWServerChannelProvider::shared_pointer configure_client(const pvd::PVStructurePtr& conf)
+GWServerChannelProvider::shared_pointer configure_client(ServerConfig& arg, const pvd::PVStructurePtr& conf)
 {
+    std::string name(conf->getSubFieldT<pvd::PVString>("name")->get());
     std::string provider(conf->getSubFieldT<pvd::PVString>("provider")->get());
 
+    LOG(pva::logLevelInfo, "Configure client '%s' with provider '%s'", name.c_str(), provider.c_str());
+
     pva::Configuration::shared_pointer C(pva::ConfigurationBuilder()
                                          .add("EPICS_PVA_ADDR_LIST", conf->getSubFieldT<pvd::PVString>("addrlist")->get())
                                          .add("EPICS_PVA_AUTO_ADDR_LIST", conf->getSubFieldT<pvd::PVBoolean>("autoaddrlist")->get())
                                          .add("EPICS_PVA_SERVER_PORT", conf->getSubFieldT<pvd::PVScalar>("serverport")->getAs<pvd::uint16>())
                                          .add("EPICS_PVA_BROADCAST_PORT", conf->getSubFieldT<pvd::PVScalar>("bcastport")->getAs<pvd::uint16>())
+                                         .add("EPICS_PVA_DEBUG", arg.debug>=5 ? 5 : 0)
                                          .push_map()
                                          .build());
 
@@ -138,10 +156,17 @@ GWServerChannelProvider::shared_pointer configure_client(const pvd::PVStructureP
 
 pva::ServerContext::shared_pointer configure_server(ServerConfig& arg, const pvd::PVStructurePtr& conf)
 {
+    std::string name(conf->getSubFieldT<pvd::PVString>("name")->get());
+
+    LOG(pva::logLevelInfo, "Configure server '%s'", name.c_str());
+
     pva::Configuration::shared_pointer C(pva::ConfigurationBuilder()
                                          .add("EPICS_PVAS_INTF_ADDR_LIST", conf->getSubFieldT<pvd::PVString>("interface")->get())
+                                         .add("EPICS_PVAS_BEACON_ADDR_LIST", conf->getSubFieldT<pvd::PVString>("addrlist")->get())
+                                         .add("EPICS_PVAS_AUTO_BEACON_ADDR_LIST", conf->getSubFieldT<pvd::PVBoolean>("autoaddrlist")->get())
                                          .add("EPICS_PVAS_SERVER_PORT", conf->getSubFieldT<pvd::PVScalar>("serverport")->getAs<pvd::uint16>())
                                          .add("EPICS_PVAS_BROADCAST_PORT", conf->getSubFieldT<pvd::PVScalar>("bcastport")->getAs<pvd::uint16>())
+                                         .add("EPICS_PVA_DEBUG", arg.debug>=5 ? 5 : 0)
                                          .push_map()
                                          .build());
 
@@ -221,6 +246,8 @@ int main(int argc, char *argv[])
         epics::iocshRegister<int, const char*, &gwsr>("gwsr", "level", "channel");
         epics::iocshRegister<int, const char*, const char*, &gwcr>("gwcr", "level", "client", "channel");
 
+        libComRegister();
+        registerReadOnly();
         epics::registerRefCounter("ChannelCacheEntry", &ChannelCacheEntry::num_instances);
         epics::registerRefCounter("ChannelCacheEntry::CRequester", &ChannelCacheEntry::CRequester::num_instances);
         epics::registerRefCounter("GWChannel", &GWChannel::num_instances);
@@ -231,6 +258,21 @@ int main(int argc, char *argv[])
         theserver = &arg;
         getargs(arg, argc, argv);
 
+        pva::pvAccessLogLevel lvl;
+        if(arg.debug<0)
+            lvl = pva::logLevelError;
+        else if(arg.debug==0)
+            lvl = pva::logLevelWarn;
+        else if(arg.debug==1)
+            lvl = pva::logLevelInfo;
+        else if(arg.debug==2)
+            lvl = pva::logLevelDebug;
+        else if(arg.debug==3)
+            lvl = pva::logLevelTrace;
+        else if(arg.debug>=4)
+            lvl = pva::logLevelAll;
+        SET_LOG_LEVEL(lvl);
+
         pva::ClientFactory::start();
 
         pvd::PVStructureArray::const_svector arr;
@@ -249,7 +291,7 @@ int main(int argc, char *argv[])
             if(it!=arg.clients.end())
                 throw std::runtime_error(std::string("Duplicate client name not allowed : ")+name);
 
-            arg.clients[name] = configure_client(client);
+            arg.clients[name] = configure_client(arg, client);
         }
 
         arr = arg.conf->getSubFieldT<pvd::PVStructureArray>("servers")->view();

p2pApp/pva2pva.h

@@ -10,9 +10,9 @@
 typedef epicsGuard<epicsMutex> Guard;
 typedef epicsGuardRelease<epicsMutex> UnGuard;
 
-epicsShareExtern void registerGWClientIocsh();
-epicsShareExtern void gwServerShutdown();
-epicsShareExtern void gwClientShutdown();
-epicsShareExtern void registerReadOnly();
+void registerGWClientIocsh();
+void gwServerShutdown();
+void gwClientShutdown();
+void registerReadOnly();
 
 #endif // PVA2PVA_H

p2pApp/server.cpp

@@ -2,7 +2,9 @@
 
 #include <epicsAtomic.h>
 #include <epicsString.h>
+#include <epicsTimer.h>
 
+#include <pv/logger.h>
 #include <pv/pvIntrospect.h> /* for pvdVersion.h */
 #include <pv/epicsException.h>
 #include <pv/serverContext.h>
@@ -39,14 +41,8 @@ GWServerChannelProvider::channelFind(std::string const & channelName,
 
     if(!channelName.empty())
     {
-        std::string newName;
-
-        // rewrite name
-        newName = channelName;
-        //newName[0] = 'y';
-
-
-        ChannelCacheEntry::shared_pointer ent(cache.lookup(newName));
+        LOG(pva::logLevelDebug, "Searching for '%s'", channelName.c_str());
+        ChannelCacheEntry::shared_pointer ent(cache.lookup(channelName));
         if(ent) {
             found = true;
             ret = shared_from_this();
@@ -68,19 +64,13 @@ GWServerChannelProvider::createChannel(std::string const & channelName,
                                        short priority, std::string const & addressx)
 {
     GWChannel::shared_pointer ret;
-    std::string newName;
     std::string address = channelRequester->getRequesterName();
 
     if(!channelName.empty())
     {
-
-        // rewrite name
-        newName = channelName;
-        //newName[0] = 'y';
-
         Guard G(cache.cacheLock);
 
-        ChannelCacheEntry::shared_pointer ent(cache.lookup(newName)); // recursively locks cacheLock
+        ChannelCacheEntry::shared_pointer ent(cache.lookup(channelName)); // recursively locks cacheLock
 
         if(ent)
         {

p2pApp/server.h

@@ -48,7 +48,7 @@ struct ServerConfig {
     typedef std::map<std::string, epics::pvAccess::ServerContext::shared_pointer> servers_t;
     servers_t servers;
 
-    ServerConfig() :debug(0), interactive(true) {}
+    ServerConfig() :debug(1), interactive(true) {}
 
     void drop(const char *client, const char *channel);
     void status_server(int lvl, const char *server);

p2pApp/testmon.cpp

@@ -7,6 +7,7 @@
 #include <pv/epicsException.h>
 #include <pv/monitor.h>
 #include <pv/thread.h>
+#include <pv/serverContext.h>
 
 #include "server.h"
 

pdbApp/Makefile

@@ -5,23 +5,53 @@ include $(TOP)/configure/CONFIG
 #  ADD MACRO DEFINITIONS AFTER THIS LINE
 #=============================
 
+ifeq ($(OS_CLASS),RTEMS)
+# set by Base in configure/os/CONFIG.UnixCommon.Common
+# then clobbered by included RTEMS make/host.cfg
+# to drop the '-p'
+MKDIR = mkdir -p
+endif
+
 LIBRARY += qsrv
 
 SHRLIB_VERSION ?= $(EPICS_QSRV_ABI_MAJOR_VERSION).$(EPICS_QSRV_ABI_MINOR_VERSION)
 
 USR_CPPFLAGS += -I$(TOP)/common -I$(TOP)/p2pApp
 
+INC += pv/qsrv.h
+INC += pv/qsrvVersionNum.h
+
+EXPANDVARS += EPICS_QSRV_MAJOR_VERSION
+EXPANDVARS += EPICS_QSRV_MINOR_VERSION
+EXPANDVARS += EPICS_QSRV_MAINTENANCE_VERSION
+EXPANDVARS += EPICS_QSRV_DEVELOPMENT_FLAG
+EXPANDVARS += EPICS_QSRV_ABI_MAJOR_VERSION
+EXPANDVARS += EPICS_QSRV_ABI_MINOR_VERSION
+
+EXPANDFLAGS += $(foreach var,$(EXPANDVARS),-D$(var)="$(strip $($(var)))")
+
 qsrv_SRCS += pvif.cpp
 qsrv_SRCS += qsrv.cpp
 qsrv_SRCS += pdb.cpp
 qsrv_SRCS += pdbsingle.cpp
-#qsrv_SRCS += pvalink.cpp
 qsrv_SRCS += demo.cpp
 qsrv_SRCS += imagedemo.c
 
 ifdef BASE_3_16
 qsrv_SRCS += pdbgroup.cpp
 qsrv_SRCS += configparse.cpp
+
+qsrv_SRCS += dbf_copy.cpp
+qsrv_SRCS += tpool.cpp
+
+qsrv_SRCS += pvalink.cpp
+qsrv_SRCS += pvalink_lset.cpp
+qsrv_SRCS += pvalink_jlif.cpp
+qsrv_SRCS += pvalink_link.cpp
+qsrv_SRCS += pvalink_channel.cpp
+else
+
+qsrv_SRCS += pvalink_null.cpp
 endif
 
 qsrv_LIBS += pvAccess pvData
@@ -43,6 +73,11 @@ softIocPVA_LIBS += $(EPICS_BASE_IOC_LIBS)
 DBD += softIocPVA.dbd
 DBD += qsrv.dbd
 
+ifneq ($(FINAL_LOCATION),$(EPICS_BASE))
+# Copy from Base if we won't be installed there
+DB_INSTALLS += $(EPICS_BASE)/db/softIocExit.db
+endif
+
 softIocPVA_DBD += softIoc.dbd
 softIocPVA_DBD += PVAServerRegister.dbd
 softIocPVA_DBD += qsrv.dbd
@@ -53,3 +88,24 @@ include $(TOP)/configure/RULES
 #----------------------------------------
 #  ADD RULES AFTER THIS LINE
 
+# Can't use EXPAND as generated headers must appear
+# in O.Common, but EXPAND emits rules for O.$(T_A)
+../O.Common/pv/qsrvVersionNum.h: ../pv/qsrvVersionNum.h@
+	$(MKDIR) $(COMMON_DIR)/pv
+	$(EXPAND_TOOL) $(EXPANDFLAGS) $($@_EXPANDFLAGS) $< $@
+
+qsrv$(DEP): ../O.Common/pv/qsrvVersionNum.h
+pvalink$(DEP): ../O.Common/pv/qsrvVersionNum.h
+
+ifdef BASE_3_16
+../O.Common/qsrv.dbd: ../qsrv-new.dbd
+	$(CP) $< $@
+else
+../O.Common/qsrv.dbd: ../qsrv-old.dbd
+	$(CP) $< $@
+endif
+qsrv.dbd$(DEP):
+	@$(RM) $@
+	@echo "$(COMMONDEP_TARGET): ../Makefile" > $@
+
+../O.Common/softIocPVA.dbd: ../O.Common/qsrv.dbd

pdbApp/configparse.cpp

@@ -3,11 +3,15 @@
 
 #include <dbAccess.h>
 
+#include <dbAccess.h>
+#include <dbChannel.h>
+#include <dbStaticLib.h>
 #include <dbEvent.h>
 #include <dbLock.h>
 
 #include <pv/pvIntrospect.h>
 #include <pv/pvAccess.h>
+#include <pv/configuration.h>
 #include <pv/json.h>
 
 #define epicsExportSharedSymbols

pdbApp/dbf_copy.cpp

@@ -0,0 +1,246 @@
+
+#include <epicsStdio.h>
+#include <dbAccess.h>
+#include <dbChannel.h>
+#include <dbStaticLib.h>
+#include <dbLock.h>
+#include <dbEvent.h>
+#include <epicsString.h>
+#include <epicsVersion.h>
+
+#include <pv/status.h>
+#include <pv/bitSet.h>
+#include <pv/pvData.h>
+#include <pv/anyscalar.h>
+
+#define epicsExportSharedSymbols
+#include "pvif.h"
+
+namespace pvd = epics::pvData;
+
+// note that we handle DBF_ENUM differently than in pvif.cpp
+static
+pvd::ScalarType DBR2PVD(short dbr)
+{
+    switch(dbr) {
+#define CASE(BASETYPE, PVATYPE, DBFTYPE, PVACODE) case DBR_##DBFTYPE: return pvd::pv##PVACODE;
+#define CASE_SKIP_BOOL
+#define CASE_REAL_INT64
+#include "pv/typemap.h"
+#undef CASE_SKIP_BOOL
+#undef CASE_REAL_INT64
+#undef CASE
+    case DBF_ENUM: return pvd::pvUShort;
+    case DBF_STRING: return pvd::pvString;
+    }
+    throw std::invalid_argument("Unsupported DBR code");
+}
+
+long copyPVD2DBF(const pvd::PVField::const_shared_pointer& inraw,
+                 void *outbuf, short outdbf, long *outnReq)
+{
+    long nreq = outnReq ? *outnReq : 1;
+    if(!inraw || nreq <= 0 || INVALID_DB_REQ(outdbf)) return S_db_errArg;
+
+    pvd::ScalarType outpvd = DBR2PVD(outdbf);
+
+    pvd::PVField::const_shared_pointer in(inraw);
+
+    if(outdbf != DBF_STRING && in->getField()->getType() == pvd::structure) {
+        // assume NTEnum.
+        // index to string not requested, so attempt to treat .index as plain integer
+        in = static_cast<const pvd::PVStructure*>(in.get())->getSubField("index");
+        if(!in) return S_db_errArg;
+    }
+
+    if(in->getField()->getType() == pvd::structure) {
+        assert(outdbf == DBF_STRING);
+        char *outsbuf = (char*)outbuf;
+
+        // maybe NTEnum
+        // try index -> string
+        const pvd::PVStructure* sin = static_cast<const pvd::PVStructure*>(in.get());
+
+        pvd::PVScalar::const_shared_pointer index(sin->getSubField<pvd::PVScalar>("index"));
+        if(!index) return S_db_badField; // Not NTEnum, don't know how to handle...
+
+        // we will have an answer.
+        if(outnReq)
+            *outnReq = 1;
+
+        pvd::uint16 ival = index->getAs<pvd::uint16>();
+
+
+        pvd::PVStringArray::const_shared_pointer choices(sin->getSubField<pvd::PVStringArray>("choices"));
+
+        if(choices) {
+            pvd::PVStringArray::const_svector strs(choices->view());
+
+            if(ival < strs.size()) {
+                // found it!
+
+                const std::string& sval = strs[ival];
+                size_t slen = std::min(sval.size(), size_t(MAX_STRING_SIZE-1));
+                memcpy(outbuf, sval.c_str(), slen);
+                outsbuf[slen] = '\0';
+                return 0;
+            }
+        }
+        // didn't find it.  either no choices or index is out of range
+
+        // print numeric index
+        epicsSnprintf(outsbuf, MAX_STRING_SIZE, "%u", ival);
+        return 0;
+
+    } else if(in->getField()->getType() == pvd::scalarArray) {
+        const pvd::PVScalarArray* sarr = static_cast<const pvd::PVScalarArray*>(in.get());
+        pvd::shared_vector<const void> arr;
+        sarr->getAs(arr);
+        size_t elemsize = pvd::ScalarTypeFunc::elementSize(arr.original_type());
+
+        arr.slice(0, nreq*elemsize);
+        nreq = arr.size()/elemsize;
+
+        if(outdbf == DBF_STRING) {
+            char *outsbuf = (char*)outbuf;
+
+            // allocate a temp buffer of string[], ick...
+            pvd::shared_vector<std::string> strs(nreq); // alloc
+
+            pvd::castUnsafeV(nreq, pvd::pvString, strs.data(), arr.original_type(), arr.data());
+
+            for(long i =0; i<nreq; i++, outsbuf += MAX_STRING_SIZE) {
+                size_t slen = std::min(strs[i].size(), size_t(MAX_STRING_SIZE-1));
+                memcpy(outsbuf, strs[i].c_str(), slen);
+                outsbuf[slen] = '\0';
+            }
+
+        } else {
+            pvd::castUnsafeV(nreq, outpvd, outbuf, arr.original_type(), arr.data());
+        }
+
+        if(outnReq)
+            *outnReq = nreq;
+        return 0;
+
+    } else if(in->getField()->getType() == pvd::scalar) {
+        char *outsbuf = (char*)outbuf;
+        const pvd::PVScalar* sval = static_cast<const pvd::PVScalar*>(in.get());
+        pvd::AnyScalar val;
+        sval->getAs(val);
+
+        if(outdbf == DBF_STRING && val.type()==pvd::pvString) {
+            // std::string to char*
+            size_t len = std::min(val.as<std::string>().size(), size_t(MAX_STRING_SIZE-1));
+
+            memcpy(outbuf, val.as<std::string>().c_str(), len);
+            outsbuf[len] = '\0';
+
+        } else if(outdbf == DBF_STRING) {
+            // non-string to char*
+            std::string temp;
+
+            pvd::castUnsafeV(1, pvd::pvString, &temp, val.type(), val.unsafe());
+
+            size_t len = std::min(temp.size(), size_t(MAX_STRING_SIZE-1));
+
+            memcpy(outbuf, temp.c_str(), len);
+            outsbuf[len] = '\0';
+
+        } else {
+            // non-string to any
+            pvd::castUnsafeV(1, outpvd, outbuf, val.type(), val.unsafe());
+        }
+
+        if(outnReq)
+            *outnReq = 1;
+        return 0;
+
+    } else {
+        // struct array or other strangeness which I don't know how to handle
+        return S_dbLib_badField;
+    }
+}
+
+long copyDBF2PVD(const pvd::shared_vector<const void> &inbuf,
+                 const pvd::PVField::shared_pointer& outraw,
+                 pvd::BitSet& changed,
+                 const pvd::PVStringArray::const_svector &choices)
+{
+
+    pvd::ScalarType inpvd = inbuf.original_type();
+    size_t incnt = inbuf.size()/pvd::ScalarTypeFunc::elementSize(inpvd);
+
+    if(!outraw) return S_db_errArg;
+
+    pvd::PVField::shared_pointer out(outraw);
+
+    if(inpvd != pvd::pvString && out->getField()->getType() == pvd::structure) {
+        // assume NTEnum.
+        // string to index not requested, so attempt to treat .index as plain integer
+        out = static_cast<pvd::PVStructure*>(out.get())->getSubField("index");
+        if(!out) return S_db_errArg;
+    }
+
+    if(out->getField()->getType() == pvd::structure) {
+        assert(inpvd == pvd::pvString);
+
+        if(incnt==0)
+            return S_db_errArg; // Need at least one string
+
+        const pvd::shared_vector<const std::string> insbuf(pvd::static_shared_vector_cast<const std::string>(inbuf));
+        const std::string& instr(insbuf[0]);
+
+        // assume NTEnum
+        // try string to index, then parse
+        pvd::PVStructure* sout = static_cast<pvd::PVStructure*>(out.get());
+
+        pvd::PVScalar::shared_pointer index(sout->getSubField<pvd::PVScalar>("index"));
+        if(!index) return S_db_badField; // Not NTEnum, don't know how to handle...
+
+        pvd::uint16 result = pvd::uint16(-1);
+        bool match = false;
+
+        for(size_t i=0, N=std::min(size_t(0xffff), choices.size()); i<N; i++) {
+            if(choices[i] == instr) {
+                match = true;
+                result = pvd::uint16(i);
+            }
+        }
+
+        if(!match) {
+            // no choice string matched, so try to parse as integer
+
+            try{
+                result = pvd::castUnsafe<pvd::uint16>(instr);
+            }catch(std::exception&){
+                return S_db_errArg;
+            }
+        }
+
+        index->putFrom(result);
+
+        out = index;
+
+    } else if(out->getField()->getType() == pvd::scalarArray) {
+        pvd::PVScalarArray* sarr = static_cast<pvd::PVScalarArray*>(out.get());
+
+        sarr->putFrom(inbuf);
+
+    } else if(out->getField()->getType() == pvd::scalar) {
+        pvd::PVScalar* sval = static_cast<pvd::PVScalar*>(out.get());
+
+        if(incnt==0) return S_db_errArg;
+
+        pvd::AnyScalar val(inpvd, inbuf.data());
+
+        sval->putFrom(val);
+
+    } else {
+        // struct array or other strangeness which I don't know how to handle
+        return S_db_badField;
+    }
+
+    changed.set(out->getFieldOffset());
+    return 0;
+}

pdbApp/pdb.cpp

@@ -10,11 +10,14 @@
 #include <epicsStdio.h>
 
 #include <dbAccess.h>
+#include <dbChannel.h>
+#include <dbStaticLib.h>
 #include <dbNotify.h>
 
 #include <dbEvent.h>
 
 #include <pv/pvAccess.h>
+#include <pv/configuration.h>
 
 #define epicsExportSharedSymbols
 #include "helper.h"
@@ -196,9 +199,9 @@ struct PDBProcessor
                 GroupConfig conf;
                 GroupConfig::parse(json, conf);
                 if(!conf.warning.empty())
-                    fprintf(stderr, "%s: warning(s) from info(Q:group, ...\n%s", rec.record()->name, conf.warning.c_str());
+                    fprintf(stderr, "%s: warning(s) from info(Q:group, ...\n%s", rec.name(), conf.warning.c_str());
 
-                recbase = rec.record()->name;
+                recbase = rec.name();
                 recbase += ".";
 
                 for(GroupConfig::groups_t::const_iterator git=conf.groups.begin(), gend=conf.groups.end();
@@ -583,8 +586,24 @@ pva::ChannelFind::shared_pointer
 PDBProvider::channelList(pva::ChannelListRequester::shared_pointer const & requester)
 {
     pva::ChannelFind::shared_pointer ret;
-    requester->channelListResult(pvd::Status(pvd::Status::STATUSTYPE_ERROR, "not supported"),
-                                 ret, pvd::PVStringArray::const_svector(), true);
+    pvd::PVStringArray::svector names;
+    for(pdbRecordIterator rec; !rec.done(); rec.next())
+    {
+        names.push_back(rec.name());
+    }
+    {
+        epicsGuard<epicsMutex> G(transient_pv_map.mutex());
+
+        for(persist_pv_map_t::const_iterator it=persist_pv_map.begin(), end=persist_pv_map.end();
+            it != end; ++it)
+        {
+            names.push_back(it->first);
+        }
+    }
+    // check for duplicates?
+    requester->channelListResult(pvd::Status::Ok,
+                                 shared_from_this(),
+                                 pvd::freeze(names), false);
     return ret;
 }
 

pdbApp/pdb.h

@@ -31,23 +31,30 @@ struct PDBPV
 };
 
 struct epicsShareClass PDBProvider : public epics::pvAccess::ChannelProvider,
-                     public std::tr1::enable_shared_from_this<PDBProvider>
+                                     public epics::pvAccess::ChannelFind,
+                                     public std::tr1::enable_shared_from_this<PDBProvider>
 {
     POINTER_DEFINITIONS(PDBProvider);
 
     explicit PDBProvider(const epics::pvAccess::Configuration::const_shared_pointer& =epics::pvAccess::Configuration::const_shared_pointer());
     virtual ~PDBProvider();
-    virtual void destroy();
-    virtual std::string getProviderName();
+
+    // ChannelProvider
+    virtual void destroy() OVERRIDE FINAL;
+    virtual std::string getProviderName() OVERRIDE FINAL;
     virtual epics::pvAccess::ChannelFind::shared_pointer channelFind(std::string const & channelName,
-                                             epics::pvAccess::ChannelFindRequester::shared_pointer const & channelFindRequester);
-    virtual epics::pvAccess::ChannelFind::shared_pointer channelList(epics::pvAccess::ChannelListRequester::shared_pointer const & channelListRequester);
+                                             epics::pvAccess::ChannelFindRequester::shared_pointer const & channelFindRequester) OVERRIDE FINAL;
+    virtual epics::pvAccess::ChannelFind::shared_pointer channelList(epics::pvAccess::ChannelListRequester::shared_pointer const & channelListRequester) OVERRIDE FINAL;
     virtual epics::pvAccess::Channel::shared_pointer createChannel(std::string const & channelName,
                                                                    epics::pvAccess::ChannelRequester::shared_pointer const & channelRequester,
-                                           short priority = PRIORITY_DEFAULT);
+                                           short priority = PRIORITY_DEFAULT) OVERRIDE FINAL;
     virtual epics::pvAccess::Channel::shared_pointer createChannel(std::string const & channelName,
                                                                    epics::pvAccess::ChannelRequester::shared_pointer const & channelRequester,
-                                                                   short priority, std::string const & address);
+                                                                   short priority, std::string const & address) OVERRIDE FINAL;
+
+    // ChannelFind
+    virtual std::tr1::shared_ptr<ChannelProvider> getChannelProvider() OVERRIDE FINAL { return shared_from_this(); }
+    virtual void cancel() OVERRIDE FINAL {/* our channelFind() is synchronous, so nothing to cancel */}
 
     typedef std::map<std::string, PDBPV::shared_pointer> persist_pv_map_t;
     persist_pv_map_t persist_pv_map;

pdbApp/pdbgroup.cpp

@@ -6,6 +6,12 @@
 
 #include <epicsAtomic.h>
 #include <dbAccess.h>
+#include <dbChannel.h>
+#include <dbStaticLib.h>
+
+#include <pv/pvAccess.h>
+#include <pv/configuration.h>
+#include <pv/epicsException.h>
 
 #define epicsExportSharedSymbols
 #include "helper.h"
@@ -31,30 +37,10 @@ void pdb_group_event(void *user_arg, struct dbChannel *chan,
         PDBGroupPV::shared_pointer self(std::tr1::static_pointer_cast<PDBGroupPV>(((PDBGroupPV*)evt->self)->shared_from_this()));
         PDBGroupPV::Info& info = self->members[idx];
 
+        PDBGroupPV::interested_remove_t temp;
         {
-            bool doPost;
-            {
-                Guard G(self->lock);
 
-                if(!(evt->dbe_mask&DBE_PROPERTY)) {
-                    if(!info.had_initial_VALUE) {
-                        info.had_initial_VALUE = true;
-                        assert(self->initial_waits>0);
-                        self->initial_waits--;
-                    }
-                } else {
-                    if(!info.had_initial_PROPERTY) {
-                        info.had_initial_PROPERTY = true;
-                        assert(self->initial_waits>0);
-                        self->initial_waits--;
-                    }
-                }
-
-                doPost = self->initial_waits==0;
-
-                if(doPost)
-                    self->interested_iterating = true;
-            }
+            Guard G(self->lock);
 
             self->scratch.clear();
             if(evt->dbe_mask&DBE_PROPERTY || !self->monatomic)
@@ -75,35 +61,50 @@ void pdb_group_event(void *user_arg, struct dbChannel *chan,
                 }
             }
 
-            if(!doPost) return; // don't post() until all subscriptions get initial updates
-
-            FOREACH(PDBGroupPV::interested_t::const_iterator, it, end, self->interested) {
-                PDBGroupMonitor& mon = **it;
-                mon.post(self->scratch);
+            if(!(evt->dbe_mask&DBE_PROPERTY)) {
+                if(!info.had_initial_VALUE) {
+                    info.had_initial_VALUE = true;
+                    assert(self->initial_waits>0);
+                    self->initial_waits--;
+                }
+            } else {
+                if(!info.had_initial_PROPERTY) {
+                    info.had_initial_PROPERTY = true;
+                    assert(self->initial_waits>0);
+                    self->initial_waits--;
+                }
             }
 
-            PDBGroupPV::interested_remove_t temp;
-            {
-                Guard G(self->lock);
+            if(self->initial_waits==0) {
+                self->interested_iterating = true;
 
-                assert(self->interested_iterating);
-
-                while(!self->interested_add.empty()) {
-                    PDBGroupPV::interested_t::iterator first(self->interested_add.begin());
-                    self->interested.insert(*first);
-                    self->interested_add.erase(first);
+                FOREACH(PDBGroupPV::interested_t::const_iterator, it, end, self->interested) {
+                    PDBGroupMonitor& mon = **it;
+                    mon.post(G, self->scratch); // G unlocked
                 }
 
-                temp.swap(self->interested_remove);
-                for(PDBGroupPV::interested_remove_t::iterator it(temp.begin()),
-                    end(temp.end()); it != end; ++it)
                 {
-                    self->interested.erase(static_cast<PDBGroupMonitor*>(it->get()));
+                    Guard G(self->lock);
+
+                    assert(self->interested_iterating);
+
+                    while(!self->interested_add.empty()) {
+                        PDBGroupPV::interested_t::iterator first(self->interested_add.begin());
+                        self->interested.insert(*first);
+                        self->interested_add.erase(first);
+                    }
+
+                    temp.swap(self->interested_remove);
+                    for(PDBGroupPV::interested_remove_t::iterator it(temp.begin()),
+                        end(temp.end()); it != end; ++it)
+                    {
+                        self->interested.erase(static_cast<PDBGroupMonitor*>(it->get()));
+                    }
+
+                    self->interested_iterating = false;
+
+                    self->finalizeMonitor();
                 }
-
-                self->interested_iterating = false;
-
-                self->finalizeMonitor();
             }
         }
 
@@ -144,45 +145,40 @@ PDBGroupPV::connect(const std::tr1::shared_ptr<PDBProvider>& prov,
 // caller must not hold lock
 void PDBGroupPV::addMonitor(PDBGroupMonitor *mon)
 {
-    bool needpost = false;
-    {
-        Guard G(lock);
-        if(interested.empty() && interested_add.empty()) {
-            // first monitor
-            // start subscriptions
+    Guard G(lock);
+    if(interested.empty() && interested_add.empty()) {
+        // first monitor
+        // start subscriptions
 
-            size_t ievts = 0;
-            for(size_t i=0; i<members.size(); i++) {
-                PDBGroupPV::Info& info = members[i];
+        size_t ievts = 0;
+        for(size_t i=0; i<members.size(); i++) {
+            PDBGroupPV::Info& info = members[i];
 
-                if(!!info.evt_VALUE) {
-                    db_event_enable(info.evt_VALUE.subscript);
-                    db_post_single_event(info.evt_VALUE.subscript);
-                    ievts++;
-                    info.had_initial_VALUE = false;
-                } else {
-                    info.had_initial_VALUE = true;
-                }
-                assert(info.evt_PROPERTY.subscript);
-                db_event_enable(info.evt_PROPERTY.subscript);
-                db_post_single_event(info.evt_PROPERTY.subscript);
+            if(!!info.evt_VALUE) {
+                db_event_enable(info.evt_VALUE.subscript);
+                db_post_single_event(info.evt_VALUE.subscript);
                 ievts++;
-                info.had_initial_PROPERTY = false;
+                info.had_initial_VALUE = false;
+            } else {
+                info.had_initial_VALUE = true;
             }
-            initial_waits = ievts;
+            assert(info.evt_PROPERTY.subscript);
+            db_event_enable(info.evt_PROPERTY.subscript);
+            db_post_single_event(info.evt_PROPERTY.subscript);
+            ievts++;
+            info.had_initial_PROPERTY = false;
+        }
+        initial_waits = ievts;
 
-        } else if(initial_waits==0) {
-            // new subscriber and already had initial update
-            needpost = true;
-        } // else new subscriber, but no initial update.  so just wait
+    } else if(initial_waits==0) {
+        // new subscriber and already had initial update
+        mon->post(G);
+    } // else new subscriber, but no initial update.  so just wait
 
-        if(interested_iterating)
-            interested_add.insert(mon);
-        else
-            interested.insert(mon);
-    }
-    if(needpost)
-        mon->post();
+    if(interested_iterating)
+        interested_add.insert(mon);
+    else
+        interested.insert(mon);
 }
 
 // caller must not hold lock
@@ -280,7 +276,8 @@ PDBGroupChannel::createMonitor(
     PDBGroupMonitor::shared_pointer ret(new PDBGroupMonitor(pv->shared_from_this(), requester, pvRequest));
     ret->weakself = ret;
     assert(!!pv->complete);
-    ret->connect(pv->complete);
+    guard_t G(pv->lock);
+    ret->connect(G, pv->complete);
     return ret;
 }
 
@@ -411,7 +408,7 @@ void PDBGroupPut::get()
 PDBGroupMonitor::PDBGroupMonitor(const PDBGroupPV::shared_pointer& pv,
                  const epics::pvAccess::MonitorRequester::weak_pointer &requester,
                  const pvd::PVStructure::shared_pointer& pvReq)
-    :BaseMonitor(requester, pvReq)
+    :BaseMonitor(pv->lock, requester, pvReq)
     ,pv(pv)
 {
     epics::atomic::increment(num_instances);
@@ -446,5 +443,5 @@ void PDBGroupMonitor::onStop()
 void PDBGroupMonitor::requestUpdate()
 {
     Guard G(pv->lock);
-    post();
+    post(G);
 }

pdbApp/pdbgroup.h

@@ -124,7 +124,7 @@ struct epicsShareClass PDBGroupPV : public PDBPV
     virtual
     epics::pvAccess::Channel::shared_pointer
         connect(const std::tr1::shared_ptr<PDBProvider>& prov,
-                const epics::pvAccess::ChannelRequester::shared_pointer& req) OVERRIDE;
+                const epics::pvAccess::ChannelRequester::shared_pointer& req) OVERRIDE FINAL;
 
     void addMonitor(PDBGroupMonitor*);
     void removeMonitor(PDBGroupMonitor*);
@@ -149,12 +149,12 @@ struct epicsShareClass PDBGroupChannel : public BaseChannel,
 
     virtual epics::pvAccess::ChannelPut::shared_pointer createChannelPut(
             epics::pvAccess::ChannelPutRequester::shared_pointer const & requester,
-            epics::pvData::PVStructure::shared_pointer const & pvRequest);
+            epics::pvData::PVStructure::shared_pointer const & pvRequest) OVERRIDE FINAL;
     virtual epics::pvData::Monitor::shared_pointer createMonitor(
             epics::pvData::MonitorRequester::shared_pointer const & requester,
-            epics::pvData::PVStructure::shared_pointer const & pvRequest);
+            epics::pvData::PVStructure::shared_pointer const & pvRequest) OVERRIDE FINAL;
 
-    virtual void printInfo(std::ostream& out);
+    virtual void printInfo(std::ostream& out) OVERRIDE FINAL;
 };
 
 struct PDBGroupPut : public epics::pvAccess::ChannelPut,
@@ -180,16 +180,14 @@ struct PDBGroupPut : public epics::pvAccess::ChannelPut,
                 const epics::pvData::PVStructure::shared_pointer& pvReq);
     virtual ~PDBGroupPut();
 
-    virtual void destroy() { pvif.clear(); channel.reset(); requester.reset(); }
-    virtual void lock() {}
-    virtual void unlock() {}
-    virtual std::tr1::shared_ptr<epics::pvAccess::Channel> getChannel() { return channel; }
-    virtual void cancel() {}
-    virtual void lastRequest() {}
+    virtual void destroy() OVERRIDE FINAL { pvif.clear(); channel.reset(); requester.reset(); }
+    virtual std::tr1::shared_ptr<epics::pvAccess::Channel> getChannel() OVERRIDE FINAL { return channel; }
+    virtual void cancel() OVERRIDE FINAL {}
+    virtual void lastRequest() OVERRIDE FINAL {}
     virtual void put(
             epics::pvData::PVStructure::shared_pointer const & pvPutStructure,
-            epics::pvData::BitSet::shared_pointer const & putBitSet);
-    virtual void get();
+            epics::pvData::BitSet::shared_pointer const & putBitSet) OVERRIDE FINAL;
+    virtual void get() OVERRIDE FINAL;
 };
 
 struct PDBGroupMonitor : public BaseMonitor
@@ -207,11 +205,11 @@ struct PDBGroupMonitor : public BaseMonitor
                      const epics::pvData::PVStructure::shared_pointer& pvReq);
     virtual ~PDBGroupMonitor();
 
-    virtual void onStart();
-    virtual void onStop();
-    virtual void requestUpdate();
+    virtual void onStart() OVERRIDE FINAL;
+    virtual void onStop() OVERRIDE FINAL;
+    virtual void requestUpdate() OVERRIDE FINAL;
 
-    virtual void destroy();
+    virtual void destroy() OVERRIDE FINAL;
 
 };
 

pdbApp/pdbsingle.cpp

@@ -3,10 +3,15 @@
 #include <string.h>
 
 #include <dbAccess.h>
+#include <dbChannel.h>
+#include <dbStaticLib.h>
 #include <epicsAtomic.h>
 #include <errlog.h>
+#include <dbNotify.h>
 
 #include <pv/epicsException.h>
+#include <pv/pvAccess.h>
+#include <pv/configuration.h>
 
 #define epicsExportSharedSymbols
 #include "helper.h"
@@ -30,42 +35,31 @@ void pdb_single_event(void *user_arg, struct dbChannel *chan,
     DBEvent *evt=(DBEvent*)user_arg;
     try{
         PDBSinglePV::shared_pointer self(std::tr1::static_pointer_cast<PDBSinglePV>(((PDBSinglePV*)evt->self)->shared_from_this()));
+        PDBSinglePV::interested_remove_t temp;
         {
-            bool doPost;
-            {
-                Guard G(self->lock);
-
-                if(evt->dbe_mask&DBE_PROPERTY)
-                    self->hadevent_PROPERTY = true;
-                else
-                    self->hadevent_VALUE = true;
-
-                doPost = self->hadevent_VALUE && self->hadevent_PROPERTY;
-
-                if(doPost)
-                    self->interested_iterating = true;
-            }
+            Guard G(self->lock);
 
             // we have exclusive use of self->scratch
             self->scratch.clear();
             {
                 DBScanLocker L(dbChannelRecord(self->chan));
+                // dbGet() into self->complete
                 self->pvif->put(self->scratch, evt->dbe_mask, pfl);
             }
 
-            if(!doPost)
-                return;
+            if(evt->dbe_mask&DBE_PROPERTY)
+                self->hadevent_PROPERTY = true;
+            else
+                self->hadevent_VALUE = true;
 
-            FOREACH(PDBSinglePV::interested_t::const_iterator, it, end, self->interested) {
-                PDBSingleMonitor& mon = **it;
-                mon.post(self->scratch);
-            }
+            if(self->hadevent_VALUE && self->hadevent_PROPERTY) {
+                self->interested_iterating = true;
 
-            PDBSinglePV::interested_remove_t temp;
-            {
-                Guard G(self->lock);
-
-                assert(self->interested_iterating);
+                FOREACH(PDBSinglePV::interested_t::const_iterator, it, end, self->interested) {
+                    PDBSingleMonitor& mon = **it;
+                    // from self->complete into monitor queue element
+                    mon.post(G, self->scratch); // G unlocked during call
+                }
 
                 while(!self->interested_add.empty()) {
                     PDBSinglePV::interested_t::iterator first(self->interested_add.begin());
@@ -139,33 +133,28 @@ PDBSinglePV::connect(const std::tr1::shared_ptr<PDBProvider>& prov,
 
 void PDBSinglePV::addMonitor(PDBSingleMonitor* mon)
 {
-    bool needpost = false;
-    {
-        Guard G(lock);
-        if(interested.empty() && interested_add.empty()) {
-            // first monitor
-            // start subscription
+    Guard G(lock);
+    if(interested.empty() && interested_add.empty()) {
+        // first monitor
+        // start subscription
 
-            hadevent_VALUE = false;
-            hadevent_PROPERTY = false;
-            db_event_enable(evt_VALUE.subscript);
-            db_event_enable(evt_PROPERTY.subscript);
-            db_post_single_event(evt_VALUE.subscript);
-            db_post_single_event(evt_PROPERTY.subscript);
+        hadevent_VALUE = false;
+        hadevent_PROPERTY = false;
+        db_event_enable(evt_VALUE.subscript);
+        db_event_enable(evt_PROPERTY.subscript);
+        db_post_single_event(evt_VALUE.subscript);
+        db_post_single_event(evt_PROPERTY.subscript);
 
-        } if(hadevent_VALUE && hadevent_PROPERTY) {
-            // new subscriber and already had initial update
-            needpost = true;
-        } // else new subscriber, but no initial update.  so just wait
+    } else if(hadevent_VALUE && hadevent_PROPERTY) {
+        // new subscriber and already had initial update
+        mon->post(G);
+    } // else new subscriber, but no initial update.  so just wait
 
-        if(interested_iterating) {
-            interested_add.insert(mon);
-        } else {
-            interested.insert(mon);
-        }
+    if(interested_iterating) {
+        interested_add.insert(mon);
+    } else {
+        interested.insert(mon);
     }
-    if(needpost)
-        mon->post();
 }
 
 void PDBSinglePV::removeMonitor(PDBSingleMonitor* mon)
@@ -233,7 +222,8 @@ PDBSingleChannel::createMonitor(
     PDBSingleMonitor::shared_pointer ret(new PDBSingleMonitor(pv->shared_from_this(), requester, pvRequest));
     ret->weakself = ret;
     assert(!!pv->complete);
-    ret->connect(pv->complete);
+    guard_t G(pv->lock);
+    ret->connect(G, pv->complete);
     return ret;
 }
 
@@ -428,7 +418,7 @@ void PDBSinglePut::get()
 PDBSingleMonitor::PDBSingleMonitor(const PDBSinglePV::shared_pointer& pv,
                  const requester_t::shared_pointer& requester,
                  const pvd::PVStructure::shared_pointer& pvReq)
-    :BaseMonitor(requester, pvReq)
+    :BaseMonitor(pv->lock, requester, pvReq)
     ,pv(pv)
 {
     epics::atomic::increment(num_instances);
@@ -460,5 +450,5 @@ void PDBSingleMonitor::onStop()
 void PDBSingleMonitor::requestUpdate()
 {
     guard_t G(pv->lock);
-    post();
+    post(G);
 }

pdbApp/pdbsingle.h

@@ -62,9 +62,10 @@ struct epicsShareClass PDBSinglePV : public PDBPV
 
     void activate();
 
+    virtual
     epics::pvAccess::Channel::shared_pointer
         connect(const std::tr1::shared_ptr<PDBProvider>& prov,
-                const epics::pvAccess::ChannelRequester::shared_pointer& req);
+                const epics::pvAccess::ChannelRequester::shared_pointer& req) OVERRIDE FINAL;
 
     void addMonitor(PDBSingleMonitor*);
     void removeMonitor(PDBSingleMonitor*);
@@ -120,16 +121,14 @@ struct PDBSinglePut : public epics::pvAccess::ChannelPut,
                  const epics::pvData::PVStructure::shared_pointer& pvReq);
     virtual ~PDBSinglePut();
 
-    virtual void destroy() { pvif.reset(); channel.reset(); requester.reset(); }
-    virtual void lock() {}
-    virtual void unlock() {}
-    virtual std::tr1::shared_ptr<epics::pvAccess::Channel> getChannel() { return channel; }
-    virtual void cancel();
-    virtual void lastRequest() {}
+    virtual void destroy() OVERRIDE FINAL { pvif.reset(); channel.reset(); requester.reset(); }
+    virtual std::tr1::shared_ptr<epics::pvAccess::Channel> getChannel() OVERRIDE FINAL { return channel; }
+    virtual void cancel() OVERRIDE FINAL;
+    virtual void lastRequest() OVERRIDE FINAL {}
     virtual void put(
             epics::pvData::PVStructure::shared_pointer const & pvPutStructure,
-            epics::pvData::BitSet::shared_pointer const & putBitSet);
-    virtual void get();
+            epics::pvData::BitSet::shared_pointer const & putBitSet) OVERRIDE FINAL;
+    virtual void get() OVERRIDE FINAL;
 };
 
 struct PDBSingleMonitor : public BaseMonitor
@@ -145,11 +144,11 @@ struct PDBSingleMonitor : public BaseMonitor
                      const epics::pvData::PVStructure::shared_pointer& pvReq);
     virtual ~PDBSingleMonitor();
 
-    virtual void onStart();
-    virtual void onStop();
-    virtual void requestUpdate();
+    virtual void onStart() OVERRIDE FINAL;
+    virtual void onStop() OVERRIDE FINAL;
+    virtual void requestUpdate() OVERRIDE FINAL;
 
-    virtual void destroy();
+    virtual void destroy() OVERRIDE FINAL;
 };
 
 #endif // PDBSINGLE_H

pdbApp/pv/qsrv.h

@@ -0,0 +1,64 @@
+#ifndef PV_QSRV_H
+#define PV_QSRV_H
+
+#include <epicsVersion.h>
+#include <shareLib.h>
+
+#ifndef VERSION_INT
+#  define VERSION_INT(V,R,M,P) ( ((V)<<24) | ((R)<<16) | ((M)<<8) | (P))
+#endif
+
+/* generated header with EPICS_QSRV_*_VERSION macros */
+#  include <pv/qsrvVersionNum.h>
+
+#define QSRV_VERSION_INT VERSION_INT(EPICS_QSRV_MAJOR_VERSION, EPICS_QSRV_MINOR_VERSION, EPICS_QSRV_MAINTENANCE_VERSION, !(EPICS_QSRV_DEVELOPMENT_FLAG))
+
+#define QSRV_ABI_VERSION_INT VERSION_INT(EPICS_QSRV_ABI_MAJOR_VERSION, EPICS_QSRV_ABI_MINOR_VERSION, 0, 0)
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct link; /* aka. DBLINK from link.h */
+
+/** returns QSRV_VERSION_INT captured at compilation time */
+epicsShareExtern unsigned qsrvVersion(void);
+
+/** returns QSRV_ABI_VERSION_INT captured at compilation time */
+epicsShareExtern unsigned qsrvABIVersion(void);
+
+epicsShareFunc void testqsrvWaitForLinkEvent(struct link *plink);
+
+/** Call before testIocShutdownOk()
+ @code
+   testdbPrepare();
+   ...
+   testIocInitOk();
+   ...
+   testqsrvShutdownOk();
+   testIocShutdownOk();
+   testqsrvCleanup();
+   testdbCleanup();
+ @endcode
+ */
+epicsShareExtern void testqsrvShutdownOk(void);
+
+/** Call after testIocShutdownOk() and before testdbCleanup()
+ @code
+   testdbPrepare();
+   ...
+   testIocInitOk();
+   ...
+   testqsrvShutdownOk();
+   testIocShutdownOk();
+   testqsrvCleanup();
+   testdbCleanup();
+ @endcode
+ */
+epicsShareExtern void testqsrvCleanup(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* PV_QSRV_H */

pdbApp/pv/qsrvVersionNum.h@

@@ -0,0 +1,9 @@
+#ifndef PV_QSRV_H
+#  error qsrvVersionNum.h should never be included directly.  Include <pv/qsrv.h>
+#endif
+#define EPICS_QSRV_MAJOR_VERSION @EPICS_QSRV_MAJOR_VERSION@
+#define EPICS_QSRV_MINOR_VERSION @EPICS_QSRV_MINOR_VERSION@
+#define EPICS_QSRV_MAINTENANCE_VERSION @EPICS_QSRV_MAINTENANCE_VERSION@
+#define EPICS_QSRV_DEVELOPMENT_FLAG @EPICS_QSRV_DEVELOPMENT_FLAG@
+#define EPICS_QSRV_ABI_MAJOR_VERSION @EPICS_QSRV_ABI_MAJOR_VERSION@
+#define EPICS_QSRV_ABI_MINOR_VERSION @EPICS_QSRV_ABI_MINOR_VERSION@

pdbApp/pvalink.h

@@ -4,31 +4,69 @@
 #include <set>
 #include <map>
 
+#ifdef epicsExportSharedSymbols
+#   define pvalinkEpicsExportSharedSymbols
+#   undef epicsExportSharedSymbols
+#endif
+
 #define EPICS_DBCA_PRIVATE_API
 #include <epicsGuard.h>
 #include <dbAccess.h>
 #include <dbCommon.h>
 #include <dbLink.h>
 #include <dbScan.h>
-#include <epicsExport.h>
 #include <errlog.h>
 #include <initHooks.h>
 #include <alarm.h>
 #include <epicsExit.h>
 #include <epicsAtomic.h>
-#include <epicsThreadPool.h>
 #include <link.h>
 #include <dbJLink.h>
+#include <errlog.h>
+#include <epicsThread.h>
+#include <epicsMutex.h>
+#include <epicsEvent.h>
+#include <dbChannel.h>
+#include <dbStaticLib.h>
+#include <dbLock.h>
+#include <dbEvent.h>
+#include <epicsVersion.h>
 
-#include <pv/pvAccess.h>
-#include <pv/clientFactory.h>
+#include <pv/status.h>
+#include <pv/bitSet.h>
+#include <pv/pvData.h>
+
+#include <pva/client.h>
+#include <pv/anyscalar.h>
+#include <pv/thread.h>
+#include <pv/lock.h>
+#include <pv/iocshelper.h>
+
+#include <pv/sharedPtr.h>
+
+#ifdef pvalinkEpicsExportSharedSymbols
+#   define epicsExportSharedSymbols
+#	undef pvalinkEpicsExportSharedSymbols
+#endif
 
 #include "helper.h"
-#include "iocshelper.h"
 #include "pvif.h"
+#include "tpool.h"
 
-extern int pvaLinkDebug;
-extern int pvaLinkIsolate;
+extern "C" {
+    epicsShareExtern int pvaLinkDebug;
+    epicsShareExtern int pvaLinkIsolate;
+    epicsShareExtern int pvaLinkNWorkers;
+}
+
+#if 0
+#  define TRACE(X) std::cerr<<"PVAL "<<__func__<<" " X <<"\n"
+#else
+#  define TRACE(X) do {} while(0)
+#endif
+
+// pvaLink and pvaLinkChannel have ->debug
+#define DEBUG(OBJ, X) do{ if((OBJ)->debug) std::cout X<<"\n"; }while(0)
 
 namespace pvalink {
 
@@ -41,289 +79,173 @@ typedef epicsGuardRelease<pvd::Mutex> UnGuard;
 struct pvaLink;
 struct pvaLinkChannel;
 
-struct pvaGlobal_t {
-    pva::ChannelProvider::shared_pointer provider;
+extern lset pva_lset;
+extern jlif lsetPVA;
 
-    pvd::StructureConstPtr reqtype;
-    pvd::PVDataCreatePtr create;
+struct pvaLinkConfig : public jlink
+{
+    // configuration, output of jlif parsing
+    //! Channel (aka PV) name string
+    std::string channelName;
+    //! sub-field within addressed PVStructure
+    std::string fieldName;
+
+    size_t queueSize;
+
+    enum pp_t {
+        NPP,
+        Default, // for put() only.  For monitor, treated as NPP
+        PP,      // for put() only,  For monitor, treated as NPP
+        CP,      // for monitor only, put treats as pp
+        CPP,     // for monitor only, put treats as pp
+    } pp;
+    enum ms_t {
+        NMS,
+        MS,
+        MSI,
+    } ms;
+
+    bool defer, pipeline, time, retry, local, always;
+    int monorder;
+
+    // internals used by jlif parsing
+    std::string jkey;
+
+    pvaLinkConfig();
+    virtual ~pvaLinkConfig();
+};
+
+struct pvaGlobal_t {
+    pvac::ClientProvider provider_local,
+                         provider_remote;
+
+    const pvd::PVDataCreatePtr create;
+
+    WorkQueue queue;
 
     pvd::Mutex lock;
 
-    struct Scan {
-        // the PVA channel which triggered this scan
-        std::tr1::weak_ptr<pvaLinkChannel> chan;
-        bool usecached;
-        Scan() :usecached(false) {}
-    };
+    bool running; // set after dbEvent is initialized and safe to use
 
-    epicsThreadPrivate<Scan> scanmagic;
-    epicsThreadPool *scanpool;
-
-    typedef std::map<std::string, std::tr1::shared_ptr<pvaLinkChannel> > channels_t;
+    // a tuple of channel name and printed pvRequest (or Monitor)
+    typedef std::pair<std::string, std::string> channels_key_t;
+    // pvaLinkChannel dtor prunes dead entires
+    typedef std::map<channels_key_t, std::tr1::weak_ptr<pvaLinkChannel> > channels_t;
+    // Cache of active Channels (really about caching Monitor)
     channels_t channels;
 
-    std::tr1::shared_ptr<pvaLinkChannel> connect(const char *name);
-
     pvaGlobal_t();
-    ~pvaGlobal_t()
-    {
-        provider->destroy();
-        epicsThreadPoolDestroy(scanpool);
-    }
+    ~pvaGlobal_t();
 };
 extern pvaGlobal_t *pvaGlobal;
 
-struct pvaLinkChannel : public pva::ChannelRequester, pva::MonitorRequester,
-        std::tr1::enable_shared_from_this<pvaLinkChannel>
+struct pvaLinkChannel : public pvac::ClientChannel::MonitorCallback,
+                        public pvac::ClientChannel::PutCallback,
+                        public epicsThreadRunable,
+                        public std::tr1::enable_shared_from_this<pvaLinkChannel>
 {
-    const std::string name;
+    const pvaGlobal_t::channels_key_t key; // tuple of (channelName, pvRequest key)
+    const pvd::PVStructure::const_shared_pointer pvRequest; // used with monitor
 
-    static size_t refs;
-
-    typedef std::set<pvaLink*> links_t;
-    links_t links;
+    static size_t num_instances;
 
     pvd::Mutex lock;
+    epicsEvent run_done; // used by testing code
 
-    pva::Channel::shared_pointer chan;
+    pvac::ClientChannel chan;
+    pvac::Monitor op_mon;
+    pvac::Operation op_put;
 
-    pva::Monitor::shared_pointer chanmon;
-    //pva::ChannelPut::shared_pointer chanput;
+    std::string providerName;
+    size_t num_disconnect, num_type_change;
+    bool connected;
+    bool connected_latched; // connection status at the run()
+    bool isatomic;
+    bool queued; // added to WorkQueue
+    bool debug; // set if any jlink::debug is set
+    std::tr1::shared_ptr<const void> previous_root;
 
-    pvd::PVStructurePtr lastval;
-    pvd::PVScalarPtr isatomic;
+    struct LinkSort {
+        bool operator()(const pvaLink *L, const pvaLink *R) const;
+    };
 
-    epicsJob *scanjob;
-    std::tr1::shared_ptr<pvaLinkChannel> scanself; // create ref loop while scan is queued
-    bool scanatomic;
+    typedef std::set<pvaLink*, LinkSort> links_t;
 
-    pvaLinkChannel(const char *name)
-        :name(name)
-        ,scanjob(epicsJobCreate(pvaGlobal->scanpool, &pvaLinkChannel::scan, this))
-        ,scanatomic(false)
-    {
-        if(!scanjob)
-            throw std::runtime_error("failed to create job for pvaLink");
-        epics::atomic::increment(refs);
-    }
-    virtual ~pvaLinkChannel() {
-        Guard G(lock);
-        assert(links.empty());
-        epicsJobDestroy(scanjob);
-        scanjob = NULL;
-        epics::atomic::decrement(refs);
-        std::cerr<<"pvaLinkChannel: destroy "<<name<<"\n";
-    }
+    // list of currently attached links.  maintained by pvaLink ctor/dtor
+    // TODO: sort by PHAS
+    links_t links;
 
-    void doConnect() {
-        // TODO: local PVA?
-        Guard G(lock);
-        chan = pvaGlobal->provider->createChannel(name, shared_from_this());
-        channelStateChange(chan, chan->getConnectionState());
-    }
-    void doClose() {
-        Guard G(lock);
-        errlogPrintf("pvaLink closing %s\n", name.c_str());
-        channelStateChange(chan, pva::Channel::DESTROYED);
-        chan->destroy();
-        chan.reset();
-        std::cerr<<"pvaLink: channel destroy "<<name<<"\n";
-    }
+    // set when 'links' is modified to trigger re-compute of record scan list
+    bool links_changed;
 
-    void triggerProc(bool atomic=false, bool force=false);
+    pvaLinkChannel(const pvaGlobal_t::channels_key_t& key, const epics::pvData::PVStructure::const_shared_pointer &pvRequest);
+    virtual ~pvaLinkChannel();
 
-    static void scan(void* arg, epicsJobMode mode);
+    void open();
+    void put(bool force=false); // begin Put op.
 
-    virtual std::string getRequesterName() { return "pvaLink"; }
-    virtual void message(std::string const & message, pva::MessageType messageType)
-    {
-        errlogPrintf("%s pvaLink \"%s\": %s\n",
-                     pvd::getMessageTypeName(messageType).c_str(),
-                     name.c_str(),
-                     message.c_str());
-    }
+    // pvac::ClientChanel::MonitorCallback
+    virtual void monitorEvent(const pvac::MonitorEvent& evt) OVERRIDE FINAL;
 
-    virtual void channelCreated(const epics::pvData::Status& status, pva::Channel::shared_pointer const & channel)
-    {
-        if(!status.isSuccess()) {
-            errlogPrintf("pvaLink create fails %s: %s\n", name.c_str(), status.getMessage().c_str());
-            return;
-        }
-        Guard G(lock);
-        //assert(chan==channel); // may be called before createChannel() returns
-        chan = channel;
-    }
+    // pvac::ClientChanel::PutCallback
+    virtual void putBuild(const epics::pvData::StructureConstPtr& build, pvac::ClientChannel::PutCallback::Args& args) OVERRIDE FINAL;
+    virtual void putDone(const pvac::PutEvent& evt) OVERRIDE FINAL;
+private:
+    virtual void run() OVERRIDE FINAL;
+    void run_dbProcess(size_t idx); // idx is index in scan_records
 
-    virtual void channelStateChange(pva::Channel::shared_pointer const & channel, pva::Channel::ConnectionState connectionState);
+    // ==== Treat remaining as local to run()
 
-    virtual void monitorConnect(pvd::Status const & status,
-                                pva::Monitor::shared_pointer const & monitor,
-                                pvd::StructureConstPtr const & structure);
-
-    virtual void monitorEvent(pva::Monitor::shared_pointer const & monitor);
-
-    virtual void unlisten(pva::Monitor::shared_pointer const & monitor)
-    {
-        // what to do??
-    }
+    std::vector<dbCommon*> scan_records;
+    std::vector<bool> scan_check_passive;
+    std::vector<epics::pvData::BitSet> scan_changed;
 
+    DBManyLock atomic_lock;
 };
 
-struct pvaLink : public jlink
+struct pvaLink : public pvaLinkConfig
 {
-    static size_t refs;
+    static size_t num_instances;
+
+    bool alive; // attempt to catch some use after free
 
     DBLINK * plink; // may be NULL
-    unsigned linkmods;
-    unsigned parse_level;
-
-    std::string name, field;
-    const pva::Channel::shared_pointer chan;
-    bool alive; // attempt to catch some use after free
 
     std::tr1::shared_ptr<pvaLinkChannel> lchan;
 
-    pvd::PVScalarPtr valueS;
-    pvd::PVScalarArray::shared_pointer valueA;
-    pvd::PVScalar::shared_pointer sevr, sec, nsec;
-    pvd::ScalarType etype;
+    bool used_scratch, used_queue;
+    pvd::shared_vector<const void> put_scratch, put_queue;
 
-    struct Value {
-        bool valid;
-        bool scalar;
-        pvd::ScalarType etype;
-        pvd::shared_vector<const void> valueA;
-        dbrbuf valueS;
-        epicsUInt16 sevr;
-        epicsTimeStamp time;
-        Value() :valid(false) {}
-        void clear() {
-            valid = false;
-            valueA.clear();
-        }
-    };
+    // cached fields from channel op_mon
+    // updated in onTypeChange()
+    epics::pvData::PVField::const_shared_pointer fld_value;
+    epics::pvData::PVScalar::const_shared_pointer fld_severity,
+                                                  fld_seconds,
+                                                  fld_nanoseconds;
+    epics::pvData::PVStructure::const_shared_pointer fld_display,
+                                                     fld_control,
+                                                     fld_valueAlarm;
+    epics::pvData::BitSet proc_changed;
 
-    Value atomcache;
+    // cached snapshot of alarm and  timestamp
+    // captured in pvaGetValue().
+    // we choose not to ensure consistency with display/control meta-data
+    epicsTimeStamp snap_time;
+    short snap_severity;
 
-    pvaLink()
-        :plink(0)
-        ,linkmods(0)
-        ,parse_level(0)
-        ,alive(true)
-    {
-        epics::atomic::increment(refs);
-        //TODO: valgrind tells me these aren't initialized by Base, but probably should be.
-        parseDepth = 0;
-        parent = 0;
-    }
+    pvaLink();
+    virtual ~pvaLink();
 
-    void open()
-    {
-        if(this->name.empty())
-            throw std::logic_error("open() w/o target PV name");
-        this->name = name;
-        //TODO: how to distinguish "record.FLD" from pva "channel.subfield"?
-        size_t dot = this->name.find_first_of('.');
-        if(dot!=this->name.npos) {
-            field = this->name.substr(dot+1);
-            this->name = this->name.substr(0, dot);
-        }
-        lchan = pvaGlobal->connect(this->name.c_str());
-        Guard G(lchan->lock);
-        lchan->links.insert(this);
-        if(lchan->lastval)
-            attach();
-    }
-    ~pvaLink()
-    {
-        alive = false;
-        if(lchan) { // may be NULL if parsing fails
-            Guard G(lchan->lock);
-            detach();
-            lchan->links.erase(this);
-            if(lchan->links.empty()) {
-                pvaGlobal->channels.erase(lchan->name);
-                lchan->doClose();
-            }
-        }
-        epics::atomic::decrement(refs);
-    }
+    // returns pvRequest to be used with monitor
+    pvd::PVStructurePtr makeRequest();
 
-    void detach()
-    {
-        valueS.reset();
-        valueA.reset();
-        sevr.reset();
-        sec.reset();
-        nsec.reset();
-    }
+    bool valid() const;
 
-    bool attach()
-    {
-        pvd::PVStructurePtr base(lchan->lastval);
+    // fetch a sub-sub-field of the top monitored field.
+    pvd::PVField::const_shared_pointer getSubField(const char *name);
 
-        if(!field.empty())
-            base = base->getSubField<pvd::PVStructure>(field);
-        if(!base) {
-            errlogPrintf("pvaLink not %s%c%s\n", name.c_str(), field.empty() ? ' ' : '.', field.c_str());
-            return false;
-        }
-
-        pvd::PVFieldPtr value(base->getSubField("value"));
-        switch(value->getField()->getType())
-        {
-        case pvd::scalar:
-            valueS = std::tr1::static_pointer_cast<pvd::PVScalar>(value);
-            etype = valueS->getScalar()->getScalarType();
-            break;
-        case pvd::scalarArray:
-            valueA = std::tr1::static_pointer_cast<pvd::PVScalarArray>(value);
-            etype = valueA->getScalarArray()->getElementType();
-            break;
-        default:
-            errlogPrintf("pvaLink not .value : %s%c%s\n", name.c_str(), field.empty() ? ' ' : '.', field.c_str());
-            return false;
-        }
-
-        sevr = base->getSubField<pvd::PVScalar>("alarm.severity");
-        sec = base->getSubField<pvd::PVScalar>("timeStamp.secondsPastEpoch");
-        nsec = base->getSubField<pvd::PVScalar>("timeStamp.nanoseconds");
-        return true;
-    }
-
-    void get(Value& v)
-    {
-        if(valueA) {
-            valueA->getAs<const void>(v.valueA);
-            v.etype = v.valueA.original_type();
-            v.scalar = false;
-
-        } else if(valueS) {
-
-            switch(etype) {
-#define CASE(BASETYPE, PVATYPE, DBFTYPE, PVACODE) case pvd::pv ## PVACODE: v.valueS.dbf_##DBFTYPE = valueS->getAs<PVATYPE>(); break;
-#define CASE_SQUEEZE_INT64
-#include "pvatypemap.h"
-#undef CASE_SQUEEZE_INT64
-#undef CASE
-            case pvd::pvString: {
-                strncpy(v.valueS.dbf_STRING, valueS->getAs<std::string>().c_str(), sizeof(v.valueS.dbf_STRING));
-                v.valueS.dbf_STRING[sizeof(v.valueS.dbf_STRING)-1] = '\0';
-            }
-                break;
-            default:
-                throw std::runtime_error("putValue unsupported DBR code");
-            }
-
-            v.etype = etype;
-            v.scalar = true;
-        }
-
-        v.sevr = sevr->getAs<epicsUInt16>();
-        v.time.secPastEpoch = sec->getAs<epicsUInt32>()-POSIX_TIME_AT_EPICS_EPOCH;
-        v.time.nsec = nsec->getAs<epicsUInt32>();
-        v.valid = true;
-    }
+    void onDisconnect();
+    void onTypeChange();
 };
 
 

pdbApp/pvalink_channel.cpp

@@ -0,0 +1,385 @@
+
+#include <alarm.h>
+
+#include <pv/reftrack.h>
+
+#define epicsExportSharedSymbols
+#include <shareLib.h>
+
+#include "pvalink.h"
+
+int pvaLinkNWorkers = 1;
+
+namespace pvalink {
+
+pvaGlobal_t *pvaGlobal;
+
+
+pvaGlobal_t::pvaGlobal_t()
+    :create(pvd::getPVDataCreate())
+    ,queue("PVAL")
+    ,running(false)
+{
+    // worker should be above PVA worker priority?
+    queue.start(std::max(1, pvaLinkNWorkers), epicsThreadPriorityMedium);
+}
+
+pvaGlobal_t::~pvaGlobal_t()
+{
+}
+
+size_t pvaLinkChannel::num_instances;
+size_t pvaLink::num_instances;
+
+
+bool pvaLinkChannel::LinkSort::operator()(const pvaLink *L, const pvaLink *R) const {
+    if(L->monorder==R->monorder)
+        return L < R;
+    return L->monorder < R->monorder;
+}
+
+// being called with pvaGlobal::lock held
+pvaLinkChannel::pvaLinkChannel(const pvaGlobal_t::channels_key_t &key, const pvd::PVStructure::const_shared_pointer& pvRequest)
+    :key(key)
+    ,pvRequest(pvRequest)
+    ,num_disconnect(0u)
+    ,num_type_change(0u)
+    ,connected(false)
+    ,connected_latched(false)
+    ,isatomic(false)
+    ,queued(false)
+    ,debug(false)
+    ,links_changed(false)
+{}
+
+pvaLinkChannel::~pvaLinkChannel() {
+    {
+        Guard G(pvaGlobal->lock);
+        pvaGlobal->channels.erase(key);
+    }
+
+    Guard G(lock);
+
+    assert(links.empty());
+    REFTRACE_DECREMENT(num_instances);
+}
+
+void pvaLinkChannel::open()
+{
+    Guard G(lock);
+
+    try {
+        chan = pvaGlobal->provider_local.connect(key.first);
+        DEBUG(this, <<key.first<<" OPEN Local");
+        providerName = pvaGlobal->provider_local.name();
+    } catch(std::exception& e){
+        // The PDBProvider doesn't have a way to communicate to us
+        // whether this is an invalid record or group name,
+        // or if this is some sort of internal error.
+        // So we are forced to assume it is an invalid name.
+        DEBUG(this, <<key.first<<" OPEN Not local "<<e.what());
+    }
+    if(!pvaLinkIsolate && !chan) {
+        chan = pvaGlobal->provider_remote.connect(key.first);
+        DEBUG(this, <<key.first<<" OPEN Remote ");
+        providerName = pvaGlobal->provider_remote.name();
+    }
+
+    op_mon = chan.monitor(this, pvRequest);
+
+    REFTRACE_INCREMENT(num_instances);
+}
+
+static
+pvd::StructureConstPtr putRequestType = pvd::getFieldCreate()->createFieldBuilder()
+        ->addNestedStructure("field")
+        ->endNested()
+        ->addNestedStructure("record")
+            ->addNestedStructure("_options")
+                ->add("block", pvd::pvBoolean)
+                ->add("process", pvd::pvString) // "true", "false", or "passive"
+            ->endNested()
+        ->endNested()
+        ->createStructure();
+
+// call with channel lock held
+void pvaLinkChannel::put(bool force)
+{
+    pvd::PVStructurePtr pvReq(pvd::getPVDataCreate()->createPVStructure(putRequestType));
+    pvReq->getSubFieldT<pvd::PVBoolean>("record._options.block")->put(false); // TODO: some way to expose completion...
+
+    unsigned reqProcess = 0;
+    bool doit = force;
+    for(links_t::iterator it(links.begin()), end(links.end()); it!=end; ++it)
+    {
+        pvaLink *link = *it;
+
+        if(!link->used_scratch) continue;
+
+        pvd::shared_vector<const void> temp;
+        temp.swap(link->put_scratch);
+        link->used_scratch = false;
+        temp.swap(link->put_queue);
+        link->used_queue = true;
+
+        doit = true;
+
+        switch(link->pp) {
+        case pvaLink::NPP:
+            reqProcess |= 1;
+            break;
+        case pvaLink::Default:
+            break;
+        case pvaLink::PP:
+        case pvaLink::CP:
+        case pvaLink::CPP:
+            reqProcess |= 2;
+            break;
+        }
+    }
+
+    /* By default, use remote default (passive).
+     * Request processing, or not, if any link asks.
+     * Prefer PP over NPP if both are specified.
+     *
+     * TODO: per field granularity?
+     */
+    const char *proc = "passive";
+    if((reqProcess&2) || force) {
+        proc = "true";
+    } else if(reqProcess&1) {
+        proc = "false";
+    }
+    pvReq->getSubFieldT<pvd::PVString>("record._options.process")->put(proc);
+
+    DEBUG(this, <<key.first<<"Start put "<<doit);
+    if(doit) {
+        // start net Put, cancels in-progress put
+        op_put = chan.put(this, pvReq);
+    }
+}
+
+void pvaLinkChannel::putBuild(const epics::pvData::StructureConstPtr& build, pvac::ClientChannel::PutCallback::Args& args)
+{
+    Guard G(lock);
+
+    pvd::PVStructurePtr top(pvaGlobal->create->createPVStructure(build));
+
+    for(links_t::iterator it(links.begin()), end(links.end()); it!=end; ++it)
+    {
+        pvaLink *link = *it;
+
+        if(!link->used_queue) continue;
+        link->used_queue = false; // clear early so unexpected exception won't get us in a retry loop
+
+        pvd::PVFieldPtr value(link->fieldName.empty() ? pvd::PVFieldPtr(top) : top->getSubField(link->fieldName));
+        if(value && value->getField()->getType()==pvd::structure) {
+            // maybe drill into NTScalar et al.
+            pvd::PVFieldPtr sub(static_cast<pvd::PVStructure*>(value.get())->getSubField("value"));
+            if(sub)
+                value.swap(sub);
+        }
+
+        if(!value) continue; // TODO: how to signal error?
+
+        pvd::PVStringArray::const_svector choices; // TODO populate from op_mon
+
+        DEBUG(this, <<key.first<<" <- "<<value->getFullName());
+        copyDBF2PVD(link->put_queue, value, args.tosend, choices);
+
+        link->put_queue.clear();
+    }
+    DEBUG(this, <<key.first<<" Put built");
+
+    args.root = top;
+}
+
+void pvaLinkChannel::putDone(const pvac::PutEvent& evt)
+{
+    if(evt.event==pvac::PutEvent::Fail) {
+        errlogPrintf("%s PVA link put ERROR: %s\n", key.first.c_str(), evt.message.c_str());
+    }
+
+    Guard G(lock);
+
+    DEBUG(this, <<key.first<<" Put result "<<evt.event);
+
+    op_put = pvac::Operation();
+
+    if(evt.event==pvac::PutEvent::Success) {
+        // see if we need start a queue'd put
+        put();
+    }
+}
+
+void pvaLinkChannel::monitorEvent(const pvac::MonitorEvent& evt)
+{
+    bool queue = false;
+
+    {
+        DEBUG(this, <<key.first<<" EVENT "<<evt.event);
+        Guard G(lock);
+
+        switch(evt.event) {
+        case pvac::MonitorEvent::Disconnect:
+        case pvac::MonitorEvent::Data:
+            connected = evt.event == pvac::MonitorEvent::Data;
+            queue = true;
+            break;
+        case pvac::MonitorEvent::Cancel:
+            break; // no-op
+        case pvac::MonitorEvent::Fail:
+            connected = false;
+            queue = true;
+            errlogPrintf("%s: PVA link monitor ERROR: %s\n", chan.name().c_str(), evt.message.c_str());
+            break;
+        }
+
+        if(queued)
+            return; // already scheduled
+
+        queued = queue;
+    }
+
+    if(queue) {
+        pvaGlobal->queue.add(shared_from_this());
+    }
+}
+
+// the work in calling dbProcess() which is common to
+// both dbScanLock() and dbScanLockMany()
+void pvaLinkChannel::run_dbProcess(size_t idx)
+{
+    dbCommon *precord = scan_records[idx];
+
+    if(scan_check_passive[idx] && precord->scan!=0) {
+        return;
+
+    } else if(connected_latched && !op_mon.changed.logical_and(scan_changed[idx])) {
+        return;
+
+    } else if (precord->pact) {
+        if (precord->tpro)
+            printf("%s: Active %s\n",
+                epicsThreadGetNameSelf(), precord->name);
+        precord->rpro = TRUE;
+
+    }
+    dbProcess(precord);
+}
+
+// Running from global WorkQueue thread
+void pvaLinkChannel::run()
+{
+    bool requeue = false;
+    {
+        Guard G(lock);
+
+        queued = false;
+
+        connected_latched = connected;
+
+        // pop next update from monitor queue.
+        // still under lock to safeguard concurrent calls to lset functions
+        if(connected && !op_mon.poll()) {
+            DEBUG(this, <<key.first<<" RUN "<<"empty");
+            run_done.signal();
+            return; // monitor queue is empty, nothing more to do here
+        }
+
+        DEBUG(this, <<key.first<<" RUN "<<(connected_latched?"connected":"disconnected"));
+
+        assert(!connected || !!op_mon.root);
+
+        if(!connected) {
+            num_disconnect++;
+
+            // cancel pending put operations
+            op_put = pvac::Operation();
+
+            for(links_t::iterator it(links.begin()), end(links.end()); it!=end; ++it)
+            {
+                pvaLink *link = *it;
+                link->onDisconnect();
+            }
+
+            // Don't clear previous_root on disconnect.
+            // We will usually re-connect with the same type,
+            // and may get back the same PVStructure.
+
+        } else if(previous_root.get() != (const void*)op_mon.root.get()) {
+            num_type_change++;
+
+            for(links_t::iterator it(links.begin()), end(links.end()); it!=end; ++it)
+            {
+                pvaLink *link = *it;
+                link->onTypeChange();
+            }
+
+            previous_root = std::tr1::static_pointer_cast<const void>(op_mon.root);
+        }
+
+        // at this point we know we will re-queue, but not immediately
+        // so an expected error won't get us stuck in a tight loop.
+        requeue = queued = connected_latched;
+
+        if(links_changed) {
+            // a link has been added or removed since the last update.
+            // rebuild our cached list of records to (maybe) process.
+
+            scan_records.clear();
+            scan_check_passive.clear();
+            scan_changed.clear();
+
+            for(links_t::iterator it(links.begin()), end(links.end()); it!=end; ++it)
+            {
+                pvaLink *link = *it;
+                assert(link && link->alive);
+
+                if(!link->plink) continue;
+
+                // NPP and none/Default don't scan
+                // PP, CP, and CPP do scan
+                // PP and CPP only if SCAN=Passive
+                if(link->pp != pvaLink::PP && link->pp != pvaLink::CPP && link->pp != pvaLink::CP)
+                    continue;
+
+                scan_records.push_back(link->plink->precord);
+                scan_check_passive.push_back(link->pp != pvaLink::CP);
+                scan_changed.push_back(link->proc_changed);
+            }
+
+            DBManyLock ML(scan_records);
+
+            atomic_lock.swap(ML);
+
+            links_changed = false;
+        }
+    }
+
+    if(scan_records.empty()) {
+        // Nothing to do, so don't bother locking
+
+    } else if(isatomic && scan_records.size() > 1u) {
+        DBManyLocker L(atomic_lock);
+
+        for(size_t i=0, N=scan_records.size(); i<N; i++) {
+            run_dbProcess(i);
+        }
+
+    } else {
+        for(size_t i=0, N=scan_records.size(); i<N; i++) {
+            DBScanLocker L(scan_records[i]);
+            run_dbProcess(i);
+        }
+    }
+
+    if(requeue) {
+        // re-queue until monitor queue is empty
+        pvaGlobal->queue.add(shared_from_this());
+    } else {
+        run_done.signal();
+    }
+}
+
+} // namespace pvalink

pdbApp/pvalink_jlif.cpp

@@ -0,0 +1,324 @@
+#include <sstream>
+
+#include <epicsStdio.h> // redirects stdout/stderr
+
+#define epicsExportSharedSymbols
+#include <shareLib.h>
+
+#include "pvalink.h"
+
+namespace pvalink {
+pvaLinkConfig::pvaLinkConfig()
+    :queueSize(4)
+    ,pp(Default)
+    ,ms(NMS)
+    ,defer(false)
+    ,pipeline(false)
+    ,time(false)
+    ,retry(false)
+    ,local(false)
+    ,always(false)
+    ,monorder(0)
+{}
+pvaLinkConfig::~pvaLinkConfig() {}
+}
+
+namespace {
+
+using namespace pvalink;
+
+/* link options.
+ *
+ * "pvname" # short-hand, sets PV name only
+ *
+ * {
+ *  "pv":"name",
+ *  "field":"blah.foo",
+ *  "Q":5,
+ *  "pipeline":false,
+ *  "proc":true, // false, true, none, "", "NPP", "PP", "CP", "CPP"
+ *  "sevr":true, // false, true, "NMS", "MS", "MSI", "MSS"
+ *  "time":true, // false, true
+ *  "monorder":#,// order of processing during CP scan
+ *  "defer":true,// whether to immediately start Put, or only queue value to be sent
+ *  "retry":true,// queue Put while disconnected, and retry on connect
+ *  "always":true,// CP/CPP updates always process a like, even if its input field hasn't changed
+ *  "local":false,// Require local channel
+ * }
+ */
+
+jlink* pva_alloc_jlink(short dbr)
+{
+    try {
+        TRACE();
+        return new pvaLink;
+
+    }catch(std::exception& e){
+        errlogPrintf("Error allocating pva link: %s\n", e.what());
+        return NULL;
+    }
+}
+
+#define TRY  pvaLinkConfig *pvt = static_cast<pvaLinkConfig*>(pjlink); (void)pvt; try
+#define CATCH(RET) catch(std::exception& e){ \
+    errlogPrintf("Error in %s link: %s\n", __FUNCTION__, e.what()); \
+    return RET; }
+
+void pva_free_jlink(jlink *pjlink)
+{
+    TRY {
+        TRACE();
+        delete pvt;
+    }catch(std::exception& e){
+        errlogPrintf("Error freeing pva link: %s\n", e.what());
+    }
+}
+
+jlif_result pva_parse_null(jlink *pjlink)
+{
+    TRY {
+        TRACE(<<pvt->jkey<<" ");
+        if(pvt->parseDepth!=1) {
+            // ignore
+        } else if(pvt->jkey == "proc") {
+            pvt->pp = pvaLinkConfig::Default;
+        } else if(pvt->jkey == "sevr") {
+            pvt->ms = pvaLinkConfig::NMS;
+        } else if(pvt->jkey == "local") {
+            pvt->local = false; // alias for local:false
+        } else if(pvt->debug) {
+            printf("pva link parsing unknown none depth=%u key=\"%s\"\n",
+                   pvt->parseDepth, pvt->jkey.c_str());
+        }
+
+        pvt->jkey.clear();
+        return jlif_continue;
+    }CATCH(jlif_stop)
+}
+
+jlif_result pva_parse_bool(jlink *pjlink, int val)
+{
+    TRY {
+        TRACE(<<pvt->jkey<<" "<<(val?"true":"false"));
+        if(pvt->parseDepth!=1) {
+            // ignore
+        } else if(pvt->jkey == "proc") {
+            pvt->pp = val ? pvaLinkConfig::PP : pvaLinkConfig::NPP;
+        } else if(pvt->jkey == "sevr") {
+            pvt->ms = val ? pvaLinkConfig::MS : pvaLinkConfig::NMS;
+        } else if(pvt->jkey == "defer") {
+            pvt->defer = !!val;
+        } else if(pvt->jkey == "pipeline") {
+            pvt->pipeline = !!val;
+        } else if(pvt->jkey == "time") {
+            pvt->time = !!val;
+        } else if(pvt->jkey == "retry") {
+            pvt->retry = !!val;
+        } else if(pvt->jkey == "local") {
+            pvt->local = !!val;
+        } else if(pvt->jkey == "always") {
+            pvt->always = !!val;
+        } else if(pvt->debug) {
+            printf("pva link parsing unknown integer depth=%u key=\"%s\" value=%s\n",
+                   pvt->parseDepth, pvt->jkey.c_str(), val ? "true" : "false");
+        }
+
+        pvt->jkey.clear();
+        return jlif_continue;
+    }CATCH(jlif_stop)
+}
+
+jlif_result pva_parse_integer(jlink *pjlink, long long val)
+{
+    TRY {
+        TRACE(<<pvt->jkey<<" "<<val);
+        if(pvt->parseDepth!=1) {
+            // ignore
+        } else if(pvt->jkey == "Q") {
+            pvt->queueSize = val < 1 ? 1 : size_t(val);
+        } else if(pvt->jkey == "monorder") {
+            pvt->monorder = std::max(-1024, std::min(int(val), 1024));
+        } else if(pvt->debug) {
+            printf("pva link parsing unknown integer depth=%u key=\"%s\" value=%lld\n",
+                   pvt->parseDepth, pvt->jkey.c_str(), val);
+        }
+
+        pvt->jkey.clear();
+        return jlif_continue;
+    }CATCH(jlif_stop)
+}
+
+jlif_result pva_parse_string(jlink *pjlink, const char *val, size_t len)
+{
+    TRY{
+        std::string sval(val, len);
+        TRACE(<<pvt->jkey<<" "<<sval);
+        if(pvt->parseDepth==0 || (pvt->parseDepth==1 && pvt->jkey=="pv")) {
+            pvt->channelName = sval;
+
+        } else if(pvt->parseDepth > 1) {
+            // ignore
+
+        } else if(pvt->jkey=="field") {
+            pvt->fieldName = sval;
+
+        } else if(pvt->jkey=="proc") {
+            if(sval.empty()) {
+                pvt->pp = pvaLinkConfig::Default;
+            } else if(sval=="CP") {
+                pvt->pp = pvaLinkConfig::CP;
+            } else if(sval=="CPP") {
+                pvt->pp = pvaLinkConfig::CPP;
+            } else if(sval=="PP") {
+                pvt->pp = pvaLinkConfig::PP;
+            } else if(sval=="NPP") {
+                pvt->pp = pvaLinkConfig::NPP;
+            } else if(pvt->debug) {
+                printf("pva link parsing unknown proc depth=%u key=\"%s\" value=\"%s\"\n",
+                       pvt->parseDepth, pvt->jkey.c_str(), sval.c_str());
+            }
+
+        } else if(pvt->jkey=="sevr") {
+            if(sval=="NMS") {
+                pvt->ms = pvaLinkConfig::NMS;
+            } else if(sval=="MS") {
+                pvt->ms = pvaLinkConfig::MS;
+            } else if(sval=="MSI") {
+                pvt->ms = pvaLinkConfig::MSI;
+            } else if(sval=="MSS") {
+                // not sure how to handle mapping severity for MSS.
+                // leave room for this to happen compatibly later by
+                // handling as alias for MS until then.
+                pvt->ms = pvaLinkConfig::MS;
+            } else if(pvt->debug) {
+                printf("pva link parsing unknown sevr depth=%u key=\"%s\" value=\"%s\"\n",
+                       pvt->parseDepth, pvt->jkey.c_str(), sval.c_str());
+            }
+
+        } else if(pvt->debug) {
+            printf("pva link parsing unknown string depth=%u key=\"%s\" value=\"%s\"\n",
+                   pvt->parseDepth, pvt->jkey.c_str(), sval.c_str());
+        }
+
+        pvt->jkey.clear();
+        return jlif_continue;
+    }CATCH(jlif_stop)
+}
+
+jlif_key_result pva_parse_start_map(jlink *pjlink)
+{
+    TRY {
+        TRACE();
+        return jlif_key_continue;
+    }CATCH(jlif_key_stop)
+}
+
+jlif_result pva_parse_key_map(jlink *pjlink, const char *key, size_t len)
+{
+    TRY {
+        std::string sval(key, len);
+        TRACE(<<sval);
+        pvt->jkey = sval;
+
+        return jlif_continue;
+    }CATCH(jlif_stop)
+}
+
+jlif_result pva_parse_end_map(jlink *pjlink)
+{
+    TRY {
+        TRACE();
+        return jlif_continue;
+    }CATCH(jlif_stop)
+}
+
+struct lset* pva_get_lset(const jlink *pjlink)
+{
+    TRACE();
+    return &pva_lset;
+}
+
+void pva_report(const jlink *rpjlink, int lvl, int indent)
+{
+    const pvaLink *pval = static_cast<const pvaLink*>(rpjlink);
+    try {
+        (void)pval;
+        printf("%*s'pva': %s", indent, "", pval->channelName.c_str());
+        if(!pval->fieldName.empty())
+            printf("|.%s", pval->fieldName.c_str());
+
+        switch(pval->pp) {
+        case pvaLinkConfig::NPP: printf(" NPP"); break;
+        case pvaLinkConfig::Default: printf(" Def"); break;
+        case pvaLinkConfig::PP: printf(" PP"); break;
+        case pvaLinkConfig::CP: printf(" CP"); break;
+        case pvaLinkConfig::CPP: printf(" CPP"); break;
+        }
+        switch(pval->ms) {
+        case pvaLinkConfig::NMS: printf(" NMS"); break;
+        case pvaLinkConfig::MS:  printf(" MS"); break;
+        case pvaLinkConfig::MSI: printf(" MSI"); break;
+        }
+        if(lvl>0) {
+            printf(" Q=%u pipe=%c defer=%c time=%c retry=%c morder=%d",
+                   unsigned(pval->queueSize),
+                   pval->pipeline ? 'T' : 'F',
+                   pval->defer ? 'T' : 'F',
+                   pval->time ? 'T' : 'F',
+                   pval->retry ? 'T' : 'F',
+                   pval->monorder);
+        }
+
+        if(pval->lchan) {
+            // after open()
+            Guard G(pval->lchan->lock);
+
+            printf(" conn=%c", pval->lchan->connected ? 'T' : 'F');
+            if(pval->lchan->op_put.valid()) {
+                printf(" Put");
+            }
+
+            if(lvl>0) {
+                printf(" #disconn=%zu prov=%s", pval->lchan->num_disconnect, pval->lchan->providerName.c_str());
+            }
+            if(lvl>1) {
+                printf(" inprog=%c",
+                       pval->lchan->queued?'T':'F');
+            }
+            if(lvl>5) {
+                std::ostringstream strm;
+                pval->lchan->chan.show(strm);
+                printf("\n%*s   CH: %s", indent, "", strm.str().c_str());
+            }
+        } else {
+            printf(" No Channel");
+        }
+        printf("\n");
+    }CATCH()
+}
+
+} //namespace
+
+namespace pvalink {
+
+jlif lsetPVA = {
+    "pva",
+    &pva_alloc_jlink,
+    &pva_free_jlink,
+    &pva_parse_null,
+    &pva_parse_bool,
+    &pva_parse_integer,
+    NULL,
+    &pva_parse_string,
+    &pva_parse_start_map,
+    &pva_parse_key_map,
+    &pva_parse_end_map,
+    NULL,
+    NULL,
+    NULL,
+    &pva_get_lset,
+    &pva_report,
+    NULL
+};
+
+} //namespace pvalink

pdbApp/pvalink_link.cpp

@@ -0,0 +1,156 @@
+#include <pv/reftrack.h>
+#include <alarm.h>
+
+#define epicsExportSharedSymbols
+#include <shareLib.h>
+
+#include "pvalink.h"
+
+namespace pvalink {
+
+pvaLink::pvaLink()
+    :alive(true)
+    ,plink(0)
+    ,used_scratch(false)
+    ,used_queue(false)
+{
+    REFTRACE_INCREMENT(num_instances);
+
+    snap_severity = INVALID_ALARM;
+    snap_time.secPastEpoch = 0;
+    snap_time.nsec = 0;
+
+    //TODO: valgrind tells me these aren't initialized by Base, but probably should be.
+    parseDepth = 0;
+    parent = 0;
+}
+
+pvaLink::~pvaLink()
+{
+    alive = false;
+
+    if(lchan) { // may be NULL if parsing fails
+        Guard G(lchan->lock);
+
+        lchan->links.erase(this);
+        lchan->links_changed = true;
+
+        bool new_debug = false;
+        for(pvaLinkChannel::links_t::const_iterator it(lchan->links.begin()), end(lchan->links.end())
+            ; it!=end; ++it)
+        {
+            const pvaLink *pval = *it;
+            if(pval->debug) {
+                new_debug = true;
+                break;
+            }
+        }
+
+        lchan->debug = new_debug;
+    }
+
+    REFTRACE_DECREMENT(num_instances);
+}
+
+static
+pvd::StructureConstPtr monitorRequestType = pvd::getFieldCreate()->createFieldBuilder()
+        ->addNestedStructure("field")
+        ->endNested()
+        ->addNestedStructure("record")
+            ->addNestedStructure("_options")
+                ->add("pipeline", pvd::pvBoolean)
+                ->add("atomic", pvd::pvBoolean)
+                ->add("queueSize", pvd::pvUInt)
+            ->endNested()
+        ->endNested()
+        ->createStructure();
+
+pvd::PVStructurePtr pvaLink::makeRequest()
+{
+    pvd::PVStructurePtr ret(pvd::getPVDataCreate()->createPVStructure(monitorRequestType));
+    ret->getSubFieldT<pvd::PVBoolean>("record._options.pipeline")->put(pipeline);
+    ret->getSubFieldT<pvd::PVBoolean>("record._options.atomic")->put(true);
+    ret->getSubFieldT<pvd::PVUInt>("record._options.queueSize")->put(queueSize);
+    return ret;
+}
+
+// caller must lock lchan->lock
+bool pvaLink::valid() const
+{
+    return lchan->connected_latched && lchan->op_mon.root;
+}
+
+// caller must lock lchan->lock
+pvd::PVField::const_shared_pointer pvaLink::getSubField(const char *name)
+{
+    pvd::PVField::const_shared_pointer ret;
+    if(valid()) {
+        if(fieldName.empty()) {
+            // we access the top level struct
+            ret = lchan->op_mon.root->getSubField(name);
+
+        } else {
+            // we access a sub-struct
+            ret = lchan->op_mon.root->getSubField(fieldName);
+            if(ret->getField()->getType()!=pvd::structure) {
+                // addressed sub-field isn't a sub-structure
+                if(strcmp(name, "value")!=0) {
+                    // unless we are trying to fetch the "value", we fail here
+                    ret.reset();
+                }
+            } else {
+                ret = static_cast<const pvd::PVStructure*>(ret.get())->getSubField(name);
+            }
+        }
+    }
+    return ret;
+}
+
+// call with channel lock held
+void pvaLink::onDisconnect()
+{
+    DEBUG(this,<<plink->precord->name<<" disconnect");
+    // TODO: option to remain queue'd while disconnected
+
+    used_queue = used_scratch = false;
+}
+
+void pvaLink::onTypeChange()
+{
+    DEBUG(this,<<plink->precord->name<<" type change");
+
+    assert(lchan->connected_latched && !!lchan->op_mon.root); // we should only be called when connected
+
+    fld_value = getSubField("value");
+    fld_seconds = std::tr1::dynamic_pointer_cast<const pvd::PVScalar>(getSubField("timeStamp.secondsPastEpoch"));
+    fld_nanoseconds = std::tr1::dynamic_pointer_cast<const pvd::PVScalar>(getSubField("timeStamp.nanoseconds"));
+    fld_severity = std::tr1::dynamic_pointer_cast<const pvd::PVScalar>(getSubField("alarm.severity"));
+    fld_display = std::tr1::dynamic_pointer_cast<const pvd::PVStructure>(getSubField("display"));
+    fld_control = std::tr1::dynamic_pointer_cast<const pvd::PVStructure>(getSubField("control"));
+    fld_valueAlarm = std::tr1::dynamic_pointer_cast<const pvd::PVStructure>(getSubField("valueAlarm"));
+
+    proc_changed.clear();
+
+    // build mask of all "changed" bits associated with our .value
+    // CP/CPP input links will process this link only for updates where
+    // the changed mask and proc_changed share at least one set bit.
+    if(fld_value) {
+        // bit for this field
+        proc_changed.set(fld_value->getFieldOffset());
+
+        // bits of all parent fields
+        for(const pvd::PVStructure* parent = fld_value->getParent(); parent; parent = parent->getParent()) {
+            proc_changed.set(parent->getFieldOffset());
+        }
+
+        if(fld_value->getField()->getType()==pvd::structure)
+        {
+            // bits of all child fields
+            const pvd::PVStructure *val = static_cast<const pvd::PVStructure*>(fld_value.get());
+            for(size_t i=val->getFieldOffset(), N=val->getNextFieldOffset(); i<N; i++)
+                proc_changed.set(i);
+        }
+    }
+}
+
+} // namespace pvalink

pdbApp/pvalink_lset.cpp

@@ -0,0 +1,496 @@
+
+#include <epicsString.h>
+#include <alarm.h>
+#include <recGbl.h>
+#include <epicsStdio.h> // redirect stdout/stderr
+
+#include <pv/current_function.h>
+
+#define epicsExportSharedSymbols
+#include <shareLib.h>
+
+#include "pvalink.h"
+
+
+namespace {
+
+using namespace pvalink;
+
+#define TRY pvaLink *self = static_cast<pvaLink*>(plink->value.json.jlink); assert(self->alive); try
+#define CATCH() catch(std::exception& e) { \
+    errlogPrintf("pvaLink %s fails %s: %s\n", CURRENT_FUNCTION, plink->precord->name, e.what()); \
+}
+
+#define CHECK_VALID() if(!self->valid()) { DEBUG(self, <<CURRENT_FUNCTION<<" "<<self->channelName<<" !valid"); return -1;}
+
+void pvaOpenLink(DBLINK *plink)
+{
+    try {
+        pvaLink* self((pvaLink*)plink->value.json.jlink);
+
+        // workaround for Base not propagating info(base:lsetDebug to us
+        {
+            pdbRecordIterator rec(plink->precord);
+
+            if(epicsStrCaseCmp(rec.info("base:lsetDebug", "NO"), "YES")==0) {
+                self->debug = 1;
+            }
+        }
+
+        DEBUG(self, <<plink->precord->name<<" OPEN "<<self->channelName);
+
+        // still single threaded at this point.
+        // also, no pvaLinkChannel::lock yet
+
+        self->plink = plink;
+
+        if(self->channelName.empty())
+            return; // nothing to do...
+
+        pvd::PVStructure::const_shared_pointer pvRequest(self->makeRequest());
+        pvaGlobal_t::channels_key_t key;
+
+        {
+            std::ostringstream strm;
+            strm<<*pvRequest; // print the request as a convient key for our channel cache
+
+            key = std::make_pair(self->channelName, strm.str());
+        }
+
+        std::tr1::shared_ptr<pvaLinkChannel> chan;
+        bool doOpen = false;
+        {
+            Guard G(pvaGlobal->lock);
+
+            pvaGlobal_t::channels_t::iterator it(pvaGlobal->channels.find(key));
+
+            if(it!=pvaGlobal->channels.end()) {
+                // re-use existing channel
+                chan = it->second.lock();
+            }
+
+            if(!chan) {
+                // open new channel
+
+                chan.reset(new pvaLinkChannel(key, pvRequest));
+                pvaGlobal->channels.insert(std::make_pair(key, chan));
+                doOpen = true;
+            }
+
+            doOpen &= pvaGlobal->running; // if not running, then open from initHook
+        }
+
+        if(doOpen) {
+            chan->open(); // start subscription
+        }
+
+        if(!self->local || chan->providerName=="QSRV"){
+            Guard G(chan->lock);
+
+            chan->links.insert(self);
+            chan->links_changed = true;
+
+            self->lchan.swap(chan); // we are now attached
+
+            self->lchan->debug |= !!self->debug;
+        } else {
+            // TODO: only print duing iocInit()?
+            fprintf(stderr, "%s Error: local:true link to '%s' can't be fulfilled\n",
+                   plink->precord->name, self->channelName.c_str());
+            plink->lset = NULL;
+        }
+
+        return;
+    }CATCH()
+    // on error, prevent any further calls to our lset functions
+    plink->lset = NULL;
+}
+
+void pvaRemoveLink(struct dbLocker *locker, DBLINK *plink)
+{
+    try {
+        p2p::auto_ptr<pvaLink> self((pvaLink*)plink->value.json.jlink);
+        DEBUG(self, <<plink->precord->name<<" "<<CURRENT_FUNCTION<<" "<<self->channelName);
+        assert(self->alive);
+
+    }CATCH()
+}
+
+int pvaIsConnected(const DBLINK *plink)
+{
+    TRY {
+        Guard G(self->lchan->lock);
+
+        bool ret = self->valid();
+        DEBUG(self, <<plink->precord->name<<" "<<CURRENT_FUNCTION<<" "<<self->channelName<<" "<<ret);
+        return ret;
+
+    }CATCH()
+    return 0;
+}
+
+int pvaGetDBFtype(const DBLINK *plink)
+{
+    TRY {
+        Guard G(self->lchan->lock);
+        CHECK_VALID();
+
+        // if fieldName is empty, use top struct value
+        // if fieldName not empty
+        //    if sub-field is struct, use sub-struct .value
+        //    if sub-field not struct, treat as value
+
+        pvd::PVField::const_shared_pointer value(self->getSubField("value"));
+
+        pvd::ScalarType ftype = pvd::pvInt; // default for un-mapable types.
+        if(!value) {
+            // no-op
+        } else if(value->getField()->getType()==pvd::scalar)
+            ftype = static_cast<const pvd::Scalar*>(value->getField().get())->getScalarType();
+        else if(value->getField()->getType()==pvd::scalarArray)
+            ftype = static_cast<const pvd::ScalarArray*>(value->getField().get())->getElementType();
+
+        int ret;
+        switch(ftype) {
+#define CASE(BASETYPE, PVATYPE, DBFTYPE, PVACODE) case pvd::pv##PVACODE: ret = DBF_##DBFTYPE;
+#define CASE_REAL_INT64
+#include "pv/typemap.h"
+#undef CASE_REAL_INT64
+#undef CASE
+        case pvd::pvString: ret = DBF_STRING; // TODO: long string?
+        }
+
+        DEBUG(self, <<plink->precord->name<<" "<<CURRENT_FUNCTION<<" "<<self->channelName<<" "<<dbGetFieldTypeString(ret));
+        return ret;
+
+    }CATCH()
+    return -1;
+}
+
+long pvaGetElements(const DBLINK *plink, long *nelements)
+{
+    TRY {
+        Guard G(self->lchan->lock);
+        CHECK_VALID();
+
+        long ret = 0;
+        if(self->fld_value && self->fld_value->getField()->getType()==pvd::scalarArray)
+            ret = static_cast<const pvd::PVScalarArray*>(self->fld_value.get())->getLength();
+
+        DEBUG(self, <<plink->precord->name<<" "<<CURRENT_FUNCTION<<" "<<self->channelName<<" "<<ret);
+
+        return ret;
+    }CATCH()
+    return -1;
+}
+
+long pvaGetValue(DBLINK *plink, short dbrType, void *pbuffer,
+        long *pnRequest)
+{
+    TRY {
+        Guard G(self->lchan->lock);
+
+        if(!self->valid()) {
+            // disconnected
+            if(self->ms != pvaLink::NMS) {
+                recGblSetSevr(plink->precord, LINK_ALARM, self->snap_severity);
+            }
+            // TODO: better capture of disconnect time
+            epicsTimeGetCurrent(&self->snap_time);
+            if(self->time) {
+                plink->precord->time = self->snap_time;
+            }
+            DEBUG(self, <<CURRENT_FUNCTION<<" "<<self->channelName<<" !valid");
+            return -1;
+        }
+
+        if(self->fld_value) {
+            long status = copyPVD2DBF(self->fld_value, pbuffer, dbrType, pnRequest);
+            if(status) {
+                DEBUG(self, <<plink->precord->name<<" "<<CURRENT_FUNCTION<<" "<<self->channelName<<" "<<status);
+                return status;
+            }
+        }
+
+        if(self->fld_seconds) {
+            self->snap_time.secPastEpoch = self->fld_seconds->getAs<pvd::uint32>() - POSIX_TIME_AT_EPICS_EPOCH;
+            if(self->fld_nanoseconds) {
+                self->snap_time.nsec = self->fld_nanoseconds->getAs<pvd::uint32>();
+            } else {
+                self->snap_time.nsec = 0u;
+            }
+        } else {
+            self->snap_time.secPastEpoch = 0u;
+            self->snap_time.nsec = 0u;
+        }
+
+        if(self->fld_severity) {
+            self->snap_severity = self->fld_severity->getAs<pvd::uint16>();
+        } else {
+            self->snap_severity = NO_ALARM;
+        }
+
+        if((self->snap_severity!=NO_ALARM && self->ms == pvaLink::MS) ||
+           (self->snap_severity==INVALID_ALARM && self->ms == pvaLink::MSI))
+        {
+            recGblSetSevr(plink->precord, LINK_ALARM, self->snap_severity);
+        }
+
+        if(self->time) {
+            plink->precord->time = self->snap_time;
+        }
+
+        DEBUG(self, <<plink->precord->name<<" "<<CURRENT_FUNCTION<<" "<<self->channelName<<" OK");
+        return 0;
+    }CATCH()
+    return -1;
+}
+
+long pvaGetControlLimits(const DBLINK *plink, double *lo, double *hi)
+{
+    TRY {
+        Guard G(self->lchan->lock);
+        CHECK_VALID();
+
+        if(self->fld_control) {
+            pvd::PVScalar::const_shared_pointer value;
+            if(lo) {
+                value = std::tr1::static_pointer_cast<const pvd::PVScalar>(self->fld_control->getSubField("limitLow"));
+                *lo = value ? value->getAs<double>() : 0.0;
+            }
+            if(hi) {
+                value = std::tr1::static_pointer_cast<const pvd::PVScalar>(self->fld_control->getSubField("limitHigh"));
+                *hi = value ? value->getAs<double>() : 0.0;
+            }
+        } else {
+            *lo = *hi = 0.0;
+        }
+        DEBUG(self, <<plink->precord->name<<" "<<CURRENT_FUNCTION<<" "<<self->channelName<<" "<<(lo ? *lo : 0)<<" "<<(hi ? *hi : 0));
+        return 0;
+    }CATCH()
+    return -1;
+}
+
+long pvaGetGraphicLimits(const DBLINK *plink, double *lo, double *hi)
+{
+    TRY {
+        Guard G(self->lchan->lock);
+        CHECK_VALID();
+
+        if(self->fld_display) {
+            pvd::PVScalar::const_shared_pointer value;
+            if(lo) {
+                value = std::tr1::static_pointer_cast<const pvd::PVScalar>(self->fld_display->getSubField("limitLow"));
+                *lo = value ? value->getAs<double>() : 0.0;
+            }
+            if(hi) {
+                value = std::tr1::static_pointer_cast<const pvd::PVScalar>(self->fld_display->getSubField("limitHigh"));
+                *hi = value ? value->getAs<double>() : 0.0;
+            }
+        } else {
+            *lo = *hi = 0.0;
+        }
+        DEBUG(self, <<plink->precord->name<<" "<<CURRENT_FUNCTION<<" "<<self->channelName<<" "<<(lo ? *lo : 0)<<" "<<(hi ? *hi : 0));
+        return 0;
+    }CATCH()
+    return -1;
+}
+
+long pvaGetAlarmLimits(const DBLINK *plink, double *lolo, double *lo,
+        double *hi, double *hihi)
+{
+    TRY {
+        //Guard G(self->lchan->lock);
+        //CHECK_VALID();
+        *lolo = *lo = *hi = *hihi = 0.0;
+        DEBUG(self, <<plink->precord->name<<" "<<CURRENT_FUNCTION<<" "<<self->channelName<<" "<<(lolo ? *lolo : 0)<<" "<<(lo ? *lo : 0)<<" "<<(hi ? *hi : 0)<<" "<<(hihi ? *hihi : 0));
+        return 0;
+    }CATCH()
+    return -1;
+}
+
+long pvaGetPrecision(const DBLINK *plink, short *precision)
+{
+    TRY {
+        //Guard G(self->lchan->lock);
+        //CHECK_VALID();
+
+        // No sane way to recover precision from display.format string.
+        *precision = 0;
+        DEBUG(self, <<plink->precord->name<<" "<<CURRENT_FUNCTION<<" "<<self->channelName<<" "<<precision);
+        return 0;
+    }CATCH()
+    return -1;
+}
+
+long pvaGetUnits(const DBLINK *plink, char *units, int unitsSize)
+{
+    TRY {
+        Guard G(self->lchan->lock);
+        CHECK_VALID();
+
+        if(unitsSize==0) return 0;
+
+        if(units && self->fld_display) {
+            pvd::PVString::const_shared_pointer value(std::tr1::static_pointer_cast<const pvd::PVString>(self->fld_display->getSubField("units")));
+            if(value) {
+                const std::string& egu = value->get();
+                strncpy(units, egu.c_str(), unitsSize);
+            }
+        } else if(units) {
+            units[0] = '\0';
+        }
+        units[unitsSize-1] = '\0';
+        DEBUG(self, <<plink->precord->name<<" "<<CURRENT_FUNCTION<<" "<<self->channelName<<" "<<units);
+        return 0;
+    }CATCH()
+    return -1;
+}
+
+long pvaGetAlarm(const DBLINK *plink, epicsEnum16 *status,
+        epicsEnum16 *severity)
+{
+    TRY {
+        Guard G(self->lchan->lock);
+        CHECK_VALID();
+
+        if(severity) {
+            *severity = self->snap_severity;
+        }
+        if(status) {
+            *status = self->snap_severity ? LINK_ALARM : NO_ALARM;
+        }
+
+        DEBUG(self, <<plink->precord->name<<" "<<CURRENT_FUNCTION<<" "<<self->channelName<<" "<<(severity ? *severity : 0)<<" "<<(status ? *status : 0));
+        return 0;
+    }CATCH()
+    return -1;
+}
+
+long pvaGetTimeStamp(const DBLINK *plink, epicsTimeStamp *pstamp)
+{
+    TRY {
+        Guard G(self->lchan->lock);
+        CHECK_VALID();
+
+        if(pstamp) {
+            *pstamp = self->snap_time;
+        }
+
+        DEBUG(self, <<plink->precord->name<<" "<<CURRENT_FUNCTION<<" "<<self->channelName<<" "<<(pstamp ? pstamp->secPastEpoch : 0)<<":"<<(pstamp ? pstamp->nsec: 0));
+        return 0;
+    }CATCH()
+    return -1;
+}
+
+// note that we handle DBF_ENUM differently than in pvif.cpp
+pvd::ScalarType DBR2PVD(short dbr)
+{
+    switch(dbr) {
+#define CASE(BASETYPE, PVATYPE, DBFTYPE, PVACODE) case DBR_##DBFTYPE: return pvd::pv##PVACODE;
+#define CASE_SKIP_BOOL
+#define CASE_REAL_INT64
+#include "pv/typemap.h"
+#undef CASE_SKIP_BOOL
+#undef CASE_REAL_INT64
+#undef CASE
+    case DBF_ENUM: return pvd::pvUShort;
+    case DBF_STRING: return pvd::pvString;
+    }
+    throw std::invalid_argument("Unsupported DBR code");
+}
+
+long pvaPutValue(DBLINK *plink, short dbrType,
+        const void *pbuffer, long nRequest)
+{
+    TRY {
+        (void)self;
+        Guard G(self->lchan->lock);
+
+        if(nRequest < 0) return -1;
+
+        if(!self->retry && !self->valid()) {
+            DEBUG(self, <<CURRENT_FUNCTION<<" "<<self->channelName<<" !valid");
+            return -1;
+        }
+
+        pvd::ScalarType stype = DBR2PVD(dbrType);
+
+        pvd::shared_vector<const void> buf;
+
+        if(dbrType == DBF_STRING) {
+            const char *sbuffer = (const char*)pbuffer;
+            pvd::shared_vector<std::string> sval(nRequest);
+
+            for(long n=0; n<nRequest; n++, sbuffer += MAX_STRING_SIZE) {
+                sval[n] = std::string(sbuffer, epicsStrnLen(sbuffer, MAX_STRING_SIZE));
+            }
+
+            self->put_scratch = pvd::static_shared_vector_cast<const void>(pvd::freeze(sval));
+
+        } else {
+            pvd::shared_vector<void> val(pvd::ScalarTypeFunc::allocArray(stype, size_t(nRequest)));
+
+            assert(size_t(dbValueSize(dbrType)*nRequest) == val.size());
+
+            memcpy(val.data(), pbuffer, val.size());
+
+            self->put_scratch = pvd::freeze(val);
+        }
+
+        self->used_scratch = true;
+
+        if(!self->defer) self->lchan->put();
+
+        DEBUG(self, <<plink->precord->name<<" "<<CURRENT_FUNCTION<<" "<<self->channelName<<" "<<self->lchan->op_put.valid());
+        return 0;
+    }CATCH()
+    return -1;
+}
+
+void pvaScanForward(DBLINK *plink)
+{
+    TRY {
+        Guard G(self->lchan->lock);
+
+        if(!self->retry && !self->valid()) {
+            return;
+        }
+
+        // FWD_LINK is never deferred, and always results in a Put
+        self->lchan->put(true);
+
+        DEBUG(self, <<plink->precord->name<<" "<<CURRENT_FUNCTION<<" "<<self->channelName<<" "<<self->lchan->op_put.valid());
+    }CATCH()
+}
+
+#undef TRY
+#undef CATCH
+
+} //namespace
+
+namespace pvalink {
+
+lset pva_lset = {
+    0, 1, // non-const, volatile
+    &pvaOpenLink,
+    &pvaRemoveLink,
+    NULL, NULL, NULL,
+    &pvaIsConnected,
+    &pvaGetDBFtype,
+    &pvaGetElements,
+    &pvaGetValue,
+    &pvaGetControlLimits,
+    &pvaGetGraphicLimits,
+    &pvaGetAlarmLimits,
+    &pvaGetPrecision,
+    &pvaGetUnits,
+    &pvaGetAlarm,
+    &pvaGetTimeStamp,
+    &pvaPutValue,
+    NULL,
+    &pvaScanForward
+    //&pvaReportLink,
+};
+
+} //namespace pvalink

pdbApp/pvalink_null.cpp

@@ -0,0 +1,16 @@
+
+#include <epicsExport.h>
+
+static void installPVAAddLinkHook() {}
+
+struct jlif {} lsetPVA;
+
+extern "C" {
+int pvaLinkDebug;
+int pvaLinkNWorkers;
+
+    epicsExportRegistrar(installPVAAddLinkHook);
+    epicsExportAddress(jlif, lsetPVA);
+    epicsExportAddress(int, pvaLinkDebug);
+    epicsExportAddress(int, pvaLinkNWorkers);
+}

pdbApp/pvif.cpp

@@ -11,6 +11,7 @@
 #include <alarm.h>
 #include <errSymTbl.h>
 #include <epicsVersion.h>
+#include <errlog.h>
 
 #include <pv/status.h>
 #include <pv/bitSet.h>
@@ -19,6 +20,7 @@
 #include <pv/reftrack.h>
 
 #define epicsExportSharedSymbols
+#include "sb.h"
 #include "pvif.h"
 
 #include <epicsExport.h>
@@ -26,44 +28,31 @@
 #ifdef EPICS_VERSION_INT
 #  if EPICS_VERSION_INT>=VERSION_INT(3,16,1,0)
 #    define USE_INT64
+     // effects all uses of pv/typemap.h
+#    define CASE_REAL_INT64
 #  endif
 #endif
 
-extern "C" {
-int qsrvDisableFormat = 1;
-}
-
 namespace pvd = epics::pvData;
 
 DBCH::DBCH(dbChannel *ch) :chan(ch)
 {
-    if(dbChannelOpen(chan)) {
-        dbChannelDelete(chan);
-        throw std::invalid_argument("Failed to open channel");
-    }
-    if(!chan)
-        throw std::invalid_argument(std::string("Invalid channel ")+dbChannelName(ch));
+    prepare();
 }
 
 DBCH::DBCH(const std::string& name)
     :chan(dbChannelCreate(name.c_str()))
 {
-    if(!chan)
-        throw std::invalid_argument("Invalid channel");
-    if(dbChannelOpen(chan)) {
-        dbChannelDelete(chan);
-        throw std::invalid_argument("Failed to open channel "+name);
-    }
+    prepare();
 }
 
-DBCH::DBCH(const char *name)
-    :chan(dbChannelCreate(name))
+void DBCH::prepare()
 {
     if(!chan)
-        throw std::invalid_argument("Invalid channel");
+        throw std::invalid_argument("NULL channel");
     if(dbChannelOpen(chan)) {
         dbChannelDelete(chan);
-        throw std::invalid_argument(std::string("Failed to open channel ")+name);
+        throw std::invalid_argument(SB()<<"Failed to open channel "<<dbChannelName(chan));
     }
 }
 
@@ -102,7 +91,8 @@ struct pvCommon : public pvTimeAlarm {
     pvd::BitSet maskVALUE, maskPROPERTY, maskVALUEPut;
 
     pvd::PVDoublePtr displayLow, displayHigh, controlLow, controlHigh;
-    pvd::PVStringPtr egu, desc, prec;
+    pvd::PVStringPtr egu, desc;
+    pvd::PVIntPtr fmt, prec;
 
     pvd::PVScalarPtr warnLow, warnHigh, alarmLow, alarmHigh;
 
@@ -183,9 +173,32 @@ void attachTime(pvTimeAlarm& pvm, const pvd::PVStructurePtr& pv)
 #undef FMAP
 }
 
+static
+pvd::shared_vector<const std::string> buildFormats()
+{
+    pvd::shared_vector<std::string> fmt;
+    fmt.push_back("Default");
+    fmt.push_back("String");
+    fmt.push_back("Binary");
+    fmt.push_back("Decimal");
+    fmt.push_back("Hex");
+    fmt.push_back("Exponential");
+    fmt.push_back("Engineering");
+    return pvd::freeze(fmt);
+}
+
+static const
+pvd::shared_vector<const std::string> displayForms(buildFormats());
+
 // lookup fields and populate pvCommon.  Non-existant fields will be NULL.
 void attachMeta(pvCommon& pvm, const pvd::PVStructurePtr& pv)
 {
+    {
+        pvd::PVStructurePtr fmt(pv->getSubField<pvd::PVStructure>("display.form"));
+        if(fmt) {
+            fmt->getSubFieldT<pvd::PVStringArray>("choices")->replace(displayForms);
+        }
+    }
     attachTime(pvm, pv);
 #define FMAP(MNAME, PVT, FNAME, DBE) pvm.MNAME = pv->getSubField<pvd::PVT>(FNAME); \
         if(pvm.MNAME) pvm.mask ## DBE.set(pvm.MNAME->getFieldOffset())
@@ -195,7 +208,8 @@ void attachMeta(pvCommon& pvm, const pvd::PVStructurePtr& pv)
     FMAP(controlLow, PVDouble, "control.limitLow", PROPERTY);
     FMAP(egu, PVString, "display.units", PROPERTY);
     FMAP(desc, PVString, "display.description", PROPERTY);
-    FMAP(prec,  PVString, "display.format", PROPERTY);
+    FMAP(prec, PVInt, "display.precision", PROPERTY);
+    FMAP(fmt,  PVInt, "display.form.index", PROPERTY);
     FMAP(warnHigh, PVScalar, "valueAlarm.highWarningLimit", PROPERTY);
     FMAP(warnLow,  PVScalar, "valueAlarm.lowWarningLimit", PROPERTY);
     FMAP(alarmHigh, PVScalar, "valueAlarm.highAlarmLimit", PROPERTY);
@@ -269,6 +283,18 @@ void mapStatus(unsigned code, pvd::PVInt* status, pvd::PVString* message)
     status->put(out);
 }
 
+
+template<typename META>
+void putMetaImpl(const pvTimeAlarm& pv, const META& meta)
+{
+    pvd::int32 nsec = meta.time.nsec;
+    if(pv.nsecMask) {
+        pv.userTag->put(nsec&pv.nsecMask);
+        nsec &= ~pv.nsecMask;
+    }
+    pv.nsec->put(nsec);    pv.sec->put(meta.time.secPastEpoch+POSIX_TIME_AT_EPICS_EPOCH);
+}
+
 void putTime(const pvTimeAlarm& pv, unsigned dbe, db_field_log *pfl)
 {
     metaTIME meta;
@@ -278,12 +304,7 @@ void putTime(const pvTimeAlarm& pv, unsigned dbe, db_field_log *pfl)
     if(status)
         throw std::runtime_error("dbGet for meta fails");
 
-    pvd::int32 nsec = meta.time.nsec;
-    if(pv.nsecMask) {
-        pv.userTag->put(nsec&pv.nsecMask);
-        nsec &= ~pv.nsecMask;
-    }
-    pv.nsec->put(nsec);    pv.sec->put(meta.time.secPastEpoch+POSIX_TIME_AT_EPICS_EPOCH);
+    putMetaImpl(pv, meta);
     if(dbe&DBE_ALARM) {
         mapStatus(meta.status, pv.status.get(), pv.message.get());
         pv.severity->put(meta.severity);
@@ -299,6 +320,11 @@ void putValue(dbChannel *chan, pvd::PVScalar* value, db_field_log *pfl)
     if(status)
         throw std::runtime_error("dbGet for meta fails");
 
+    if(nReq==0) {
+        // this was an actual max length 1 array, which has zero elements now.
+        memset(&buf, 0, sizeof(buf));
+    }
+
     switch(dbChannelFinalFieldType(chan)) {
 #define CASE(BASETYPE, PVATYPE, DBFTYPE, PVACODE) case DBR_##DBFTYPE: value->putFrom<PVATYPE>(buf.dbf_##DBFTYPE); break;
 #define CASE_ENUM
@@ -412,7 +438,6 @@ void putValue(dbChannel *chan, pvd::PVScalarArray* value, db_field_log *pfl)
         value->putFrom(pvd::freeze(buf));
     }
 }
-
 template<typename META>
 void putMeta(const pvCommon& pv, unsigned dbe, db_field_log *pfl)
 {
@@ -424,14 +449,8 @@ void putMeta(const pvCommon& pv, unsigned dbe, db_field_log *pfl)
     if(status)
         throw std::runtime_error("dbGet for meta fails");
 
-    pvd::int32 nsec = meta.time.nsec;
-    if(pv.nsecMask) {
-        pv.userTag->put(nsec&pv.nsecMask);
-        nsec &= ~pv.nsecMask;
-    }
-    pv.nsec->put(nsec);
+    putMetaImpl(pv, meta);
 #define FMAP(MNAME, FNAME) pv.MNAME->put(meta.FNAME)
-    FMAP(sec, time.secPastEpoch+POSIX_TIME_AT_EPICS_EPOCH);
     if(dbe&DBE_ALARM) {
         mapStatus(meta.status, pv.status.get(), pv.message.get());
         FMAP(severity, severity);
@@ -446,61 +465,12 @@ void putMeta(const pvCommon& pv, unsigned dbe, db_field_log *pfl)
         FMAP(DBR_CTRL_DOUBLE, controlLow, lower_ctrl_limit);
         FMAP(DBR_GR_DOUBLE, egu, units);
 #undef FMAP
-        if(META::mask&DBR_PRECISION && pv.prec && !qsrvDisableFormat) {
-            // construct printf() style format.
-            // Widths based on epicsTypes.h
-            char buf[8];
-            char *pos = &buf[8]; // build string in reverse order
-            bool ok = true;
-
-            *--pos = '\0'; // buf[7] = '\0'
-
-            switch(dbChannelFinalFieldType(pv.chan)) {
-#ifdef USE_INT64
-            case DBF_UINT64:
-                *--pos = 'l';
-                *--pos = 'l';
-#endif
-            case DBF_UCHAR:
-            case DBF_USHORT:
-            case DBF_ULONG:
-                *--pos = 'u';
-                break;
-#ifdef USE_INT64
-            case DBF_INT64:
-                *--pos = 'l';
-                *--pos = 'l';
-#endif
-            case DBF_CHAR:
-            case DBF_SHORT:
-            case DBF_LONG:
-                *--pos = 'd';
-                break;
-            case DBF_DOUBLE:
-            case DBF_FLOAT:
-                *--pos = 'g'; // either decimal or scientific
-                break;
-            case DBF_STRING:
-                *--pos = 's';
-                break;
-            default:
-                ok = false;
-            }
-
-            if(ok) {
-                long dp = meta.precision.dp;
-                if(dp<0) dp = 0;
-                else if(dp>=99) dp = 99;
-                for(;dp;dp = dp/10u) {
-                    *--pos = '0'+(dp%10u);
-                }
-                *--pos = '%';
-            }
-            pv.prec->put(pos);
+        if(META::mask&DBR_PRECISION && pv.prec) {
+            pv.prec->put(pvd::int32(meta.precision.dp));
         }
 #define FMAP(MASK, MNAME, FNAME) if(META::mask&(MASK) && pv.MNAME) pv.MNAME->putFrom(meta.FNAME)
         // not handling precision until I get a better idea of what 'format' is supposed to be...
-        //FMAP(prec,  PVScalar, "display.format", PROPERTY);
+        //FMAP(prec,  PVScalar, "display.form", PROPERTY);
         FMAP(DBR_AL_DOUBLE, warnHigh, upper_warning_limit);
         FMAP(DBR_AL_DOUBLE, warnLow,  lower_warning_limit);
         FMAP(DBR_AL_DOUBLE, alarmHigh, upper_alarm_limit);
@@ -531,15 +501,15 @@ void putAll(const PVC &pv, unsigned dbe, db_field_log *pfl)
     }
 }
 
-void findNSMask(pvTimeAlarm& pvmeta, dbChannel *chan, const epics::pvData::PVStructurePtr& pvalue)
+void findNSMask(pvTimeAlarm& pvmeta, pdbRecordIterator& info, const epics::pvData::PVStructurePtr& pvalue)
 {
-    pdbRecordIterator info(chan);
     const char *UT = info.info("Q:time:tag");
     if(UT && strncmp(UT, "nsec:lsb:", 9)==0) {
         try{
             pvmeta.nsecMask = epics::pvData::castUnsafe<pvd::uint32>(std::string(&UT[9]));
         }catch(std::exception& e){
-            std::cerr<<dbChannelRecord(chan)->name<<" : Q:time:tag nsec:lsb: requires a number not '"<<UT[9]<<"'\n";
+            pvmeta.nsecMask = 0;
+            std::cerr<<info.name()<<" : Q:time:tag nsec:lsb: requires a number not '"<<UT[9]<<"'\n";
         }
     }
     if(pvmeta.nsecMask>0 && pvmeta.nsecMask<=32) {
@@ -555,6 +525,29 @@ void findNSMask(pvTimeAlarm& pvmeta, dbChannel *chan, const epics::pvData::PVStr
         pvmeta.nsecMask = 0;
 }
 
+void findFormat(pvTimeAlarm& pvmeta, pdbRecordIterator& info, const epics::pvData::PVStructurePtr& pvalue)
+{
+    const char *FMT = info.info("Q:form");
+    if(FMT) {
+        pvd::PVScalarPtr fmt(pvalue->getSubField<pvd::PVScalar>("display.form.index"));
+        if(fmt) {
+            bool found = false;
+            for(size_t i=0; !found && i<displayForms.size(); i++) {
+                if((found=(displayForms[i]==FMT)))
+                    fmt->putFrom<pvd::uint32>(i);
+            }
+            if(!found) {
+                try {
+                    fmt->putFrom(std::string(FMT)); // attempt to parse as number
+                }catch(std::exception& e){
+                    errlogPrintf("%s: info(Q:form, \"%s\") is not known format: %s\n", info.name(), FMT, e.what());
+                }
+            }
+        }
+    }
+}
+
+
 template<typename PVX, typename META>
 struct PVIFScalarNumeric : public PVIF
 {
@@ -585,7 +578,9 @@ struct PVIFScalarNumeric : public PVIF
             pvmeta.maskVALUEPut.set(0);
             pvmeta.maskVALUEPut.set(bit);
         }
-        findNSMask(pvmeta, chan, pvalue);
+        pdbRecordIterator info(chan);
+        findNSMask(pvmeta, info, pvalue);
+        findFormat(pvmeta, info, pvalue);
     }
     virtual ~PVIFScalarNumeric() {}
 
@@ -610,8 +605,11 @@ struct PVIFScalarNumeric : public PVIF
     virtual pvd::Status get(const epics::pvData::BitSet& mask, proc_t proc) OVERRIDE FINAL
     {
         pvd::Status ret;
-        if(mask.logical_and(pvmeta.maskVALUEPut)) {
+        bool newval = mask.logical_and(pvmeta.maskVALUEPut);
+        if(newval) {
             getValue(pvmeta.chan, pvmeta.value.get());
+        }
+        if(newval || proc==PVIF::ProcForce) {
             ret = PVIF::get(mask, proc);
         }
         return ret;
@@ -632,6 +630,7 @@ struct PVIFScalarNumeric : public PVIF
 
 } // namespace
 
+static
 pvd::ScalarType DBR2PVD(short dbr)
 {
     switch(dbr) {
@@ -643,22 +642,25 @@ pvd::ScalarType DBR2PVD(short dbr)
 #undef CASE_SKIP_BOOL
 #undef CASE
     case DBF_STRING: return pvd::pvString;
-    default:
-        throw std::invalid_argument("Unsupported DBR code");
     }
+    throw std::invalid_argument("Unsupported DBR code");
 }
 
 short PVD2DBR(pvd::ScalarType pvt)
 {
     switch(pvt) {
 #define CASE(BASETYPE, PVATYPE, DBFTYPE, PVACODE) case pvd::pv##PVACODE: return DBR_##DBFTYPE;
-#define CASE_SQUEEZE_INT64
+#ifndef USE_INT64
+#  define CASE_SQUEEZE_INT64
+#endif
 #include "pv/typemap.h"
-#undef CASE_SQUEEZE_INT64
+#ifndef USE_INT64
+#  undef CASE_SQUEEZE_INT64
+#endif
 #undef CASE
-    default:
-        throw std::invalid_argument("Unsupported pvType code");
+    case pvd::pvString: return DBF_STRING;
     }
+    return -1;
 }
 
 epics::pvData::FieldConstPtr
@@ -674,19 +676,45 @@ ScalarBuilder::dtype(dbChannel *channel)
     if(maxelem!=1 && dbr==DBR_ENUM)
         dbr = DBF_SHORT;
 
+    pvd::FieldBuilderPtr builder(pvd::getFieldCreate()->createFieldBuilder());
+    pvd::StandardFieldPtr standard(pvd::getStandardField());
+
     if(dbr==DBR_ENUM)
-        return pvd::getStandardField()->enumerated("alarm,timeStamp");
-
-    std::string options;
-    if(dbr!=DBR_STRING)
-        options = "alarm,timeStamp,display,control,valueAlarm";
+        builder = builder->setId("epics:nt/NTEnum:1.0")
+                         ->addNestedStructure("value")
+                            ->add("index", pvd::pvInt)
+                            ->addArray("choices", pvd::pvString)
+                         ->endNested();
+    else if(maxelem==1)
+        builder = builder->setId("epics:nt/NTScalar:1.0")
+                         ->add("value", pvt);
     else
-        options = "alarm,timeStamp,display,control";
+        builder = builder->setId("epics:nt/NTScalarArray:1.0")
+                         ->addArray("value", pvt);
 
-    if(maxelem==1)
-        return pvd::getStandardField()->scalar(pvt, options);
-    else
-        return pvd::getStandardField()->scalarArray(pvt, options);
+    builder = builder->add("alarm", standard->alarm())
+                     ->add("timeStamp", standard->timeStamp());
+
+    if(dbr!=DBR_ENUM) {
+        builder = builder->addNestedStructure("display")
+                            ->add("limitLow", pvd::pvDouble)
+                            ->add("limitHigh", pvd::pvDouble)
+                            ->add("description", pvd::pvString)
+                            ->add("units", pvd::pvString)
+                            ->add("precision", pvd::pvInt)
+                            ->addNestedStructure("form")
+                                ->setId("enum_t")
+                                ->add("index", pvd::pvInt)
+                                ->addArray("choices", pvd::pvString)
+                            ->endNested()
+                         ->endNested()
+                         ->add("control", standard->control());
+
+        if(dbr!=DBR_STRING)
+            builder = builder->add("valueAlarm", standard->doubleAlarm());
+    }
+
+    return builder->createStructure();
 }
 
 PVIF*
@@ -699,7 +727,6 @@ ScalarBuilder::attach(dbChannel *channel, const epics::pvData::PVStructurePtr& r
 
     const short dbr = dbChannelFinalFieldType(channel);
     const long maxelem = dbChannelFinalElements(channel);
-    //const pvd::ScalarType pvt = DBR2PVD(dbr);
 
     if(maxelem==1) {
         switch(dbr) {
@@ -709,6 +736,10 @@ ScalarBuilder::attach(dbChannel *channel, const epics::pvData::PVStructurePtr& r
         case DBR_USHORT:
         case DBR_LONG:
         case DBR_ULONG:
+#ifdef USE_INT64
+        case DBR_INT64:
+        case DBR_UINT64:
+#endif
             return new PVIFScalarNumeric<pvScalar, metaDOUBLE>(channel, fld, enclosing);
         case DBR_FLOAT:
         case DBR_DOUBLE:
@@ -729,6 +760,10 @@ ScalarBuilder::attach(dbChannel *channel, const epics::pvData::PVStructurePtr& r
         case DBR_ULONG:
         case DBR_STRING:
         case DBR_FLOAT:
+#ifdef USE_INT64
+        case DBR_INT64:
+        case DBR_UINT64:
+#endif
         case DBR_DOUBLE:
             return new PVIFScalarNumeric<pvArray, metaDOUBLE>(channel, fld, enclosing);
         }
@@ -771,8 +806,11 @@ struct PVIFPlain : public PVIF
     virtual pvd::Status get(const epics::pvData::BitSet& mask, proc_t proc)
     {
         pvd::Status ret;
-        if(mask.get(fieldOffset)) {
+        bool newval = mask.get(fieldOffset);
+        if(newval) {
             getValue(channel, field.get());
+        }
+        if(newval || proc==PVIF::ProcForce) {
             ret = PVIF::get(mask, proc);
         }
         return ret;
@@ -888,8 +926,10 @@ struct PVIFMeta : public PVIF
         if(!field)
             throw std::logic_error("PVIFMeta attached type mis-match");
         meta.chan = channel;
+        pdbRecordIterator info(chan);
         attachTime(meta, field);
-        findNSMask(meta, channel, field);
+        findNSMask(meta, info, field);
+        findFormat(meta, info, field);
         if(enclosing) {
             meta.maskALWAYS.clear();
             meta.maskALWAYS.set(enclosing->getFieldOffset());
@@ -1078,7 +1118,3 @@ PVIFBuilder* PVIFBuilder::create(const std::string& type)
     else
         throw std::runtime_error(std::string("Unknown +type=")+type);
 }
-
-extern "C" {
-    epicsExportAddress(int, qsrvDisableFormat);
-}

pdbApp/pvif.h

@@ -29,9 +29,19 @@
 #  define USE_MULTILOCK
 #endif
 
-epics::pvData::ScalarType DBR2PVD(short dbr);
 short PVD2DBR(epics::pvData::ScalarType pvt);
 
+// copy from PVField (.value sub-field) to DBF buffer
+epicsShareExtern
+long copyPVD2DBF(const epics::pvData::PVField::const_shared_pointer& in,
+                 void *outbuf, short outdbf, long *outnReq);
+// copy from DBF buffer to PVField (.value sub-field)
+epicsShareExtern
+long copyDBF2PVD(const epics::pvData::shared_vector<const void>& buf,
+                 const epics::pvData::PVField::shared_pointer& out,
+                 epics::pvData::BitSet &changed,
+                 const epics::pvData::PVStringArray::const_svector& choices);
+
 union dbrbuf {
         epicsInt8		dbf_CHAR;
         epicsUInt8		dbf_UCHAR;
@@ -42,6 +52,13 @@ union dbrbuf {
         epicsUInt32		dbf_ULONG;
         epicsFloat32	dbf_FLOAT;
         epicsFloat64    dbf_DOUBLE;
+
+#ifdef EPICS_VERSION_INT
+#  if EPICS_VERSION_INT>=VERSION_INT(3,16,1,0)
+        epicsInt64      dbf_INT64;
+        epicsUInt64     dbf_UINT64;
+#  endif
+#endif
         char		dbf_STRING[MAX_STRING_SIZE];
 };
 
@@ -50,7 +67,6 @@ struct epicsShareClass DBCH {
     DBCH() :chan(0) {}
     explicit DBCH(dbChannel *ch); // calls dbChannelOpen()
     explicit DBCH(const std::string& name);
-    explicit DBCH(const char *name);
     ~DBCH();
 
     void swap(DBCH&);
@@ -62,6 +78,7 @@ struct epicsShareClass DBCH {
 private:
     DBCH(const DBCH&);
     DBCH& operator=(const DBCH&);
+    void prepare();
 };
 
 struct pdbRecordInfo {
@@ -100,11 +117,22 @@ struct pdbRecordIterator {
     }
     pdbRecordIterator(const dbChannel *chan)
     {
+#if EPICS_VERSION_INT>=VERSION_INT(3,16,1,0)
+        dbInitEntryFromRecord(dbChannelRecord(chan), &ent);
+#else
         dbInitEntry(pdbbase, &ent);
         if(dbFindRecord(&ent, dbChannelRecord(chan)->name)!=0)
-            throw std::runtime_error("Record not found");
+            throw std::logic_error("Record not found");
+#endif
         m_done = false;
     }
+#if EPICS_VERSION_INT>=VERSION_INT(3,16,1,0)
+    pdbRecordIterator(dbCommon *prec)
+    {
+        dbInitEntryFromRecord(prec, &ent);
+        m_done = false;
+    }
+#endif
     ~pdbRecordIterator()
     {
         dbFinishEntry(&ent);
@@ -128,7 +156,7 @@ struct pdbRecordIterator {
         return m_done ? NULL : (dbCommon*)ent.precnode->precord;
     }
     const char *name() const {
-        return m_done ? NULL : ((dbCommon*)ent.precnode->precord)->name;
+        return m_done ? NULL : ent.precnode->recordname;
     }
     const char *info(const char *key, const char *def =0)
     {
@@ -225,7 +253,7 @@ struct DBManyLock
 {
     dbLocker *plock;
     DBManyLock() :plock(NULL) {}
-    DBManyLock(const std::vector<dbCommon*>& recs, unsigned flags)
+    DBManyLock(const std::vector<dbCommon*>& recs, unsigned flags=0)
         :plock(dbLockerAlloc((dbCommon**)&recs[0], recs.size(), flags))
     {
         if(!plock) throw std::invalid_argument("Failed to create locker");

pdbApp/qsrv-new.dbd

@@ -0,0 +1,17 @@
+# Changes to this file may require incrementing
+# the ABI version in CONFIG_QSRV_VERSION
+
+registrar(QSRVRegistrar)
+registrar(installPVAAddLinkHook)
+link("pva", "lsetPVA")
+
+# from demo.cpp
+device(waveform, CONSTANT, devWfPDBDemo, "QSRV Demo")
+# from imagedemo.c
+function(QSRV_image_demo)
+# from pdb.cpp
+# Extra debug info when parsing group definitions
+variable(PDBProviderDebug, int)
+# Number of worker threads for handling monitor updates.
+# Default: 1
+variable(pvaLinkNWorkers, int)

pdbApp/qsrv-old.dbd

@@ -2,16 +2,15 @@
 # the ABI version in CONFIG_QSRV_VERSION
 
 registrar(QSRVRegistrar)
-#registrar(installPVAAddLinkHook)
-#link("pva", "lsetPVA")
+registrar(installPVAAddLinkHook)
 
 # from demo.cpp
 device(waveform, CONSTANT, devWfPDBDemo, "QSRV Demo")
 # from imagedemo.c
 function(QSRV_image_demo)
-# from pvif.cpp
-# Disable mapping of display.format
-variable(qsrvDisableFormat, int)
 # from pdb.cpp
 # Extra debug info when parsing group definitions
 variable(PDBProviderDebug, int)
+# Number of worker threads for handling monitor updates.
+# Default: 1
+variable(pvaLinkNWorkers, int)

pdbApp/qsrv.cpp

@@ -1,5 +1,4 @@
 
-#include <epicsExport.h>
 #include <initHooks.h>
 #include <epicsExit.h>
 #include <epicsThread.h>
@@ -12,6 +11,7 @@
 #include <dbLock.h>
 #include <dbEvent.h>
 #include <epicsVersion.h>
+#include <dbNotify.h>
 
 #include <pv/reftrack.h>
 #include <pv/pvAccess.h>
@@ -20,6 +20,7 @@
 
 #define epicsExportSharedSymbols
 
+#include "pv/qsrv.h"
 #include "pvahelper.h"
 #include "pvif.h"
 #include "pdb.h"
@@ -28,6 +29,8 @@
 #  include "pdbgroup.h"
 #endif
 
+#include <epicsExport.h>
+
 namespace pva = epics::pvAccess;
 
 void QSRVRegistrar_counters()
@@ -91,6 +94,16 @@ void QSRVRegistrar()
 
 } // namespace
 
+unsigned qsrvVersion(void)
+{
+    return QSRV_VERSION_INT;
+}
+
+unsigned qsrvABIVersion(void)
+{
+    return QSRV_ABI_VERSION_INT;
+}
+
 extern "C" {
     epicsExportRegistrar(QSRVRegistrar);
 }

pdbApp/softMain.cpp

@@ -73,8 +73,13 @@
 
 extern "C" int softIocPVA_registerRecordDeviceDriver(struct dbBase *pdbbase);
 
+#ifdef __rtems__
+#define DBD_FILE "dbd/softIocPVA.dbd"
+#define EXIT_FILE "db/softIocExit.db"
+#else
 #define DBD_FILE FINAL_LOCATION "/dbd/softIocPVA.dbd"
 #define EXIT_FILE FINAL_LOCATION "/db/softIocExit.db"
+#endif
 
 #ifdef VERSION_INT
 #if EPICS_VERSION_INT>=VERSION_INT(3,15,0,1)

pdbApp/tpool.cpp

@@ -0,0 +1,136 @@
+
+#include <typeinfo>
+#include <stdexcept>
+
+#include <epicsEvent.h>
+#include <epicsGuard.h>
+#include <epicsThread.h>
+#include <errlog.h>
+
+#include <pv/sharedPtr.h>
+
+#define epicsExportSharedSymbols
+#include "helper.h"
+#include "tpool.h"
+
+typedef epicsGuard<epicsMutex> Guard;
+typedef epicsGuardRelease<epicsMutex> UnGuard;
+
+WorkQueue::WorkQueue(const std::string& name)
+    :name(name)
+    ,state(Idle)
+{}
+
+WorkQueue::~WorkQueue() { close(); }
+
+void WorkQueue::start(unsigned nworkers, unsigned prio)
+{
+    Guard G(mutex);
+
+    if(state!=Idle)
+        throw std::logic_error("Already started");
+
+    try {
+        state = Active;
+
+        for(unsigned i=0; i<nworkers; i++) {
+            p2p::auto_ptr<epicsThread> worker(new epicsThread(*this, name.c_str(),
+                                                              epicsThreadGetStackSize(epicsThreadStackSmall),
+                                                              prio));
+
+            worker->start();
+
+            workers.push_back(worker.get());
+            worker.release();
+        }
+    }catch(...){
+        UnGuard U(G); // unlock as close() blocks to join any workers which were started
+        close();
+        throw;
+    }
+}
+
+void WorkQueue::close()
+{
+    workers_t temp;
+
+    {
+        Guard G(mutex);
+        if(state!=Active)
+            return;
+
+        temp.swap(workers);
+        state = Stopping;
+    }
+
+    wakeup.signal();
+
+    for(workers_t::iterator it(temp.begin()), end(temp.end()); it!=end; ++it)
+    {
+        (*it)->exitWait();
+        delete *it;
+    }
+
+    {
+        Guard G(mutex);
+        state = Idle;
+    }
+}
+
+void WorkQueue::add(const value_type& work)
+{
+    bool empty;
+
+    {
+        Guard G(mutex);
+        if(state!=Active)
+            return;
+
+        empty = queue.empty();
+
+        queue.push_back(work);
+    }
+
+    if(empty) {
+        wakeup.signal();
+    }
+}
+
+void WorkQueue::run()
+{
+    Guard G(mutex);
+
+    std::tr1::shared_ptr<epicsThreadRunable> work;
+
+    while(state==Active) {
+
+        if(!queue.empty()) {
+            work = queue.front().lock();
+            queue.pop_front();
+        }
+
+        bool last = queue.empty();
+
+        {
+            UnGuard U(G);
+
+            if(work) {
+                try {
+                    work->run();
+                    work.reset();
+                }catch(std::exception& e){
+                    errlogPrintf("%s Unhandled exception from %s: %s\n",
+                                 name.c_str(), typeid(work.get()).name(), e.what());
+                    work.reset();
+                }
+            }
+
+            if(last) {
+                wakeup.wait();
+            }
+        }
+    }
+
+    // pass along the close() signal to next worker
+    wakeup.signal();
+}

pdbApp/tpool.h

@@ -0,0 +1,54 @@
+#ifndef TPOOL_H
+#define TPOOL_H
+
+#include <stdexcept>
+#include <deque>
+#include <vector>
+#include <string>
+
+#include <errlog.h>
+#include <epicsThread.h>
+#include <epicsMutex.h>
+#include <epicsEvent.h>
+
+#include <pv/sharedPtr.h>
+
+#include <shareLib.h>
+
+struct WorkQueue : private epicsThreadRunable
+{
+    typedef std::tr1::weak_ptr<epicsThreadRunable> value_type;
+
+private:
+    const std::string name;
+
+    epicsMutex mutex;
+
+    enum state_t {
+        Idle,
+        Active,
+        Stopping,
+    } state;
+
+    typedef std::deque<value_type> queue_t;
+    queue_t queue;
+
+    epicsEvent wakeup;
+
+    typedef std::vector<epicsThread*> workers_t;
+    workers_t workers;
+
+public:
+    WorkQueue(const std::string& name);
+    virtual ~WorkQueue();
+
+    void start(unsigned nworkers=1, unsigned prio = epicsThreadPriorityLow);
+    void close();
+
+    void add(const value_type& work);
+
+private:
+    virtual void run();
+};
+
+#endif // TPOOL_H

testApp/Makefile

@@ -14,6 +14,10 @@ p2pTestIoc_DBD += base.dbd
 # Tests explicitly create/destory PDB provider
 #p2pTestIoc_DBD += qsrv.dbd
 
+TARGETS += $(COMMON_DIR)/pvaLinkTestIoc.dbd
+pvaLinkTestIoc_DBD += base.dbd
+pvaLinkTestIoc_DBD += qsrv.dbd
+
 PROD_SRCS += utilitiesx.cpp
 PROD_LIBS += pvAccess pvData
 PROD_LIBS += $(EPICS_BASE_IOC_LIBS)
@@ -43,17 +47,24 @@ TESTS += testpdb
 PROD_HOST += check_consist
 check_consist_SRCS += check_consist.cpp
 
-#TESTPROD_HOST += testpvalink
-testpvalink_SRCS += testpvalink.cpp
-testpvalink_SRCS += p2pTestIoc_registerRecordDeviceDriver.cpp
-testpvalink_LIBS += qsrv
-#TESTS += testpvalink
-
 ifdef BASE_3_16
+TESTPROD_HOST += testpvalink
+testpvalink_SRCS += testpvalink.cpp
+testpvalink_SRCS += pvaLinkTestIoc_registerRecordDeviceDriver.cpp
+testpvalink_LIBS += qsrv
+TESTS += testpvalink
+
 TESTPROD_HOST += testgroupconfig
 testgroupconfig_SRCS += testgroupconfig
 testgroupconfig_LIBS += qsrv pvAccess pvData
 testgroupconfig_LIBS += $(EPICS_BASE_IOC_LIBS)
+TESTS += testgroupconfig
+
+TESTPROD_HOST += testdbf_copy
+testdbf_copy_SRCS += testdbf_copy
+testdbf_copy_LIBS += qsrv pvAccess pvData
+testdbf_copy_LIBS += $(EPICS_BASE_IOC_LIBS)
+TESTS += testdbf_copy
 endif
 
 TESTSCRIPTS_HOST += $(TESTS:%=%.t)

testApp/testdbf_copy.cpp

@@ -0,0 +1,271 @@
+#include <stdexcept>
+
+#include <pv/pvUnitTest.h>
+#include <testMain.h>
+
+#include <dbStaticLib.h>
+#include <epicsTypes.h>
+#include <pv/valueBuilder.h>
+#include <pv/pvData.h>
+
+
+#include "pvif.h"
+
+namespace pvd = epics::pvData;
+
+namespace {
+template<pvd::ScalarType ENUM, typename DBF, typename E>
+void testPVD2DBR_scalar(unsigned dbf, typename pvd::meta::arg_type<typename pvd::ScalarTypeTraits<ENUM>::type>::type V, E expect)
+{
+    testDiag("testPVD2DBR_scalar(%s, %s)", pvd::ScalarTypeFunc::name(ENUM), dbGetFieldTypeString(dbf));
+
+    pvd::PVStructure::shared_pointer top(pvd::ValueBuilder()
+                                         .add<ENUM>("value", V)
+                                         .buildPVStructure());
+
+    DBF buf;
+
+    copyPVD2DBF(top->getSubFieldT("value"), &buf, dbf, NULL);
+
+    testEqual(buf, expect);
+}
+
+void testPVD2DBR_enum()
+{
+    testDiag("testPVD2DBR_enum()");
+
+    pvd::shared_vector<std::string> choices(3);
+    choices[0] = "zero";
+    choices[1] = "one";
+    choices[2] = "two";
+
+    pvd::PVStructure::shared_pointer top(pvd::ValueBuilder()
+                                         .addNested("value")
+                                             .add<pvd::pvInt>("index", 1)
+                                             .add("choices", pvd::static_shared_vector_cast<const void>(pvd::freeze(choices)))
+                                         .endNested()
+                                         .buildPVStructure());
+
+    {
+        epicsEnum16 ival;
+
+        copyPVD2DBF(top->getSubFieldT("value"), &ival, DBF_ENUM, NULL);
+        testEqual(ival, 1);
+
+        ival = 0;
+
+        testOk1(!!top->getSubField("value"));
+        copyPVD2DBF(top->getSubFieldT("value"), &ival, DBF_USHORT, NULL);
+        testEqual(ival, 1);
+    }
+
+    {
+        epicsUInt32 ival;
+
+        copyPVD2DBF(top->getSubFieldT("value"), &ival, DBF_LONG, NULL);
+        testEqual(ival, 1u);
+    }
+
+    char sval[MAX_STRING_SIZE];
+
+    copyPVD2DBF(top->getSubFieldT("value"), sval, DBF_STRING, NULL);
+    testEqual(std::string(sval) , "one");
+}
+
+void testPVD2DBR_array()
+{
+    testDiag("testPVD2DBR_array()");
+
+    pvd::shared_vector<const pvd::uint32> arr;
+    {
+        pvd::shared_vector<pvd::uint32> iarr(3);
+        iarr[0] = 1; iarr[1] = 2; iarr[2] = 3;
+        arr = pvd::freeze(iarr);
+    }
+
+    pvd::PVStructure::shared_pointer top(pvd::ValueBuilder()
+                                         .add("value", pvd::static_shared_vector_cast<const void>(arr))
+                                         .buildPVStructure());
+
+    {
+        epicsUInt16 sarr[5];
+
+        {
+            long nreq = 5;
+            copyPVD2DBF(top->getSubFieldT("value"), sarr, DBF_SHORT, &nreq);
+            testEqual(nreq, 3);
+        }
+
+        testEqual(sarr[0], arr[0]);
+        testEqual(sarr[1], arr[1]);
+        testEqual(sarr[2], arr[2]);
+    }
+
+    {
+        char sarr[MAX_STRING_SIZE*5];
+
+        {
+            long nreq = 5;
+            copyPVD2DBF(top->getSubFieldT("value"), sarr, DBF_STRING, &nreq);
+            testEqual(nreq, 3);
+        }
+
+        testEqual(sarr[0*MAX_STRING_SIZE+0], '1');
+        testEqual(int(sarr[0*MAX_STRING_SIZE+1]), int('\0'));
+        testEqual(sarr[1*MAX_STRING_SIZE+0], '2');
+        testEqual(int(sarr[1*MAX_STRING_SIZE+1]), int('\0'));
+        testEqual(sarr[2*MAX_STRING_SIZE+0], '3');
+        testEqual(int(sarr[2*MAX_STRING_SIZE+1]), int('\0'));
+    }
+}
+
+template<typename input_t, typename output_t>
+void testDBR2PVD_scalar(const input_t& input,
+                        const output_t& expect)
+{
+    pvd::ScalarType  in = (pvd::ScalarType)pvd::ScalarTypeID<input_t>::value;
+    pvd::ScalarType out = (pvd::ScalarType)pvd::ScalarTypeID<output_t>::value;
+    testDiag("testDBR2PVD_scalar(%s, %s)", pvd::ScalarTypeFunc::name(in), pvd::ScalarTypeFunc::name(out));
+
+    pvd::PVStructure::shared_pointer top(pvd::getPVDataCreate()->createPVStructure(pvd::getFieldCreate()->createFieldBuilder()
+                                                                                   ->add("value", out) // initially zero or ""
+                                                                                   ->createStructure()));
+    pvd::PVStringArray::const_svector choices;
+    pvd::BitSet changed;
+
+    pvd::shared_vector<input_t> buf(1);
+    buf[0] = input;
+
+    copyDBF2PVD(pvd::static_shared_vector_cast<const void>(pvd::freeze(buf)),
+                top->getSubFieldT("value"), changed, choices);
+
+    output_t actual = top->getSubFieldT<pvd::PVScalar>("value")->getAs<output_t>();
+    testEqual(actual, expect);
+    testOk1(changed.get(top->getSubFieldT("value")->getFieldOffset()));
+}
+
+template<typename input_t>
+void testDBR2PVD_enum(const input_t& input, pvd::int32 expect)
+{
+    testDiag("testDBR2PVD_enum()");
+
+    pvd::shared_vector<const std::string> choices;
+    {
+        pvd::shared_vector<std::string> temp(3);
+        temp[0] = "zero";
+        temp[1] = "one";
+        temp[2] = "two";
+        choices = pvd::freeze(temp);
+    }
+
+    pvd::PVStructure::shared_pointer top(pvd::ValueBuilder()
+                                         .addNested("value")
+                                             .add<pvd::pvInt>("index", 0)
+                                             .add("choices", pvd::static_shared_vector_cast<const void>(choices))
+                                         .endNested()
+                                         .buildPVStructure());
+
+    pvd::BitSet changed;
+
+    pvd::shared_vector<input_t> buf(1);
+    buf[0] = input;
+
+    copyDBF2PVD(pvd::static_shared_vector_cast<const void>(pvd::freeze(buf)),
+                top->getSubFieldT("value"), changed, choices);
+
+    pvd::int32 actual = top->getSubFieldT<pvd::PVScalar>("value.index")->getAs<pvd::int32>();
+    testShow()<<top;
+    testShow()<<changed;
+    testEqual(actual, expect);
+    testOk1(changed.get(top->getSubFieldT("value.index")->getFieldOffset()));
+}
+
+void testDBR2PVD_array()
+{
+    testDiag("testDBR2PVD_array()");
+
+    pvd::PVStructure::shared_pointer top(pvd::getPVDataCreate()->createPVStructure(pvd::getFieldCreate()->createFieldBuilder()
+                                                                                   ->addArray("value", pvd::pvInt) // initially zero or ""
+                                                                                   ->createStructure()));
+    pvd::PVStringArray::const_svector choices;
+    pvd::BitSet changed;
+
+    {
+        pvd::shared_vector<pvd::uint32> buf(3);
+        buf[0] = 1; buf[1] = 2; buf[2] = 3;
+        copyDBF2PVD(pvd::static_shared_vector_cast<const void>(pvd::freeze(buf)),
+                    top->getSubFieldT("value"), changed, choices);
+
+        pvd::PVIntArray::const_svector arr(top->getSubFieldT<pvd::PVIntArray>("value")->view());
+        testEqual(arr.size(), 3u);
+        testEqual(arr[0], 1);
+        testEqual(arr[1], 2);
+        testEqual(arr[2], 3);
+        testOk1(changed.get(top->getSubFieldT("value")->getFieldOffset()));
+    }
+
+    changed.clear();
+
+    {
+        pvd::shared_vector<std::string> buf(4);
+        buf[0] = "4";
+        buf[1] = "5";
+        buf[2] = "6";
+        buf[3] = "7";
+
+        copyDBF2PVD(pvd::static_shared_vector_cast<const void>(pvd::freeze(buf)),
+                    top->getSubFieldT("value"), changed, choices);
+
+        pvd::PVIntArray::const_svector arr(top->getSubFieldT<pvd::PVIntArray>("value")->view());
+        testEqual(arr.size(), 4u);
+        testEqual(arr[0], 4);
+        testEqual(arr[1], 5);
+        testEqual(arr[2], 6);
+        testEqual(arr[3], 7);
+        testOk1(changed.get(top->getSubFieldT("value")->getFieldOffset()));
+    }
+}
+
+}
+
+MAIN(testdbf_copy)
+{
+    testPlan(53);
+    try{
+        testPVD2DBR_scalar<pvd::pvDouble, double>(DBF_DOUBLE, 42.2, 42.2);
+        testPVD2DBR_scalar<pvd::pvDouble, pvd::uint16>(DBF_USHORT, 42.2, 42u);
+
+        testPVD2DBR_scalar<pvd::pvInt, pvd::int32>(DBF_LONG, 42, 42);
+        testPVD2DBR_scalar<pvd::pvInt, char[MAX_STRING_SIZE]>(DBF_STRING, 42, std::string("42"));
+
+        testPVD2DBR_scalar<pvd::pvLong, pvd::int64>(DBF_INT64, 42, 42);
+        testPVD2DBR_scalar<pvd::pvLong, char[MAX_STRING_SIZE]>(DBF_STRING, 42, std::string("42"));
+
+        testPVD2DBR_scalar<pvd::pvUShort, pvd::uint16>(DBF_USHORT, 41u, 41);
+        testPVD2DBR_scalar<pvd::pvByte, pvd::int8>(DBF_CHAR, 41, 41);
+
+        testPVD2DBR_scalar<pvd::pvString, char[MAX_STRING_SIZE]>(DBF_STRING, "hello", std::string("hello"));
+        testPVD2DBR_scalar<pvd::pvString, pvd::int32>(DBF_LONG, "-100", -100);
+
+        //testPVD2DBR_scalar<pvd::pvBoolean, pvd::int8>(DBF_CHAR, true, 1);
+
+        testPVD2DBR_enum();
+
+        testPVD2DBR_array();
+
+        testDBR2PVD_scalar<double, double>(42.2, 42.2);
+        testDBR2PVD_scalar<pvd::uint16, double>(42u, 42.0);
+        testDBR2PVD_scalar<pvd::int32, pvd::int32>(-41, -41);
+        testDBR2PVD_scalar<std::string, pvd::int32>("-41", -41);
+        testDBR2PVD_scalar<std::string, std::string>("hello", "hello");
+        testDBR2PVD_scalar<pvd::int32, std::string>(-42, "-42");
+
+        testDBR2PVD_enum<pvd::uint32>(2, 2);
+        testDBR2PVD_enum<std::string>("two", 2);
+
+        testDBR2PVD_array();
+    }catch(std::exception& e){
+        testFail("Unexpected exception: %s", e.what());
+    }
+    return testDone();
+}

testApp/testpvalink.cpp

@@ -1,9 +1,13 @@
 
 #include <dbUnitTest.h>
 #include <testMain.h>
+#include <int64inRecord.h>
+#include <int64outRecord.h>
 
+#include <pv/qsrv.h>
 #include "utilities.h"
 #include "pvalink.h"
+#include "pv/qsrv.h"
 
 namespace {
 
@@ -11,66 +15,77 @@ void testGet()
 {
     testDiag("==== testGet ====");
 
-    testdbGetFieldEqual("target:li.VAL", DBF_LONG, 42);
-    testdbGetFieldEqual("src:li1.VAL", DBF_LONG, 0);
-    testdbGetFieldEqual("src:li1.INP", DBF_STRING, "{\"pva\":\"target:li\"}");
+    int64inRecord *i1 = (int64inRecord*)testdbRecordPtr("src:i1");
 
-    testdbPutFieldOk("src:li1.PROC", DBF_LONG, 1);
-    //TODO: wait for dbEvent queue update
-    epicsThreadSleep(0.1);
+    while(!dbIsLinkConnected(&i1->inp))
+        testqsrvWaitForLinkEvent(&i1->inp);
 
-    testdbGetFieldEqual("src:li1.VAL", DBF_LONG, 42);
+    testdbGetFieldEqual("target:i.VAL", DBF_INT64, 42LL);
 
-    testdbPutFieldOk("src:li1.INP", DBF_STRING, "{\"pva\":\"target:ai\"}");
+    testdbGetFieldEqual("src:i1.VAL", DBF_INT64, 0LL); // value before first process
 
-    testdbGetFieldEqual("src:li1.VAL", DBF_LONG, 42);
+    testdbGetFieldEqual("src:i1.INP", DBF_STRING, "{\"pva\":\"target:i\"}");
 
-    //TODO: wait for pvalink worker update
-    epicsThreadSleep(0.1);
-    testdbPutFieldOk("src:li1.PROC", DBF_LONG, 1);
-    //TODO: wait for dbEvent queue update
-    epicsThreadSleep(0.1);
+    testdbPutFieldOk("src:i1.PROC", DBF_INT64, 1LL);
 
-    testdbGetFieldEqual("src:li1.VAL", DBF_LONG, 4);
+    testdbGetFieldEqual("src:i1.VAL", DBF_INT64, 42LL);
+
+    testdbPutFieldOk("src:i1.INP", DBF_STRING, "{\"pva\":\"target:ai\"}");
+
+    while(!dbIsLinkConnected(&i1->inp))
+        testqsrvWaitForLinkEvent(&i1->inp);
+
+    testdbGetFieldEqual("src:i1.VAL", DBF_INT64, 42LL); // changing link doesn't automatically process
+
+    testdbPutFieldOk("src:i1.PROC", DBF_INT64, 1LL);
+
+    testdbGetFieldEqual("src:i1.VAL", DBF_INT64, 4LL); // now it's changed
 }
 
 void testPut()
 {
     testDiag("==== testPut ====");
-    testdbGetFieldEqual("target:li2.VAL", DBF_LONG, 43);
-    testdbGetFieldEqual("src:li2.VAL", DBF_LONG, 0);
-    testdbGetFieldEqual("src:li2.INP", DBF_STRING, "{\"pva\":\"target:l2\"}");
 
-    testdbPutFieldOk("src:li2.VAL", DBF_LONG, 14);
+    int64outRecord *o2 = (int64outRecord*)testdbRecordPtr("src:o2");
 
-    testdbGetFieldEqual("target:li2.VAL", DBF_LONG, 14);
-    testdbGetFieldEqual("src:li2.VAL", DBF_LONG, 14);
+    while(!dbIsLinkConnected(&o2->out))
+        testqsrvWaitForLinkEvent(&o2->out);
+
+    testdbGetFieldEqual("target:i2.VAL", DBF_INT64, 43LL);
+    testdbGetFieldEqual("src:o2.VAL", DBF_INT64, 0LL);
+    testdbGetFieldEqual("src:o2.OUT", DBF_STRING, "{\"pva\":\"target:i2\"}");
+
+    testdbPutFieldOk("src:o2.VAL", DBF_INT64, 14LL);
+
+    testdbGetFieldEqual("target:i2.VAL", DBF_INT64, 14LL);
+    testdbGetFieldEqual("src:o2.VAL", DBF_INT64, 14LL);
 }
 
 } // namespace
 
 extern "C"
-void p2pTestIoc_registerRecordDeviceDriver(struct dbBase *);
+void pvaLinkTestIoc_registerRecordDeviceDriver(struct dbBase *);
 
 MAIN(testpvalink)
 {
-    testPlan(0);
+    testPlan(15);
 
     // Disable PVA client provider, use local/QSRV provider
     pvaLinkIsolate = 1;
-    pvaLinkDebug = 5;
 
     try {
         TestIOC IOC;
 
-        testdbReadDatabase("p2pTestIoc.dbd", NULL, NULL);
-        p2pTestIoc_registerRecordDeviceDriver(pdbbase);
+        testdbReadDatabase("pvaLinkTestIoc.dbd", NULL, NULL);
+        pvaLinkTestIoc_registerRecordDeviceDriver(pdbbase);
         testdbReadDatabase("testpvalink.db", NULL, NULL);
 
         IOC.init();
         testGet();
         testPut();
+        testqsrvShutdownOk();
         IOC.shutdown();
+        testqsrvCleanup();
 
     }catch(std::exception& e){
         testFail("Unexpected exception: %s", e.what());

testApp/testpvalink.db

@@ -1,21 +1,21 @@
 
 # used by testGet()
-record(longin, "target:li") {
+record(int64in, "target:i") {
     field(VAL, "42")
 }
 record(ai, "target:ai") {
     field(VAL, "4.0")
 }
 
-record(longin, "src:li1") {
-    field(INP, {pva:"target:li"})
+record(int64in, "src:i1") {
+    field(INP, {pva:"target:i"})
 }
 
 # used by testPut()
-record(longin, "target:li2") {
+record(int64in, "target:i2") {
     field(VAL, "43")
 }
 
-record(longout, "src:li2") {
-    field(OUT, {pva:"target:li"})
+record(int64out, "src:o2") {
+    field(OUT, {pva:"target:i2"})
 }

testApp/testpvif.cpp

@@ -7,6 +7,14 @@
 #include <aiRecord.h>
 #include <mbbiRecord.h>
 #include <stringinRecord.h>
+#include <epicsVersion.h>
+
+#ifdef EPICS_VERSION_INT
+#  if EPICS_VERSION_INT>=VERSION_INT(3,16,1,0)
+#    define USE_INT64
+#    include <int64inRecord.h>
+#  endif
+#endif
 
 #include "helper.h"
 #include "pvif.h"
@@ -28,11 +36,17 @@ void testScalar()
     testdbReadDatabase("p2pTestIoc.dbd", NULL, NULL);
     p2pTestIoc_registerRecordDeviceDriver(pdbbase);
     testdbReadDatabase("testpvif.db", NULL, NULL);
+#ifdef USE_INT64
+    testdbReadDatabase("testpvif64.db", NULL, NULL);
+#endif
 
     longinRecord *prec_li = (longinRecord*)testdbRecordPtr("test:li");
     stringinRecord *prec_si = (stringinRecord*)testdbRecordPtr("test:si");
     aiRecord *prec_ai = (aiRecord*)testdbRecordPtr("test:ai");
     mbbiRecord *prec_mbbi = (mbbiRecord*)testdbRecordPtr("test:mbbi");
+#ifdef USE_INT64
+    int64inRecord *prec_i64 = (int64inRecord*)testdbRecordPtr("test:i64");
+#endif
 
     IOC.init();
 
@@ -44,6 +58,9 @@ void testScalar()
     DBCH chan_ai("test:ai");
     DBCH chan_ai_rval("test:ai.RVAL");
     DBCH chan_mbbi("test:mbbi");
+#ifdef USE_INT64
+    DBCH chan_i64("test:i64");
+#endif
     testEqual(dbChannelFieldType(chan_li), DBR_LONG);
     testEqual(dbChannelFieldType(chan_si), DBR_STRING);
     testEqual(dbChannelFieldType(chan_ai), DBR_DOUBLE);
@@ -53,10 +70,16 @@ void testScalar()
     testEqual(dbChannelFinalFieldType(chan_ai), DBR_DOUBLE);
     testEqual(dbChannelFinalFieldType(chan_ai_rval), DBR_LONG);
     testEqual(dbChannelFinalFieldType(chan_mbbi), DBR_ENUM);
+#ifdef USE_INT64
+    testEqual(dbChannelFinalFieldType(chan_i64), DBR_INT64);
+#endif
 
     ScalarBuilder builder;
 
     pvd::FieldConstPtr dtype_li(builder.dtype(chan_li));
+#ifdef USE_INT64
+    pvd::FieldConstPtr dtype_i64(builder.dtype(chan_i64));
+#endif
     pvd::FieldConstPtr dtype_si(builder.dtype(chan_si));
     pvd::FieldConstPtr dtype_ai(builder.dtype(chan_ai));
     pvd::FieldConstPtr dtype_ai_rval(builder.dtype(chan_ai_rval));
@@ -64,6 +87,9 @@ void testScalar()
 
     pvd::StructureConstPtr dtype_root(pvd::getFieldCreate()->createFieldBuilder()
                                       ->add("li", dtype_li)
+#ifdef USE_INT64
+                                      ->add("i64", dtype_i64)
+#endif
                                       ->add("si", dtype_si)
                                       ->add("ai", dtype_ai)
                                       ->add("ai_rval", dtype_ai_rval)
@@ -73,11 +99,16 @@ void testScalar()
     pvd::PVStructurePtr root(pvd::getPVDataCreate()->createPVStructure(dtype_root));
 
     p2p::auto_ptr<PVIF> pvif_li(builder.attach(chan_li, root, FieldName("li")));
+#ifdef USE_INT64
+    p2p::auto_ptr<PVIF> pvif_i64(builder.attach(chan_i64, root, FieldName("i64")));
+#endif
     p2p::auto_ptr<PVIF> pvif_si(builder.attach(chan_si, root, FieldName("si")));
     p2p::auto_ptr<PVIF> pvif_ai(builder.attach(chan_ai, root, FieldName("ai")));
     p2p::auto_ptr<PVIF> pvif_ai_rval(builder.attach(chan_ai_rval, root, FieldName("ai_rval")));
     p2p::auto_ptr<PVIF> pvif_mbbi(builder.attach(chan_mbbi, root, FieldName("mbbi")));
 
+    testShow()<<"Entire structure\n"<<root;
+
     pvd::BitSet mask;
 
     dbScanLock((dbCommon*)prec_li);
@@ -94,21 +125,56 @@ void testScalar()
               .set(OFF("li.alarm.message"))
               .set(OFF("li.timeStamp.secondsPastEpoch"))
               .set(OFF("li.timeStamp.nanoseconds"))
-              //.set(OFF("li.timeStamp.userTag"))
               .set(OFF("li.display.limitHigh"))
               .set(OFF("li.display.limitLow"))
               .set(OFF("li.display.description"))
-              .set(OFF("li.display.format"))
               .set(OFF("li.display.units"))
+              .set(OFF("li.display.precision"))
+              .set(OFF("li.display.form.index"))
               .set(OFF("li.control.limitHigh"))
               .set(OFF("li.control.limitLow"))
               .set(OFF("li.valueAlarm.highWarningLimit"))
               .set(OFF("li.valueAlarm.lowWarningLimit"))
               .set(OFF("li.valueAlarm.highAlarmLimit"))
-              .set(OFF("li.valueAlarm.lowAlarmLimit")));
+              .set(OFF("li.valueAlarm.lowAlarmLimit")))
+            <<" li changes\n"<<root->stream().show(mask);
 #undef OFF
     mask.clear();
 
+#ifdef USE_INT64
+
+    dbScanLock((dbCommon*)prec_i64);
+    prec_i64->time.secPastEpoch = 0x12345678;
+    prec_i64->time.nsec = 12345678;
+    pvif_i64->put(mask, DBE_VALUE|DBE_ALARM|DBE_PROPERTY, NULL);
+    dbScanUnlock((dbCommon*)prec_i64);
+
+#define OFF(NAME) (epicsUInt32)root->getSubFieldT(NAME)->getFieldOffset()
+    testEqual(mask, pvd::BitSet()
+              .set(OFF("i64.value"))
+              .set(OFF("i64.alarm.severity"))
+              .set(OFF("i64.alarm.status"))
+              .set(OFF("i64.alarm.message"))
+              .set(OFF("i64.timeStamp.secondsPastEpoch"))
+              .set(OFF("i64.timeStamp.nanoseconds"))
+              .set(OFF("i64.display.limitHigh"))
+              .set(OFF("i64.display.limitLow"))
+              .set(OFF("i64.display.description"))
+              .set(OFF("i64.display.units"))
+              .set(OFF("i64.display.precision"))
+              .set(OFF("i64.display.form.index"))
+              .set(OFF("i64.control.limitHigh"))
+              .set(OFF("i64.control.limitLow"))
+              .set(OFF("i64.valueAlarm.highWarningLimit"))
+              .set(OFF("i64.valueAlarm.lowWarningLimit"))
+              .set(OFF("i64.valueAlarm.highAlarmLimit"))
+              .set(OFF("i64.valueAlarm.lowAlarmLimit")))
+            <<" i64 changes\n"<<root->stream().show(mask);
+#undef OFF
+    mask.clear();
+
+#endif
+
     dbScanLock((dbCommon*)prec_si);
     prec_si->time.secPastEpoch = 0x12345678;
     prec_si->time.nsec = 12345678;
@@ -127,10 +193,12 @@ void testScalar()
               .set(OFF("si.display.limitHigh"))
               .set(OFF("si.display.limitLow"))
               .set(OFF("si.display.description"))
-              .set(OFF("si.display.format"))
               .set(OFF("si.display.units"))
+              .set(OFF("si.display.precision"))
+              .set(OFF("si.display.form.index"))
               .set(OFF("si.control.limitHigh"))
-              .set(OFF("si.control.limitLow")));
+              .set(OFF("si.control.limitLow")))
+            <<" si changes\n"<<root->stream().show(mask);
 #undef OFF
     mask.clear();
 
@@ -153,7 +221,8 @@ void testScalar()
               .set(OFF("ai.display.limitHigh"))
               .set(OFF("ai.display.limitLow"))
               .set(OFF("ai.display.description"))
-              .set(OFF("ai.display.format"))
+              .set(OFF("ai.display.precision"))
+              .set(OFF("ai.display.form.index"))
               .set(OFF("ai.display.units"))
               .set(OFF("ai.control.limitHigh"))
               .set(OFF("ai.control.limitLow"))
@@ -171,15 +240,17 @@ void testScalar()
               .set(OFF("ai_rval.display.limitHigh"))
               .set(OFF("ai_rval.display.limitLow"))
               .set(OFF("ai_rval.display.description"))
-              .set(OFF("ai_rval.display.format"))
               .set(OFF("ai_rval.display.units"))
+              .set(OFF("ai_rval.display.precision"))
+              .set(OFF("ai_rval.display.form.index"))
               .set(OFF("ai_rval.control.limitHigh"))
               .set(OFF("ai_rval.control.limitLow"))
               .set(OFF("ai_rval.valueAlarm.highWarningLimit"))
               .set(OFF("ai_rval.valueAlarm.lowWarningLimit"))
               .set(OFF("ai_rval.valueAlarm.highAlarmLimit"))
               .set(OFF("ai_rval.valueAlarm.lowAlarmLimit"))
-              );
+              )
+            <<" ai changes\n"<<root->stream().show(mask);
 #undef OFF
     mask.clear();
 
@@ -198,7 +269,8 @@ void testScalar()
               .set(OFF("mbbi.alarm.message"))
               .set(OFF("mbbi.timeStamp.secondsPastEpoch"))
               .set(OFF("mbbi.timeStamp.nanoseconds"))
-              .set(OFF("mbbi.timeStamp.userTag")));
+              .set(OFF("mbbi.timeStamp.userTag")))
+            <<" mbbi changes\n"<<root->stream().show(mask);
 #undef OFF
     mask.clear();
 
@@ -210,6 +282,22 @@ void testScalar()
     testFieldEqual<pvd::PVDouble>(root, "li.display.limitHigh", 100.0);
     testFieldEqual<pvd::PVDouble>(root, "li.display.limitLow", 10.0);
     testFieldEqual<pvd::PVString>(root, "li.display.units", "arb");
+    testFieldEqual<pvd::PVInt>(root, "li.display.precision", 0);
+    testFieldEqual<pvd::PVInt>(root, "li.display.form.index", 4); // "Hex"
+
+#ifdef USE_INT64
+    testFieldEqual<pvd::PVLong>(root, "i64.value", 0x7fffffffffffffffLL);
+    testFieldEqual<pvd::PVInt>(root, "i64.alarm.severity", 1);
+    testFieldEqual<pvd::PVInt>(root, "i64.alarm.status", 1);
+    testFieldEqual<pvd::PVLong>(root, "i64.timeStamp.secondsPastEpoch", 0x12345678+POSIX_TIME_AT_EPICS_EPOCH);
+    testFieldEqual<pvd::PVInt>(root, "i64.timeStamp.nanoseconds", 12345678);
+    testFieldEqual<pvd::PVDouble>(root, "i64.display.limitHigh", 100.0);
+    testFieldEqual<pvd::PVDouble>(root, "i64.display.limitLow", 10.0);
+    testTodoBegin("Bug in int64inRecord get_units()");
+    testFieldEqual<pvd::PVString>(root, "i64.display.units", "arb");
+    testTodoEnd();
+    testFieldEqual<pvd::PVInt>(root, "i64.display.precision", 0);
+#endif
 
     testFieldEqual<pvd::PVString>(root, "si.value", "hello");
     testFieldEqual<pvd::PVInt>(root, "si.alarm.severity", 0);
@@ -223,8 +311,9 @@ void testScalar()
     testFieldEqual<pvd::PVInt>(root, "ai.timeStamp.nanoseconds", 12345678);
     testFieldEqual<pvd::PVDouble>(root, "ai.display.limitHigh", 200.0);
     testFieldEqual<pvd::PVDouble>(root, "ai.display.limitLow", 20.0);
-    testFieldEqual<pvd::PVString>(root, "ai.display.format", "");
+    testFieldEqual<pvd::PVInt>(root, "ai.display.precision", 2);
     testFieldEqual<pvd::PVString>(root, "ai.display.units", "foo");
+    testFieldEqual<pvd::PVInt>(root, "ai.display.form.index", 0);
 
     testFieldEqual<pvd::PVInt>(root, "ai_rval.value", 1234);
     testFieldEqual<pvd::PVInt>(root, "ai_rval.alarm.severity", 2);
@@ -233,8 +322,9 @@ void testScalar()
     testFieldEqual<pvd::PVInt>(root, "ai_rval.timeStamp.userTag", 0);
     testFieldEqual<pvd::PVDouble>(root, "ai_rval.display.limitHigh", 2147483647.0);
     testFieldEqual<pvd::PVDouble>(root, "ai_rval.display.limitLow", -2147483648.0);
-    testFieldEqual<pvd::PVString>(root, "ai_rval.display.format", "");
+    testFieldEqual<pvd::PVInt>(root, "ai_rval.display.precision", 0);
     testFieldEqual<pvd::PVString>(root, "ai_rval.display.units", "");
+    testFieldEqual<pvd::PVInt>(root, "ai_rval.display.form.index", 0);
 
     testFieldEqual<pvd::PVInt>(root, "mbbi.value.index", 1);
     testFieldEqual<pvd::PVInt>(root, "mbbi.alarm.severity", 0);
@@ -250,6 +340,9 @@ void testScalar()
     }
 
     root->getSubFieldT<pvd::PVInt>("li.value")->put(102043);
+#ifdef USE_INT64
+    root->getSubFieldT<pvd::PVLong>("i64.value")->put(-0x8000000000000000LL);
+#endif
     root->getSubFieldT<pvd::PVString>("si.value")->put("world");
     root->getSubFieldT<pvd::PVDouble>("ai.value")->put(44.4);
     root->getSubFieldT<pvd::PVInt>("ai_rval.value")->put(2143);
@@ -262,6 +355,24 @@ void testScalar()
     testEqual(prec_li->val, 102043);
     dbScanUnlock((dbCommon*)prec_li);
 
+#ifdef USE_INT64
+    dbScanLock((dbCommon*)prec_i64);
+    mask.clear();
+    mask.set(root->getSubFieldT("i64.value")->getFieldOffset());
+    pvif_i64->get(mask);
+    testEqual(prec_i64->val, epicsInt64(-0x8000000000000000LL));
+    dbScanUnlock((dbCommon*)prec_i64);
+#endif
+
+#ifdef USE_INT64
+    dbScanLock((dbCommon*)prec_i64);
+    mask.clear();
+    mask.set(root->getSubFieldT("i64.value")->getFieldOffset());
+    pvif_i64->get(mask);
+    testEqual(prec_i64->val, epicsInt64(-0x8000000000000000LL));
+    dbScanUnlock((dbCommon*)prec_i64);
+#endif
+
     dbScanLock((dbCommon*)prec_si);
     mask.clear();
     mask.set(root->getSubFieldT("si.value")->getFieldOffset());
@@ -289,8 +400,6 @@ void testScalar()
     pvif_mbbi->get(mask);
     testEqual(prec_mbbi->val, 2);
     dbScanUnlock((dbCommon*)prec_mbbi);
-
-    iocshCmd("stopPVAServer");
 }
 
 void testPlain()
@@ -416,7 +525,16 @@ void testPlain()
 
 MAIN(testpvif)
 {
-    testPlan(71);
+    testPlan(75
+#ifdef USE_INT64
+             +13
+#endif
+             );
+#ifdef USE_INT64
+    testDiag("Testing of 64-bit field access");
+#else
+    testDiag("64-bit field access not supported");
+#endif
     testScalar();
     testPlain();
     return testDone();

testApp/testpvif.db

@@ -5,6 +5,7 @@ record(longin, "test:li") {
   field(EGU, "arb")
   field(HOPR, "100")
   field(LOPR, "10")
+  info(Q:form, "Hex")
 }
 record(ai, "test:ai") {
   field(VAL, "42.2")

testApp/testpvif64.db

@@ -0,0 +1,8 @@
+record(int64in, "test:i64") {
+  field(VAL, "0x7fffffffffffffff")
+  field(SEVR, "1")
+  field(STAT, "1")
+  field(EGU, "arb")
+  field(HOPR, "100")
+  field(LOPR, "10")
+}