Merge lp:~epics-core/epics-base/link-support-2 into lp:~epics-core/epics-base/3.16

[Andrew Johnson]

Progress on JSON Link types, including constant array value initialization.

This branch passes the existing test programs, but I haven't added new test programs or documentation yet.

The functionality is present for device support to register itself as taking a JSON_LINK address type, and for such addresses to be checked for valid JSON syntax when the INP/OUT field gets set. The device must do its own parsing of the stored string, probably from the call to its dsxt->addRecord() routine. DB files may contain unquoted JSON in link field values and in info tags. Constant links containing JSON arrays are supported by the devAaiSoft and devWfSoft device support and the aSub record type; code changes are needed for adding constant array value support.

Still in progress: A DBD file may declare a link(name, lset) type, but nothing uses the registered data yet, and the lset needs extending to handle extensible link types anyway.

[mdavidsaver (mdavidsaver)]

What I see looks like JSON_LINK as another hardware link type, which as you say device support would parse/consume the json string. How would this relate to my use case of a CA_LINK-like arrangement, where device support should leave the string alone? Is this part of the remaining work? Some slight of hand changing the link type code to CA_LINK?

review: Needs Information

[mdavidsaver (mdavidsaver)]

Did some playing around with this. Looks extra trailing brackets and commas don't errors as I would expect. I find some unexpected parser successes.

> field(INP, "{x: 4 }, {{}}}}")
> field(INP, "{y:3} }}}")

[mdavidsaver (mdavidsaver)]

Oh, I see. I don't want the quotes.

[lp:~epics-core/epics-base/link-support-2]

12759. By mdavidsaver on 2016-08-12

iocInit: close CA_LINKs through lset

[mdavidsaver (mdavidsaver)]

From what I see it looks like the remaining work is:

* Add the registerLinks infrastructure and hooks in registerRecordDeviceDriver.pl
* Hooks in iocInit.c to populate linkSup::lset
* Hooks in dbInitLink() and dbAddLink() to select lset

FYI, before merging this branch I'm going to want to port my PVA link code to work with it. I don't think this will be a big task.

https://github.com/mdavidsaver/epics-base/tree/calinkplug

From my branch, have you seen the report lset function?

https://github.com/mdavidsaver/epics-base/commit/905c5e33362d940f92c12de5f528fe9ab00a0c20

review: Needs Fixing

[lp:~epics-core/epics-base/link-support-2]

12760. By Andrew Johnson on 2016-08-13

A cleaner way to close CA & DB links

12761. By Andrew Johnson on 2016-08-13

Fix issues related to const array initialization

12762. By Andrew Johnson on 2016-08-13

Undo a small & unnecessary behaviour change

[Andrew Johnson (anj)]

Yes, the JSON_LINK type is intended for something like asynDriver that wants flexibility. The IOC may not know until iocInit or even runtime how to parse the complete hardware address, but the device layer can work it out.

I had forgotten exactly what you were working on, so your responses are helpful. I don't really like your lset hijacking approach, I'm trying to see if I can provide an alternative that will put both pva and ca link types at the same level, but I'm not there yet.

I'm currently adding an LSET routine for putCallback as required by the dev*oSoftCallback device supports — actually it implements put-wait-reprocess since the only thing the callbacks are ever used for is to reprocess the record containing the link after the put has completed. Currently these device supports only work over CA, but I see no real reason they can't be extended to support dbNotify (i.e. local DB) links as well, that's JMOP.

I also want to add a dbLinkIsRemote() routine which is really what many of the remaining tests for (plink->type == CA_LINK) are really asking about; that should allow all the CA-specific calls in the calcout record type to use the generic API as well. A remote link type is one that can connect or disconnect asynchronously, so both ca and pva are remote; I want to remove as much code that looks at the plink->type value as possible.

For fully generic link types we will need one or more routines that get integrated into the JSON parser used for link-resolution and either accept or reject the link address. I'm not sure yet if these should be included in the LSET or in some other table (the one that the DBD link entry actually refers to); I'm leaning towards the latter for simplicity's sake, but haven't implemented anything yet.

[mdavidsaver (mdavidsaver)]

> Yes, the JSON_LINK type is intended for something like asynDriver that wants flexibility.

Well, this would be convenience, though for me the critical need for 3.16.1 is an API for adding code on par with CA_LINK.

> I had forgotten exactly what you were working on, so your responses are helpful. I don't really like your lset hijacking approach, I'm trying to see if I can provide an alternative that will put both pva and ca link types at the same level, but I'm not there yet.

My API is a placeholder, you aren't meant to like it (I don't). I wanted to test the principle. If you can come up with something better before 3.16.1 then great. If would take me ~1 week to re-cast my API into a more maintainable form.

[lp:~epics-core/epics-base/link-support-2]

12763. By Andrew Johnson on 2016-08-14

Add lset::dbPutLinkAsync and S_db_noLSET

12764. By Andrew Johnson on 2016-08-14

Use dbPutLinkAsync() in all output SoftCallback dev's

12765. By Andrew Johnson on 2016-08-16

Remove 2 obsolete dbStatic routines (forms)

12766. By Andrew Johnson on 2016-08-18

Missed a spot handling JSON_LINK field values

[Andrew Johnson (anj)]

One thing I realized earlier that I want to be possible at some point: The JSON link parsing code and operations must be re-entrant and designed so a link can embed other links if it wants to. Here's one possibility that should allow:

record(ai, "current") {
  field(DTYP, "some-psu")
  field(INP, "#C0 S0 @whatever")
  field(SIML, "simulate")
  field(SIOL, {calc:{
    expr:"(val+a/b)/2",
    in:[{ca:"voltage CP"}, 10e3]
  }})
}

I'm not saying the implementation will support this to start with, but I want to bear the use-case in mind so as not to preclude its addition in the future. This comment is here to remind me...

[lp:~epics-core/epics-base/link-support-2]

12767. By Andrew Johnson on 2016-08-27

Add isConstant and isVolatile to LSET

12768. By Andrew Johnson on 2016-08-27

Use new dbLink APIs instead of checking link.type

12769. By Andrew Johnson on 2016-08-27

Start documenting changes

[Andrew Johnson (anj)]

Hi Michael,

I just committed changes so LSETs indicate if they are constants (i.e. they implement LoadScalar and/or LoadArray and don't set any data in Get), or volatile (links can disconnect like CA). I have changed most places where the record and device types look at plink->type to use these flags instead, so they will still work with JSON-links as well. Not done the SoftCallback devices though, the LSET doesn't have a processNotify API yet anyway.

Needless to say I haven't tested most of the changes to the std/dev or std/rec sources. Many of them should be simple enough to accept by inspection, but the calcout changes should probably be checked carefully (now uses the volatile property and the dbLink APIs instead of dbCa; I forgot to remove that header though).

I also started to document what I've been doing in the RELEASE_NOTES, probably several bits missing there still though.

Lots more code on the way, I have implemented the "remaining work" you itemized and created a const JSON link type to help prove my new dbJLink.c code. I don't have the ability to embed links inside other links yet though, I think that will need an API change. This stuff isn't quite ready to commit yet, maybe a day or two more.

I will be asking you to think about locking and if/how it will be possible to implement DB links type through a JSON link. That will probably require adding one or more routines to the LSET or even to the JLink interface for querying lock-sets, but I'll get back to you on that topic after I've committed the JLinks.

Sorry I haven't been too communicative recently, I've been on occasion working until 1:30/2am on this stuff since I don't have time at work.

- Andrew

[lp:~epics-core/epics-base/link-support-2]

12770. By Andrew Johnson on 2016-08-29

Undo buggy change

12771. By Andrew Johnson on 2016-08-29

JSON Links implementation

The lnkConst.c implementation is not yet complete, no support for arrays of
strings (JMOP).

Link error messages should display their record & field name, which is not yet
possible.

The ability to embed links as parameters to other link types is not complete
yet; this will be required for the calc link type.

This code currently passes all existing tests, but additional tests are needed
for the new functionality.

12772. By Andrew Johnson on 2016-08-29

Fix build warning from clang

[mdavidsaver (mdavidsaver)]

> I will be asking you to think about locking and if/how it will be possible to implement DB links type through a JSON link.

Not for 3.16.1. I'm going to draw a line at making further changes to lockset code for this release.

From your prospective, a hard requirement will be that all involved records be known when dbParseLink() returns. I see no way to relax this without introducing tremendous complexity (eg. higher level fail and re-try). So the fact that there are no link support callbacks before dbSetLink() seems like a show stopper for changing lock sets.

In general I'd like to see more validation in dbParseLink() as this is the point where such errors can be failed cleanly. Forgetting the '@' w/ INST_IO is easy. I see typos in json strings being even more common. I'm sure you won't like the idea of parsing twice, but I see this as worthwhile trade off.

> I have implemented the "remaining work" you itemized

Ok, I'll give it a shot.

[lp:~epics-core/epics-base/link-support-2]

12773. By Andrew Johnson on 2016-08-30

Pass link dbfType to jlif allocator; needed!

[mdavidsaver (mdavidsaver)]

> status = dbPutLinkAsync(plink, DBR_DOUBLE, &prec->oval, 1);
> if (!status)
> prec->pact = TRUE;
> else if (status == S_db_noLSET)
> status = dbPutLink(plink, DBR_DOUBLE, &prec->oval, 1);

Can you describe the difference between dbPutLink() and dbPutLinkAsync()? Naively I would expect that dbPutLinkAsync() would include a completion callback, and possibly some means of cancellation.

Perhaps what you are after isn't so much a decision, but an effect. Maybe it would be better to either require the caller to check dbLinkIsVolatile() to find out whether puts complete immediately, or have a special status code to indicate that the request was successfully sent?

[Andrew Johnson (anj)]

We will have to mark the dbLink.h and possibly dbJLink.h APIs as incomplete for the 3.16.1 release then, because they will have to change to add the locking support. I would also expect that change to move the code for handling DB_LINKs from dbLock.c into dbDbLink.c.

> all involved records be known when dbParseLink() returns.
...
> I'd like to see more validation in dbParseLink()

There is syntax checking of the JSON that happens at dbLoadRecords() time, but no semantic checks of the content then. Currently dbInitLink() and hence dbJInitLink() are called from doResolveLinks() in iocInit.c which is part of initDatabase(), whereas dbParseLink() is run from prepareLinks() which happens earlier, before any record initialization has happened.

I don't see any problems with doing the JSON parsing earlier though, so I will work to split dbJLinkInit() into two parts: One called from dbParseLink() for parsing the JSON into a jlink pointer stored in the dbLinkInfo object, and a second one called from dbInitLink() that assigns the jlink object to its specific link field and sets plink->lset.

> Can you describe the difference between dbPutLink() and dbPutLinkAsync()?

dbPutLinkAsync() is used by all of the dev*oSoftCallback.c device support, i.e. Async Soft Channel support for output record types. This isn't new functionality, it's why CA has ca_put_complete(), to wait until all record processing at the far end has finished. If you come up with a better name for this routine let me know.

On completion the link's implementation must call the routine dbLinkAsyncComplete(plink) which locks the record and calls the record's process() routine. Previously for CA links the device supports all called
    dbCaPutLinkCallback(plink, DBR_xx, &prec->oval, 1, dbCaCallbackProcess, plink)
but since they all specified the same callback routine and context parameter I thought we might as well take those out of the argument list.

I was wondering if we could make the completion more useful by adding another RSET routine which (if set) would be called instead of process(), passing it a pointer to the link that just completed; the idea being to simplify record types like motor and table that remain active for long periods and want completion notifications. However I need to consider how the callback would work for embedded links, so I might need to reinstate those callback parameters).

[lp:~epics-core/epics-base/link-support-2]

12774. By Andrew Johnson on 2016-08-31

Add code for arrays of strings

12775. By Andrew Johnson on 2016-08-31

Added loadLS routine to lset

The long string in/out records use a different initializer
for constant links. The new loadLS method allows a constant
link type to initialize such a long string field.

NB: This routine was added in the middle of the lset table.
Any external link support implementations must be adjusted.

12776. By Andrew Johnson on 2016-09-01

Split dbJLinkInit, JLinks are now parsed at load-time

[Andrew Johnson (anj)]

I have split up the dbJLink initialization, but I also had to change the link type registration code for it to work. For the other entry table pointers (drvet, dset etc) the "vtable" pointer gets set during iocInit, but in this case it must be set earlier in the ioc_registerRecordDeviceDriver() routine so the dbLoadRecords() calls to dbParseLink() can call the link-type's parsing routines.

This reorganization cleaned up the JLink code slightly and the result works again, but now that it's returning errors properly from the JSON parser the dbPutLinkTest.c program is failing. I know what at least some of the issues are in that, but I haven't tried to fix them for this commit. I'll probably have to write a test link type for that code anyway.

[mdavidsaver (mdavidsaver)]

I haven't check your latest changes, so this may be fixed. I find that the jlif free callback isn't being called if parsing is stopped. Thus a memory leak.

I would definitely say a unit test is in order w/ ref. counting to detect situations like this. Something with lnkConst.c which does link modification and checks a ref. count on shutdown to ensure that cleanup is done.

[mdavidsaver (mdavidsaver)]

> jlink* (*alloc_jlink)(short dbfType);

I see that alloc_link no longer gets a DBLINK* argument. I had been using this to find the associated record name for use in error messages. Can this be re-added?

[Andrew Johnson (anj)]

> the jlif free callback isn't being called if parsing is stopped

I partially fixed that in last night's commit, but there are more places in dbJLink.c that need fixes. I'll work on that tonight.

> I see that alloc_link no longer gets a DBLINK* argument.

Your dbParseLink() routine doesn't get the link pointer, so I couldn't pass it on (I was using it for that too). Obviously I could add it, but actually I think the inability to access the link at parse-time is probably good protection from someone writing a link type that changes the fields in the link while parsing the string instead of storing the parse results in their jlink. I believe the record and link field name will get printed anyway as long as the parse is aborted (that's probably new with last night's commit though). dbParseLink() doesn't print any error messages at the moment either.

This latest version is almost sufficient for child links (just one more jlif routine to add) and with that there's the question of how to identify a link embedded inside another link inside a record instance. Children get a link to their parent so can print the names of their antecedents, but they don't currently know how to self-identify among siblings.

[mdavidsaver (mdavidsaver)]

> Your dbParseLink() routine doesn't get the link pointer,

Good point. Maybe add a char* with the record name to dbLinkInfo?

> I believe the record and link field name will get printed anyway

I'll check this out.

[mdavidsaver (mdavidsaver)]

I'd like to use ->get_lset() as the place to open PVA (or CA) channels. It's in the right place, and has DBLINK* which I need for CP/CPP decisions, but the 'const jlink*' is complicating this. Can the 'const' go away?

[lp:~epics-core/epics-base/link-support-2]

12777. By Andrew Johnson on 2016-09-02

Various improvements

* Added new lset::openLink() method, called on JSON_LINKs only
* Cleanup in dbJLink.c to prevent memory leaks.
* Removed jlif::start_parse() method.
* Renamed jlif::end_parse() to end_child, which will be called on
the parent link when a child link has succesfully finished parsing.

[Andrew Johnson (anj)]

The const was to try and keep all the run-time stuff happening through the lset routines, so it sounds like it has been doing its job! I would like to keep get_lset as a single-purpose routine so it can be called from elsewhere without having any side-effects. The link pointer was only provided to it because at one point I thought the routine might set the plink->lset field directly, but that isn't going to happen now so I just removed it.

I do understand the need for a method to start off the connection process, but that should be an lset method, not a jlink one. I've added the following optional routine at the top of the lset table that I now call from dbJLinkInit():

    /* Activation */
    void (*openLink)(struct link *plink);

You should also look at using the lset's loadScalar(), loadLS() and loadArray() methods for configuring monitors for input links, they are given the data type that the record is going to be asking for when it later calls getValue(). I have been removing the conditionals from the calls to recGblConstInit() so these routines can be used for exactly this purpose, although your code must still work if they don't get called before getValue() does. They don't have to set a value, they can just return a non-zero value to indicate that they didn't.

BTW some people have written subroutine record code that abuses the INPA-L input links and uses them for outputs. That works OK with the existing link-types, so your code should expect it and either handle it or reject it.

I think I fixed the memory leaks too, but it's hard to be sure that I got all of them.

[mdavidsaver (mdavidsaver)]

> they are given the data type that the record is going to be asking for when it later calls getValue

Given that this isn't certain, I don't think I'll try to use it. A caller could first use dbGetLinkDBFtype() in an effort to get the "native" type. The cost of looking up a conversion function each time has never seemed like much.

> BTW some people have written subroutine record code that abuses the INPA-L input links and uses them for outputs

I've done this myself. As far as I'm concerned, "input" vs. "output" is a label/convention. There won't be a functional difference. In fact, with PVA, forward links also won't be different either.

> I think I fixed the memory leaks too, but it's hard to be sure that I got all of them.

A unit test would help...

[Andrew Johnson (anj)]

> Given that this isn't certain

It is certain for the input links of all the built-in record types. I think you would also be justified in printing a warning message if a subsequent getValue() disagrees with the data type or requests a larger size than the initial load*() request.

> A caller could first use dbGetLinkDBFtype()

They could, but the existing code doesn't, it relies on dbCa to handle all the data type stuff. That routine is also going to return -1 until the link gets connected, whereas if you use the hints the link would be able to subscribe sooner and so start delivering real data sooner.

> The cost of looking up a conversion function each time has never seemed like much.

It's not the cost of looking up the conversion function, but the data type and size you subscribe for that I was thinking about. If the link is an ai record asking for the first element from a waveform record and you always subscribe for the target's array size…

> A unit test would help...

Yeah, luckily there's a long wekend coming up and my wife will be away for most of it. I do have a hard deadline on some other EPICS stuff coming up, but I'll work on adding that.

[lp:~epics-core/epics-base/link-support-2]

12778. By Andrew Johnson on 2016-09-03

Added epicsStrnDup() and dbmfStrndup() routines

The JSON parser passes string arguments with a length
instead or nil-terminating them. These routines make it
simple to copy such strings into either permanent or
temporary storage.

12779. By Andrew Johnson on 2016-09-03

Use new epicsStrnDup() API

12780. By Andrew Johnson on 2016-09-03

Fixes to dbJLink, added dbJLinkFree()

Moved the clearing of key_is_link to the right place,
embedded links now parse correctly.

[mdavidsaver (mdavidsaver)]

I noticed epicsStrnDup(), which calls cantProceed() on allocation failure. While this is fine in startup-only code like dbmf.c, I don't like to see it used in lnkConst.c where it is run after startup.

From our previous discussions (some time ago) the idea that I have is that after IOC startup, cantProceed() is only appropriate for unrecoverable errors (eg. linked list corruption or pthread mutex errors).

[mdavidsaver (mdavidsaver)]

Any reason that doCloseLinks() in iocInit() doesn't close JSON_LINK?

[mdavidsaver (mdavidsaver)]

I think I have the basics of pvalink.cpp w/ input links working again with json links, except for the lack of cleanup on shutdown. Still need to test output link.

https://github.com/mdavidsaver/v4workspace.git

Previously I had hooked into dbcar() for reporting. Do you intend some general reporting function for json links, or do I need to add a PVA link specific reporting function?

[lp:~epics-core/epics-base/link-support-2]

12781. By Andrew Johnson on 2016-09-04

Moved PV_LINK-specific code out of dbLink.c into link types

This required a change to the lset::getValue arguments, removing
the pstat and psevr pointers. Links can still return a non-zero
value from getValue and trigger a LINK:INVALID alarm, but for any
other alarm settings they must manipulate the record themselves.

12782. By Andrew Johnson on 2016-09-04

Added calc link-type

[Andrew Johnson (anj)]

Just committed a couple more changes, one of which will require you to modify your getValue() routine slightly (the pstat & psevr args have gone, look at the commit for why).

You should take a look at the new calc link type that I also added (some docs generated in links.html).

I agree about the cantProceed stuff, for now I was keeping the routines the same but we need to fix them properly including their call-sites. The new dbmfStrndup() will segfault like dbmfStrdup() if dbmfMalloc() ever returns NULL.

doCloseLinks() should close JSON_LINKs, I'll fix that later.

I'm hitting string length limits, dbpr can't display long JSON_LINK strings, and I think there's also a length limit to the long-string one can caput to a link field which will need to be increased somewhat.

I need to stop for supper now, later!

[lp:~epics-core/epics-base/link-support-2]

12783. By Andrew Johnson on 2016-09-04

Minor cleanups

12784. By Andrew Johnson on 2016-09-04

Clean up JSON_LINKs in doCloseLinks

12785. By Andrew Johnson on 2016-09-04

Minor fixes to the calc link-type

[Andrew Johnson (anj)]

Fixed doCloseLinks(), which now cleans up JSON links (and ensures that the lockset is locked before cleaning up DBlinks on a buildIsolated IOC.

There is still a bug in the embedded JLink handling, multiple levels of embeds don't work properly. I know roughly what's going on, I just have to work out how to fix it.

[lp:~epics-core/epics-base/link-support-2]

12786. By Andrew Johnson on 2016-09-04

Fix jlink memory leak in dbStaticLib

Added dbFreeLinkInfo(), use everywhere to release dbLinkInfo resources.

Renamed link_type => expected_type in db[Can]SetLink(),
my brain understands this name faster.

12787. By Andrew Johnson on 2016-09-04

Add lnkConst_remove, fix debug messages

12788. By Andrew Johnson on 2016-09-04

JLink: Convert parser->linkDepth into jlink->parseDepth

This counter is indicates when we've finished parsing a link,
and needs to be stored with link rather than the parser so it
keeps its value while parsing embedded links. This fixes the
embedded links bug.

Also removed the limit on a link name's length.

12789. By Andrew Johnson on 2016-09-04

Make the long-string buffer for link fields bigger

When representing a link field as a long string (.INP$)
we have to pick some size limit for the buffer.
Previously this was the max length of a PV name + 12 chars,
but with JSON links that's not big enough.

This commit sets it to 1KB and defines a macro so it will be
easier to change in the future if necessary.

12790. By Andrew Johnson on 2016-09-05

Added JLink reporting infrastructure

Command 'dbjlr <record|*> <level>' calls the report method for
all JSON links in all records, or in one named record.
Added level and indent arguments to the jlif::report() method.

Added jlif::map_children() method for recursing through all
JSON links, plus dbJLinkMapChildren() and dbJLinkMapAll() APIs.

Implemented the report and map_children methods in the const
and calc link types.

[Andrew Johnson (anj)]

Added the 'dbjlr <record> <level>' command that calls jlif::report() for all JSON_LINKs:
    void (*report)(const jlink *, int level, int indent);
        /* Optional, print status information about this link instance, then
         * if (level > 0) print a link identifier (at indent+2) and call
         * dbJLinkReport(child, level-1, indent+4)
         * for each child.
         */

The report method is intended for individual status reports and not collecting summary statistics, but I've also added another optional jlif routine for recursing through all child links:
    typedef long (*jlink_map_fn)(jlink *, void *ctx);

    long (*map_children)(jlink *, jlink_map_fn rtn, void *ctx);
        /* Optional, call dbJLinkMapChildren() on all embedded links.
         * Stop immediately and return status if non-zero.
         */
There is also a top-level API for running that on all records:
    long dbJLinkMapAll(char *recname, jlink_map_fn rtn, void *ctx)

Question about alarms and embedded links: Currently a link that wants to raise an alarm does so by calling recGblSetSevr(plink->record, stat, sevr), so for embedded links the parent link has no idea that the child raised an alarm or what alarm state it's in. Should I add an lset routine and a dbLink wrapper for handling alarms from child links, which for a top-level link (or when this is unimplemented in the parent) would call recGblSetSevr()? This way the parent could see and filter the child's alarms if it wanted to.

I think I'm done implementing for the weekend now. I'll check back for any comments later, but I have to produce a 45-minute talk to give at LBNL in 7 days time, and 4.6.0 is also due out this week too.

What if anything do you think is still missing or wrong in this code? Ahh, except for still having a broken dbPutLinkTest...

Thanks!

[Andrew Johnson (anj)]

... and 'dbpr' dying when it tries to print a JSON link that is way too big for its buffer.

Did we fix that problem already on another branch?

[mdavidsaver (mdavidsaver)]

> Did we fix that problem already on another branch?

Supposedly I fixed this for 3.16 as per lp:1462214.

[mdavidsaver (mdavidsaver)]

> Should I add an lset routine and a dbLink wrapper for handling alarms from child links, which for a top-level link (or when this is unimplemented in the parent) would call recGblSetSevr()? This way the parent could see and filter the child's alarms if it wanted to.

Do you have a use case in mind? I can't think of anything other than maximize severity.

[lp:~epics-core/epics-base/link-support-2]

12791. By Andrew Johnson on 2016-09-05

Some documentation updates

[Andrew Johnson (anj)]

> Supposedly I fixed this for 3.16 as per lp:1462214.

I thought we did, thanks.

> Do you have a use case in mind?

I think the NMS/MS/MSI/MSS flag belongs in the child link, not in the parent.

I was thinking the user may want to find out which link a link alarm is coming from, but I guess that information should appear in the report from the child link itself (fix to lnkCalc needed). Ok, no API changes needed there, thanks!

[lp:~epics-core/epics-base/link-support-2]

12792. By Andrew Johnson on 2016-09-05

Minor updates

12793. By Andrew Johnson on 2016-09-06

Fix warnings from clang

[mdavidsaver (mdavidsaver)]

I see that doCloseLinks() now calls lset::removeLink, but not jlif::free_jlink. Is this intended? I think it's consistent that I should free() in both place, I just want to clarify the lifecycle to avoid leaks.

[lp:~epics-core/epics-base/link-support-2]

12794. By Andrew Johnson on 2016-09-07

Fixed a small memory leak in lnkCalc

[Andrew Johnson (anj)]

Yes, it feels a bit strange but both routines are needed and do almost the same thing, but with different arguments. jlif:free_jlink() is called when a jlink doesn't parse correctly; it doesn't have a plink or an lset pointer yet, so we couldn't call the lset::removeLink() method at this point anyway. The lset::removeLink() routine is called after a link has been opened when the link field's value gets overwritten, and is also needed for the CA_LINK and DB_LINK types which don't have a jlif.

A link that has embedded child links must call all their free_jlink() routines from its free_jlink(), and all their removeLink() routines from its removeLink() routine.

Unfortunately it is fairly easy for the two routines to get out of step during development, as evidenced by my lnkCalc where I forgot to update removeLink() after adding some fields for the report displays; another fix committed!

I started working on the test code again and found a major flaw: When I moved the JSON parsing to before record initialization I forgot that while parsing a JSON link for an OUT/INP field we need to be able to tell whether DTYP is set to a device support like "Soft Channel" (when link name lookup must occur while parsing) or to "My JSON-addressed device support" (when it shouldn't). I'm going to need to sleep on this to work out what to do, but for now we can't handle JSON_LINK addresses for device support routines.

[lp:~epics-core/epics-base/link-support-2]

12795. By Andrew Johnson on 2016-09-07

Clean up memory leaks

12796. By Andrew Johnson on 2016-09-07

Added test link type, fix dbPutLinkTest for JSON_LINKs

[Andrew Johnson (anj)]

dbPutLinkTest now works and doesn't leak memory when checking JSON_LINK values.

The Release Notes entries are still incomplete, and there's that device(JSON_LINK) issue...

[mdavidsaver (mdavidsaver)]

valgrind tells me that jlink::parent and jlink::parseDepth are not being initialized, at least for a top level jlink.

[lp:~epics-core/epics-base/link-support-2]

12797. By Andrew Johnson on 2016-09-08

Initialize all fields of jlink, link types may not use calloc

[Andrew Johnson (anj)]

Your alloc_jlink() method is probably using malloc() rather than calloc(), which is why valgrind doesn't flag my link types with that problem. Ok, I added code to dbJLink.c to explicitly initialize those fields.

[Andrew Johnson (anj)]

So instead of the DTYP controlling what address types are accepted in the INP/OUT link (as with the original hardware addresses), how about making it so that putting a JSON address into the INP/OUT link would also set the DTYP field to match the device type named in the address? The user won't have to set DTYP at all when they're using a JSON device type. The interface between record support and device support doesn't change at all, but there will be a new table for the JSON parsing routines.

There will need to be a new DBD keyword, probably
    devlink(<rectype>, <linktype>, <devlinkIf>, "DTYP Name")
The <linktype> name will be matched against the keys in the JSON INP/OUT address, so I have to pass them from the record type into the dbParseLink() routine. I haven't worked out yet where the DTYP field would actually get set, I guess that could be just another value stored in the link_info object, so it should probably be in dbSetLinkJSON() except that the plink->precord links haven't been set up yet so it can't find the prec->dtyp field.

Haven't implemented anything yet, but I think this idea has a good chance of working, do you see any obvious flaws?

[lp:~epics-core/epics-base/link-support-2]

12798. By Andrew Johnson on 2016-09-09

Fixes for Windows builds

12799. By Andrew Johnson on 2016-12-12

Update comments in calcoutRecord

12800. By Andrew Johnson on 2017-02-17

Remove constant link checks from test device

12801. By Andrew Johnson on 2017-02-17

Fix HTML entities

12802. By mdavidsaver on 2017-03-01

add testing lset

12803. By mdavidsaver on 2017-03-01

libCom: add errSymMsg() error message lookup

Like errSymLookup() but always returns a static string.

12804. By mdavidsaver on 2017-03-01

dbUnitTest: more informative dbPutField*()

12805. By Andrew Johnson on 2017-03-01

dbUnitTest: Improve output slightly

12806. By mdavidsaver on 2017-03-01

db/test: dbPutLinkTest include json links and more

12807. By mdavidsaver on 2017-03-01

dbLock: add assert in dbScanLock

catch locking attempts before iocInit()

[Andrew Johnson (anj)]

Cherry-picked the additional tests from your integration branch (different order though, and I merged 2 of your commits into one to keep the tests passing).

Need to write some more text for the Release Notes and the std/link/links.dbd.pod file.

[lp:~epics-core/epics-base/link-support-2]

12808. By Andrew Johnson on 2017-03-03

db/test: Fix warning from clang

[Andrew Johnson (anj)]

F2F 3/15: OK for merging with the API being PROVISIONAL with doLocked method. The link API might still see drastic changes in the future. At least one more link type implementation desired to prove API validity and completeness. AJ to merge doLocked code.

[mdavidsaver (mdavidsaver)]

As an exercise in exercising the new API I started on a second implementation of CA links. Only input links work w/o CP. In the process I came across two points.

* What to do about pvlOptTSELisTime? How does TSEL work wrt. link support. It seems quite redundant to copy+paste INP/OUT into TSEL every time.

* I realized that the meta-data functions in struct lset taken together are equivalent to struct dbr_ctrl_double (aka always double). So the typeiness of dbGet() with *poptions isn't needed. Why not have a single lset call which is given a struct to fill in. Perhaps with a bit-mask to reduce work (although I wonder if the locking overhead would be greater).

> long (*getValue)(struct link *plink, short dbrType, void *pbuffer,
> long *pnRequest, dbr_ctrl_double *meta);

(I'm aware that dbr_ctrl_double is in db_access.h, and can't appear in dbLink.h, this is an example)

https://github.com/mdavidsaver/epics-base/blob/integration/src/std/link/lnkCa.c

[mdavidsaver (mdavidsaver)]

> How does TSEL work wrt. link support.

So far my thinking is to add another special case (in addition to .TIME). That linking TSEL to INP/OUT of the same record will cause dbGetTimeStamp to be called with the INP/OUT link. This would look like:

> record(ai, "xxxx") {
> field(INP, {....})
> field(TSEL, "xxxx.INP")
> }

[mdavidsaver (mdavidsaver)]

> That linking TSEL to INP/OUT of the same record

or maybe any DBF_*LINK field of the same record.

[mdavidsaver (mdavidsaver)]

wrt. lset locking and consistency between value/alarm/time. I still don't like the proposed doLocked() method. It seems cumbersome to use, and requires re-fetching the (possibly different) value. For example, this isn't compatible with the present handling of TSEL.

My thinking so far is to latch value+meta data at some point, so that subsequent calls to eg. dbGetAlarm() return the cached value. I can think of two ways this could work (there are certainly more).

1. A call to dbGetLink() latches alarm/time (and GR/CTRL meta). This requires that dbGetLink() is called before dbGetAlarm()/dbGetTimeStamp() or values would be returned. This wouldn't break any code I've written or seen. Such errors could be detected (and a warning printed?)

2. The first call to a dbGet*() function after a record starts dbProcess() could cause a latch.

Both 2. and the warning in 1. could be implemented with a per-record sequence counter.

[mdavidsaver (mdavidsaver)]

More ca link work adding CP and output link (put). Now testable.

https://github.com/mdavidsaver/epics-base/blob/integration/src/std/link/lnkCa.c

[Andrew Johnson (anj)]

doLocked() only requires the value re-fetching when you're writing aSub code, where the problem is that you don't (currently) have a way to prevent the record type from doing the initial fetch of all the INP* links. When writing a record type or device support which does the get itself that wouldn't be a problem. We could add a way to allow an aSub Init routine to tell the record type not to get the values of the record's INP* links but leave them to the subroutine itself.

I don't see any other way to avoid doing wasted work — either the link will be copying metadata which will never be used (this is likely to be the vast majority of cases, so arguably your suggestion would waste more effort here) or (absent the above aSub changes) you have to do the get/convert thing twice in that particular case. All link types that provide their own locks (i.e. except for DB-links) should be using an epicsMutex, so I don't see the recursive locking as being a big problem.

Your discussion about TSEL is for the case where you want to copy the timestamp from the same place as the INP link, without having to set up a second link — is this correct? If you're using the standard record types with DTYP=Soft Channel you can set TSEL=-2 (epicsTimeEventDeviceTime) and we already do almost the right thing. The code that handles TSEL==epicsTimeEventDeviceTime in the existing soft device support code can be made atomic using doLocked(), e.g. for devAiSoft.c (untested):

static long readLocked(struct link *pinp, void *dummy)
{
    double val;
    aiRecord *prec = pinp->precord;
    long status = dbGetLink(pinp, DBR_DOUBLE, &val, 0, 0);

    if (status) return status;

    /* Apply smoothing algorithm */
    if (prec->smoo != 0.0 && prec->dpvt && finite(prec->val))
        prec->val = val * (1.00 - prec->smoo) + (prec->val * prec->smoo);
    else
        prec->val = val;

    prec->udf = FALSE;
    prec->dpvt = &devAiSoft; /* Any non-zero value */

    if (dbLinkIsConstant(&prec->tsel) &&
        prec->tse == epicsTimeEventDeviceTime)
        dbGetTimeStamp(pinp, &prec->time);

    return 0;
}

static long read_ai(aiRecord *prec)
{
    if (dbLinkIsConstant(&prec->inp))
        return 2;

    if (dbLinkDoLocked(&prec->inp, readLocked, NULL)) {
        prec->dpvt = NULL;
    }
    return 2;
}

[mdavidsaver (mdavidsaver)]

> ... link will be copying metadata which will never be used ...

Oh, Andrew I thought you knew me better than this :) There is no reason to extra copying. Double buffering and/or a bit mask (like dbGet *options) can avoid this. I don't see that any significant overhead need be added.

To modify my previous:

> long (*getValue)(struct link *plink, short dbrType, void *pbuffer,
> long *pnRequest, const dbr_ctrl_double **meta);

where:

> const dbr_ctrl_double *pmeta = NULL;
> ...->getValue(... , &pmeta);

The pointer stored in 'pmeta' would remain stable until the subsequent call to getValue.

Do you have any thoughts about imposing an ordering requirement? (dbGetLink first then metadata calls)

> ... When writing a record type or device support which does the get itself
> ... you can set TSEL=-2 ...

> Your discussion about TSEL is for the case where you want to copy the timestamp from the same place as the INP link, without having to set up a second link — is this correct?

Yes. Although I'm focused on CA-like links, not the HW links that I think you're considering. The TSE=-2 hack is sufficient for HW links, but isn't relevant otherwise. It might be better if you think about this in the context of calcRecord, which doesn't (and shouldn't) know about the difference between DB/CA/... links.

To rephrase my previous example:

> record(calc, "xxxx") {
> field(INPA, {ca:{pv:"src:pv",proc:"CP"})
> ...
> field(TSEL, "xxxx.INPA")
> }

My requirement is to ensure that the result will have the same timestamp as the input update it derives from.

[Andrew Johnson (anj)]

What changes will you have to make to the record types to actually make use of your solution? You forgot to pass in the bitmask BTW, or is that going to be stored inside the data structure? The fact that you have to consider the ordering is a code smell, and one of the reasons I don't like your approach. It seems to me that implementing your getValue() method would involve adding quite a bit of code to each link type.

> My requirement is to ensure that the result will have the same timestamp as the input update it derives from.

I'm not discussing hardware links at all, I'm pretty sure that I'm talking about the same thing you are. TSEL support for epicsTimeEventDeviceTime has been in place for a very long time; it tells recGblGetTimeStamp() that device support has already set the TIME field, and my modified devAiSoft.c shows how Soft Channel input device support can get the timestamp and the data atomically from any link type that supports dbLinkDoLocked().

The devAiSoft.c implementation I posted does currently assume that all link types provide the doLocked() method, so I do need to modify the read_ai routine slightly to cover the case where a link type doesn't (in which case we can't provide atomicity with that link type), but that's a simple change. I could modify dbLinkDoLocked() to call the subroutine directly in that case, but I think it's better to let the caller do that so it can warn the user about non-atomic operations if it wants to.

What is your actual requirement for timestamps with a calc record? It may be implementable with my solution by interposing (with a DB link) an ai record with TSEL=-2 in front of the INPx link which provides the timestamp, and pointing the calc's TSEL to that ai.TIME field using another DB link. The lockset should ensure atomicity of the calc's fetch of both value and timestamp from that ai record.

It may be though that your requirements can't be solved using a generic record type, or that the aSub needs to add more fields to hold the timestamps associated with the data from each of its INP* links, but you haven't really said what those additional requirements might be.

[Andrew Johnson (anj)]

Ok, you did give the calc example, I described how to solve it with an extra ai record. How much would you have to change the calc record to implement your solution? Note that most record types don't have to handle the TSEL field at the moment, it's all automatic, but I don't think that could be the case with your getValue() approach (or significantly complicating recGblGetTimeStamp()).

[Andrew Johnson (anj)]

Another approach which would work for your calc.INPx links directly would be to add a flag to the link type telling it to set the TIME field as well as fetch the data — similar to the way implementing MS/MSI/MSS flags requires the link's getValue() method to call recGblInheritSevr() to flag link alarms. Note this still require TSEL=-2. Thusly:

> record(calc, "xxxx") {
> field(INPA, {ca:{pv:"src:pv",proc:"CP",ts:true})
> ...
> field(TSEL, "-2")
> }

If the user doesn't set TSEL=-2 the timestamp will be overwritten when process() calls recGblGetTimeStamp().

[mdavidsaver (mdavidsaver)]

From 4 April meeting: waiting for ANJ to post code adding dbLinkDoLocked()

[Andrew Johnson (anj)]

dbLinkDoLocked() changes pushed (to the git repo at https://git.launchpad.net/~epics-core/epics-base/+git/link-support-2 ) including a test of the new API for dbCa links and changes to synchronize the soft device support supplied time-stamps.

Still some documentation missing (FIXME and ... in the Release Notes).

[mdavidsaver (mdavidsaver)]

wrt. FIXMEs

Doesn't look like any code calling dbmfMalloc() directly or indirectly (via dbmfStrdup) every checks for allocation failure. So imo. this should be cantProceed().

"lnkConst: Mixed data types in array". imo error is the best choice atm.

"FIXME: const strings are now supported". What is to be fixed here?

"FIXME This handles the common case, but not the general one...". also doesn't test for len>=4. The string handling in dbConstLoadLS() looks too similar to what caused problems of lp:1678494. After strlen() is called and compared with size, better to use memcpy() and no reason for second strlen().

arrayOpTest should have tests of array initialization failure. eg. missing ']', number parse error, and mixed data type.

[mdavidsaver (mdavidsaver)]

Also seeing the device support changes related to dbLinkDoLocked() does somewhat confirm my fear that too much work will be done in this callback. All work from the read functions is moved into the locked callback. And as we know, these soft channel dsets are frequently taken as best practice example by users.

[Andrew Johnson (anj)]

>> Doesn't look like any code calling dbmfMalloc() directly or indirectly
>> (via dbmfStrdup) every checks for allocation failure. So imo. this
>> should be cantProceed().

Right. This isn't a new issue though, I added those FIXMEs to libCom/dbmf/dbmf.c when I noticed the problem in the current implementation, while adding dbmfStrndup().

>> "lnkConst: Mixed data types in array". imo error is the best choice atm.

Agreed, they do currently print an error and fall through to return jlif_stop, so maybe we just need to remove those comments.

>> "FIXME: const strings are now supported". What is to be fixed here?

Don't see anything obvious, maybe I just forgot to remove the comment.

>> "FIXME This handles the common case, but not the general one...".
>> also doesn't test for len>=4. The string handling in dbConstLoadLS()
>> looks too similar to what caused problems of lp:1678494. After strlen()
>> is called and compared with size, better to use memcpy() and no reason
>> for second strlen().

The if condition will always be false when len < 4 because one of those character comparisons won't match — it tests them in order and uses && so it's never in danger of dereferencing an element after the first 0 byte in the string.

I think my point about the general case may have been multiple string items, but I don't have time right now to investigate.

>> arrayOpTest should have tests of array initialization failure.
>> eg. missing ']', number parse error, and mixed data type.

(out of time to comment, tomorrow...)

I am looking at fixing the device support. For some such as devBiSoft I see no point changing the code, but I agree that devAiSoft needs work.

[mdavidsaver (mdavidsaver)]

Should these three be equivalent initializations of INP w/ a long string? Hint, longstr2 seems to truncate.

record(lsi, "longstr1") {
  field(SIZV, "100")
  field(INP, ["!----------------------------------------------!"])
}

record(lsi, "longstr2") {
  field(SIZV, "100")
  field(INP, {const: ["!----------------------------------------------!"]})
}

record(lsi, "longstr3") {
  field(SIZV, "100")
  field(INP, {const: "!----------------------------------------------!"})
}

[mdavidsaver (mdavidsaver)]

Also, I want to use testdbGetArrFieldEqual() with these tests, so I will either rebase this branch onto the latest 3.16, or merge the latest 3.16 into this branch (I haven't decided which).

[Andrew Johnson (anj)]

>> Should these three be equivalent initializations of INP w/ a long string?
>> longstr2 seems to truncate.

If you create a const link with an array of strings the elements do currently get truncated, the assumption being that you're initializing a waveform with an array of DBF_STRINGs, which are stored as a series of 40 character buffers for something like this:

record(waveform, "longstr4") {
  field(FTVL, "STRING")
  field(NELM, 100)
  field(INP, ["!----------------------------------------------!", "2..."])
}
record(waveform, "longstr5") {
  field(FTVL, "STRING")
  field(NELM, 100)
  field(INP, {const: ["!----------------------------------------------!", "2..."]})
}

Looking at lnkConst_loadArray() though I guess there's no reason to truncate the individual elements when storing them in lnkConst_string(), the truncation will happen when they get copied into the waveform anyway, and doing this lets your 3 initializations be equivalent. Commit that fix?

[Andrew Johnson (anj)]

Fix Committed.

Interestingly mixed data types are legal (they work fine) in an array when using dbConstLink, but aren't with the lnkConst type. That's because in dbConstLink the JSON parsing gets deferred until you know what data type you're initializing.

epics> dbpr longstr4 1
APST: Always ASG: BKPT: 00 BUSY: 0
DESC: DISA: 0 DISP: 0 DISS: NO_ALARM
DISV: 1 DTYP: Soft Channel EGU: EVNT:
FLNK:CONSTANT 0 FTVL: STRING HOPR: 0
INP:CONSTANT ["!- One -!",2,3.0] LOPR: 0 MPST: Always
NAME: longstr4 NELM: 100 NORD: 3 PACT: 0
PHAS: 0 PINI: NO PREC: 0 PRIO: LOW
PUTF: 0 RARM: 0 RPRO: 0 SCAN: Passive
SDIS:CONSTANT SEVR: INVALID SIML:CONSTANT SIMM: NO
SIOL:CONSTANT STAT: UDF TPRO: 0 TSE: 0
TSEL:CONSTANT UDF: 0 UDFS: INVALID VAL: (nil)

tux% caget -c longstr4
longstr4 3 !- One -! 2 3.000000

[mdavidsaver (mdavidsaver)]

found and fixed mem leak in dbConstLink. found buffer overrun in linkCalc, fixed by anj. Also added unittest of linksupport initialization, merged in latest 3.16. Testing continues.

[Andrew Johnson (anj)]

Pushed a clean-up and slight simplification of lnkConst.c

[Andrew Johnson (anj)]

Have been working on Release Notes and other documentation, not complete yet.

[Andrew Johnson (anj)]

Pushed a fix to the printfRecord which resolves the FIXME (the comment was right), and adds tests.

[Andrew Johnson (anj)]

Resolved the FIXME in dbConstLink.c by parsing the JSON properly — added a new parser to dbConvertJSON.c. Additional test in linkInitTest which would have failed before.

[Andrew Johnson (anj)]

Committed updates to the Release Notes and links.dbd.pod, this documentation is probably done for now.

I also committed some changes to make the dbLinkIsConstant() and dbLinkIsVolatile() routines return only TRUE (1) or FALSE (0) — they used to return -1 when plset was NULL, but now that condition gives a constant, non-volatile result.

Still working on fixing the readLocked() methods of the soft device layers and adding a number of tests, but I won't have as much free time after committing those changes (probably tomorrow).

[Andrew Johnson (anj)]

Done what I think are my final commits, moving code out of readLocked(), fixing issues and adding tests.

I also added a feature to the subArray record, which can now be used as a lookup table, and fixed a bug in the event record.

I think I'm going to close this merge request and open up a new one for the git repo, to make it easier to examine the diffs against the current Base-3.16.

review: Needs Resubmitting

Unmerged revisions

12808. By Andrew Johnson on 2017-03-03

db/test: Fix warning from clang

12807. By mdavidsaver on 2017-03-01

dbLock: add assert in dbScanLock

catch locking attempts before iocInit()

12806. By mdavidsaver on 2017-03-01

db/test: dbPutLinkTest include json links and more

12805. By Andrew Johnson on 2017-03-01

dbUnitTest: Improve output slightly

12804. By mdavidsaver on 2017-03-01

dbUnitTest: more informative dbPutField*()

12803. By mdavidsaver on 2017-03-01

libCom: add errSymMsg() error message lookup

Like errSymLookup() but always returns a static string.

12802. By mdavidsaver on 2017-03-01

add testing lset

12801. By Andrew Johnson on 2017-02-17

Fix HTML entities

12800. By Andrew Johnson on 2017-02-17

Remove constant link checks from test device

12799. By Andrew Johnson on 2016-12-12

Update comments in calcoutRecord

=== modified file 'documentation/RELEASE_NOTES.html'
--- documentation/RELEASE_NOTES.html	2017-02-01 17:57:04 +0000
+++ documentation/RELEASE_NOTES.html	2017-03-03 18:23:23 +0000
@@ -21,6 +21,152 @@
 
 -->
 
+<h3>Device Support Address Type <tt>JSON_LINK</tt></h3>
+
+<p>Device support may be written to expect hardware addresses in the new
+<tt>JSON_LINK</tt> address type. Addresses loaded from a database file will be
+checked against the JSON rules, and a strict JSON representation of the result
+is provided as a C string pointed to by <tt>link.value.json.string</tt>.</p>
+
+<p>Currently the device support is responsible for parsing the JSON text itself.
+An event-driven JSON parser library has been included in libCom since Base-3.15,
+<a href="https://lloyd.github.io/yajl/">YAJL (Yet Another JSON Library)</a>
+Version 1.012, <a href="https://lloyd.github.io/yajl/yajl-1.0.12/">documented
+here</a>.</p>
+
+
+<h3>JSON Link Addressing</h3>
+
+<blockquote>
+
+<p><b style="color:red">FIXME</b> text missing here...</p>
+
+<h4>Support routine changes</h4>
+
+<p>For link fields in external record types and soft device support to be able
+to use the new JSON link types properly, the following changes are
+necessary:</p>
+
+<ul>
+
+<li>Make all calls to <tt>recGblInitConstantLink()</tt> unconditional on the
+link type, i.e. change this code:
+
+<pre>
+    if (prec->siml.type == CONSTANT) {
+        recGblInitConstantLink(&amp;prec->siml, DBF_USHORT, &amp;prec->simm);
+    }
+</pre>
+
+into this:
+
+<pre>
+    recGblInitConstantLink(&amp;prec->siml, DBF_USHORT, &amp;prec->simm);
+</pre>
+
+Note that <tt>recGblInitConstantLink()</tt> still returns true if the field was
+successfully initialized from the link.</li>
+
+<li>Code like this:
+
+<pre>
+    if ((prec->dol.type != CONSTANT) &amp;&amp;
+</pre>
+
+should usually become:
+
+<pre>
+    if (!dbLinkIsConstant(&amp;prec->dol) &amp;&amp;
+</pre>
+</li>
+
+<li>Other code that compares a link type with CONSTANT should be modified to
+use the new routine <tt>dbLinkIsConstant(plink)</tt> instead.</li>
+
+<li>Any code that calls dbCa routines directly or that explicitly checks if a
+link has been resolved as a CA link using code such as
+
+<pre>
+    if (plink->type == CA_LINK)
+</pre>
+
+should be modified to use the new generic routines defined in dbLink.h. As an
+example, the calcout record has been modified to use the new dbLink API.</li>
+
+<li>...</li>
+
+</ul>
+
+<p><b style="color:red">FIXME</b> text missing here...</p>
+
+</blockquote>
+
+
+<h3>Constant Link Values</h3>
+
+<p>Previously a constant link (i.e. a link that does not point to another PV,
+either local or over Channel Access) has only been able to provide a numeric
+value; any string found in a link field that was not recognized as a number was
+treated as a PV name. In this release, constant links may contain string values,
+arrays, or even arrays of strings. These are indicated by ...</p>
+
+<p><b style="color:red">FIXME</b> text missing here...</p>
+
+
+<h3>Database Parsing of "Relaxed JSON" Values</h3>
+
+<p>A database file can now provide a "relaxed JSON" value for a database field
+value or an info tag. Only a few field types can currently accept such values,
+but the capability is now available for use in other places in the future. If a
+JSON-capable field is written to at run-time though only strictly compliant JSON
+may be used (the dbStaticLib parser rewrites relaxed JSON values into strict
+JSON before passing them to the datase for interpretation, where the strict
+rules must be followed).</p>
+
+<p>"Relaxed JSON" was developed to maximize compatibility with the previous
+database parser rules and reduce the number of double-quotes that would be
+needed using strict JSON syntax. The parser will also accept strict JSON, which
+should be used when machine-generating database files. The differences are:</p>
+
+<ul>
+
+<li>Strings containing only the characters <tt><b>a-z A-Z 0-9 _ - + .</b></tt>
+do not have to be enclosed in double-quote characters.</li>
+
+<li>The above rule applies to map keys as well as to regular string values.</li>
+
+<li>The JSON keywords <tt>null</tt>, <tt>true</tt> and <tt>false</tt> (all
+lower-case) will be recognized as keywords, so must be quoted to use any of
+these single words as a string.</li>
+
+<li>Comments may be used, introduced as usual by the <tt><b>#</b></tt>
+character and extending to the end of the line.</li>
+
+</ul>
+
+<p>A JSON field or info value is only enclosed in quotes when the value being
+provided is a single string, and even here the quotes can be omitted in some
+cases as described above. The following shows both correct and incorrect
+excerpts from a database file:</p>
+
+<pre>
+    record(ai, math:pi) {
+        field(INP, {const: 3.14159265358979})   # Correct
+        field(SIOL, "{const: 3.142857}")        # Wrong
+
+        info(autosave, {            # White-space and comments are allowed
+            fields:[DESC, SIMM],
+            pass0:[VAL]
+        })                          # Correct
+    }
+</pre>
+
+<p>Note that the record, field and info-tag names do <em>not</em> accept JSON
+values, so they follows the older bareword rules for quoting where the colon
+<tt><b>:</b></tt> and several additional characters are legal in a bareword
+string.</p>
+
+
 <h3>Echoless comments in iocsh</h3>
 
 <p>The way comments are parsed by the iocsh interpreter has changed. The
 
=== modified file 'src/ioc/db/Makefile'
--- src/ioc/db/Makefile	2016-05-03 00:51:11 +0000
+++ src/ioc/db/Makefile	2017-03-03 18:23:23 +0000
@@ -14,14 +14,18 @@
 INC += callback.h
 INC += dbAccess.h
 INC += dbAccessDefs.h
-INC += dbCa.h
 INC += dbAddr.h
 INC += dbBkpt.h
+INC += dbCa.h
 INC += dbChannel.h
+INC += dbConstLink.h
 INC += dbConvert.h
 INC += dbConvertFast.h
+INC += dbConvertJSON.h
+INC += dbDbLink.h
 INC += dbExtractArray.h
 INC += dbEvent.h
+INC += dbJLink.h
 INC += dbLink.h
 INC += dbLock.h
 INC += dbNotify.h
@@ -64,9 +68,13 @@
 dbCore_SRCS += dbAccess.c
 dbCore_SRCS += dbBkpt.c
 dbCore_SRCS += dbChannel.c
+dbCore_SRCS += dbConstLink.c
 dbCore_SRCS += dbConvert.c
+dbCore_SRCS += dbConvertJSON.c
+dbCore_SRCS += dbDbLink.c
 dbCore_SRCS += dbFastLinkConv.c
 dbCore_SRCS += dbExtractArray.c
+dbCore_SRCS += dbJLink.c
 dbCore_SRCS += dbLink.c
 dbCore_SRCS += dbNotify.c
 dbCore_SRCS += dbScan.c
 
=== modified file 'src/ioc/db/dbAccess.c'
--- src/ioc/db/dbAccess.c	2017-02-01 17:57:04 +0000
+++ src/ioc/db/dbAccess.c	2017-03-03 18:23:23 +0000
@@ -41,7 +41,6 @@
 #include "dbAddr.h"
 #include "dbBase.h"
 #include "dbBkpt.h"
-#include "dbCa.h"
 #include "dbCommon.h"
 #include "dbConvertFast.h"
 #include "dbConvert.h"
@@ -668,7 +667,7 @@
             paddr->dbr_field_type = DBR_CHAR;
         } else if (dbfType >= DBF_INLINK && dbfType <= DBF_FWDLINK) {
             /* Clients see a char array, but keep original dbfType */
-            paddr->no_elements = PVNAME_STRINGSZ + 12;
+            paddr->no_elements = PVLINK_STRINGSZ;
             paddr->field_size = 1;
             paddr->dbr_field_type = DBR_CHAR;
         } else {
@@ -1059,23 +1058,12 @@
         }
     }
 
-    switch (plink->type) { /* Old link type */
-    case DB_LINK:
-    case CA_LINK:
-    case CONSTANT:
-        dbRemoveLink(&locker, plink);   /* link type becomes PV_LINK */
-        break;
-
-    case PV_LINK:
-    case MACRO_LINK:
-        break;  /* should never get here */
-
-    default: /* Hardware address */
-        if (!isDevLink) {
-            status = S_db_badHWaddr;
-            goto restoreScan;
-        }
-        break;
+    if (dbLinkIsDefined(plink)) {
+        dbRemoveLink(&locker, plink);   /* Clear out old link */
+    }
+    else if (!isDevLink) {
+        status = S_db_badHWaddr;
+        goto restoreScan;
     }
 
     if (special) status = dbPutSpecial(paddr, 0);
@@ -1108,6 +1096,7 @@
     switch (plink->type) { /* New link type */
     case PV_LINK:
     case CONSTANT:
+    case JSON_LINK:
         dbAddLink(&locker, plink, pfldDes->field_type, pdbaddr);
         break;
 
 
=== modified file 'src/ioc/db/dbAccessDefs.h'
--- src/ioc/db/dbAccessDefs.h	2016-05-22 12:38:18 +0000
+++ src/ioc/db/dbAccessDefs.h	2017-03-03 18:23:23 +0000
@@ -181,6 +181,7 @@
 #define S_db_badChoice 	(M_dbAccess|13) /*Illegal choice*/
 #define S_db_badField 	(M_dbAccess|15) /*Illegal field value*/
 #define S_db_lsetLogic 	(M_dbAccess|17) /*Logic error generating lock sets*/
+#define S_db_noLSET     (M_dbAccess|21) /*No link support table or entry*/
 #define S_db_noRSET 	(M_dbAccess|31) /*missing record support entry table*/
 #define S_db_noSupport 	(M_dbAccess|33) /*RSET or DSXT routine not defined*/
 #define S_db_BadSub 	(M_dbAccess|35) /*Subroutine not found*/
 
=== modified file 'src/ioc/db/dbCa.c'
--- src/ioc/db/dbCa.c	2017-02-01 17:57:04 +0000
+++ src/ioc/db/dbCa.c	2017-03-03 18:23:23 +0000
@@ -49,6 +49,7 @@
 #include "dbLock.h"
 #include "dbScan.h"
 #include "link.h"
+#include "recGbl.h"
 #include "recSup.h"
 
 /* defined in dbContext.cpp
@@ -231,11 +232,8 @@
 void dbCaCallbackProcess(void *userPvt)
 {
     struct link *plink = (struct link *)userPvt;
-    dbCommon *pdbCommon = plink->precord;
 
-    dbScanLock(pdbCommon);
-    pdbCommon->rset->process(pdbCommon);
-    dbScanUnlock(pdbCommon);
+    dbLinkAsyncComplete(plink);
 }
 
 void dbCaShutdown(void)
@@ -339,8 +337,8 @@
     addAction(pca, CA_CLEAR_CHANNEL);
 }
 
-long dbCaGetLink(struct link *plink,short dbrType, void *pdest,
-    epicsEnum16 *pstat, epicsEnum16 *psevr, long *nelements)
+long dbCaGetLink(struct link *plink, short dbrType, void *pdest,
+    long *nelements)
 {
     caLink *pca = (caLink *)plink->value.pv_link.pvt;
     long   status = 0;
@@ -412,13 +410,23 @@
         aConvert(&dbAddr, pdest, ntoget, ntoget, 0);
     }
 done:
-    if (pstat) *pstat = pca->stat;
-    if (psevr) *psevr = pca->sevr;
-    if (link_action) addAction(pca, link_action);
+    if (link_action)
+        addAction(pca, link_action);
+    if (!status)
+        recGblInheritSevr(plink->value.pv_link.pvlMask & pvlOptMsMode,
+            plink->precord, pca->stat, pca->sevr);
     epicsMutexUnlock(pca->lock);
+
     return status;
 }
 
 
+static long dbCaPutAsync(struct link *plink,short dbrType,
+    const void *pbuffer,long nRequest)
+{
+    return dbCaPutLinkCallback(plink, dbrType, pbuffer, nRequest,
+        dbCaCallbackProcess, plink);
+}
+
 long dbCaPutLinkCallback(struct link *plink,short dbrType,
     const void *pbuffer,long nRequest,dbCaCallback callback,void *userPvt)
 {
@@ -708,14 +716,16 @@
 }
 
 static lset dbCa_lset = {
-    dbCaRemoveLink,
+    0, 1, /* not Constant, Volatile */
+    NULL, dbCaRemoveLink,
+    NULL, NULL, NULL,
     isConnected,
     getDBFtype, getElements,
     dbCaGetLink,
     getControlLimits, getGraphicLimits, getAlarmLimits,
     getPrecision, getUnits,
     getAlarm, getTimeStamp,
-    dbCaPutLink,
+    dbCaPutLink, dbCaPutAsync,
     scanForward
 };
 
 
=== modified file 'src/ioc/db/dbCa.h'
--- src/ioc/db/dbCa.h	2017-02-01 17:57:04 +0000
+++ src/ioc/db/dbCa.h	2017-03-03 18:23:23 +0000
@@ -33,8 +33,7 @@
 epicsShareFunc void dbCaRemoveLink(struct dbLocker *locker, struct link *plink);
 
 epicsShareFunc long dbCaGetLink(struct link *plink,
-    short dbrType, void *pbuffer, epicsEnum16 *pstat, epicsEnum16 *psevr,
-    long *nRequest);
+    short dbrType, void *pbuffer, long *nRequest);
 
 epicsShareFunc long dbCaGetAttributes(const struct link *plink,
     dbCaCallback callback, void *userPvt);
 
=== modified file 'src/ioc/db/dbChannel.c'
--- src/ioc/db/dbChannel.c	2017-02-01 17:57:04 +0000
+++ src/ioc/db/dbChannel.c	2017-03-03 18:23:23 +0000
@@ -531,7 +531,7 @@
                 paddr->dbr_field_type = DBR_CHAR;
             } else if (dbfType >= DBF_INLINK && dbfType <= DBF_FWDLINK) {
                 /* Clients see a char array, but keep original dbfType */
-                paddr->no_elements = PVNAME_STRINGSZ + 12;
+                paddr->no_elements = PVLINK_STRINGSZ;
                 paddr->field_size = 1;
                 paddr->dbr_field_type = DBR_CHAR;
             } else {
 
=== added file 'src/ioc/db/dbConstLink.c'
--- src/ioc/db/dbConstLink.c	1970-01-01 00:00:00 +0000
+++ src/ioc/db/dbConstLink.c	2017-03-03 18:23:23 +0000
@@ -0,0 +1,140 @@
+/*************************************************************************\
+* Copyright (c) 2010 UChicago Argonne LLC, as Operator of Argonne
+*     National Laboratory.
+* Copyright (c) 2002 The Regents of the University of California, as
+*     Operator of Los Alamos National Laboratory.
+* EPICS BASE is distributed subject to a Software License Agreement found
+* in file LICENSE that is included with this distribution.
+\*************************************************************************/
+/* dbConstLink.c
+ *
+ *      Original Authors: Bob Dalesio, Marty Kraimer
+ *      Current Author: Andrew Johnson
+ */
+
+#include <stdio.h>
+#include <string.h>
+
+#include "dbDefs.h"
+
+#define epicsExportSharedSymbols
+#include "dbAccessDefs.h"
+#include "dbAddr.h"
+#include "dbCommon.h"
+#include "dbConstLink.h"
+#include "dbConvertFast.h"
+#include "dbConvertJSON.h"
+#include "dbFldTypes.h"
+#include "dbLink.h"
+#include "link.h"
+
+/***************************** Constant Links *****************************/
+
+/* Forward definition */
+static lset dbConst_lset;
+
+void dbConstInitLink(struct link *plink)
+{
+    plink->lset = &dbConst_lset;
+}
+
+void dbConstAddLink(struct link *plink)
+{
+    plink->lset = &dbConst_lset;
+}
+
+/**************************** Member functions ****************************/
+
+static long dbConstLoadScalar(struct link *plink, short dbrType, void *pbuffer)
+{
+    const char *pstr = plink->value.constantStr;
+    size_t len;
+
+    if (!pstr)
+        return S_db_badField;
+    len = strlen(pstr);
+
+    /* Choice values must be numeric */
+    if (dbrType == DBF_MENU || dbrType == DBF_ENUM || dbrType == DBF_DEVICE)
+        dbrType = DBF_USHORT;
+
+    if (*pstr == '[' && pstr[len-1] == ']') {
+        /* Convert from JSON array */
+        long nReq = 1;
+
+        return dbPutConvertJSON(pstr, dbrType, pbuffer, &nReq);
+    }
+
+    return dbFastPutConvertRoutine[DBR_STRING][dbrType]
+            (pstr, pbuffer, NULL);
+}
+
+static long dbConstLoadLS(struct link *plink, char *pbuffer, epicsUInt32 size,
+    epicsUInt32 *plen)
+{
+    const char *pstr = plink->value.constantStr;
+    size_t len;
+
+    if (!pstr)
+        return S_db_badField;
+    len = strlen(pstr);
+
+    /* FIXME This handles the common case, but not the general one... */
+    if (pstr[0] == '[' && pstr[1] == '"' &&
+        pstr[len-2] == '"' && pstr[len-1] == ']') {
+        pstr += 2;
+        len -= 4;
+    }
+    if (--size > len) size = len;
+
+    strncpy(pbuffer, pstr, size);
+    pbuffer[size] = 0;
+    *plen = (epicsUInt32) strlen(pbuffer) + 1;
+    return 0;
+}
+
+static long dbConstLoadArray(struct link *plink, short dbrType, void *pbuffer,
+        long *pnReq)
+{
+    const char *pstr = plink->value.constantStr;
+
+    if (!pstr)
+        return S_db_badField;
+
+    /* Choice values must be numeric */
+    if (dbrType == DBF_MENU || dbrType == DBF_ENUM || dbrType == DBF_DEVICE)
+        dbrType = DBF_USHORT;
+
+    return dbPutConvertJSON(pstr, dbrType, pbuffer, pnReq);
+}
+
+static long dbConstGetNelements(const struct link *plink, long *nelements)
+{
+    *nelements = 0;
+    return 0;
+}
+
+static long dbConstGetValue(struct link *plink, short dbrType, void *pbuffer,
+        long *pnRequest)
+{
+    if (pnRequest)
+        *pnRequest = 0;
+    return 0;
+}
+
+static lset dbConst_lset = {
+    1, 0, /* Constant, not Volatile */
+    NULL, NULL,
+    dbConstLoadScalar,
+    dbConstLoadLS,
+    dbConstLoadArray,
+    NULL,
+    NULL, dbConstGetNelements,
+    dbConstGetValue,
+    NULL, NULL, NULL,
+    NULL, NULL,
+    NULL, NULL,
+    NULL, NULL,
+    NULL
+};
+
 
=== added file 'src/ioc/db/dbConstLink.h'
--- src/ioc/db/dbConstLink.h	1970-01-01 00:00:00 +0000
+++ src/ioc/db/dbConstLink.h	2017-03-03 18:23:23 +0000
@@ -0,0 +1,34 @@
+/*************************************************************************\
+* Copyright (c) 2016 UChicago Argonne LLC, as Operator of Argonne
+*     National Laboratory.
+* Copyright (c) 2002 The Regents of the University of California, as
+*     Operator of Los Alamos National Laboratory.
+* EPICS BASE is distributed subject to a Software License Agreement found
+* in file LICENSE that is included with this distribution.
+\*************************************************************************/
+/* dbConstLink.h
+ *
+ *  Created on: April 3rd, 2016
+ *      Author: Andrew Johnson
+ */
+
+#ifndef INC_dbConstLink_H
+#define INC_dbConstLink_H
+
+#include "shareLib.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct link;
+
+epicsShareFunc void dbConstInitLink(struct link *plink);
+epicsShareFunc void dbConstAddLink(struct link *plink);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* INC_dbConstLink_H */
+
 
=== added file 'src/ioc/db/dbConvertJSON.c'
--- src/ioc/db/dbConvertJSON.c	1970-01-01 00:00:00 +0000
+++ src/ioc/db/dbConvertJSON.c	2017-03-03 18:23:23 +0000
@@ -0,0 +1,172 @@
+/*************************************************************************\
+* Copyright (c) 2016 UChicago Argonne LLC, as Operator of Argonne
+*     National Laboratory.
+* EPICS BASE is distributed subject to a Software License Agreement found
+* in file LICENSE that is included with this distribution. 
+\*************************************************************************/
+/* dbConvertJSON.c */
+
+#include <string.h>
+#include <stdio.h>
+
+#include "dbDefs.h"
+#include "errlog.h"
+#include "yajl_alloc.h"
+#include "yajl_parse.h"
+
+#define epicsExportSharedSymbols
+#include "dbAccessDefs.h"
+#include "dbConvertFast.h"
+
+typedef long (*FASTCONVERT)();
+
+typedef struct parseContext {
+    int depth;
+    short dbrType;
+    short dbrSize;
+    char *pdest;
+    int elems;
+} parseContext;
+
+static int dbcj_null(void *ctx) {
+    return 0;    /* Illegal */
+}
+
+static int dbcj_boolean(void *ctx, int val) {
+    return 0;    /* Illegal */
+}
+
+static int dbcj_integer(void *ctx, long num) {
+    parseContext *parser = (parseContext *) ctx;
+    epicsInt32 val32 = num;
+    FASTCONVERT conv = dbFastPutConvertRoutine[DBF_LONG][parser->dbrType];
+
+    if (parser->elems > 0) {
+        conv(&val32, parser->pdest, NULL);
+        parser->pdest += parser->dbrSize;
+        parser->elems--;
+    }
+    return 1;
+}
+
+static int dbcj_double(void *ctx, double num) {
+    parseContext *parser = (parseContext *) ctx;
+    FASTCONVERT conv = dbFastPutConvertRoutine[DBF_DOUBLE][parser->dbrType];
+
+    if (parser->elems > 0) {
+        conv(&num, parser->pdest, NULL);
+        parser->pdest += parser->dbrSize;
+        parser->elems--;
+    }
+    return 1;
+}
+
+static int dbcj_string(void *ctx, const unsigned char *val, unsigned int len) {
+    parseContext *parser = (parseContext *) ctx;
+    char *pdest = parser->pdest;
+
+    /* Not attempting to handle char-array fields here, they need more
+     * metadata about the field than we have available at the moment.
+     */
+    if (parser->dbrType != DBF_STRING) {
+        errlogPrintf("dbPutConvertJSON: String provided, numeric value(s) expected\n");
+        return 0; /* Illegal */
+    }
+
+    if (parser->elems > 0) {
+        if (len > parser->dbrSize - 1)
+            len = parser->dbrSize - 1;
+        strncpy(pdest, (const char *) val, len);
+        pdest[len] = 0;
+        parser->pdest += parser->dbrSize;
+        parser->elems--;
+    }
+    return 1;
+}
+
+static int dbcj_start_map(void *ctx) {
+    errlogPrintf("dbPutConvertJSON: Map type not supported\n");
+    return 0;    /* Illegal */
+}
+
+static int dbcj_map_key(void *ctx, const unsigned char *key, unsigned int len) {
+    return 0;    /* Illegal */
+}
+
+static int dbcj_end_map(void *ctx) {
+    return 0;    /* Illegal */
+}
+
+static int dbcj_start_array(void *ctx) {
+    parseContext *parser = (parseContext *) ctx;
+
+    if (++parser->depth > 1) 
+        errlogPrintf("dbPutConvertJSON: Embedded arrays not supported\n");
+
+    return (parser->depth == 1);
+}
+
+static int dbcj_end_array(void *ctx) {
+    parseContext *parser = (parseContext *) ctx;
+
+    parser->depth--;
+    return (parser->depth == 0);
+}
+
+
+static yajl_callbacks dbcj_callbacks = {
+    dbcj_null, dbcj_boolean, dbcj_integer, dbcj_double, NULL, dbcj_string,
+    dbcj_start_map, dbcj_map_key, dbcj_end_map,
+    dbcj_start_array, dbcj_end_array
+};
+
+static const yajl_parser_config dbcj_config =
+    { 0, 0 }; /* allowComments = NO, checkUTF8 = NO */
+
+long dbPutConvertJSON(const char *json, short dbrType,
+    void *pdest, long *pnRequest)
+{
+    parseContext context, *parser = &context;
+    yajl_alloc_funcs dbcj_alloc;
+    yajl_handle yh;
+    yajl_status ys;
+    size_t jlen = strlen(json);
+    long status;
+
+    parser->depth = 0;
+    parser->dbrType = dbrType;
+    parser->dbrSize = dbValueSize(dbrType);
+    parser->pdest = pdest;
+    parser->elems = *pnRequest;
+
+    yajl_set_default_alloc_funcs(&dbcj_alloc);
+    yh = yajl_alloc(&dbcj_callbacks, &dbcj_config, &dbcj_alloc, parser);
+    if (!yh)
+        return S_db_noMemory;
+
+    ys = yajl_parse(yh, (const unsigned char *) json, (unsigned int) jlen);
+    if (ys == yajl_status_insufficient_data)
+        ys = yajl_parse_complete(yh);
+
+    switch (ys) {
+    case yajl_status_ok:
+        *pnRequest -= parser->elems;
+        status = 0;
+        break;
+
+    case yajl_status_error: {
+        unsigned char *err = yajl_get_error(yh, 1,
+            (const unsigned char *) json, (unsigned int) jlen);
+        fprintf(stderr, "dbPutConvertJSON: %s\n", err);
+        yajl_free_error(yh, err);
+        }
+        /* fall through */
+    default:
+        status = S_db_badField;
+    }
+
+    yajl_free(yh);
+    return status;
+}
+
+
 
=== added file 'src/ioc/db/dbConvertJSON.h'
--- src/ioc/db/dbConvertJSON.h	1970-01-01 00:00:00 +0000
+++ src/ioc/db/dbConvertJSON.h	2017-03-03 18:23:23 +0000
@@ -0,0 +1,27 @@
+/*************************************************************************\
+* Copyright (c) 2016 UChicago Argonne LLC, as Operator of Argonne
+*     National Laboratory.
+* EPICS BASE is distributed subject to a Software License Agreement found
+* in file LICENSE that is included with this distribution. 
+\*************************************************************************/
+/* dbConvertJSON.h */
+
+#ifndef INC_dbConvertJSON_H
+#define INC_dbConvertJSON_H
+
+#include <shareLib.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* This name should probably be changed to inclue "array" */
+epicsShareFunc long dbPutConvertJSON(const char *json, short dbrType,
+    void *pdest, long *psize);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* INC_dbConvertJSON_H */
+
 
=== added file 'src/ioc/db/dbDbLink.c'
--- src/ioc/db/dbDbLink.c	1970-01-01 00:00:00 +0000
+++ src/ioc/db/dbDbLink.c	2017-03-03 18:23:23 +0000
@@ -0,0 +1,353 @@
+/*************************************************************************\
+* Copyright (c) 2010 UChicago Argonne LLC, as Operator of Argonne
+*     National Laboratory.
+* Copyright (c) 2002 The Regents of the University of California, as
+*     Operator of Los Alamos National Laboratory.
+* EPICS BASE is distributed subject to a Software License Agreement found
+* in file LICENSE that is included with this distribution.
+\*************************************************************************/
+/* dbDbLink.c
+ *
+ *      Original Authors: Bob Dalesio, Marty Kraimer
+ *      Current Author: Andrew Johnson
+ */
+
+#include <stddef.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "alarm.h"
+#include "cantProceed.h"
+#include "cvtFast.h"
+#include "dbDefs.h"
+#include "ellLib.h"
+#include "epicsTime.h"
+#include "errlog.h"
+
+#include "caeventmask.h"
+
+#define epicsExportSharedSymbols
+#include "dbAccessDefs.h"
+#include "dbAddr.h"
+#include "dbBase.h"
+#include "dbBkpt.h"
+#include "dbCommon.h"
+#include "dbConvertFast.h"
+#include "dbConvert.h"
+#include "db_field_log.h"
+#include "dbFldTypes.h"
+#include "dbLink.h"
+#include "dbLockPvt.h"
+#include "dbNotify.h"
+#include "dbScan.h"
+#include "dbStaticLib.h"
+#include "devSup.h"
+#include "link.h"
+#include "recGbl.h"
+#include "recSup.h"
+#include "special.h"
+
+/***************************** Database Links *****************************/
+
+/* Forward definition */
+static lset dbDb_lset;
+
+long dbDbInitLink(struct link *plink, short dbfType)
+{
+    DBADDR dbaddr;
+    long status;
+    DBADDR *pdbAddr;
+
+    status = dbNameToAddr(plink->value.pv_link.pvname, &dbaddr);
+    if (status)
+        return status;
+
+    plink->lset = &dbDb_lset;
+    plink->type = DB_LINK;
+    pdbAddr = dbCalloc(1, sizeof(struct dbAddr));
+    *pdbAddr = dbaddr; /* structure copy */
+    plink->value.pv_link.pvt = pdbAddr;
+    ellAdd(&dbaddr.precord->bklnk, &plink->value.pv_link.backlinknode);
+    /* merging into the same lockset is deferred to the caller.
+     * cf. initPVLinks()
+     */
+    dbLockSetMerge(NULL, plink->precord, dbaddr.precord);
+    assert(plink->precord->lset->plockSet == dbaddr.precord->lset->plockSet);
+    return 0;
+}
+
+void dbDbAddLink(struct dbLocker *locker, struct link *plink, short dbfType,
+    DBADDR *ptarget)
+{
+    plink->lset = &dbDb_lset;
+    plink->type = DB_LINK;
+    plink->value.pv_link.pvt = ptarget;
+    ellAdd(&ptarget->precord->bklnk, &plink->value.pv_link.backlinknode);
+
+    /* target record is already locked in dbPutFieldLink() */
+    dbLockSetMerge(locker, plink->precord, ptarget->precord);
+}
+
+static void dbDbRemoveLink(struct dbLocker *locker, struct link *plink)
+{
+    DBADDR *pdbAddr = (DBADDR *) plink->value.pv_link.pvt;
+
+    plink->type = PV_LINK;
+
+    /* locker is NULL when an isolated IOC is closing its links */
+    if (locker) {
+        plink->value.pv_link.pvt = 0;
+        plink->value.pv_link.getCvt = 0;
+        plink->value.pv_link.pvlMask = 0;
+        plink->value.pv_link.lastGetdbrType = 0;
+        ellDelete(&pdbAddr->precord->bklnk, &plink->value.pv_link.backlinknode);
+        dbLockSetSplit(locker, plink->precord, pdbAddr->precord);
+    }
+    free(pdbAddr);
+}
+
+static int dbDbIsConnected(const struct link *plink)
+{
+    return TRUE;
+}
+
+static int dbDbGetDBFtype(const struct link *plink)
+{
+    DBADDR *paddr = (DBADDR *) plink->value.pv_link.pvt;
+
+    return paddr->field_type;
+}
+
+static long dbDbGetElements(const struct link *plink, long *nelements)
+{
+    DBADDR *paddr = (DBADDR *) plink->value.pv_link.pvt;
+
+    *nelements = paddr->no_elements;
+    return 0;
+}
+
+static long dbDbGetValue(struct link *plink, short dbrType, void *pbuffer,
+        long *pnRequest)
+{
+    struct pv_link *ppv_link = &plink->value.pv_link;
+    DBADDR *paddr = ppv_link->pvt;
+    dbCommon *precord = plink->precord;
+    long status;
+
+    /* scan passive records if link is process passive  */
+    if (ppv_link->pvlMask & pvlOptPP) {
+        unsigned char pact = precord->pact;
+
+        precord->pact = TRUE;
+        status = dbScanPassive(precord, paddr->precord);
+        precord->pact = pact;
+        if (status)
+            return status;
+    }
+
+    if (ppv_link->getCvt && ppv_link->lastGetdbrType == dbrType) {
+        status = ppv_link->getCvt(paddr->pfield, pbuffer, paddr);
+    } else {
+        unsigned short dbfType = paddr->field_type;
+
+        if (dbrType < 0 || dbrType > DBR_ENUM || dbfType > DBF_DEVICE)
+            return S_db_badDbrtype;
+
+        if (paddr->no_elements == 1 && (!pnRequest || *pnRequest == 1)
+                && paddr->special != SPC_ATTRIBUTE) {
+            ppv_link->getCvt = dbFastGetConvertRoutine[dbfType][dbrType];
+            status = ppv_link->getCvt(paddr->pfield, pbuffer, paddr);
+        } else {
+            ppv_link->getCvt = NULL;
+            status = dbGet(paddr, dbrType, pbuffer, NULL, pnRequest, NULL);
+        }
+        ppv_link->lastGetdbrType = dbrType;
+    }
+
+    if (!status)
+        recGblInheritSevr(plink->value.pv_link.pvlMask & pvlOptMsMode,
+            plink->precord, paddr->precord->stat, paddr->precord->sevr);
+    return status;
+}
+
+static long dbDbGetControlLimits(const struct link *plink, double *low,
+        double *high)
+{
+    DBADDR *paddr = (DBADDR *) plink->value.pv_link.pvt;
+    struct buffer {
+        DBRctrlDouble
+        double value;
+    } buffer;
+    long options = DBR_CTRL_DOUBLE;
+    long number_elements = 0;
+    long status = dbGet(paddr, DBR_DOUBLE, &buffer, &options, &number_elements,
+            NULL);
+
+    if (status)
+        return status;
+
+    *low = buffer.lower_ctrl_limit;
+    *high = buffer.upper_ctrl_limit;
+    return 0;
+}
+
+static long dbDbGetGraphicLimits(const struct link *plink, double *low,
+        double *high)
+{
+    DBADDR *paddr = (DBADDR *) plink->value.pv_link.pvt;
+    struct buffer {
+        DBRgrDouble
+        double value;
+    } buffer;
+    long options = DBR_GR_DOUBLE;
+    long number_elements = 0;
+    long status = dbGet(paddr, DBR_DOUBLE, &buffer, &options, &number_elements,
+            NULL);
+
+    if (status)
+        return status;
+
+    *low = buffer.lower_disp_limit;
+    *high = buffer.upper_disp_limit;
+    return 0;
+}
+
+static long dbDbGetAlarmLimits(const struct link *plink, double *lolo,
+        double *low, double *high, double *hihi)
+{
+    DBADDR *paddr = (DBADDR *) plink->value.pv_link.pvt;
+    struct buffer {
+        DBRalDouble
+        double value;
+    } buffer;
+    long options = DBR_AL_DOUBLE;
+    long number_elements = 0;
+    long status = dbGet(paddr, DBR_DOUBLE, &buffer, &options, &number_elements,
+            0);
+
+    if (status)
+        return status;
+
+    *lolo = buffer.lower_alarm_limit;
+    *low = buffer.lower_warning_limit;
+    *high = buffer.upper_warning_limit;
+    *hihi = buffer.upper_alarm_limit;
+    return 0;
+}
+
+static long dbDbGetPrecision(const struct link *plink, short *precision)
+{
+    DBADDR *paddr = (DBADDR *) plink->value.pv_link.pvt;
+    struct buffer {
+        DBRprecision
+        double value;
+    } buffer;
+    long options = DBR_PRECISION;
+    long number_elements = 0;
+    long status = dbGet(paddr, DBR_DOUBLE, &buffer, &options, &number_elements,
+            0);
+
+    if (status)
+        return status;
+
+    *precision = (short) buffer.precision.dp;
+    return 0;
+}
+
+static long dbDbGetUnits(const struct link *plink, char *units, int unitsSize)
+{
+    DBADDR *paddr = (DBADDR *) plink->value.pv_link.pvt;
+    struct buffer {
+        DBRunits
+        double value;
+    } buffer;
+    long options = DBR_UNITS;
+    long number_elements = 0;
+    long status = dbGet(paddr, DBR_DOUBLE, &buffer, &options, &number_elements,
+            0);
+
+    if (status)
+        return status;
+
+    strncpy(units, buffer.units, unitsSize);
+    return 0;
+}
+
+static long dbDbGetAlarm(const struct link *plink, epicsEnum16 *status,
+        epicsEnum16 *severity)
+{
+    DBADDR *paddr = (DBADDR *) plink->value.pv_link.pvt;
+
+    if (status)
+        *status = paddr->precord->stat;
+    if (severity)
+        *severity = paddr->precord->sevr;
+    return 0;
+}
+
+static long dbDbGetTimeStamp(const struct link *plink, epicsTimeStamp *pstamp)
+{
+    DBADDR *paddr = (DBADDR *) plink->value.pv_link.pvt;
+
+    *pstamp = paddr->precord->time;
+    return 0;
+}
+
+static long dbDbPutValue(struct link *plink, short dbrType,
+        const void *pbuffer, long nRequest)
+{
+    struct pv_link *ppv_link = &plink->value.pv_link;
+    struct dbCommon *psrce = plink->precord;
+    DBADDR *paddr = (DBADDR *) ppv_link->pvt;
+    dbCommon *pdest = paddr->precord;
+    long status = dbPut(paddr, dbrType, pbuffer, nRequest);
+
+    recGblInheritSevr(ppv_link->pvlMask & pvlOptMsMode, pdest, psrce->nsta,
+        psrce->nsev);
+    if (status)
+        return status;
+
+    if (paddr->pfield == (void *) &pdest->proc ||
+            (ppv_link->pvlMask & pvlOptPP && pdest->scan == 0)) {
+        /* if dbPutField caused asyn record to process */
+        /* ask for reprocessing*/
+        if (pdest->putf) {
+            pdest->rpro = TRUE;
+        } else { /* process dest record with source's PACT true */
+            unsigned char pact;
+
+            if (psrce && psrce->ppn)
+                dbNotifyAdd(psrce, pdest);
+            pact = psrce->pact;
+            psrce->pact = TRUE;
+            status = dbProcess(pdest);
+            psrce->pact = pact;
+        }
+    }
+    return status;
+}
+
+static void dbDbScanFwdLink(struct link *plink)
+{
+    dbCommon *precord = plink->precord;
+    dbAddr *paddr = (dbAddr *) plink->value.pv_link.pvt;
+
+    dbScanPassive(precord, paddr->precord);
+}
+
+static lset dbDb_lset = {
+    0, 0, /* not Constant, not Volatile */
+    NULL, dbDbRemoveLink,
+    NULL, NULL, NULL,
+    dbDbIsConnected,
+    dbDbGetDBFtype, dbDbGetElements,
+    dbDbGetValue,
+    dbDbGetControlLimits, dbDbGetGraphicLimits, dbDbGetAlarmLimits,
+    dbDbGetPrecision, dbDbGetUnits,
+    dbDbGetAlarm, dbDbGetTimeStamp,
+    dbDbPutValue, NULL,
+    dbDbScanFwdLink
+};
+
 
=== added file 'src/ioc/db/dbDbLink.h'
--- src/ioc/db/dbDbLink.h	1970-01-01 00:00:00 +0000
+++ src/ioc/db/dbDbLink.h	2017-03-03 18:23:23 +0000
@@ -0,0 +1,35 @@
+/*************************************************************************\
+* Copyright (c) 2016 UChicago Argonne LLC, as Operator of Argonne
+*     National Laboratory.
+* Copyright (c) 2002 The Regents of the University of California, as
+*     Operator of Los Alamos National Laboratory.
+* EPICS BASE is distributed subject to a Software License Agreement found
+* in file LICENSE that is included with this distribution.
+\*************************************************************************/
+/* dbDbLink.h
+ *
+ *  Created on: April 3rd, 2016
+ *      Author: Andrew Johnson
+ */
+
+#ifndef INC_dbDbLink_H
+#define INC_dbDbLink_H
+
+#include "shareLib.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct link;
+struct dbLocker;
+
+epicsShareFunc long dbDbInitLink(struct link *plink, short dbfType);
+epicsShareFunc void dbDbAddLink(struct dbLocker *locker, struct link *plink,
+    short dbfType, DBADDR *ptarget);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* INC_dbDbLink_H */
 
=== modified file 'src/ioc/db/dbIocRegister.c'
--- src/ioc/db/dbIocRegister.c	2015-07-13 18:05:33 +0000
+++ src/ioc/db/dbIocRegister.c	2017-03-03 18:23:23 +0000
@@ -16,6 +16,7 @@
 #include "dbCaTest.h"
 #include "dbEvent.h"
 #include "dbIocRegister.h"
+#include "dbJLink.h"
 #include "dbLock.h"
 #include "dbNotify.h"
 #include "dbScan.h"
@@ -109,6 +110,16 @@
     dbcar(args[0].sval,args[1].ival);
 }
 
+/* dbjlr */
+static const iocshArg dbjlrArg0 = { "record name",iocshArgString};
+static const iocshArg dbjlrArg1 = { "level",iocshArgInt};
+static const iocshArg * const dbjlrArgs[2] = {&dbjlrArg0,&dbjlrArg1};
+static const iocshFuncDef dbjlrFuncDef = {"dbjlr",2,dbjlrArgs};
+static void dbjlrCallFunc(const iocshArgBuf *args)
+{
+    dbjlr(args[0].sval,args[1].ival);
+}
+
 /* dbel */
 static const iocshArg dbelArg0 = { "record name",iocshArgString};
 static const iocshArg dbelArg1 = { "level",iocshArgInt};
@@ -395,6 +406,7 @@
     iocshRegister(&dbsrFuncDef,dbsrCallFunc);
     iocshRegister(&dbcarFuncDef,dbcarCallFunc);
     iocshRegister(&dbelFuncDef,dbelCallFunc);
+    iocshRegister(&dbjlrFuncDef,dbjlrCallFunc);
 
     iocshRegister(&dbLoadDatabaseFuncDef,dbLoadDatabaseCallFunc);
     iocshRegister(&dbLoadRecordsFuncDef,dbLoadRecordsCallFunc);
 
=== added file 'src/ioc/db/dbJLink.c'
--- src/ioc/db/dbJLink.c	1970-01-01 00:00:00 +0000
+++ src/ioc/db/dbJLink.c	2017-03-03 18:23:23 +0000
@@ -0,0 +1,542 @@
+/*************************************************************************\
+* Copyright (c) 2016 UChicago Argonne LLC, as Operator of Argonne
+*     National Laboratory.
+* EPICS BASE is distributed subject to a Software License Agreement found
+* in file LICENSE that is included with this distribution. 
+\*************************************************************************/
+/* dbJLink.c */
+
+#include <stdio.h>
+#include <string.h>
+
+#include "epicsAssert.h"
+#include "dbmf.h"
+#include "errlog.h"
+#include "yajl_alloc.h"
+#include "yajl_parse.h"
+
+#define epicsExportSharedSymbols
+#include "dbAccessDefs.h"
+#include "dbCommon.h"
+#include "dbLink.h"
+#include "dbJLink.h"
+#include "dbLock.h"
+#include "dbStaticLib.h"
+#include "link.h"
+
+/* Change 'undef' to 'define' to turn on debug statements: */
+#undef DEBUG_JLINK
+
+#ifdef DEBUG_JLINK
+    int jlinkDebug = 10;
+#   define IFDEBUG(n) \
+        if (jlinkDebug >= n) /* block or statement */
+#else
+#   define IFDEBUG(n) \
+        if(0) /* Compiler will elide the block or statement */
+#endif
+
+
+typedef struct parseContext {
+    jlink *pjlink;
+    jlink *product;
+    short dbfType;
+    short jsonDepth;
+    unsigned key_is_link:1;
+} parseContext;
+
+#define CALL_OR_STOP(routine) !(routine) ? jlif_stop : (routine)
+
+static int dbjl_return(parseContext *parser, jlif_result result) {
+    jlink *pjlink = parser->pjlink;
+
+    IFDEBUG(10) {
+        printf("dbjl_return(%s@%p, %d)\t", pjlink->pif->name, pjlink, result);
+        printf("    jsonDepth=%d, parseDepth=%d, key_is_link=%d\n",
+            parser->jsonDepth, pjlink->parseDepth, parser->key_is_link);
+    }
+
+    if (result == jlif_stop && pjlink) {
+        jlink *parent;
+
+        while ((parent = pjlink->parent)) {
+            pjlink->pif->free_jlink(pjlink);
+            pjlink = parent;
+        }
+        pjlink->pif->free_jlink(pjlink);
+    }
+
+    return result;
+}
+
+static int dbjl_value(parseContext *parser, jlif_result result) {
+    jlink *pjlink = parser->pjlink;
+    jlink *parent;
+
+    IFDEBUG(10) {
+        printf("dbjl_value(%s@%p, %d)\t", pjlink->pif->name, pjlink, result);
+        printf("    jsonDepth=%d, parseDepth=%d, key_is_link=%d\n",
+            parser->jsonDepth, pjlink->parseDepth, parser->key_is_link);
+    }
+
+    if (result == jlif_stop || pjlink->parseDepth > 0)
+        return dbjl_return(parser, result);
+
+    parent = pjlink->parent;
+    if (!parent)
+        parser->product = pjlink;
+   else if (parent->pif->end_child)
+        parent->pif->end_child(parent, pjlink);
+
+    parser->pjlink = parent;
+
+    IFDEBUG(8)
+        printf("dbjl_value: product = %p\n", pjlink);
+
+    return jlif_continue;
+}
+
+static int dbjl_null(void *ctx) {
+    parseContext *parser = (parseContext *) ctx;
+    jlink *pjlink = parser->pjlink;
+
+    IFDEBUG(10)
+        printf("dbjl_null(%s@%p)\n", pjlink->pif->name, pjlink);
+
+    assert(pjlink);
+    return dbjl_value(parser,
+        CALL_OR_STOP(pjlink->pif->parse_null)(pjlink));
+}
+
+static int dbjl_boolean(void *ctx, int val) {
+    parseContext *parser = (parseContext *) ctx;
+    jlink *pjlink = parser->pjlink;
+
+    assert(pjlink);
+    return dbjl_value(parser,
+        CALL_OR_STOP(pjlink->pif->parse_boolean)(pjlink, val));
+}
+
+static int dbjl_integer(void *ctx, long num) {
+    parseContext *parser = (parseContext *) ctx;
+    jlink *pjlink = parser->pjlink;
+
+    IFDEBUG(10)
+        printf("dbjl_integer(%s@%p, %ld)\n",
+            pjlink->pif->name, pjlink, num);
+
+    assert(pjlink);
+    return dbjl_value(parser,
+        CALL_OR_STOP(pjlink->pif->parse_integer)(pjlink, num));
+}
+
+static int dbjl_double(void *ctx, double num) {
+    parseContext *parser = (parseContext *) ctx;
+    jlink *pjlink = parser->pjlink;
+
+    IFDEBUG(10)
+        printf("dbjl_double(%s@%p, %g)\n",
+            pjlink->pif->name, pjlink, num);
+
+    assert(pjlink);
+    return dbjl_value(parser,
+        CALL_OR_STOP(pjlink->pif->parse_double)(pjlink, num));
+}
+
+static int dbjl_string(void *ctx, const unsigned char *val, unsigned len) {
+    parseContext *parser = (parseContext *) ctx;
+    jlink *pjlink = parser->pjlink;
+
+    IFDEBUG(10)
+        printf("dbjl_string(%s@%p, \"%.*s\")\n",
+            pjlink->pif->name, pjlink, len, val);
+
+    assert(pjlink);
+    return dbjl_value(parser,
+        CALL_OR_STOP(pjlink->pif->parse_string)(pjlink, (const char *) val, len));
+}
+
+static int dbjl_start_map(void *ctx) {
+    parseContext *parser = (parseContext *) ctx;
+    jlink *pjlink = parser->pjlink;
+    int result;
+
+    if (!pjlink) {
+        IFDEBUG(10) {
+            printf("dbjl_start_map(NULL)\t");
+            printf("    jsonDepth=%d, parseDepth=00, key_is_link=%d\n",
+                parser->jsonDepth, parser->key_is_link);
+        }
+
+        assert(parser->jsonDepth == 0);
+        parser->jsonDepth++;
+        parser->key_is_link = 1;
+        return jlif_continue; /* Opening '{' */
+    }
+
+    IFDEBUG(10) {
+        printf("dbjl_start_map(%s@%p)\t", pjlink->pif->name, pjlink);
+        printf("    jsonDepth=%d, parseDepth=%d, key_is_link=%d\n",
+            parser->jsonDepth, pjlink->parseDepth, parser->key_is_link);
+    }
+
+    pjlink->parseDepth++;
+    parser->jsonDepth++;
+
+    result = CALL_OR_STOP(pjlink->pif->parse_start_map)(pjlink);
+    if (result == jlif_key_child_link) {
+        parser->key_is_link = 1;
+        result = jlif_continue;
+    }
+
+    IFDEBUG(10)
+        printf("dbjl_start_map -> %d\n", result);
+
+    return dbjl_return(parser, result);
+}
+
+static int dbjl_map_key(void *ctx, const unsigned char *key, unsigned len) {
+    parseContext *parser = (parseContext *) ctx;
+    jlink *pjlink = parser->pjlink;
+    char *link_name;
+    linkSup *linkSup;
+    jlif *pjlif;
+
+    if (!parser->key_is_link) {
+        if (!pjlink) {
+            errlogPrintf("dbJLinkInit: Illegal second link key '%.*s'\n",
+                len, key);
+            return dbjl_return(parser, jlif_stop);
+        }
+
+        IFDEBUG(10) {
+            printf("dbjl_map_key(%s@%p, \"%.*s\")\t",
+                pjlink->pif->name, pjlink, len, key);
+            printf("    jsonDepth=%d, parseDepth=%d, key_is_link=%d\n",
+                parser->jsonDepth, pjlink->parseDepth, parser->key_is_link);
+        }
+
+        assert(pjlink->parseDepth > 0);
+        return dbjl_return(parser,
+            CALL_OR_STOP(pjlink->pif->parse_map_key)(pjlink,
+                (const char *) key, len));
+    }
+
+    IFDEBUG(10) {
+        printf("dbjl_map_key(NULL, \"%.*s\")\t", len, key);
+        printf("    jsonDepth=%d, parseDepth=00, key_is_link=%d\n",
+            parser->jsonDepth, parser->key_is_link);
+    }
+
+    link_name = dbmfStrndup((const char *) key, len);
+
+    linkSup = dbFindLinkSup(pdbbase, link_name);
+    if (!linkSup) {
+        errlogPrintf("dbJLinkInit: Link type '%s' not found\n",
+            link_name);
+        dbmfFree(link_name);
+        return dbjl_return(parser, jlif_stop);
+    }
+
+    pjlif = linkSup->pjlif;
+    if (!pjlif) {
+        errlogPrintf("dbJLinkInit: Support for Link type '%s' not loaded\n",
+            link_name);
+        dbmfFree(link_name);
+        return dbjl_return(parser, jlif_stop);
+    }
+
+    dbmfFree(link_name);
+
+    pjlink = pjlif->alloc_jlink(parser->dbfType);
+    if (!pjlink) {
+        errlogPrintf("dbJLinkInit: Out of memory\n");
+        return dbjl_return(parser, jlif_stop);
+    }
+    pjlink->pif = pjlif;
+    pjlink->parent = NULL;
+    pjlink->parseDepth = 0;
+
+    if (parser->pjlink) {
+        /* We're starting a child link, save its parent */
+        pjlink->parent = parser->pjlink;
+    }
+    parser->pjlink = pjlink;
+    parser->key_is_link = 0;
+
+    IFDEBUG(8)
+        printf("dbjl_map_key: New %s@%p\n", pjlink->pif->name, pjlink);
+
+    return jlif_continue;
+}
+
+static int dbjl_end_map(void *ctx) {
+    parseContext *parser = (parseContext *) ctx;
+    jlink *pjlink = parser->pjlink;
+    jlif_result result;
+
+    IFDEBUG(10) {
+        printf("dbjl_end_map(%s@%p)\t",
+            pjlink ? pjlink->pif->name : "NULL", pjlink);
+        printf("    jsonDepth=%d, parseDepth=%d, key_is_link=%d\n",
+            parser->jsonDepth, pjlink ? pjlink->parseDepth : 0,
+            parser->key_is_link);
+    }
+
+    parser->jsonDepth--;
+    if (pjlink) {
+        pjlink->parseDepth--;
+
+        result = dbjl_value(parser,
+            CALL_OR_STOP(pjlink->pif->parse_end_map)(pjlink));
+    }
+    else {
+        result = jlif_continue;
+    }
+    return result;
+}
+
+static int dbjl_start_array(void *ctx) {
+    parseContext *parser = (parseContext *) ctx;
+    jlink *pjlink = parser->pjlink;
+
+    IFDEBUG(10) {
+        printf("dbjl_start_array(%s@%p)\t", pjlink->pif->name, pjlink);
+        printf("    jsonDepth=%d, parseDepth=%d, key_is_link=%d\n",
+            parser->jsonDepth, pjlink->parseDepth, parser->key_is_link);
+    }
+
+    assert(pjlink);
+    pjlink->parseDepth++;
+    parser->jsonDepth++;
+
+    return dbjl_return(parser,
+        CALL_OR_STOP(pjlink->pif->parse_start_array)(pjlink));
+}
+
+static int dbjl_end_array(void *ctx) {
+    parseContext *parser = (parseContext *) ctx;
+    jlink *pjlink = parser->pjlink;
+
+    IFDEBUG(10) {
+        printf("dbjl_end_array(%s@%p)\t", pjlink->pif->name, pjlink);
+        printf("    jsonDepth=%d, parseDepth=%d, key_is_link=%d\n",
+            parser->jsonDepth, pjlink->parseDepth, parser->key_is_link);
+    }
+
+    assert(pjlink);
+    pjlink->parseDepth--;
+    parser->jsonDepth--;
+
+    return dbjl_value(parser,
+        CALL_OR_STOP(pjlink->pif->parse_end_array)(pjlink));
+}
+
+
+static yajl_callbacks dbjl_callbacks = {
+    dbjl_null, dbjl_boolean, dbjl_integer, dbjl_double, NULL, dbjl_string,
+    dbjl_start_map, dbjl_map_key, dbjl_end_map, dbjl_start_array, dbjl_end_array
+};
+
+static const yajl_parser_config dbjl_config =
+    { 0, 0 }; /* allowComments = NO, checkUTF8 = NO */
+
+long dbJLinkParse(const char *json, size_t jlen, short dbfType,
+    jlink **ppjlink)
+{
+    parseContext context, *parser = &context;
+    yajl_alloc_funcs dbjl_allocs;
+    yajl_handle yh;
+    yajl_status ys;
+    long status;
+
+    IFDEBUG(10)
+        printf("dbJLinkInit(\"%.*s\", %d, %p)\n",
+            (int) jlen, json, dbfType, ppjlink);
+
+    parser->pjlink = NULL;
+    parser->product = NULL;
+    parser->dbfType = dbfType;
+    parser->jsonDepth = 0;
+    parser->key_is_link = 0;
+
+    IFDEBUG(10)
+        printf("dbJLinkInit: jsonDepth=%d, key_is_link=%d\n",
+            parser->jsonDepth, parser->key_is_link);
+
+    yajl_set_default_alloc_funcs(&dbjl_allocs);
+    yh = yajl_alloc(&dbjl_callbacks, &dbjl_config, &dbjl_allocs, parser);
+    if (!yh)
+        return S_db_noMemory;
+
+    ys = yajl_parse(yh, (const unsigned char *) json, (unsigned) jlen);
+    if (ys == yajl_status_insufficient_data)
+        ys = yajl_parse_complete(yh);
+
+    switch (ys) {
+        unsigned char *err;
+
+    case yajl_status_ok:
+        assert(parser->jsonDepth == 0);
+        *ppjlink = parser->product;
+        status = 0;
+        break;
+
+    case yajl_status_error:
+        err = yajl_get_error(yh, 1, (const unsigned char *) json, (unsigned) jlen);
+        errlogPrintf("dbJLinkInit: %s\n", err);
+        yajl_free_error(yh, err);
+        dbJLinkFree(parser->pjlink);
+        /* fall through */
+    default:
+        status = S_db_badField;
+    }
+
+    yajl_free(yh);
+    return status;
+}
+
+long dbJLinkInit(struct link *plink)
+{
+    jlink *pjlink;
+
+    assert(plink);
+    pjlink = plink->value.json.jlink;
+
+    if (pjlink)
+        plink->lset = pjlink->pif->get_lset(pjlink);
+
+    dbLinkOpen(plink);
+    return 0;
+}
+
+void dbJLinkFree(jlink *pjlink)
+{
+    if (pjlink)
+        pjlink->pif->free_jlink(pjlink);
+}
+
+void dbJLinkReport(jlink *pjlink, int level, int indent) {
+    if (pjlink && pjlink->pif->report)
+        pjlink->pif->report(pjlink, level, indent);
+}
+
+long dbJLinkMapChildren(struct link *plink, jlink_map_fn rtn, void *ctx)
+{
+    jlink *pjlink;
+    long status;
+
+    if (!plink || plink->type != JSON_LINK)
+        return 0;
+
+    pjlink = plink->value.json.jlink;
+    if (!pjlink)
+        return 0;
+
+    status = rtn(pjlink, ctx);
+    if (!status && pjlink->pif->map_children)
+        status = pjlink->pif->map_children(pjlink, rtn, ctx);
+
+    return status;
+}
+
+long dbjlr(const char *recname, int level)
+{
+    DBENTRY dbentry;
+    DBENTRY * const pdbentry = &dbentry;
+    long status;
+
+    if (!recname || recname[0] == '\0' || !strcmp(recname, "*")) {
+        recname = NULL;
+        printf("JSON links in all records\n\n");
+    }
+    else
+        printf("JSON links in record '%s'\n\n", recname);
+
+    dbInitEntry(pdbbase, pdbentry);
+    for (status = dbFirstRecordType(pdbentry);
+         status == 0;
+         status = dbNextRecordType(pdbentry)) {
+        for (status = dbFirstRecord(pdbentry);
+             status == 0;
+             status = dbNextRecord(pdbentry)) {
+            dbRecordType *pdbRecordType = pdbentry->precordType;
+            dbCommon *precord = pdbentry->precnode->precord;
+            char *prec = (char *) precord;
+            int i;
+
+            if (recname && strcmp(recname, dbGetRecordName(pdbentry)))
+                continue;
+            if (dbIsAlias(pdbentry))
+                continue;
+
+            printf("  %s record '%s':\n", pdbRecordType->name, precord->name);
+
+            dbScanLock(precord);
+            for (i = 0; i < pdbRecordType->no_links; i++) {
+                int idx = pdbRecordType->link_ind[i];
+                dbFldDes *pdbFldDes = pdbRecordType->papFldDes[idx];
+                DBLINK *plink = (DBLINK *) (prec + pdbFldDes->offset);
+
+                if (plink->type != JSON_LINK)
+                    continue;
+                if (!dbLinkIsDefined(plink))
+                    continue;
+
+                printf("    Link field '%s':\n", pdbFldDes->name);
+                dbJLinkReport(plink->value.json.jlink, level, 6);
+            }
+            dbScanUnlock(precord);
+            if (recname)
+                goto done;
+        }
+    }
+done:
+    return 0;
+}
+
+long dbJLinkMapAll(char *recname, jlink_map_fn rtn, void *ctx)
+{
+    DBENTRY dbentry;
+    DBENTRY * const pdbentry = &dbentry;
+    long status;
+
+    if (recname && (recname[0] = '\0' || !strcmp(recname, "*")))
+        recname = NULL;
+
+    dbInitEntry(pdbbase, pdbentry);
+    for (status = dbFirstRecordType(pdbentry);
+         status == 0;
+         status = dbNextRecordType(pdbentry)) {
+        for (status = dbFirstRecord(pdbentry);
+             status == 0;
+             status = dbNextRecord(pdbentry)) {
+            dbRecordType *pdbRecordType = pdbentry->precordType;
+            dbCommon *precord = pdbentry->precnode->precord;
+            char *prec = (char *) precord;
+            int i;
+
+            if (recname && strcmp(recname, dbGetRecordName(pdbentry)))
+                continue;
+            if (dbIsAlias(pdbentry))
+                continue;
+
+            dbScanLock(precord);
+            for (i = 0; i < pdbRecordType->no_links; i++) {
+                int idx = pdbRecordType->link_ind[i];
+                dbFldDes *pdbFldDes = pdbRecordType->papFldDes[idx];
+                DBLINK *plink = (DBLINK *) (prec + pdbFldDes->offset);
+
+                status = dbJLinkMapChildren(plink, rtn, ctx);
+                if (status)
+                    goto unlock;
+            }
+unlock:
+            dbScanUnlock(precord);
+            if (status || recname)
+                goto done;
+        }
+    }
+done:
+    return status;
+}
 
=== added file 'src/ioc/db/dbJLink.h'
--- src/ioc/db/dbJLink.h	1970-01-01 00:00:00 +0000
+++ src/ioc/db/dbJLink.h	2017-03-03 18:23:23 +0000
@@ -0,0 +1,132 @@
+/*************************************************************************\
+* Copyright (c) 2016 UChicago Argonne LLC, as Operator of Argonne
+*     National Laboratory.
+* EPICS BASE is distributed subject to a Software License Agreement found
+* in file LICENSE that is included with this distribution. 
+\*************************************************************************/
+/* dbJLink.h */
+
+#ifndef INC_dbJLink_H
+#define INC_dbJLink_H
+
+#include <stdlib.h>
+#include <shareLib.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum {
+    jlif_stop = 0,
+    jlif_continue = 1
+} jlif_result;
+
+typedef enum {
+    jlif_key_stop = jlif_stop,
+    jlif_key_continue = jlif_continue,
+    jlif_key_child_link
+} jlif_key_result;
+
+struct link;
+struct lset;
+struct jlif;
+
+typedef struct jlink {
+    struct jlif *pif;       /* Link methods */
+    struct jlink *parent;   /* NULL for top-level links */
+    int parseDepth;         /* Used by parser, unused afterwards */
+    /* Link types extend or embed this structure for private storage */
+} jlink;
+
+typedef long (*jlink_map_fn)(jlink *, void *ctx);
+
+typedef struct jlif {
+    /* Optional parser methods below given as NULL are equivalent to
+     * providing a routine that always returns jlif_stop, meaning that
+     * this JSON construct is not allowed at this point in the parse.
+     */
+
+    const char *name;
+        /* Name for the link type, used in link value */
+
+    jlink* (*alloc_jlink)(short dbfType);
+        /* Required, allocate new link structure */
+
+    void (*free_jlink)(jlink *);
+        /* Required, release all resources allocated for link */
+
+    jlif_result (*parse_null)(jlink *);
+        /* Optional, parser saw a null value */
+
+    jlif_result (*parse_boolean)(jlink *, int val);
+        /* Optional, parser saw a boolean value */
+
+    jlif_result (*parse_integer)(jlink *, long num);
+        /* Optional, parser saw an integer value */
+
+    jlif_result (*parse_double)(jlink *, double num);
+        /* Optional, parser saw a double value */
+
+    jlif_result (*parse_string)(jlink *, const char *val, size_t len);
+        /* Optional, parser saw a string value */
+
+    jlif_key_result (*parse_start_map)(jlink *);
+        /* Optional, parser saw an open-brace '{'. Return jlif_key_child_link
+         * to expect a child link next (extra key/value pairs may follow).
+         */
+
+    jlif_result (*parse_map_key)(jlink *, const char *key, size_t len);
+        /* Optional, parser saw a map key */
+
+    jlif_result (*parse_end_map)(jlink *);
+        /* Optional, parser saw a close-brace '}' */
+
+    jlif_result (*parse_start_array)(jlink *);
+        /* Optional, parser saw an open-bracket */
+
+    jlif_result (*parse_end_array)(jlink *);
+        /* Optional, parser saw a close-bracket */
+
+    void (*end_child)(jlink *parent, jlink *child);
+        /* Optional, called with pointer to the new child link after
+         * parse_start_map() returned jlif_key_child_link */
+
+    struct lset* (*get_lset)(const jlink *);
+        /* Required, return lset for this link instance */
+
+    void (*report)(const jlink *, int level, int indent);
+        /* Optional, print status information about this link instance, then
+         * if (level > 0) print a link identifier (at indent+2) and call
+         *     dbJLinkReport(child, level-1, indent+4) 
+         * for each child.
+         */
+
+    long (*map_children)(jlink *, jlink_map_fn rtn, void *ctx);
+        /* Optional, call dbJLinkMapChildren() on all embedded links.
+         * Stop immediately and return status if non-zero.
+         */
+
+    /* Link types must NOT extend this table with their own routines,
+     * this space is reserved for extensions to the jlink interface.
+     */
+} jlif;
+
+epicsShareFunc long dbJLinkParse(const char *json, size_t len, short dbfType,
+    jlink **ppjlink);
+epicsShareFunc long dbJLinkInit(struct link *plink);
+
+epicsShareFunc void dbJLinkFree(jlink *);
+epicsShareFunc void dbJLinkReport(jlink *, int level, int indent);
+
+epicsShareFunc long dbJLinkMapChildren(struct link *,
+    jlink_map_fn rtn, void *ctx);
+
+epicsShareFunc long dbjlr(const char *recname, int level);
+epicsShareFunc long dbJLinkMapAll(char *recname, jlink_map_fn rtn, void *ctx);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* INC_dbJLink_H */
+
 
=== modified file 'src/ioc/db/dbLink.c'
--- src/ioc/db/dbLink.c	2017-02-01 17:57:04 +0000
+++ src/ioc/db/dbLink.c	2017-03-03 18:23:23 +0000
@@ -19,62 +19,35 @@
 #include <string.h>
 
 #include "alarm.h"
-#include "cantProceed.h"
 #include "cvtFast.h"
 #include "dbDefs.h"
 #include "ellLib.h"
-#include "epicsThread.h"
 #include "epicsTime.h"
 #include "errlog.h"
 
 #include "caeventmask.h"
 
 #define epicsExportSharedSymbols
-#include "callback.h"
 #include "dbAccessDefs.h"
 #include "dbAddr.h"
 #include "dbBase.h"
-#include "dbBkpt.h"
 #include "dbCa.h"
 #include "dbCommon.h"
-#include "dbConvertFast.h"
-#include "dbConvert.h"
-#include "dbEvent.h"
+#include "dbConstLink.h"
+#include "dbDbLink.h"
 #include "db_field_log.h"
 #include "dbFldTypes.h"
-#include "dbFldTypes.h"
+#include "dbJLink.h"
 #include "dbLink.h"
-#include "dbLockPvt.h"
-#include "dbNotify.h"
+#include "dbLock.h"
 #include "dbScan.h"
 #include "dbStaticLib.h"
 #include "devSup.h"
-#include "epicsEvent.h"
-#include "errMdef.h"
 #include "link.h"
 #include "recGbl.h"
 #include "recSup.h"
 #include "special.h"
 
-static void inherit_severity(const struct pv_link *ppv_link, dbCommon *pdest,
-        epicsEnum16 stat, epicsEnum16 sevr)
-{
-    switch (ppv_link->pvlMask & pvlOptMsMode) {
-    case pvlOptNMS:
-        break;
-    case pvlOptMSI:
-        if (sevr < INVALID_ALARM)
-            break;
-        /* Fall through */
-    case pvlOptMS:
-        recGblSetSevr(pdest, LINK_ALARM, sevr);
-        break;
-    case pvlOptMSS:
-        recGblSetSevr(pdest, stat, sevr);
-        break;
-    }
-}
-
 /* How to identify links in error messages */
 static const char * link_field_name(const struct link *plink)
 {
@@ -94,6 +67,7 @@
 }
 
 
+<<<<<<< TREE
 /***************************** Constant Links *****************************/
 
 /* Forward definition */
@@ -443,6 +417,8 @@
     dbDbScanFwdLink
 };
 
+=======
+>>>>>>> MERGE-SOURCE
 /***************************** Generic Link API *****************************/
 
 void dbInitLink(struct link *plink, short dbfType)
@@ -454,6 +430,11 @@
         return;
     }
 
+    if (plink->type == JSON_LINK) {
+        dbJLinkInit(plink);
+        return;
+    }
+
     if (plink->type != PV_LINK)
         return;
 
@@ -487,7 +468,8 @@
     }
 }
 
-void dbAddLink(dbLocker *locker, struct link *plink, short dbfType, DBADDR *ptarget)
+void dbAddLink(struct dbLocker *locker, struct link *plink, short dbfType,
+    DBADDR *ptarget)
 {
     struct dbCommon *precord = plink->precord;
 
@@ -496,6 +478,18 @@
         return;
     }
 
+    if (plink->type == JSON_LINK) {
+        /*
+         * FIXME: Can't create DB links as dbJLink types yet,
+         * dbLock.c doesn't have any way to find/track them.
+         */
+        dbJLinkInit(plink);
+        return;
+    }
+
+    if (plink->type != PV_LINK)
+        return;
+
     if (plink == &precord->tsel)
         recGblTSELwasModified(plink);
 
@@ -518,16 +512,15 @@
     }
 }
 
-long dbLoadLink(struct link *plink, short dbrType, void *pbuffer)
+void dbLinkOpen(struct link *plink)
 {
-    if (plink->type == CONSTANT)
-        return dbConstLoadLink(plink, dbrType, pbuffer);
+    lset *plset = plink->lset;
 
-    /* Could pass a type hint to the other link types here */
-    return S_db_notFound;
+    if (plset && plset->openLink)
+        plset->openLink(plink);
 }
 
-void dbRemoveLink(dbLocker *locker, struct link *plink)
+void dbRemoveLink(struct dbLocker *locker, struct link *plink)
 {
     lset *plset = plink->lset;
 
@@ -536,6 +529,65 @@
             plset->removeLink(locker, plink);
         plink->lset = NULL;
     }
+    if (plink->type == JSON_LINK)
+        plink->value.json.jlink = NULL;
+}
+
+int dbLinkIsDefined(const struct link *plink)
+{
+    return (plink->lset != 0);
+}
+
+int dbLinkIsConstant(const struct link *plink)
+{
+    lset *plset = plink->lset;
+
+    if (plset)
+        return plset->isConstant;
+
+    return -1;
+}
+
+int dbLinkIsVolatile(const struct link *plink)
+{
+    lset *plset = plink->lset;
+
+    if (plset)
+        return plset->isVolatile;
+
+    return -1;
+}
+
+long dbLoadLink(struct link *plink, short dbrType, void *pbuffer)
+{
+    lset *plset = plink->lset;
+
+    if (plset && plset->loadScalar)
+        return plset->loadScalar(plink, dbrType, pbuffer);
+
+    return S_db_noLSET;
+}
+
+long dbLoadLinkLS(struct link *plink, char *pbuffer, epicsUInt32 size,
+    epicsUInt32 *plen)
+{
+    lset *plset = plink->lset;
+
+    if (plset && plset->loadLS)
+        return plset->loadLS(plink, pbuffer, size, plen);
+
+    return S_db_noLSET;
+}
+
+long dbLoadLinkArray(struct link *plink, short dbrType, void *pbuffer,
+    long *pnRequest)
+{
+    lset *plset = plink->lset;
+
+    if (plset && plset->loadArray)
+        return plset->loadArray(plink, dbrType, pbuffer, pnRequest);
+
+    return S_db_noLSET;
 }
 
 int dbIsLinkConnected(const struct link *plink)
@@ -563,7 +615,7 @@
     lset *plset = plink->lset;
 
     if (!plset || !plset->getElements)
-        return S_db_badField;
+        return S_db_noLSET;
 
     return plset->getElements(plink, nelements);
 }
@@ -572,24 +624,20 @@
         long *poptions, long *pnRequest)
 {
     struct dbCommon *precord = plink->precord;
-    epicsEnum16 sevr = 0, stat = 0;
     lset *plset = plink->lset;
     long status;
 
     if (poptions && *poptions) {
-        printf("dbGetLinkValue: Use of poptions no longer supported\n");
+        printf("dbGetLink: Use of poptions no longer supported\n");
         *poptions = 0;
     }
 
     if (!plset || !plset->getValue)
         return -1;
 
-    status = plset->getValue(plink, dbrType, pbuffer, &stat, &sevr, pnRequest);
-    if (status) {
+    status = plset->getValue(plink, dbrType, pbuffer, pnRequest);
+    if (status)
         recGblSetSevr(precord, LINK_ALARM, INVALID_ALARM);
-    } else {
-        inherit_severity(&plink->value.pv_link, precord, stat, sevr);
-    }
     return status;
 }
 
@@ -598,7 +646,7 @@
     lset *plset = plink->lset;
 
     if (!plset || !plset->getControlLimits)
-        return S_db_notFound;
+        return S_db_noLSET;
 
     return plset->getControlLimits(plink, low, high);
 }
@@ -608,7 +656,7 @@
     lset *plset = plink->lset;
 
     if (!plset || !plset->getGraphicLimits)
-        return S_db_notFound;
+        return S_db_noLSET;
 
     return plset->getGraphicLimits(plink, low, high);
 }
@@ -619,7 +667,7 @@
     lset *plset = plink->lset;
 
     if (!plset || !plset->getAlarmLimits)
-        return S_db_notFound;
+        return S_db_noLSET;
 
     return plset->getAlarmLimits(plink, lolo, low, high, hihi);
 }
@@ -629,7 +677,7 @@
     lset *plset = plink->lset;
 
     if (!plset || !plset->getPrecision)
-        return S_db_notFound;
+        return S_db_noLSET;
 
     return plset->getPrecision(plink, precision);
 }
@@ -639,7 +687,7 @@
     lset *plset = plink->lset;
 
     if (!plset || !plset->getUnits)
-        return S_db_notFound;
+        return S_db_noLSET;
 
     return plset->getUnits(plink, units, unitsSize);
 }
@@ -650,7 +698,7 @@
     lset *plset = plink->lset;
 
     if (!plset || !plset->getAlarm)
-        return S_db_notFound;
+        return S_db_noLSET;
 
     return plset->getAlarm(plink, status, severity);
 }
@@ -660,7 +708,7 @@
     lset *plset = plink->lset;
 
     if (!plset || !plset->getTimeStamp)
-        return S_db_notFound;
+        return S_db_noLSET;
 
     return plset->getTimeStamp(plink, pstamp);
 }
@@ -672,7 +720,7 @@
     long status;
 
     if (!plset || !plset->putValue)
-        return S_db_notFound;
+        return S_db_noLSET;
 
     status = plset->putValue(plink, dbrType, pbuffer, nRequest);
     if (status) {
@@ -683,6 +731,33 @@
     return status;
 }
 
+void dbLinkAsyncComplete(struct link *plink)
+{
+    dbCommon *pdbCommon = plink->precord;
+
+    dbScanLock(pdbCommon);
+    pdbCommon->rset->process(pdbCommon);
+    dbScanUnlock(pdbCommon);
+}
+
+long dbPutLinkAsync(struct link *plink, short dbrType, const void *pbuffer,
+        long nRequest)
+{
+    lset *plset = plink->lset;
+    long status;
+
+    if (!plset || !plset->putAsync)
+        return S_db_noLSET;
+
+    status = plset->putAsync(plink, dbrType, pbuffer, nRequest);
+    if (status) {
+        struct dbCommon *precord = plink->precord;
+
+        recGblSetSevr(precord, LINK_ALARM, INVALID_ALARM);
+    }
+    return status;
+}
+
 void dbScanFwdLink(struct link *plink)
 {
     lset *plset = plink->lset;
@@ -693,20 +768,6 @@
 
 /* Helper functions for long string support */
 
-long dbLoadLinkLS(struct link *plink, char *pbuffer, epicsUInt32 size,
-    epicsUInt32 *plen)
-{
-    if (plink->type == CONSTANT &&
-        plink->value.constantStr) {
-        strncpy(pbuffer, plink->value.constantStr, --size);
-        pbuffer[size] = 0;
-        *plen = (epicsUInt32) strlen(pbuffer) + 1;
-        return 0;
-    }
-
-    return S_db_notFound;
-}
-
 long dbGetLinkLS(struct link *plink, char *pbuffer, epicsUInt32 size,
     epicsUInt32 *plen)
 {
 
=== modified file 'src/ioc/db/dbLink.h'
--- src/ioc/db/dbLink.h	2017-02-01 17:57:04 +0000
+++ src/ioc/db/dbLink.h	2017-03-03 18:23:23 +0000
@@ -28,12 +28,31 @@
 struct dbLocker;
 
 typedef struct lset {
+    /* Characteristics of the link type */
+    const unsigned isConstant:1;
+    const unsigned isVolatile:1;
+
+    /* Activation */
+    void (*openLink)(struct link *plink);
+
+    /* Destructor */
     void (*removeLink)(struct dbLocker *locker, struct link *plink);
+
+    /* Const init, data type hinting */
+    long (*loadScalar)(struct link *plink, short dbrType, void *pbuffer);
+    long (*loadLS)(struct link *plink, char *pbuffer, epicsUInt32 size,
+            epicsUInt32 *plen);
+    long (*loadArray)(struct link *plink, short dbrType, void *pbuffer,
+            long *pnRequest);
+
+    /* Metadata */
     int (*isConnected)(const struct link *plink);
     int (*getDBFtype)(const struct link *plink);
     long (*getElements)(const struct link *plink, long *nelements);
+
+    /* Get data */
     long (*getValue)(struct link *plink, short dbrType, void *pbuffer,
-            epicsEnum16 *pstat, epicsEnum16 *psevr, long *pnRequest);
+            long *pnRequest);
     long (*getControlLimits)(const struct link *plink, double *lo, double *hi);
     long (*getGraphicLimits)(const struct link *plink, double *lo, double *hi);
     long (*getAlarmLimits)(const struct link *plink, double *lolo, double *lo,
@@ -43,8 +62,14 @@
     long (*getAlarm)(const struct link *plink, epicsEnum16 *status,
             epicsEnum16 *severity);
     long (*getTimeStamp)(const struct link *plink, epicsTimeStamp *pstamp);
+
+    /* Put data */
     long (*putValue)(struct link *plink, short dbrType,
             const void *pbuffer, long nRequest);
+    long (*putAsync)(struct link *plink, short dbrType,
+            const void *pbuffer, long nRequest);
+
+    /* Process */
     void (*scanForward)(struct link *plink);
 } lset;
 
@@ -52,11 +77,20 @@
     dbGetAlarm(link, NULL, sevr)
 
 epicsShareFunc void dbInitLink(struct link *plink, short dbfType);
-epicsShareFunc void dbAddLink(struct dbLocker *locker, struct link *plink, short dbfType,
-        DBADDR *ptarget);
+epicsShareFunc void dbAddLink(struct dbLocker *locker, struct link *plink,
+        short dbfType, DBADDR *ptarget);
+
+epicsShareFunc void dbLinkOpen(struct link *plink);
+epicsShareFunc void dbRemoveLink(struct dbLocker *locker, struct link *plink);
+
+epicsShareFunc int dbLinkIsDefined(const struct link *plink);  /* 0 or 1 */
+epicsShareFunc int dbLinkIsConstant(const struct link *plink); /* -1, 0 or 1 */
+epicsShareFunc int dbLinkIsVolatile(const struct link *plink); /* -1, 0 or 1 */
+
 epicsShareFunc long dbLoadLink(struct link *plink, short dbrType,
         void *pbuffer);
-epicsShareFunc void dbRemoveLink(struct dbLocker *locker, struct link *plink);
+epicsShareFunc long dbLoadLinkArray(struct link *, short dbrType, void *pbuffer,
+        long *pnRequest);
 
 epicsShareFunc long dbGetNelements(const struct link *plink, long *nelements);
 epicsShareFunc int dbIsLinkConnected(const struct link *plink);
@@ -78,6 +112,9 @@
         epicsTimeStamp *pstamp);
 epicsShareFunc long dbPutLink(struct link *plink, short dbrType,
         const void *pbuffer, long nRequest);
+epicsShareFunc void dbLinkAsyncComplete(struct link *plink);
+epicsShareFunc long dbPutLinkAsync(struct link *plink, short dbrType,
+        const void *pbuffer, long nRequest);
 epicsShareFunc void dbScanFwdLink(struct link *plink);
 
 epicsShareFunc long dbLoadLinkLS(struct link *plink, char *pbuffer,
 
=== modified file 'src/ioc/db/dbLock.c'
--- src/ioc/db/dbLock.c	2017-02-01 17:57:04 +0000
+++ src/ioc/db/dbLock.c	2017-03-03 18:23:23 +0000
@@ -190,6 +190,8 @@
     lockRecord * const lr = precord->lset;
     lockSet *ls;
 
+    assert(lr);
+
     ls = dbLockGetRef(lr);
     assert(epicsAtomicGetIntT(&ls->refcount)>0);
 
 
=== modified file 'src/ioc/db/dbTest.c'
=== modified file 'src/ioc/db/dbUnitTest.c'
--- src/ioc/db/dbUnitTest.c	2017-02-01 17:57:04 +0000
+++ src/ioc/db/dbUnitTest.c	2017-03-03 18:23:23 +0000
@@ -106,8 +106,8 @@
     DBADDR addr;
     union anybuf pod;
 
-    if(dbNameToAddr(pv, &addr)) {
-        testFail("Missing PV %s", pv);
+    if (dbNameToAddr(pv, &addr)) {
+        testFail("Missing PV \"%s\"", pv);
         return S_dbLib_recNotFound;
     }
 
@@ -152,7 +152,7 @@
     ret = testdbVPutField(pv, dbrType, ap);
     va_end(ap);
 
-    testOk(ret==0, "dbPutField(%s, %d, ...) == %ld", pv, dbrType, ret);
+    testOk(ret==0, "dbPutField(\"%s\", %d, ...) -> %#lx (%s)", pv, dbrType, ret, errSymMsg(ret));
 }
 
 void testdbPutFieldFail(long status, const char* pv, short dbrType, ...)
@@ -164,10 +164,8 @@
     ret = testdbVPutField(pv, dbrType, ap);
     va_end(ap);
 
-    if(ret==status)
-        testPass("dbPutField(\"%s\", %d, ...) == %ld", pv, dbrType, status);
-    else
-        testFail("dbPutField(\"%s\", %d, ...) != %ld (%ld)", pv, dbrType, status, ret);
+    testOk(ret==status, "dbPutField(\"%s\", %d, ...) -> %#lx (%s) == %#lx (%s)",
+           pv, dbrType, status, errSymMsg(status), ret, errSymMsg(ret));
 }
 
 void testdbGetFieldEqual(const char* pv, short dbrType, ...)
@@ -187,13 +185,13 @@
     long status;
 
     if(dbNameToAddr(pv, &addr)) {
-        testFail("Missing PV %s", pv);
+        testFail("Missing PV \"%s\"", pv);
         return;
     }
 
     status = dbGetField(&addr, dbrType, pod.bytes, NULL, &nReq, NULL);
-    if(status) {
-        testFail("dbGetField(\"%s\",%d,...) returns %ld", pv, dbrType, status);
+    if (status) {
+        testFail("dbGetField(\"%s\", %d, ...) -> %#lx (%s)", pv, dbrType, status, errSymMsg(status));
         return;
     }
 
@@ -226,8 +224,8 @@
 {
     DBADDR addr;
 
-    if(dbNameToAddr(pv, &addr))
-        testAbort("Missing record %s", pv);
+    if (dbNameToAddr(pv, &addr))
+        testAbort("Missing record \"%s\"", pv);
 
     return addr.precord;
 }
 
=== modified file 'src/ioc/db/recGbl.c'
--- src/ioc/db/recGbl.c	2017-02-01 17:57:04 +0000
+++ src/ioc/db/recGbl.c	2017-03-03 18:23:23 +0000
@@ -17,6 +17,7 @@
 #include <string.h>
 #include <limits.h>
 
+#include "alarm.h"
 #include "dbDefs.h"
 #include "epicsMath.h"
 #include "epicsPrint.h"
@@ -30,7 +31,6 @@
 #include "dbAccessDefs.h"
 #include "dbAddr.h"
 #include "dbBase.h"
-#include "dbCa.h"
 #include "dbCommon.h"
 #include "dbEvent.h"
 #include "db_field_log.h"
@@ -214,7 +214,27 @@
     }
     return FALSE;
 }
-
 
+
+void recGblInheritSevr(int msMode, void *precord, epicsEnum16 stat,
+    epicsEnum16 sevr)
+{
+    switch (msMode) {
+    case pvlOptNMS:
+	break;
+    case pvlOptMSI:
+        if (sevr < INVALID_ALARM)
+	    break;
+	/* Fall through */
+    case pvlOptMS:
+	recGblSetSevr(precord, LINK_ALARM, sevr);
+	break;
+    case pvlOptMSS:
+        recGblSetSevr(precord, stat, sevr);
+	break;
+    }
+}
+
+
 void recGblFwdLink(void *precord)
 {
     dbCommon *pdbc = precord;
@@ -236,7 +256,7 @@
     dbCommon* prec = (dbCommon*)pvoid;
     struct link *plink = &prec->tsel;
 
-    if (plink->type != CONSTANT) {
+    if (!dbLinkIsConstant(plink)) {
         struct pv_link *ppv_link = &plink->value.pv_link;
 
         if (ppv_link->pvlMask & pvlOptTSELisTime) {
 
=== modified file 'src/ioc/db/recGbl.h'
--- src/ioc/db/recGbl.h	2014-10-31 21:18:25 +0000
+++ src/ioc/db/recGbl.h	2017-03-03 18:23:23 +0000
@@ -59,6 +59,8 @@
 epicsShareFunc unsigned short recGblResetAlarms(void *precord);
 epicsShareFunc int recGblSetSevr(void *precord, epicsEnum16 new_stat,
     epicsEnum16 new_sevr);
+epicsShareFunc void recGblInheritSevr(int msMode, void *precord, epicsEnum16 stat,
+    epicsEnum16 sevr);
 epicsShareFunc void recGblFwdLink(void *precord);
 epicsShareFunc void recGblGetTimeStamp(void *precord);
 epicsShareFunc void recGblTSELwasModified(struct link *plink);
 
=== modified file 'src/ioc/db/test/Makefile'
--- src/ioc/db/test/Makefile	2017-02-01 17:57:04 +0000
+++ src/ioc/db/test/Makefile	2017-03-03 18:23:23 +0000
@@ -18,7 +18,9 @@
 dbTestIoc_SRCS += arrRecord.c
 dbTestIoc_SRCS += xRecord.c
 dbTestIoc_SRCS += dbLinkdset.c
+dbTestIoc_SRCS += xLink.c
 dbTestIoc_SRCS += devx.c
+dbTestIoc_SRCS += jlinkz.c
 dbTestIoc_LIBS = dbCore ca Com
 
 TARGETS += $(COMMON_DIR)/dbTestIoc.dbd
@@ -26,10 +28,11 @@
 dbTestIoc_DBD += menuGlobal.dbd
 dbTestIoc_DBD += menuConvert.dbd
 dbTestIoc_DBD += menuScan.dbd
-#dbTestIoc_DBD += arrRecord.dbd
 dbTestIoc_DBD += xRecord.dbd
 dbTestIoc_DBD += arrRecord.dbd
+dbTestIoc_DBD += xLink.dbd
 dbTestIoc_DBD += devx.dbd
+dbTestIoc_DBD += jlinkz.dbd
 dbTestIoc_DBD += dbLinkdset.dbd
 TESTFILES += $(COMMON_DIR)/dbTestIoc.dbd ../xRecord.db
 
@@ -54,7 +57,7 @@
 dbPutLinkTest_SRCS += dbTestIoc_registerRecordDeviceDriver.cpp
 testHarness_SRCS += dbPutLinkTest.c
 TESTS += dbPutLinkTest
-TESTFILES += ../dbPutLinkTest.db ../dbBadLink.db
+TESTFILES += ../dbPutLinkTest.db ../dbPutLinkTestJ.db ../dbBadLink.db
 
 TESTPROD_HOST += dbLockTest
 dbLockTest_SRCS += dbLockTest.c
@@ -152,7 +155,7 @@
 testHarness_SRCS += recGblCheckDeadbandTest.c
 TESTS += recGblCheckDeadbandTest
 
-# The testHarness runs all the test programs in a known working order.
+# This runs all the test programs in a known working order:
 testHarness_SRCS += epicsRunDbTests.c
 
 dbTestHarness_SRCS += $(testHarness_SRCS)
 
=== modified file 'src/ioc/db/test/dbLinkdset.c'
--- src/ioc/db/test/dbLinkdset.c	2017-02-01 17:57:04 +0000
+++ src/ioc/db/test/dbLinkdset.c	2017-03-03 18:23:23 +0000
@@ -29,6 +29,7 @@
     static dset devxLTest ## LTYPE = {4, NULL, &link_test_init, &link_test_noop, &link_test_noop}; \
     epicsExportAddress(dset, devxLTest ## LTYPE);
 
+DEFDSET(JSON_LINK)
 DEFDSET(VME_IO)
 DEFDSET(CAMAC_IO)
 DEFDSET(AB_IO)
 
=== modified file 'src/ioc/db/test/dbLinkdset.dbd'
--- src/ioc/db/test/dbLinkdset.dbd	2017-02-01 17:57:04 +0000
+++ src/ioc/db/test/dbLinkdset.dbd	2017-03-03 18:23:23 +0000
@@ -1,3 +1,4 @@
+device(x, JSON_LINK, devxLTestJSON_LINK, "Unit Test JSON_LINK")
 device(x, VME_IO, devxLTestVME_IO, "Unit Test VME_IO")
 device(x, CAMAC_IO, devxLTestCAMAC_IO, "Unit Test CAMAC_IO")
 device(x, AB_IO, devxLTestAB_IO, "Unit Test AB_IO")
 
=== modified file 'src/ioc/db/test/dbPutLinkTest.c'
--- src/ioc/db/test/dbPutLinkTest.c	2017-02-01 17:57:04 +0000
+++ src/ioc/db/test/dbPutLinkTest.c	2017-03-03 18:23:23 +0000
@@ -24,8 +24,10 @@
 #include "osiFileName.h"
 #include "dbmf.h"
 #include "errlog.h"
+#include <epicsAtomic.h>
 
 #include "xRecord.h"
+#include "jlinkz.h"
 
 #include "testMain.h"
 
@@ -60,6 +62,7 @@
     {"#B11 C12 N13 A14 F15 @cparam", {CAMAC_IO, "cparam", 0, "BCNAF", {11, 12, 13, 14, 15}}},
     {" #B111 C112 N113 @cparam", {CAMAC_IO, "cparam", 0, "BCN", {111, 112, 113}}},
     {" @hello world ", {INST_IO, "hello world", 0, "", /*{}*/}},
+    {" {\"x\":true} ", {JSON_LINK, "{\"x\":true}", 0, "", /*{}*/}},
     {NULL}
 };
 
@@ -67,7 +70,7 @@
 {
     const struct testParseDataT *td = testParseData;
     dbLinkInfo info;
-    testDiag("link parsing");
+    testDiag("\n# Checking link parsing\n#");
     testdbPrepare();
 
     testdbReadDatabase("dbTestIoc.dbd", NULL, NULL);
@@ -80,27 +83,32 @@
     testIocInitOk();
     eltc(1);
 
-    for(;td->str; td++) {
+    for (;td->str; td++) {
         int i, N;
-        testDiag("Parse \"%s\"", td->str);
-        testOk1(dbParseLink(td->str, DBF_INLINK, &info)==0);
-        testOk1(info.ltype==td->info.ltype);
-        if(td->info.target)
+        testDiag("Parsing \"%s\"", td->str);
+        testOk(dbParseLink(td->str, DBF_INLINK, &info) == 0, "Parser returned OK");
+        if (!testOk(info.ltype == td->info.ltype, "Link type value"))
+            testDiag("Expected %d, got %d", td->info.ltype, info.ltype);
+        if (td->info.target)
             testStrcmp(0, info.target, td->info.target);
-        if(info.ltype==td->info.ltype) {
-            switch(info.ltype) {
+        if (info.ltype == td->info.ltype) {
+            switch (info.ltype) {
             case PV_LINK:
-                testOk1(info.modifiers==td->info.modifiers);
+                if (!testOk(info.modifiers == td->info.modifiers,
+                        "PV Link modifier flags"))
+                    testDiag("Expected %d, got %d", td->info.modifiers,
+                        info.modifiers);
                 break;
             case VME_IO:
+            case CAMAC_IO:
                 testStrcmp(0, info.hwid, td->info.hwid);
                 N = strlen(td->info.hwid);
-                for(i=0; i<N; i++)
+                for (i=0; i<N; i++)
                     testOk(info.hwnums[i]==td->info.hwnums[i], "%d == %d",
                            info.hwnums[i], td->info.hwnums[i]);
             }
         }
-        free(info.target);
+        dbFreeLinkInfo(&info);
     }
 
     testIocShutdownOk();
@@ -124,7 +132,7 @@
 {
     const char * const *td = testParseFailData;
     dbLinkInfo info;
-    testDiag("link parsing of invalid input");
+    testDiag("\n# Check parsing of invalid inputs\n#");
     testdbPrepare();
 
     testdbReadDatabase("dbTestIoc.dbd", NULL, NULL);
@@ -138,8 +146,8 @@
     eltc(1);
 
     for(;*td; td++) {
-        testDiag("Expect failure \"%s\"", *td);
-        testOk1(dbParseLink(*td, DBF_INLINK, &info)==S_dbLib_badField);
+        testOk(dbParseLink(*td, DBF_INLINK, &info) == S_dbLib_badField,
+            "dbParseLink correctly rejected \"%s\"", *td);
     }
 
     testIocShutdownOk();
@@ -179,7 +187,7 @@
     const struct testDataT *td = testSetData;
     xRecord *prec;
     DBLINK *plink;
-    testDiag("DB/CA link retargeting");
+    testDiag("\n# Checking DB/CA link retargeting\n#");
     testdbPrepare();
 
     testdbReadDatabase("dbTestIoc.dbd", NULL, NULL);
@@ -196,21 +204,22 @@
     plink = &prec->lnk;
 
     for (;td->linkstring;td++) {
-        testDiag("x1.LNK <- \"%s\"", td->linkstring);
+        testDiag("Trying field value \"%s\"", td->linkstring);
 
         testdbPutFieldOk("x1.LNK", DBF_STRING, td->linkstring);
         if (td->linkback)
             testdbGetFieldEqual("x1.LNK", DBF_STRING, td->linkback);
         else
             testdbGetFieldEqual("x1.LNK", DBF_STRING, td->linkstring);
-        testOk1(plink->type==td->linkType);
+        if (!testOk(plink->type == td->linkType, "Link type"))
+            testDiag("Expected %d, got %d", td->linkType, plink->type);
 
-        if (plink->type==td->linkType) {
-            switch(td->linkType) {
+        if (plink->type == td->linkType) {
+            switch (td->linkType) {
             case CONSTANT:
-                if(plink->value.constantStr)
-                    testOk1(strcmp(plink->value.constantStr,td->linkstring)==0);
-                else if(td->linkstring[0]=='\0')
+                if (plink->value.constantStr)
+                    testOk1(strcmp(plink->value.constantStr, td->linkstring) == 0);
+                else if (td->linkstring[0]=='\0')
                     testPass("Empty String");
                 else
                     testFail("oops");
@@ -218,7 +227,7 @@
 
             case DB_LINK:
             case CA_LINK:
-                testOk(plink->value.pv_link.pvlMask==td->pvlMask,
+                testOk(plink->value.pv_link.pvlMask == td->pvlMask,
                        "pvlMask %x == %x", plink->value.pv_link.pvlMask, td->pvlMask);
                 break;
             }
@@ -239,6 +248,7 @@
 } testHWDataT;
 
 static const testHWDataT testHWData[] = {
+    {"rJSON_LINK", JSON_LINK, "{\"x\":true}", {0}, "{\"x\":true}"},
     {"rVME_IO", VME_IO, "#C100 S101 @parm VME_IO", {100, 101}, "parm VME_IO"},
     {"rCAMAC_IO", CAMAC_IO, "#B11 C12 N13 A14 F15 @parm CAMAC_IO", {11, 12, 13, 14, 15}, "parm CAMAC_IO"},
     {"rAB_IO", AB_IO, "#L21 A22 C23 S24 @parm AB_IO", {21, 22, 23, 24}, "parm AB_IO"},
@@ -255,63 +265,66 @@
 static void testLink(DBLINK *plink, const testHWDataT *td)
 {
     switch(td->ltype) {
+    case JSON_LINK:
+        testOk1(strcmp(plink->value.json.string, td->parm) == 0);
+        break;
     case VME_IO:
-        testOk1(plink->value.vmeio.card==td->vals[0]);
-        testOk1(plink->value.vmeio.signal==td->vals[1]);
-        testOk1(strcmp(plink->value.vmeio.parm, td->parm)==0);
+        testOk1(plink->value.vmeio.card == td->vals[0]);
+        testOk1(plink->value.vmeio.signal == td->vals[1]);
+        testOk1(strcmp(plink->value.vmeio.parm, td->parm) == 0);
         break;
     case CAMAC_IO:
-        testOk1(plink->value.camacio.b==td->vals[0]);
-        testOk1(plink->value.camacio.c==td->vals[1]);
-        testOk1(plink->value.camacio.n==td->vals[2]);
-        testOk1(plink->value.camacio.a==td->vals[3]);
-        testOk1(plink->value.camacio.f==td->vals[4]);
-        testOk1(strcmp(plink->value.camacio.parm, td->parm)==0);
+        testOk1(plink->value.camacio.b == td->vals[0]);
+        testOk1(plink->value.camacio.c == td->vals[1]);
+        testOk1(plink->value.camacio.n == td->vals[2]);
+        testOk1(plink->value.camacio.a == td->vals[3]);
+        testOk1(plink->value.camacio.f == td->vals[4]);
+        testOk1(strcmp(plink->value.camacio.parm, td->parm) == 0);
         break;
     case AB_IO:
-        testOk1(plink->value.abio.link==td->vals[0]);
-        testOk1(plink->value.abio.adapter==td->vals[1]);
-        testOk1(plink->value.abio.card==td->vals[2]);
-        testOk1(plink->value.abio.signal==td->vals[3]);
-        testOk1(strcmp(plink->value.abio.parm, td->parm)==0);
+        testOk1(plink->value.abio.link == td->vals[0]);
+        testOk1(plink->value.abio.adapter == td->vals[1]);
+        testOk1(plink->value.abio.card == td->vals[2]);
+        testOk1(plink->value.abio.signal == td->vals[3]);
+        testOk1(strcmp(plink->value.abio.parm, td->parm) == 0);
         break;
     case GPIB_IO:
-        testOk1(plink->value.gpibio.link==td->vals[0]);
-        testOk1(plink->value.gpibio.addr==td->vals[1]);
-        testOk1(strcmp(plink->value.gpibio.parm, td->parm)==0);
+        testOk1(plink->value.gpibio.link == td->vals[0]);
+        testOk1(plink->value.gpibio.addr == td->vals[1]);
+        testOk1(strcmp(plink->value.gpibio.parm, td->parm) == 0);
         break;
     case BITBUS_IO:
-        testOk1(plink->value.bitbusio.link==td->vals[0]);
-        testOk1(plink->value.bitbusio.node==td->vals[1]);
-        testOk1(plink->value.bitbusio.port==td->vals[2]);
-        testOk1(plink->value.bitbusio.signal==td->vals[3]);
-        testOk1(strcmp(plink->value.bitbusio.parm, td->parm)==0);
+        testOk1(plink->value.bitbusio.link == td->vals[0]);
+        testOk1(plink->value.bitbusio.node == td->vals[1]);
+        testOk1(plink->value.bitbusio.port == td->vals[2]);
+        testOk1(plink->value.bitbusio.signal == td->vals[3]);
+        testOk1(strcmp(plink->value.bitbusio.parm, td->parm) == 0);
         break;
     case INST_IO:
-        testOk1(strcmp(plink->value.instio.string, td->parm)==0);
+        testOk1(strcmp(plink->value.instio.string, td->parm) == 0);
         break;
     case BBGPIB_IO:
-        testOk1(plink->value.bbgpibio.link==td->vals[0]);
-        testOk1(plink->value.bbgpibio.bbaddr==td->vals[1]);
-        testOk1(plink->value.bbgpibio.gpibaddr==td->vals[2]);
-        testOk1(strcmp(plink->value.bbgpibio.parm, td->parm)==0);
+        testOk1(plink->value.bbgpibio.link == td->vals[0]);
+        testOk1(plink->value.bbgpibio.bbaddr == td->vals[1]);
+        testOk1(plink->value.bbgpibio.gpibaddr == td->vals[2]);
+        testOk1(strcmp(plink->value.bbgpibio.parm, td->parm) == 0);
         break;
     case RF_IO:
-        testOk1(plink->value.rfio.cryo==td->vals[0]);
-        testOk1(plink->value.rfio.micro==td->vals[1]);
-        testOk1(plink->value.rfio.dataset==td->vals[2]);
-        testOk1(plink->value.rfio.element==td->vals[3]);
+        testOk1(plink->value.rfio.cryo == td->vals[0]);
+        testOk1(plink->value.rfio.micro == td->vals[1]);
+        testOk1(plink->value.rfio.dataset == td->vals[2]);
+        testOk1(plink->value.rfio.element == td->vals[3]);
         break;
     case VXI_IO:
-        if(plink->value.vxiio.flag==VXIDYNAMIC) {
-            testOk1(plink->value.vxiio.frame==td->vals[0]);
-            testOk1(plink->value.vxiio.slot==td->vals[1]);
-            testOk1(plink->value.vxiio.signal==td->vals[2]);
+        if(plink->value.vxiio.flag == VXIDYNAMIC) {
+            testOk1(plink->value.vxiio.frame == td->vals[0]);
+            testOk1(plink->value.vxiio.slot == td->vals[1]);
+            testOk1(plink->value.vxiio.signal == td->vals[2]);
         } else {
-            testOk1(plink->value.vxiio.la==td->vals[0]);
-            testOk1(plink->value.vxiio.signal==td->vals[1]);
+            testOk1(plink->value.vxiio.la == td->vals[0]);
+            testOk1(plink->value.vxiio.signal == td->vals[1]);
         }
-        testOk1(strcmp(plink->value.vxiio.parm, td->parm)==0);
+        testOk1(strcmp(plink->value.vxiio.parm, td->parm) == 0);
         break;
     }
 }
@@ -319,7 +332,7 @@
 static void testHWInitSet(void)
 {
     const testHWDataT *td = testHWData;
-    testDiag("HW link parsing during initialization");
+    testDiag("\n# Checking HW link parsing during initialization\n#");
     testdbPrepare();
 
     testdbReadDatabase("dbTestIoc.dbd", NULL, NULL);
@@ -332,13 +345,14 @@
     testIocInitOk();
     eltc(1);
 
-    for(;td->recname;td++) {
+    for (;td->recname; td++) {
         char buf[MAX_STRING_SIZE];
         xRecord *prec;
         DBLINK *plink;
+
         testDiag("%s == \"%s\"", td->recname, td->wval);
 
-        prec = (xRecord*)testdbRecordPtr(td->recname);
+        prec = (xRecord *) testdbRecordPtr(td->recname);
         plink = &prec->inp;
 
         strcpy(buf, td->recname);
@@ -346,9 +360,11 @@
 
         testdbGetFieldEqual(buf, DBR_STRING, td->wval);
 
-        testOk(plink->type==td->ltype, "link type %d == %d",
-               plink->type, td->ltype);
-        if(plink->type==td->ltype) {
+        if (!testOk(plink->type == td->ltype, "Link type")) {
+            testDiag("Expected %d, got %d",
+               td->ltype, plink->type);
+        }
+        else {
             testLink(plink, td);
         }
 
@@ -360,6 +376,7 @@
 }
 
 static const testHWDataT testHWData2[] = {
+    {"rJSON_LINK", JSON_LINK, "{\"x\":true}", {0}, "{\"x\":true}"},
     {"rVME_IO", VME_IO, "#C200 S201 @another VME_IO", {200, 201}, "another VME_IO"},
     {"rCAMAC_IO", CAMAC_IO, "#B111 C112 N113 A114 F115 @CAMAC_IO", {111, 112, 113, 114, 115}, "CAMAC_IO"},
     {"rAB_IO", AB_IO, "#L121 A122 C123 S124 @another AB_IO", {121, 122, 123, 124}, "another AB_IO"},
@@ -376,7 +393,8 @@
 static void testHWMod(void)
 {
     const testHWDataT *td = testHWData2;
-    testDiag("HW link parsing during retarget");
+
+    testDiag("\n# Checking HW link parsing during retarget\n#");
     testdbPrepare();
 
     testdbReadDatabase("dbTestIoc.dbd", NULL, NULL);
@@ -405,9 +423,11 @@
 
         testdbGetFieldEqual(buf, DBR_STRING, td->wval);
 
-        testOk(plink->type==td->ltype, "link type %d == %d",
-               plink->type, td->ltype);
-        if(plink->type==td->ltype) {
+        if (!testOk(plink->type == td->ltype, "Link type")) {
+            testDiag("Expected %d, got %d",
+               td->ltype, plink->type);
+        }
+        else {
             testLink(plink, td);
         }
 
@@ -422,42 +442,42 @@
 {
     xRecord *prec;
     DBLINK *plink;
-    testDiag("Link parsing failures during initialization");
+    testDiag("\n# Checking link parse failures at iocInit\n#");
     testdbPrepare();
 
     testdbReadDatabase("dbTestIoc.dbd", NULL, NULL);
 
     dbTestIoc_registerRecordDeviceDriver(pdbbase);
 
-
     /* this load will fail */
     eltc(0);
-    testOk1(dbReadDatabase(&pdbbase, "dbBadLink.db", "." OSI_PATH_LIST_SEPARATOR ".." OSI_PATH_LIST_SEPARATOR
-                           "../O.Common" OSI_PATH_LIST_SEPARATOR "O.Common", NULL)!=0);
+    testOk(dbReadDatabase(&pdbbase, "dbBadLink.db", "." OSI_PATH_LIST_SEPARATOR
+        ".." OSI_PATH_LIST_SEPARATOR "../O.Common" OSI_PATH_LIST_SEPARATOR
+	"O.Common", NULL) != 0, "dbReadDatabase returned error (expected)");
 
     testIocInitOk();
     eltc(1);
 
     testdbGetFieldEqual("eVME_IO1.INP", DBR_STRING, "#C0 S0 @");
 
-    prec = (xRecord*)testdbRecordPtr("eVME_IO1");
+    prec = (xRecord *) testdbRecordPtr("eVME_IO1");
     plink = &prec->inp;
-    testOk1(plink->type==VME_IO);
-    testOk1(plink->value.vmeio.parm!=NULL);
+    testOk1(plink->type == VME_IO);
+    testOk1(plink->value.vmeio.parm != NULL);
 
     testdbGetFieldEqual("eVME_IO2.INP", DBR_STRING, "#C0 S0 @");
 
-    prec = (xRecord*)testdbRecordPtr("eVME_IO2");
+    prec = (xRecord *) testdbRecordPtr("eVME_IO2");
     plink = &prec->inp;
-    testOk1(plink->type==VME_IO);
-    testOk1(plink->value.vmeio.parm!=NULL);
+    testOk1(plink->type == VME_IO);
+    testOk1(plink->value.vmeio.parm != NULL);
 
     testdbGetFieldEqual("eINST_IO.INP", DBR_STRING, "@");
 
-    prec = (xRecord*)testdbRecordPtr("eINST_IO");
+    prec = (xRecord *) testdbRecordPtr("eINST_IO");
     plink = &prec->inp;
-    testOk1(plink->type==INST_IO);
-    testOk1(plink->value.instio.string!=NULL);
+    testOk1(plink->type == INST_IO);
+    testOk1(plink->value.instio.string != NULL);
 
     testIocShutdownOk();
 
@@ -466,7 +486,7 @@
 
 static void testLinkFail(void)
 {
-    testDiag("Link parsing failures");
+    testDiag("\n# Checking runtime link parse failures\n#");
     testdbPrepare();
 
     testdbReadDatabase("dbTestIoc.dbd", NULL, NULL);
@@ -482,9 +502,22 @@
     /* INST_IO doesn't accept empty string */
     testdbPutFieldFail(S_dbLib_badField, "rINST_IO.INP", DBR_STRING, "");
 
-    /* INST_IO doesn't accept empty string */
+    /* INST_IO doesn't accept string without @ */
     testdbPutFieldFail(S_dbLib_badField, "rINST_IO.INP", DBR_STRING, "abc");
 
+    /* JSON_LINK dies when expected */
+    testdbPutFieldOk("rJSON_LINK.INP", DBR_STRING, "{\"x\":true}");
+    testdbPutFieldFail(S_dbLib_badField, "rJSON_LINK.INP", DBR_STRING, "{\"x\":false}");
+    testdbPutFieldFail(S_dbLib_badField, "rJSON_LINK.INP", DBR_STRING, "{\"x\":null}");
+    testdbPutFieldFail(S_dbLib_badField, "rJSON_LINK.INP", DBR_STRING, "{\"x\":1}");
+    testdbPutFieldFail(S_dbLib_badField, "rJSON_LINK.INP", DBR_STRING, "{\"x\":1.1}");
+    testdbPutFieldFail(S_dbLib_badField, "rJSON_LINK.INP", DBR_STRING, "{\"x\":\"x\"}");
+    testdbPutFieldFail(S_dbLib_badField, "rJSON_LINK.INP", DBR_STRING, "{\"x\":[]}");
+    testdbPutFieldFail(S_dbLib_badField, "rJSON_LINK.INP", DBR_STRING, "{\"x\":{}}");
+
+    /* JSON_LINK syntax errors */
+    testdbPutFieldFail(S_dbLib_badField, "rJSON_LINK.INP", DBR_STRING, "{\"x\":bbbb}");
+
     /* syntax errors */
     testdbPutFieldFail(S_dbLib_badField, "rVME_IO.INP", DBR_STRING, "#S201 C200 @another VME_IO");
     testdbPutFieldFail(S_dbLib_badField, "rVME_IO.INP", DBR_STRING, "C200 #S201");
@@ -502,9 +535,73 @@
     testdbCleanup();
 }
 
+static
+void testNumZ(int expect)
+{
+    int numz = epicsAtomicGetIntT(&numzalloc);
+    testOk(numz==expect, "numzalloc==%d (%d)", expect, numz);
+}
+
+static
+void testJLink(void)
+{
+    testDiag("Test json link setup/retarget");
+
+    testNumZ(0);
+
+    testDiag("Link parsing failures");
+    testdbPrepare();
+
+    testdbReadDatabase("dbTestIoc.dbd", NULL, NULL);
+
+    dbTestIoc_registerRecordDeviceDriver(pdbbase);
+
+    testdbReadDatabase("dbPutLinkTest.db", NULL, NULL);
+    testdbReadDatabase("dbPutLinkTestJ.db", NULL, NULL);
+
+    testNumZ(0);
+
+    eltc(0);
+    testIocInitOk();
+    eltc(1);
+
+    testNumZ(3);
+
+    testdbPutFieldOk("j1.PROC", DBF_LONG, 1);
+    testdbPutFieldOk("j2.PROC", DBF_LONG, 1);
+    testdbPutFieldOk("j3.PROC", DBF_LONG, 1);
+
+    testdbGetFieldEqual("j1.INP", DBF_STRING, "{\"z\":{\"good\":1}}");
+    testdbGetFieldEqual("j1.VAL", DBF_LONG, 1);
+    testdbGetFieldEqual("j2.VAL", DBF_LONG, 2);
+    testdbGetFieldEqual("j3.VAL", DBF_LONG, 3);
+
+    testNumZ(3);
+
+    testdbPutFieldOk("j1.INP", DBF_STRING, "{\"z\":{\"good\":4}}");
+    testdbPutFieldOk("j1.PROC", DBF_LONG, 1);
+    testdbGetFieldEqual("j1.VAL", DBF_LONG, 4);
+
+    testNumZ(3);
+
+    testdbPutFieldFail(S_dbLib_badField, "j1.INP", DBF_STRING, "{\"z\":{\"fail\":5}}");
+    testdbPutFieldOk("j1.PROC", DBF_LONG, 1);
+    testdbGetFieldEqual("j1.VAL", DBF_LONG, 4);
+    /* put failure in parsing stage doesn't modify link */
+    testdbGetFieldEqual("j1.INP", DBF_STRING, "{\"z\":{\"good\":4}}");
+
+    testNumZ(3);
+
+    testIocShutdownOk();
+
+    testNumZ(0);
+
+    testdbCleanup();
+}
+
 MAIN(dbPutLinkTest)
 {
-    testPlan(251);
+    testPlan(301);
     testLinkParse();
     testLinkFailParse();
     testCADBSet();
@@ -512,5 +609,6 @@
     testHWMod();
     testLinkInitFail();
     testLinkFail();
+    testJLink();
     return testDone();
 }
 
=== modified file 'src/ioc/db/test/dbPutLinkTest.db'
--- src/ioc/db/test/dbPutLinkTest.db	2014-07-31 20:22:02 +0000
+++ src/ioc/db/test/dbPutLinkTest.db	2017-03-03 18:23:23 +0000
@@ -3,6 +3,10 @@
 record(x, "x3") {}
 record(x, "x4") {}
 
+record(x, "rJSON_LINK") {
+  field(DTYP, "Unit Test JSON_LINK")
+  field(INP, {x:true})
+}
 record(x, "rVME_IO") {
   field(DTYP, "Unit Test VME_IO")
   field(INP, "#C100 S101 @parm VME_IO")
 
=== added file 'src/ioc/db/test/dbPutLinkTestJ.db'
--- src/ioc/db/test/dbPutLinkTestJ.db	1970-01-01 00:00:00 +0000
+++ src/ioc/db/test/dbPutLinkTestJ.db	2017-03-03 18:23:23 +0000
@@ -0,0 +1,12 @@
+
+record(x, "j1") {
+  field(INP, {z:{good:1}})
+}
+
+record(x, "j2") {
+  field(INP, {z:{good:2}})
+}
+
+record(x, "j3") {
+  field(INP, {z:{good:3}})
+}
 
=== modified file 'src/ioc/db/test/devx.c'
--- src/ioc/db/test/devx.c	2015-03-13 19:24:06 +0000
+++ src/ioc/db/test/devx.c	2017-03-03 18:23:23 +0000
@@ -141,17 +141,13 @@
 /* basic DTYP="Soft Channel" */
 static long xsoft_init_record(xRecord *prec)
 {
-    if(prec->inp.type==CONSTANT)
-        recGblInitConstantLink(&prec->inp, DBF_LONG, &prec->val);
+    recGblInitConstantLink(&prec->inp, DBF_LONG, &prec->val);
     return 0;
 }
 
 static long xsoft_read(xRecord *prec)
 {
-    if(prec->inp.type==CONSTANT)
-        return 0;
-    dbGetLink(&prec->inp, DBR_DOUBLE, &prec->val, NULL, NULL);
-    return 0;
+    return dbGetLink(&prec->inp, DBR_LONG, &prec->val, NULL, NULL);
 }
 
 static struct xdset devxSoft = {
 
=== added file 'src/ioc/db/test/jlinkz.c'
--- src/ioc/db/test/jlinkz.c	1970-01-01 00:00:00 +0000
+++ src/ioc/db/test/jlinkz.c	2017-03-03 18:23:23 +0000
@@ -0,0 +1,250 @@
+/*************************************************************************\
+* Copyright (c) 2016 Michael Davidsaver
+* EPICS BASE is distributed subject to a Software License Agreement found
+* in file LICENSE that is included with this distribution.
+ \*************************************************************************/
+
+#include <stdlib.h>
+#include <string.h>
+
+#include <epicsExport.h>
+#include <dbAccess.h>
+#include <link.h>
+#include <alarm.h>
+#include <dbJLink.h>
+#include <dbDefs.h>
+#include <dbConvertFast.h>
+#include <epicsMutex.h>
+#include <epicsAtomic.h>
+#include <epicsUnitTest.h>
+
+#define epicsExportSharedSymbols
+
+#include "jlinkz.h"
+
+int numzalloc;
+
+
+static
+void z_open(struct link *plink)
+{
+    zpriv *priv = CONTAINER(plink->value.json.jlink, zpriv, base);
+
+    if(priv->isopen)
+        testDiag("lsetZ re-open");
+    priv->isopen = 1;
+    testDiag("Open jlinkz %p", priv);
+}
+
+static
+void z_remove(struct dbLocker *locker, struct link *plink)
+{
+    zpriv *priv = CONTAINER(plink->value.json.jlink, zpriv, base);
+
+    epicsMutexLock(priv->lock);
+
+    if(!priv->isopen)
+        testDiag("lsetZ remove without open");
+
+    epicsMutexUnlock(priv->lock);
+
+    testDiag("Remove/free jlinkz %p", priv);
+
+    epicsAtomicDecrIntT(&numzalloc);
+
+    epicsMutexDestroy(priv->lock);
+    free(priv);
+    plink->value.json.jlink = NULL; /* paranoia */
+}
+
+static
+int z_connected(const struct link *plink)
+{
+    return 1; /* TODO: not provided should be connected */
+}
+
+static
+int z_dbftype(const struct link *plink)
+{
+    return DBF_LONG;
+}
+
+static
+long z_elements(const struct link *plink, long *nelements)
+{
+    *nelements = 1;
+    return 0;
+}
+
+static
+long z_getval(struct link *plink, short dbrType, void *pbuffer,
+        long *pnRequest)
+{
+    long ret;
+    long (*pconv)(const epicsInt32 *, void *, const dbAddr *) = dbFastGetConvertRoutine[DBF_LONG][dbrType];
+    zpriv *priv = CONTAINER(plink->value.json.jlink, zpriv, base);
+
+    if(pnRequest && *pnRequest==0) return 0;
+
+    epicsMutexLock(priv->lock);
+    ret = (*pconv)(&priv->value, pbuffer, NULL);
+    epicsMutexUnlock(priv->lock);
+    if(ret==0 && pnRequest) *pnRequest = 1;
+    return ret;
+}
+
+/* TODO: atomicly get value and alarm */
+static
+long z_getalarm(const struct link *plink, epicsEnum16 *status,
+        epicsEnum16 *severity)
+{
+    zpriv *priv = CONTAINER(plink->value.json.jlink, zpriv, base);
+    epicsEnum16 sevr, stat;
+
+    epicsMutexLock(priv->lock);
+    sevr = priv->isset ? 0 : INVALID_ALARM;
+    stat = priv->isset ? 0 : LINK_ALARM;
+    epicsMutexUnlock(priv->lock);
+
+    if(status)   *status = stat;
+    if(severity) *severity = sevr;
+    return 0;
+}
+
+static
+long z_putval(struct link *plink, short dbrType,
+        const void *pbuffer, long nRequest)
+{
+    long ret;
+    long (*pconv)(epicsInt32 *, const void *, const dbAddr *) = dbFastPutConvertRoutine[DBF_LONG][dbrType];
+    zpriv *priv = CONTAINER(plink->value.json.jlink, zpriv, base);
+
+    if(nRequest==0) return 0;
+
+    epicsMutexLock(priv->lock);
+    ret = (*pconv)(&priv->value, pbuffer, NULL);
+    epicsMutexUnlock(priv->lock);
+    return ret;
+}
+
+static lset lsetZ = {
+    0, 0, /* non-const, non-volatile */
+    &z_open,
+    &z_remove,
+    NULL, NULL, NULL, /* load */
+    &z_connected,
+    &z_dbftype,
+    &z_elements,
+    &z_getval,
+    NULL, /* control limits */
+    NULL, /* display limits */
+    NULL, /* alarm limits */
+    NULL, /* prec */
+    NULL, /* units */
+    &z_getalarm,
+    NULL, /* time */
+    &z_putval,
+    NULL, /* putasync */
+    NULL, /* forward */
+};
+
+static
+jlink* z_alloc(short dbfType)
+{
+    zpriv *priv;
+    priv = calloc(1, sizeof(*priv));
+    if(!priv) goto fail;
+
+    priv->lock = epicsMutexCreate();
+    if(!priv->lock) goto fail;
+
+    epicsAtomicIncrIntT(&numzalloc);
+
+    testDiag("Alloc jlinkz %p", priv);
+
+    return &priv->base;
+fail:
+    if(priv && priv->lock) epicsMutexDestroy(priv->lock);
+    free(priv);
+    return NULL;
+}
+
+static
+void z_free(jlink *pj)
+{
+    zpriv *priv = CONTAINER(pj, zpriv, base);
+
+    if(priv->isopen)
+        testDiag("lsetZ jlink free after open()");
+
+    testDiag("Free jlinkz %p", priv);
+
+    epicsAtomicDecrIntT(&numzalloc);
+
+    epicsMutexDestroy(priv->lock);
+    free(priv);
+}
+
+static
+jlif_result z_int(jlink *pj, long num)
+{
+    zpriv *priv = CONTAINER(pj, zpriv, base);
+
+    priv->value = num;
+    priv->isset = 1;
+
+    return jlif_continue;
+}
+
+static
+jlif_key_result z_start(jlink *pj)
+{
+    return jlif_key_continue;
+}
+
+static
+jlif_result z_key(jlink *pj, const char *key, size_t len)
+{
+    zpriv *priv = CONTAINER(pj, zpriv, base);
+
+    if(len==4 && strncmp(key,"fail", len)==0) {
+        testDiag("Found fail key jlinkz %p", priv);
+        return jlif_stop;
+    } else {
+        return jlif_continue;
+    }
+}
+
+static
+jlif_result z_end(jlink *pj)
+{
+    return jlif_continue;
+}
+
+static
+struct lset* z_lset(const jlink *pj)
+{
+    return &lsetZ;
+}
+
+static jlif jlifZ = {
+    "z",
+    &z_alloc,
+    &z_free,
+    NULL, /* null */
+    NULL, /* bool */
+    &z_int,
+    NULL, /* double */
+    NULL, /* string */
+    &z_start,
+    &z_key,
+    &z_end,
+    NULL, /* start array */
+    NULL, /* end array */
+    NULL, /* end child */
+    &z_lset,
+    NULL, /* report */
+    NULL  /* map child */
+};
+
+epicsExportAddress(jlif, jlifZ);
 
=== added file 'src/ioc/db/test/jlinkz.dbd'
--- src/ioc/db/test/jlinkz.dbd	1970-01-01 00:00:00 +0000
+++ src/ioc/db/test/jlinkz.dbd	2017-03-03 18:23:23 +0000
@@ -0,0 +1,1 @@
+link("z", "jlifZ")
 
=== added file 'src/ioc/db/test/jlinkz.h'
--- src/ioc/db/test/jlinkz.h	1970-01-01 00:00:00 +0000
+++ src/ioc/db/test/jlinkz.h	2017-03-03 18:23:23 +0000
@@ -0,0 +1,27 @@
+/*************************************************************************\
+* Copyright (c) 2016 Michael Davidsaver
+* EPICS BASE is distributed subject to a Software License Agreement found
+* in file LICENSE that is included with this distribution.
+ \*************************************************************************/
+
+#ifndef JLINKZ_H
+#define JLINKZ_H
+
+#include <dbJLink.h>
+#include <epicsMutex.h>
+#include <epicsTypes.h>
+
+#include <shareLib.h>
+
+epicsShareExtern
+int numzalloc;
+
+typedef struct {
+    jlink base;
+    epicsMutexId lock;
+    unsigned isset:1;
+    unsigned isopen:1;
+    epicsInt32 value;
+} zpriv;
+
+#endif /* JLINKZ_H */
 
=== added file 'src/ioc/db/test/xLink.c'
--- src/ioc/db/test/xLink.c	1970-01-01 00:00:00 +0000
+++ src/ioc/db/test/xLink.c	2017-03-03 18:23:23 +0000
@@ -0,0 +1,88 @@
+/*************************************************************************\
+* Copyright (c) 2016 UChicago Argonne LLC, as Operator of Argonne
+*     National Laboratory.
+* EPICS BASE is distributed subject to a Software License Agreement found
+* in file LICENSE that is included with this distribution. 
+\*************************************************************************/
+/* xLink.c */
+
+#include "dbDefs.h"
+#include "dbLink.h"
+#include "dbJLink.h"
+#include "epicsExport.h"
+
+
+typedef struct xlink {
+    jlink jlink;        /* embedded object */
+    /* ... */
+} xlink;
+
+static lset xlink_lset;
+
+static jlink* xlink_alloc(short dbfType)
+{
+    xlink *xlink = calloc(1, sizeof(struct xlink));
+
+    return &xlink->jlink;
+}
+
+static void xlink_free(jlink *pjlink)
+{
+    xlink *xlink = CONTAINER(pjlink, struct xlink, jlink);
+
+    free(xlink);
+}
+
+static jlif_result xlink_boolean(jlink *pjlink, int val)
+{
+    return val; /* False triggers a parse failure */
+}
+
+static struct lset* xlink_get_lset(const jlink *pjlink)
+{
+    return &xlink_lset;
+}
+
+
+static void xlink_remove(struct dbLocker *locker, struct link *plink)
+{
+    xlink_free(plink->value.json.jlink);
+}
+
+static long xlink_getNelements(const struct link *plink, long *nelements)
+{
+    *nelements = 0;
+    return 0;
+}
+
+static long xlink_getValue(struct link *plink, short dbrType, void *pbuffer,
+        long *pnRequest)
+{
+    if (pnRequest)
+        *pnRequest = 0;
+    return 0;
+}
+
+
+static lset xlink_lset = {
+    1, 0, /* Constant, not Volatile */
+    NULL, xlink_remove,
+    NULL, NULL, NULL, NULL,
+    NULL, xlink_getNelements, xlink_getValue,
+    NULL, NULL, NULL,
+    NULL, NULL,
+    NULL, NULL,
+    NULL, NULL,
+    NULL
+};
+
+static jlif xlinkIf = {
+    "x", xlink_alloc, xlink_free,
+    NULL, xlink_boolean, NULL, NULL, NULL,
+    NULL, NULL, NULL,
+    NULL, NULL,
+    NULL, xlink_get_lset,
+    NULL, NULL
+};
+epicsExportAddress(jlif, xlinkIf);
+
 
=== added file 'src/ioc/db/test/xLink.dbd'
--- src/ioc/db/test/xLink.dbd	1970-01-01 00:00:00 +0000
+++ src/ioc/db/test/xLink.dbd	2017-03-03 18:23:23 +0000
@@ -0,0 +1,1 @@
+link(x, xlinkIf)
 
=== modified file 'src/ioc/dbStatic/dbBase.h'
--- src/ioc/dbStatic/dbBase.h	2017-02-01 17:57:04 +0000
+++ src/ioc/dbStatic/dbBase.h	2017-03-03 18:23:23 +0000
@@ -43,6 +43,13 @@
 	struct dsxt	*pdsxt;       /* Extended device support */
 }devSup;
 
+typedef struct linkSup {
+	ELLNODE		node;
+	char 		*name;
+	char		*jlif_name;
+	struct jlif	*pjlif;
+} linkSup;
+
 typedef struct dbDeviceMenu {
 	int		nChoice;
 	char		**papChoice;
@@ -161,6 +168,7 @@
 	ELLLIST		menuList;
 	ELLLIST		recordTypeList;
 	ELLLIST		drvList;
+	ELLLIST		linkList;
 	ELLLIST		registrarList;
 	ELLLIST		functionList;
 	ELLLIST		variableList;
 
=== modified file 'src/ioc/dbStatic/dbLex.l'
--- src/ioc/dbStatic/dbLex.l	2015-10-13 17:03:32 +0000
+++ src/ioc/dbStatic/dbLex.l	2017-03-03 18:23:23 +0000
@@ -1,11 +1,12 @@
 /*************************************************************************\
-* Copyright (c) 2009 UChicago Argonne LLC, as Operator of Argonne
+* Copyright (c) 2016 UChicago Argonne LLC, as Operator of Argonne
 *     National Laboratory.
 * Copyright (c) 2002 The Regents of the University of California, as
 *     Operator of Los Alamos National Laboratory.
 * EPICS BASE is distributed subject to a Software License Agreement found
 * in file LICENSE that is included with this distribution. 
 \*************************************************************************/
+
 newline     "\n"
 backslash   "\\"
 doublequote "\""
@@ -15,6 +16,19 @@
 stringchar  [^"\n\\]
 bareword    [a-zA-Z0-9_\-+:.\[\]<>;]
 
+punctuation	[:,\[\]{}]
+normalchar	[^"\\\0-\x1f]
+barechar	[a-zA-Z0-9_\-+.]
+escapedchar	({backslash}["\\/bfnrt])
+hexdigit	[0-9a-fA-F]
+unicodechar	({backslash}"u"{hexdigit}{4})
+jsonchar	({normalchar}|{escapedchar}|{unicodechar})
+jsondqstr	({doublequote}{jsonchar}*{doublequote})
+int	("-"?([0-9]|[1-9][0-9]+))
+frac	("."[0-9]+)
+exp	([eE][+-]?[0-9]+)
+number	({int}{frac}?{exp}?)
+
 %{
 #undef YY_INPUT
 #define YY_INPUT(b,r,ms) (r=(*db_yyinput)((char *)b,ms))
@@ -27,6 +41,8 @@
 
 %}
 
+%x JSON
+
 %%
 
 "include"	return(tokenINCLUDE);
@@ -38,6 +54,7 @@
 "field"		return(tokenFIELD);
 "device"	return(tokenDEVICE);
 "driver"	return(tokenDRIVER);
+"link"		return(tokenLINK);
 "breaktable"	return(tokenBREAKTABLE);
 "record"	return(tokenRECORD);
 "grecord"	return(tokenGRECORD);
@@ -48,18 +65,18 @@
 "variable"	return(tokenVARIABLE);
 
 {bareword}+ { /* unquoted string or number */
-	yylval.Str = dbmfStrdup(yytext);
+	yylval.Str = dbmfStrdup((char *) yytext);
 	return(tokenSTRING); 
 }
 
 {doublequote}({stringchar}|{escape})*{doublequote} { /* quoted string */
-	yylval.Str = dbmfStrdup(yytext+1);
+	yylval.Str = dbmfStrdup((char *) yytext+1);
 	yylval.Str[strlen(yylval.Str)-1] = '\0';
 	return(tokenSTRING);
 }
 
 %.*	{ /*C definition in recordtype*/
-	yylval.Str = dbmfStrdup(yytext+1);
+	yylval.Str = dbmfStrdup((char *) yytext+1);
 	return(tokenCDEFS);
 }
 
@@ -69,14 +86,36 @@
 ")"	return(yytext[0]);
 ","	return(yytext[0]);
 
-{comment}.*	;
-{whitespace}	;
-
 {doublequote}({stringchar}|{escape})*{newline} { /* bad string */
 	yyerrorAbort("Newline in string, closing quote missing");
 }
 
-.	{
+<JSON>"null"	return jsonNULL;
+<JSON>"true"	return jsonTRUE;
+<JSON>"false"	return jsonFALSE;
+
+<JSON>{punctuation}	return yytext[0];
+
+<JSON>{jsondqstr} {
+	yylval.Str = dbmfStrdup((char *) yytext);
+	return jsonSTRING;
+}
+
+<JSON>{number} {
+	yylval.Str = dbmfStrdup((char *) yytext);
+	return jsonNUMBER;
+}
+
+<JSON>{barechar}+ {
+	yylval.Str = dbmfStrdup((char *) yytext);
+	return jsonBARE;
+}
+
+<INITIAL,JSON>{comment}.*	;
+
+<INITIAL,JSON>{whitespace}	;
+
+<INITIAL,JSON>.	{
 	char message[40];
 	YY_BUFFER_STATE *dummy=0;
 
 
=== modified file 'src/ioc/dbStatic/dbLexRoutines.c'
--- src/ioc/dbStatic/dbLexRoutines.c	2017-02-01 17:57:04 +0000
+++ src/ioc/dbStatic/dbLexRoutines.c	2017-03-03 18:23:23 +0000
@@ -77,6 +77,7 @@
 static void dbDevice(char *recordtype,char *linktype,
 	char *dsetname,char *choicestring);
 static void dbDriver(char *name);
+static void dbLinkType(char *name, char *jlif_name);
 static void dbRegistrar(char *name);
 static void dbFunction(char *name);
 static void dbVariable(char *name, char *type);
@@ -815,6 +816,26 @@
     ellAdd(&pdbbase->drvList,&pdrvSup->node);
 }
 
+static void dbLinkType(char *name, char *jlif_name)
+{
+    linkSup *pLinkSup;
+    GPHENTRY *pgphentry;
+
+    pgphentry = gphFind(pdbbase->pgpHash, name, &pdbbase->linkList);
+    if (pgphentry) {
+	return;
+    }
+    pLinkSup = dbCalloc(1,sizeof(linkSup));
+    pLinkSup->name = epicsStrDup(name);
+    pLinkSup->jlif_name = epicsStrDup(jlif_name);
+    pgphentry = gphAdd(pdbbase->pgpHash, pLinkSup->name, &pdbbase->linkList);
+    if (!pgphentry) {
+	yyerrorAbort("gphAdd failed");
+    } 
+    pgphentry->userPvt = pLinkSup;
+    ellAdd(&pdbbase->linkList, &pLinkSup->node);
+}
+
 static void dbRegistrar(char *name)
 {
     dbText	*ptext;
@@ -1057,7 +1078,12 @@
 	yyerror(NULL);
 	return;
     }
-    dbTranslateEscape(value, value);    /* yuck: in-place, but safe */
+    if (*value == '"') {
+	/* jsonSTRING values still have their quotes */
+        value++;
+	value[strlen(value) - 1] = 0;
+    }
+    dbTranslateEscape(value, value);    /* in-place; safe & legal */
     status = dbPutString(pdbentry,value);
     if(status) {
 	epicsPrintf("Can't set \"%s.%s\" to \"%s\"\n",
@@ -1076,6 +1102,12 @@
     if(duplicate) return;
     ptempListNode = (tempListNode *)ellFirst(&tempList);
     pdbentry = ptempListNode->item;
+    if (*value == '"') {
+	/* jsonSTRING values still have their quotes */
+        value++;
+	value[strlen(value) - 1] = 0;
+    }
+    dbTranslateEscape(value, value);    /* yuck: in-place, but safe */
     status = dbPutInfo(pdbentry,name,value);
     if(status) {
 	epicsPrintf("Can't set \"%s\" info \"%s\" to \"%s\"\n",
 
=== modified file 'src/ioc/dbStatic/dbStaticIocRegister.c'
--- src/ioc/dbStatic/dbStaticIocRegister.c	2014-10-06 05:57:02 +0000
+++ src/ioc/dbStatic/dbStaticIocRegister.c	2017-03-03 18:23:23 +0000
@@ -86,6 +86,14 @@
     dbDumpDriver(*iocshPpdbbase);
 }
 
+/* dbDumpLink */
+static const iocshArg * const dbDumpLinkArgs[] = { &argPdbbase};
+static const iocshFuncDef dbDumpLinkFuncDef = {"dbDumpLink",1,dbDumpLinkArgs};
+static void dbDumpLinkCallFunc(const iocshArgBuf *args)
+{
+    dbDumpLink(*iocshPpdbbase);
+}
+
 /* dbDumpRegistrar */
 static const iocshArg * const dbDumpRegistrarArgs[] = { &argPdbbase};
 static const iocshFuncDef dbDumpRegistrarFuncDef = {"dbDumpRegistrar",1,dbDumpRegistrarArgs};
@@ -160,6 +168,7 @@
     iocshRegister(&dbDumpFieldFuncDef, dbDumpFieldCallFunc);
     iocshRegister(&dbDumpDeviceFuncDef, dbDumpDeviceCallFunc);
     iocshRegister(&dbDumpDriverFuncDef, dbDumpDriverCallFunc);
+    iocshRegister(&dbDumpLinkFuncDef, dbDumpLinkCallFunc);
     iocshRegister(&dbDumpRegistrarFuncDef,dbDumpRegistrarCallFunc);
     iocshRegister(&dbDumpFunctionFuncDef, dbDumpFunctionCallFunc);
     iocshRegister(&dbDumpVariableFuncDef, dbDumpVariableCallFunc);
 
=== modified file 'src/ioc/dbStatic/dbStaticLib.c'
--- src/ioc/dbStatic/dbStaticLib.c	2017-02-01 17:57:04 +0000
+++ src/ioc/dbStatic/dbStaticLib.c	2017-03-03 18:23:23 +0000
@@ -43,6 +43,7 @@
 #include "special.h"
 
 #include "dbCommon.h"
+#include "dbJLink.h"
 
 int dbStaticDebug = 0;
 static char *pNullString = "";
@@ -64,6 +65,7 @@
 	{"GPIB_IO",GPIB_IO},
 	{"BITBUS_IO",BITBUS_IO},
 	{"MACRO_LINK",MACRO_LINK},
+	{"JSON_LINK",JSON_LINK},
         {"PN_LINK",PN_LINK},
 	{"DB_LINK",DB_LINK},
 	{"CA_LINK",CA_LINK},
@@ -118,6 +120,10 @@
 	case CONSTANT: free((void *)plink->value.constantStr); break;
 	case MACRO_LINK: free((void *)plink->value.macro_link.macroStr); break;
 	case PV_LINK: free((void *)plink->value.pv_link.pvname); break;
+	case JSON_LINK:
+	    dbJLinkFree(plink->value.json.jlink);
+	    parm = plink->value.json.string;
+	    break;
 	case VME_IO: parm = plink->value.vmeio.parm; break;
 	case CAMAC_IO: parm = plink->value.camacio.parm; break;
 	case AB_IO: parm = plink->value.abio.parm; break;
@@ -454,6 +460,7 @@
     dbVariableDef       *pvarNext;
     drvSup		*pdrvSup;
     drvSup		*pdrvSupNext;
+    linkSup		*plinkSup;
     brkTable		*pbrkTable;
     brkTable		*pbrkTableNext;
     chFilterPlugin  *pfilt;
@@ -556,6 +563,11 @@
 	free((void *)pdrvSup);
 	pdrvSup = pdrvSupNext;
     }
+    while ((plinkSup = (linkSup *) ellGet(&pdbbase->linkList))) {
+        free(plinkSup->jlif_name);
+        free(plinkSup->name);
+        free(plinkSup);
+    }
     ptext = (dbText *)ellFirst(&pdbbase->registrarList);
     while(ptext) {
 	ptextNext = (dbText *)ellNext(&ptext->node);
@@ -1097,6 +1109,21 @@
     return(0);
 }
 
+long dbWriteLinkFP(DBBASE *pdbbase, FILE *fp)
+{
+    linkSup *plinkSup;
+
+    if (!pdbbase) {
+	fprintf(stderr, "pdbbase not specified\n");
+	return -1;
+    }
+    for (plinkSup = (linkSup *) ellFirst(&pdbbase->linkList);
+        plinkSup; plinkSup = (linkSup *) ellNext(&plinkSup->node)) {
+	fprintf(fp, "link(%s,%s)\n", plinkSup->name, plinkSup->jlif_name);
+    }
+    return 0;
+}
+
 long dbWriteRegistrarFP(DBBASE *pdbbase,FILE *fp)
 {
     dbText	*ptext;
@@ -1877,6 +1904,9 @@
 		dbMsgCpy(pdbentry, "");
 	    }
 	    break;
+	case JSON_LINK:
+	    dbMsgCpy(pdbentry, plink->value.json.string);
+	    break;
         case PN_LINK:
             dbMsgPrint(pdbentry, "%s%s",
                    plink->value.pv_link.pvname ? plink->value.pv_link.pvname : "",
@@ -1972,6 +2002,9 @@
 		    dbMsgCpy(pdbentry, "");
 		}
 		break;
+	    case JSON_LINK:
+		dbMsgCpy(pdbentry, plink->value.json.string);
+		break;
 	    case PV_LINK:
 	    case CA_LINK:
 	    case DB_LINK: {
@@ -2128,6 +2161,7 @@
          */
         case CONSTANT: plink->value.constantStr = NULL; break;
         case PV_LINK:  plink->value.pv_link.pvname = callocMustSucceed(1, 1, "init PV_LINK"); break;
+        case JSON_LINK: plink->value.json.string = pNullString; break;
         case VME_IO: plink->value.vmeio.parm = pNullString; break;
         case CAMAC_IO: plink->value.camacio.parm = pNullString; break;
         case AB_IO: plink->value.abio.parm = pNullString; break;
@@ -2160,6 +2194,16 @@
     return 0;
 }
 
+void dbFreeLinkInfo(dbLinkInfo *pinfo)
+{
+    if (pinfo->ltype == JSON_LINK) {
+        dbJLinkFree(pinfo->jlink);
+        pinfo->jlink = NULL;
+    }
+    free(pinfo->target);
+    pinfo->target = NULL;
+}
+
 long dbParseLink(const char *str, short ftype, dbLinkInfo *pinfo)
 {
     char *pstr;
@@ -2194,6 +2238,15 @@
     memcpy(pstr, str, len);
     pstr[len] = '\0';
 
+    /* Check for braces => JSON */
+    if (*str == '{' && str[len-1] == '}') {
+        if (dbJLinkParse(str, len, ftype, &pinfo->jlink))
+            goto fail;
+
+        pinfo->ltype = JSON_LINK;
+        return 0;
+    }
+
     /* Check for other HW link types */
     if (*pstr == '#') {
         int ret;
@@ -2241,12 +2294,9 @@
             /* RF_IO, the string isn't needed at all */
             free(pinfo->target);
             pinfo->target = NULL;
-        } else {
-            /* missing parm when required, or found parm when not expected */
-            free(pinfo->target);
-            pinfo->target = NULL;
-            return S_dbLib_badField;
         }
+        else goto fail;
+
         return 0;
     }
 
@@ -2256,6 +2306,13 @@
         return 0;
     }
 
+    /* Link may be an array constant */
+    if (pstr[0] == '[' && pstr[len-1] == ']' &&
+        (strchr(pstr, ',') || strchr(pstr, '"'))) {
+        pinfo->ltype = CONSTANT;
+        return 0;
+    }
+
     pinfo->ltype = PV_LINK;
     pstr = strchr(pstr, ' '); /* find start of link modifiers (can't be seperated by tabs) */
     if (pstr) {
@@ -2288,27 +2345,28 @@
 
     return 0;
 fail:
-    free(pinfo->target);
+    dbFreeLinkInfo(pinfo);
     return S_dbLib_badField;
 }
 
 long dbCanSetLink(DBLINK *plink, dbLinkInfo *pinfo, devSup *devsup)
 {
-    /* consume allocated string pinfo->target on failure */
+    /* Release pinfo resources on failure */
+    int expected_type = devsup ? devsup->link_type : CONSTANT;
 
-    int link_type = CONSTANT;
-    if(devsup)
-        link_type = devsup->link_type;
-    if(link_type==pinfo->ltype)
+    if (pinfo->ltype == expected_type)
         return 0;
-    switch(pinfo->ltype) {
+
+    switch (pinfo->ltype) {
     case CONSTANT:
+    case JSON_LINK:
     case PV_LINK:
-        if(link_type==CONSTANT || link_type==PV_LINK)
+        if (expected_type == CONSTANT ||
+            expected_type == JSON_LINK ||
+            expected_type == PV_LINK)
             return 0;
     default:
-        free(pinfo->target);
-        pinfo->target = NULL;
+        dbFreeLinkInfo(pinfo);
         return 1;
     }
 }
@@ -2333,10 +2391,23 @@
 }
 
 static
+void dbSetLinkJSON(DBLINK *plink, dbLinkInfo *pinfo)
+{
+    plink->type = JSON_LINK;
+    plink->value.json.string = pinfo->target;
+    plink->value.json.jlink = pinfo->jlink;
+
+    pinfo->target = NULL;
+    pinfo->jlink = NULL;
+}
+
+static
 void dbSetLinkHW(DBLINK *plink, dbLinkInfo *pinfo)
 {
-
     switch(pinfo->ltype) {
+    case JSON_LINK:
+        plink->value.json.string = pinfo->target;
+        break;
     case INST_IO:
         plink->value.instio.string = pinfo->target;
         break;
@@ -2412,36 +2483,39 @@
 
 long dbSetLink(DBLINK *plink, dbLinkInfo *pinfo, devSup *devsup)
 {
-    int ret = 0;
-    int link_type = CONSTANT;
-
-    if(devsup)
-        link_type = devsup->link_type;
-
-    if(link_type==CONSTANT || link_type==PV_LINK) {
-        switch(pinfo->ltype) {
+    int expected_type = devsup ? devsup->link_type : CONSTANT;
+
+    if (expected_type == CONSTANT ||
+        expected_type == JSON_LINK ||
+        expected_type == PV_LINK) {
+        switch (pinfo->ltype) {
         case CONSTANT:
             dbFreeLinkContents(plink);
-            dbSetLinkConst(plink, pinfo); break;
+            dbSetLinkConst(plink, pinfo);
+            break;
         case PV_LINK:
             dbFreeLinkContents(plink);
-            dbSetLinkPV(plink, pinfo); break;
+            dbSetLinkPV(plink, pinfo);
+            break;
+        case JSON_LINK:
+            dbFreeLinkContents(plink);
+            dbSetLinkJSON(plink, pinfo);
+            break;
         default:
             errlogMessage("Warning: dbSetLink: forgot to test with dbCanSetLink() or logic error");
             goto fail; /* can't assign HW link */
         }
-
-    } else if(link_type==pinfo->ltype) {
+    }
+    else if (expected_type == pinfo->ltype) {
         dbFreeLinkContents(plink);
         dbSetLinkHW(plink, pinfo);
-
-    } else
+    }
+    else
         goto fail;
 
-    return ret;
+    return 0;
 fail:
-    free(pinfo->target);
-    pinfo->target = NULL;
+    dbFreeLinkInfo(pinfo);
     return S_dbLib_badField;
 }
 
@@ -2507,7 +2581,7 @@
                 /* links not yet initialized by dbInitRecordLinks() */
                 free(plink->text);
                 plink->text = epicsStrDup(pstring);
-                free(link_info.target);
+                dbFreeLinkInfo(&link_info);
             } else {
                 /* assignment after init (eg. autosave restore) */
                 struct dbCommon *prec = pdbentry->precnode->precord;
@@ -3035,6 +3109,12 @@
     return(rtnval);
 }
 
+linkSup* dbFindLinkSup(dbBase *pdbbase, const char *name) {
+    GPHENTRY *pgph = gphFind(pdbbase->pgpHash,name,&pdbbase->linkList);
+    if (!pgph) return NULL;
+    return (linkSup *) pgph->userPvt;
+}
+
 int  dbGetNLinks(DBENTRY *pdbentry)
 {
     dbRecordType	*precordType = pdbentry->precordType;
@@ -3087,67 +3167,6 @@
     return(-1);
 }
 
-long  dbCvtLinkToConstant(DBENTRY *pdbentry)
-{
-    dbFldDes	*pflddes;
-    DBLINK	*plink;
-
-    dbGetFieldAddress(pdbentry);
-    pflddes = pdbentry->pflddes;
-    if(!pflddes) return(-1);
-    plink = (DBLINK *)pdbentry->pfield;
-    if(!plink) return(-1);
-    switch (pflddes->field_type) {
-    case DBF_INLINK:
-    case DBF_OUTLINK:
-    case DBF_FWDLINK:
-	if(plink->type == CONSTANT) return(0);
-	if(plink->type != PV_LINK) return(S_dbLib_badLink);
-	free((void *)plink->value.pv_link.pvname);
-	plink->value.pv_link.pvname = NULL;
-	plink->type = CONSTANT;
-	if(pflddes->initial) {
-	    plink->value.constantStr =
-		dbCalloc(strlen(pflddes->initial)+1,sizeof(char));
-	    strcpy(plink->value.constantStr,pflddes->initial);
-	} else {
-	    plink->value.constantStr = NULL;
-	}
-	return(0);
-    default:
-	epicsPrintf("dbCvtLinkToConstant called for non link field\n");
-    }
-    return(S_dbLib_badLink);
-}
-
-long  dbCvtLinkToPvlink(DBENTRY *pdbentry)
-{
-    dbFldDes	*pflddes;
-    DBLINK	*plink;
-
-    dbGetFieldAddress(pdbentry);
-    pflddes = pdbentry->pflddes;
-    if(!pflddes) return(-1);
-    if(!pdbentry->precnode || !pdbentry->precnode->precord) return(-1);
-    plink = (DBLINK *)pdbentry->pfield;
-    if(!plink) return(-1);
-    switch (pflddes->field_type) {
-    case DBF_INLINK:
-    case DBF_OUTLINK:
-    case DBF_FWDLINK:
-	if(plink->type == PV_LINK) return(0);
-	if(plink->type != CONSTANT) return(S_dbLib_badLink);
-	free(plink->value.constantStr);
-	plink->type = PV_LINK;
-	plink->value.pv_link.pvlMask = 0;
-	plink->value.pv_link.pvname = 0;
-	return(0);
-    default:
-	epicsPrintf("dbCvtLinkToPvlink called for non link field\n");
-    }
-    return(S_dbLib_badLink);
-}
-
 void  dbDumpPath(DBBASE *pdbbase)
 {
     ELLLIST	*ppathList;
@@ -3383,6 +3402,15 @@
     dbWriteDriverFP(pdbbase,stdout);
 }
 
+void  dbDumpLink(DBBASE *pdbbase)
+{
+    if(!pdbbase) {
+	fprintf(stderr,"pdbbase not specified\n");
+	return;
+    }
+    dbWriteLinkFP(pdbbase,stdout);
+}
+
 void  dbDumpRegistrar(DBBASE *pdbbase)
 {
     if(!pdbbase) {
 
=== modified file 'src/ioc/dbStatic/dbStaticLib.h'
--- src/ioc/dbStatic/dbStaticLib.h	2016-10-06 11:31:40 +0000
+++ src/ioc/dbStatic/dbStaticLib.h	2017-03-03 18:23:23 +0000
@@ -102,6 +102,7 @@
 epicsShareFunc long dbWriteDriver(DBBASE *pdbbase,
     const char *filename);
 epicsShareFunc long dbWriteDriverFP(DBBASE *pdbbase, FILE *fp);
+epicsShareFunc long dbWriteLinkFP(DBBASE *pdbbase, FILE *fp);
 epicsShareFunc long dbWriteRegistrarFP(DBBASE *pdbbase, FILE *fp);
 epicsShareFunc long dbWriteFunctionFP(DBBASE *pdbbase, FILE *fp);
 epicsShareFunc long dbWriteVariableFP(DBBASE *pdbbase, FILE *fp);
@@ -209,11 +210,12 @@
     const char *name);
 epicsShareFunc char * dbGetRelatedField(DBENTRY *pdbentry);
 
+epicsShareFunc linkSup * dbFindLinkSup(dbBase *pdbbase,
+    const char *name);
+
 epicsShareFunc int  dbGetNLinks(DBENTRY *pdbentry);
 epicsShareFunc long dbGetLinkField(DBENTRY *pdbentry, int index);
 epicsShareFunc int  dbGetLinkType(DBENTRY *pdbentry);
-epicsShareFunc long dbCvtLinkToConstant(DBENTRY *pdbentry);
-epicsShareFunc long dbCvtLinkToPvlink(DBENTRY *pdbentry);
 
 /* Dump routines */
 epicsShareFunc void dbDumpPath(DBBASE *pdbbase);
@@ -228,6 +230,7 @@
 epicsShareFunc void dbDumpDevice(DBBASE *pdbbase,
     const char *recordTypeName);
 epicsShareFunc void dbDumpDriver(DBBASE *pdbbase);
+epicsShareFunc void dbDumpLink(DBBASE *pdbbase);
 epicsShareFunc void dbDumpRegistrar(DBBASE *pdbbase);
 epicsShareFunc void dbDumpFunction(DBBASE *pdbbase);
 epicsShareFunc void dbDumpVariable(DBBASE *pdbbase);
 
=== modified file 'src/ioc/dbStatic/dbStaticPvt.h'
--- src/ioc/dbStatic/dbStaticPvt.h	2017-02-01 17:57:04 +0000
+++ src/ioc/dbStatic/dbStaticPvt.h	2017-03-03 18:23:23 +0000
@@ -36,19 +36,25 @@
 char *dbGetStringNum(DBENTRY *pdbentry);
 long dbPutStringNum(DBENTRY *pdbentry,const char *pstring);
 
+struct jlink;
+
 typedef struct dbLinkInfo {
     short ltype;
 
     /* full link string for CONSTANT and PV_LINK,
-     * parm string for HW links*/
+     * parm string for HW links, JSON for JSON_LINK
+     */
     char *target;
 
     /* for PV_LINK */
     short modifiers;
 
-    /* HW links */
+    /* for HW links */
     char hwid[6]; /* one extra element for a nil */
     int  hwnums[5];
+
+    /* for JSON_LINK */
+    struct jlink *jlink;
 } dbLinkInfo;
 
 long dbInitRecordLinks(dbRecordType *rtyp, struct dbCommon *prec);
@@ -68,6 +74,8 @@
  * Unconditionally takes ownership of pinfo->target
  */
 long dbSetLink(DBLINK *plink, dbLinkInfo *pinfo, devSup *dset);
+/* Free dbLinkInfo storage */
+epicsShareFunc void dbFreeLinkInfo(dbLinkInfo *pinfo);
 
 /* The following is for path */
 typedef struct dbPathNode {
 
=== modified file 'src/ioc/dbStatic/dbYacc.y'
--- src/ioc/dbStatic/dbYacc.y	2017-02-01 17:57:04 +0000
+++ src/ioc/dbStatic/dbYacc.y	2017-03-03 18:23:23 +0000
@@ -17,17 +17,22 @@
 
 %start database
 
+%union
+{
+    char	*Str;
+}
+
 %token tokenINCLUDE tokenPATH tokenADDPATH
 %token tokenALIAS tokenMENU tokenCHOICE tokenRECORDTYPE
 %token tokenFIELD tokenINFO tokenREGISTRAR
-%token tokenDEVICE tokenDRIVER tokenBREAKTABLE
+%token tokenDEVICE tokenDRIVER tokenLINK tokenBREAKTABLE
 %token tokenRECORD tokenGRECORD tokenVARIABLE tokenFUNCTION
 %token <Str> tokenSTRING tokenCDEFS
 
-%union
-{
-    char	*Str;
-}
+%token jsonNULL jsonTRUE jsonFALSE
+%token <Str> jsonNUMBER jsonSTRING jsonBARE
+%type <Str> json_value json_object json_array
+%type <Str> json_members json_pair json_elements json_string
 
 %%
 
@@ -46,6 +51,7 @@
 	|	tokenRECORDTYPE recordtype_head recordtype_body
 	|	device
 	|	driver
+	|	link
 	|	registrar
 	|	function
 	|	variable
@@ -162,6 +168,13 @@
 	dbDriver($3); dbmfFree($3);
 };
 
+link: tokenLINK '(' tokenSTRING ',' tokenSTRING ')'
+{
+	if(dbStaticDebug>2) printf("link %s %s\n",$3,$5);
+	dbLinkType($3,$5);
+	dbmfFree($3); dbmfFree($5);
+};
+
 registrar: tokenREGISTRAR '(' tokenSTRING ')'
 {
 	if(dbStaticDebug>2) printf("registrar %s\n",$3);
@@ -239,15 +252,17 @@
 record_field_list:	record_field_list record_field
 	|	record_field;
 
-record_field: tokenFIELD '(' tokenSTRING ',' tokenSTRING ')'
+record_field: tokenFIELD '(' tokenSTRING ','
+	{ BEGIN JSON; } json_value { BEGIN INITIAL; } ')'
 {
-	if(dbStaticDebug>2) printf("record_field %s %s\n",$3,$5);
-	dbRecordField($3,$5); dbmfFree($3); dbmfFree($5);
+	if(dbStaticDebug>2) printf("record_field %s %s\n",$3,$6);
+	dbRecordField($3,$6); dbmfFree($3); dbmfFree($6);
 }
-	| tokenINFO '(' tokenSTRING ',' tokenSTRING ')'
+	| tokenINFO '(' tokenSTRING ','
+	{ BEGIN JSON; } json_value { BEGIN INITIAL; } ')'
 {
-	if(dbStaticDebug>2) printf("record_info %s %s\n",$3,$5);
-	dbRecordInfo($3,$5); dbmfFree($3); dbmfFree($5);
+	if(dbStaticDebug>2) printf("record_info %s %s\n",$3,$6);
+	dbRecordInfo($3,$6); dbmfFree($3); dbmfFree($6);
 }
 	| tokenALIAS '(' tokenSTRING ')'
 {
@@ -262,6 +277,69 @@
 	dbAlias($3,$5); dbmfFree($3); dbmfFree($5);
 };
 
+json_object: '{' '}'
+{
+	$$ = dbmfStrdup("{}");
+	if (dbStaticDebug>2) printf("json %s\n", $$);
+}
+	| '{' json_members '}'
+{
+	$$ = dbmfStrcat3("{", $2, "}");
+	dbmfFree($2);
+	if (dbStaticDebug>2) printf("json %s\n", $$);
+};
+
+json_members: json_pair
+	| json_pair ',' json_members
+{
+	$$ = dbmfStrcat3($1, ",", $3);
+	dbmfFree($1); dbmfFree($3);
+	if (dbStaticDebug>2) printf("json %s\n", $$);
+};
+
+json_pair: json_string ':' json_value
+{
+	$$ = dbmfStrcat3($1, ":", $3);
+	dbmfFree($1); dbmfFree($3);
+	if (dbStaticDebug>2) printf("json %s\n", $$);
+};
+
+json_string: jsonSTRING
+	| jsonBARE
+{
+	$$ = dbmfStrcat3("\"", $1, "\"");
+	dbmfFree($1);
+	if (dbStaticDebug>2) printf("json %s\n", $$);
+};
+
+json_array: '[' ']'
+{
+	$$ = dbmfStrdup("[]");
+	if (dbStaticDebug>2) printf("json %s\n", $$);
+}
+	| '[' json_elements ']'
+{
+	$$ = dbmfStrcat3("[", $2, "]");
+	dbmfFree($2);
+	if (dbStaticDebug>2) printf("json %s\n", $$);
+};
+
+json_elements: json_value
+	| json_value ',' json_elements
+{
+	$$ = dbmfStrcat3($1, ",", $3);
+	dbmfFree($1); dbmfFree($3);
+	if (dbStaticDebug>2) printf("json %s\n", $$);
+};
+
+json_value: jsonNULL	{ $$ = dbmfStrdup("null"); }
+	| jsonTRUE	{ $$ = dbmfStrdup("true"); }
+	| jsonFALSE	{ $$ = dbmfStrdup("false"); }
+	| jsonNUMBER
+	| json_string
+	| json_array
+	| json_object ;
+
 
 %%
 
 
 
=== modified file 'src/ioc/dbStatic/link.h'
--- src/ioc/dbStatic/link.h	2017-02-01 17:57:04 +0000
+++ src/ioc/dbStatic/link.h	2017-03-03 18:23:23 +0000
@@ -32,7 +32,7 @@
 #define GPIB_IO		5
 #define BITBUS_IO	6
 #define MACRO_LINK	7
-
+#define JSON_LINK       8
 #define PN_LINK		9
 #define DB_LINK		10
 #define CA_LINK		11
@@ -40,7 +40,7 @@
 #define	BBGPIB_IO	13		/* bitbus -> gpib */
 #define RF_IO		14
 #define VXI_IO		15
-#define LINK_NTYPES 15
+#define LINK_NTYPES 16
 typedef struct maplinkType {
     char *strvalue;
     int  value;
@@ -86,6 +86,12 @@
     short	lastGetdbrType;	/* last dbrType for DB or CA get */
 };
 
+struct jlink;
+struct json_link {
+    char *string;
+    struct jlink *jlink;
+};
+
 /* structure of a VME io channel */
 struct vmeio {
     short	card;
@@ -166,6 +172,7 @@
 union value {
     char		*constantStr;	/*constant string*/
     struct macro_link	macro_link;	/* link containing macro substitution*/
+    struct json_link    json;           /* JSON-encoded link */
     struct pv_link	pv_link;	/* link to process variable*/
     struct vmeio	vmeio;		/* vme io point */
     struct camacio	camacio;	/* camac io point */
 
=== modified file 'src/ioc/dbtemplate/dbLoadTemplate_lex.l'
--- src/ioc/dbtemplate/dbLoadTemplate_lex.l	2010-08-20 22:59:38 +0000
+++ src/ioc/dbtemplate/dbLoadTemplate_lex.l	2017-03-03 18:23:23 +0000
@@ -24,13 +24,13 @@
 
 {doublequote}({dstringchar}|{escape})*{doublequote} |
 {singlequote}({sstringchar}|{escape})*{singlequote} {
-    yylval.Str = dbmfStrdup(yytext+1);
+    yylval.Str = dbmfStrdup((char *) yytext+1);
     yylval.Str[strlen(yylval.Str)-1] = '\0';
     return(QUOTE);
 }
 
 {bareword}+ {
-    yylval.Str = dbmfStrdup(yytext);
+    yylval.Str = dbmfStrdup((char *) yytext);
     return(WORD);
 }
 
 
=== modified file 'src/ioc/misc/iocInit.c'
--- src/ioc/misc/iocInit.c	2017-02-01 17:57:04 +0000
+++ src/ioc/misc/iocInit.c	2017-03-03 18:23:23 +0000
@@ -67,6 +67,7 @@
 #include "recSup.h"
 #include "registryDeviceSupport.h"
 #include "registryDriverSupport.h"
+#include "registryJLinks.h"
 #include "registryRecordType.h"
 #include "rsrv.h"
 
@@ -655,18 +656,14 @@
             pdbRecordType->papFldDes[pdbRecordType->link_ind[j]];
         DBLINK *plink = (DBLINK *)((char *)precord + pdbFldDes->offset);
 
-        if (plink->type == CA_LINK) {
+        if (plink->type == CA_LINK ||
+            plink->type == JSON_LINK ||
+            (plink->type == DB_LINK && iocBuildMode == buildIsolated)) {
             if (!locked) {
                 dbScanLock(precord);
                 locked = 1;
             }
-            dbCaRemoveLink(NULL, plink);
-
-        } else if (iocBuildMode==buildIsolated && plink->type == DB_LINK) {
-            /* free link, but don't split lockset like dbDbRemoveLink() */
-            free(plink->value.pv_link.pvt);
-            plink->type = PV_LINK;
-            plink->lset = NULL;
+            dbRemoveLink(NULL, plink);
         }
     }
 
 
=== modified file 'src/ioc/registry/Makefile'
--- src/ioc/registry/Makefile	2012-08-10 16:40:50 +0000
+++ src/ioc/registry/Makefile	2017-03-03 18:23:23 +0000
@@ -14,6 +14,7 @@
 INC += registryRecordType.h
 INC += registryDeviceSupport.h
 INC += registryDriverSupport.h
+INC += registryJLinks.h
 INC += registryFunction.h
 INC += registryCommon.h
 INC += registryIocRegister.h
@@ -21,6 +22,7 @@
 dbCore_SRCS += registryRecordType.c
 dbCore_SRCS += registryDeviceSupport.c
 dbCore_SRCS += registryDriverSupport.c
+dbCore_SRCS += registryJLinks.c
 dbCore_SRCS += registryFunction.c
 dbCore_SRCS += registryCommon.c
 dbCore_SRCS += registryIocRegister.c
 
=== modified file 'src/ioc/registry/registryCommon.c'
--- src/ioc/registry/registryCommon.c	2014-10-06 05:57:02 +0000
+++ src/ioc/registry/registryCommon.c	2017-03-03 18:23:23 +0000
@@ -19,6 +19,7 @@
 #include "registryCommon.h"
 #include "registryDeviceSupport.h"
 #include "registryDriverSupport.h"
+#include "registryJLinks.h"
 
 
 void registerRecordTypes(DBBASE *pbase, int nRecordTypes,
@@ -76,3 +77,15 @@
     }
 }
 
+void registerJLinks(DBBASE *pbase, int nLinks, jlif * const *jlifsl)
+{
+    int i;
+    for (i = 0; i < nLinks; i++) {
+        if (!registryJLinkAdd(pbase, jlifsl[i])) {
+            errlogPrintf("registryJLinkAdd failed %s\n",
+                jlifsl[i]->name);
+            continue;
+        }
+    }
+}
+
 
=== modified file 'src/ioc/registry/registryCommon.h'
--- src/ioc/registry/registryCommon.h	2014-10-06 05:57:02 +0000
+++ src/ioc/registry/registryCommon.h	2017-03-03 18:23:23 +0000
@@ -12,6 +12,7 @@
 
 #include "dbStaticLib.h"
 #include "devSup.h"
+#include "dbJLink.h"
 #include "registryRecordType.h"
 #include "shareLib.h"
 
@@ -28,6 +29,8 @@
 epicsShareFunc void registerDrivers(
     DBBASE *pbase, int nDrivers,
     const char * const *driverSupportNames, struct drvet * const *drvsl);
+epicsShareFunc void registerJLinks(
+    DBBASE *pbase, int nDrivers, jlif * const *jlifsl);
 
 #ifdef __cplusplus
 }
 
=== added file 'src/ioc/registry/registryJLinks.c'
--- src/ioc/registry/registryJLinks.c	1970-01-01 00:00:00 +0000
+++ src/ioc/registry/registryJLinks.c	2017-03-03 18:23:23 +0000
@@ -0,0 +1,23 @@
+/*************************************************************************\
+* Copyright (c) 2016 UChicago Argonne LLC, as Operator of Argonne
+*     National Laboratory.
+* EPICS BASE is distributed subject to a Software License Agreement found
+* in file LICENSE that is included with this distribution.
+\*************************************************************************/
+/* registryJLinks.c */
+
+#include "registry.h"
+#define epicsExportSharedSymbols
+#include "dbBase.h"
+#include "dbStaticLib.h"
+#include "registryJLinks.h"
+#include "dbJLink.h"
+
+epicsShareFunc int registryJLinkAdd(DBBASE *pbase, struct jlif *pjlif)
+{
+    linkSup *plinkSup = dbFindLinkSup(pbase, pjlif->name);
+
+    if (plinkSup)
+        plinkSup->pjlif = pjlif;
+    return !!plinkSup;
+}
 
=== added file 'src/ioc/registry/registryJLinks.h'
--- src/ioc/registry/registryJLinks.h	1970-01-01 00:00:00 +0000
+++ src/ioc/registry/registryJLinks.h	2017-03-03 18:23:23 +0000
@@ -0,0 +1,28 @@
+/*************************************************************************\
+* Copyright (c) 2007 UChicago Argonne LLC, as Operator of Argonne
+*     National Laboratory.
+* Copyright (c) 2002 The Regents of the University of California, as
+*     Operator of Los Alamos National Laboratory.
+* EPICS BASE is distributed subject to a Software License Agreement found
+* in file LICENSE that is included with this distribution. 
+\*************************************************************************/
+
+#ifndef INC_registryJLinks_H
+#define INC_registryJLinks_H
+
+#include "dbBase.h"
+#include "dbJLink.h"
+#include "shareLib.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+epicsShareFunc int registryJLinkAdd(DBBASE *pbase, jlif *pjlif);
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif /* INC_registryDriverSupport_H */
 
=== modified file 'src/libCom/dbmf/dbmf.c'
--- src/libCom/dbmf/dbmf.c	2017-02-01 17:57:04 +0000
+++ src/libCom/dbmf/dbmf.c	2017-03-03 18:23:23 +0000
@@ -68,7 +68,7 @@
 static dbmfPrivate *pdbmfPvt = NULL;
 int dbmfDebug=0;
 
 
-int epicsShareAPI dbmfInit(size_t size, int chunkItems)
+int dbmfInit(size_t size, int chunkItems)
 {
     if(pdbmfPvt) {
         printf("dbmfInit: Already initialized\n");
@@ -94,7 +94,7 @@
 }
 
 
 
-void* epicsShareAPI dbmfMalloc(size_t size)
+void* dbmfMalloc(size_t size)
 {
     void      **pnextFree;
     void      **pfreeList;
@@ -156,15 +156,23 @@
     return((void *)pmem);
 }
 
-char * epicsShareAPI dbmfStrdup(unsigned char *str)
-{
-	size_t len = strlen((char *) str);
-	char *buf = dbmfMalloc(len + 1);
-	strcpy(buf, (char *) str);
-	return buf;
-}
-
-void epicsShareAPI dbmfFree(void* mem)
+char * dbmfStrdup(const char *str)
+{
+    size_t len = strlen(str);
+    char *buf = dbmfMalloc(len + 1);    /* FIXME Can return NULL */
+
+    return strcpy(buf, str);
+}
+
+char * dbmfStrndup(const char *str, size_t len)
+{
+    char *buf = dbmfMalloc(len + 1);    /* FIXME Can return NULL */
+
+    buf[len] = '\0';
+    return strncpy(buf, str, len);
+}
+
+void dbmfFree(void* mem)
 {
     char       *pmem = (char *)mem;
     chunkNode  *pchunkNode;
@@ -194,7 +202,7 @@
     epicsMutexUnlock(pdbmfPvt->lock);
 }
 
 
-int epicsShareAPI dbmfShow(int level)
+int dbmfShow(int level)
 {
     if(pdbmfPvt==NULL) {
 	printf("Never initialized\n");
@@ -230,7 +238,7 @@
     return(0);
 }
 
-void  epicsShareAPI dbmfFreeChunks(void)
+void dbmfFreeChunks(void)
 {
     chunkNode  *pchunkNode;
     chunkNode  *pnext;;
@@ -259,21 +267,32 @@
 
 #else /* DBMF_FREELIST_DEBUG */
 
-int epicsShareAPI dbmfInit(size_t size, int chunkItems)
+int dbmfInit(size_t size, int chunkItems)
 { return 0; }
 
-void* epicsShareAPI dbmfMalloc(size_t size)
+void* dbmfMalloc(size_t size)
 { return malloc(size); }
 
-char * epicsShareAPI dbmfStrdup(unsigned char *str)
+char * dbmfStrdup(const char *str)
 { return strdup((char*)str); }
 
-void epicsShareAPI dbmfFree(void* mem)
+void dbmfFree(void* mem)
 { free(mem); }
 
-int epicsShareAPI dbmfShow(int level)
+int dbmfShow(int level)
 { return 0; }
 
-void  epicsShareAPI dbmfFreeChunks(void) {}
+void dbmfFreeChunks(void) {}
 
 #endif /* DBMF_FREELIST_DEBUG */
+
+char * dbmfStrcat3(const char *lhs, const char *mid, const char *rhs)
+{
+	size_t len = strlen(lhs) + strlen(mid) + strlen(rhs) + 1;
+	char *buf = dbmfMalloc(len);
+	strcpy(buf, lhs);
+	strcat(buf, mid);
+	strcat(buf, rhs);
+	return buf;
+}
+
 
=== modified file 'src/libCom/dbmf/dbmf.h'
--- src/libCom/dbmf/dbmf.h	2012-06-28 14:55:44 +0000
+++ src/libCom/dbmf/dbmf.h	2017-03-03 18:23:23 +0000
@@ -23,12 +23,15 @@
 extern "C" {
 #endif
 
-epicsShareFunc int epicsShareAPI dbmfInit(size_t size, int chunkItems);
-epicsShareFunc void * epicsShareAPI dbmfMalloc(size_t bytes);
-epicsShareFunc char * epicsShareAPI dbmfStrdup(unsigned char *str);
-epicsShareFunc void epicsShareAPI dbmfFree(void* bytes);
-epicsShareFunc void epicsShareAPI dbmfFreeChunks(void);
-epicsShareFunc int epicsShareAPI dbmfShow(int level);
+epicsShareFunc int dbmfInit(size_t size, int chunkItems);
+epicsShareFunc void * dbmfMalloc(size_t bytes);
+epicsShareFunc char * dbmfStrdup(const char *str);
+epicsShareFunc char * dbmfStrndup(const char *str, size_t len);
+epicsShareFunc char * dbmfStrcat3(const char *lhs, const char *mid,
+    const char *rhs);
+epicsShareFunc void dbmfFree(void *bytes);
+epicsShareFunc void dbmfFreeChunks(void);
+epicsShareFunc int dbmfShow(int level);
 
 /* Rules:
  * 1) Size is always made a multiple of 8.
 
=== modified file 'src/libCom/error/errMdef.h'
--- src/libCom/error/errMdef.h	2017-02-01 17:57:04 +0000
+++ src/libCom/error/errMdef.h	2017-03-03 18:23:23 +0000
@@ -52,6 +52,7 @@
 #define M_time          (529 <<16) /*epicsTime*/
 
 epicsShareFunc void epicsShareAPI errSymLookup(long status, char *pBuf, unsigned bufLength);
+epicsShareFunc const char* errSymMsg(long status);
 epicsShareFunc void epicsShareAPI errSymTest(unsigned short modnum, unsigned short begErrNum, unsigned short endErrNum);
 epicsShareFunc void epicsShareAPI errSymTestPrint(long errNum);
 epicsShareFunc int epicsShareAPI errSymBld(void);
 
=== modified file 'src/libCom/error/errSymLib.c'
--- src/libCom/error/errSymLib.c	2016-05-22 03:43:09 +0000
+++ src/libCom/error/errSymLib.c	2017-03-03 18:23:23 +0000
@@ -192,11 +192,9 @@
         assert ( nChar < bufLength );
     }
 }
-
 
-/****************************************************************
- * errSymLookup
- ***************************************************************/
-void epicsShareAPI errSymLookup (long status, char * pBuf, unsigned bufLength)
+
+static
+const char* errSymLookupInternal(long status)
 {
     unsigned modNum;
     unsigned hashInd;
@@ -211,9 +209,7 @@
     if ( modNum <= 500 ) {
         const char * pStr = strerror ((int) status);
         if ( pStr ) {
-            strncpy(pBuf, pStr,bufLength);
-            pBuf[bufLength-1] = '\0';
-            return;
+            return pStr;
         }
     }
     else {
@@ -222,17 +218,35 @@
         pNextNode = *phashnode;
         while(pNextNode) {
             if(pNextNode->errNum==status){
-                strncpy(pBuf, pNextNode->message, bufLength);
-                pBuf[bufLength-1] = '\0';
-                return;
+                return pNextNode->message;
             }
             phashnode = &pNextNode->hashnode;
             pNextNode = *phashnode;
         }
     }
+    return NULL;
+}
+
+const char* errSymMsg(long status)
+{
+    const char* msg = errSymLookupInternal(status);
+    return msg ? msg : "<Unknown code>";
+}
+
+/****************************************************************
+ * errSymLookup
+ ***************************************************************/
+void epicsShareAPI errSymLookup (long status, char * pBuf, unsigned bufLength)
+{
+    const char* msg = errSymLookupInternal(status);
+    if(msg) {
+        strncpy(pBuf, msg, bufLength);
+        pBuf[bufLength-1] = '\0';
+        return;
+    }
     errRawCopy(status, pBuf, bufLength);
 }
-
 
+
 /****************************************************************
  * errSymDump
  ***************************************************************/
 
=== modified file 'src/libCom/error/makeStatTbl.pl'
--- src/libCom/error/makeStatTbl.pl	2009-07-09 20:11:02 +0000
+++ src/libCom/error/makeStatTbl.pl	2017-03-03 18:23:23 +0000
@@ -86,7 +86,7 @@
 {
 	print OUT "$line\n";
 	#                    define       S_symbol          /* comment */
-	if ($line =~ m'[ \t#]define[ \t]*(S_[A-Za-z0-9_]+).*\/\*(.+)\*\/')
+	if ($line =~ m'[ \t#]define[ \t]*(S_[A-Za-z0-9_]+).*\/\* ?(.+?) ?\*\/')
 	{
 		$symbol[$count] = $1;
 		$comment[$count]= $2;
 
=== modified file 'src/libCom/misc/dbDefs.h'
--- src/libCom/misc/dbDefs.h	2016-05-22 03:43:09 +0000
+++ src/libCom/misc/dbDefs.h	2017-03-03 18:23:23 +0000
@@ -59,6 +59,10 @@
 #define PVNAME_STRINGSZ 61
 #define PVNAME_SZ (PVNAME_STRINGSZ - 1)
 
+/* Buffer size for the string representation of a DBF_*LINK field */
+#define PVLINK_STRINGSZ 1024
+
+/* dbAccess enums/menus can have up to this many choices */
 #define DB_MAX_CHOICES 30
 
 #endif /* INC_dbDefs_H */
 
=== modified file 'src/libCom/misc/epicsString.c'
--- src/libCom/misc/epicsString.c	2016-12-07 22:36:58 +0000
+++ src/libCom/misc/epicsString.c	2017-03-03 18:23:23 +0000
@@ -222,6 +222,15 @@
     return 0;
 }
 
+char * epicsStrnDup(const char *s, size_t len)
+{
+    char *buf = mallocMustSucceed(len + 1, "epicsStrnDup");
+
+    strncpy(buf, s, len);
+    buf[len] = '\0';
+    return buf;
+}
+
 char * epicsStrDup(const char *s)
 {
     return strcpy(mallocMustSucceed(strlen(s)+1, "epicsStrDup"), s);
 
=== modified file 'src/libCom/misc/epicsString.h'
--- src/libCom/misc/epicsString.h	2014-01-11 15:58:39 +0000
+++ src/libCom/misc/epicsString.h	2017-03-03 18:23:23 +0000
@@ -31,6 +31,7 @@
 epicsShareFunc int epicsStrCaseCmp(const char *s1, const char *s2);
 epicsShareFunc int epicsStrnCaseCmp(const char *s1, const char *s2, size_t len);
 epicsShareFunc char * epicsStrDup(const char *s);
+epicsShareFunc char * epicsStrnDup(const char *s, size_t len);
 epicsShareFunc int epicsStrPrintEscaped(FILE *fp, const char *s, size_t n);
 #define epicsStrSnPrintEscaped epicsStrnEscapedFromRaw
 epicsShareFunc size_t epicsStrnLen(const char *s, size_t maxlen);
 
=== modified file 'src/libCom/yacc/antelope.c'
--- src/libCom/yacc/antelope.c	2012-05-03 17:19:34 +0000
+++ src/libCom/yacc/antelope.c	2017-03-03 18:23:23 +0000
@@ -115,7 +115,11 @@
     int i;
     char *s;
 
-    if (argc > 0) myname = argv[0];
+    if (argc > 0) {
+        myname = strrchr(argv[0], '/');
+	if (myname) myname++;
+	else myname = argv[0];
+    }
     for (i = 1; i < argc; ++i)
     {
 	s = argv[i];
 
=== modified file 'src/libCom/yacc/error.c'
--- src/libCom/yacc/error.c	2013-11-20 23:28:41 +0000
+++ src/libCom/yacc/error.c	2017-03-03 18:23:23 +0000
@@ -14,7 +14,7 @@
 void
 fatal(char *msg)
 {
-    fprintf(stderr, "%s: f - %s\n", myname, msg);
+    fprintf(stderr, "%s: fatal - %s\n", myname, msg);
     done(2);
 }
 
@@ -22,7 +22,7 @@
 void
 no_space(void)
 {
-    fprintf(stderr, "%s: f - out of space\n", myname);
+    fprintf(stderr, "%s: fatal - out of space\n", myname);
     done(2);
 }
 
@@ -30,7 +30,7 @@
 void
 open_error(char *filename)
 {
-    fprintf(stderr, "%s: f - cannot open \"%s\"\n", myname, filename);
+    fprintf(stderr, "%s: fatal - cannot open \"%s\"\n", myname, filename);
     done(2);
 }
 
@@ -38,7 +38,7 @@
 void
 unexpected_EOF(void)
 {
-    fprintf(stderr, "%s: e - line %d of \"%s\", unexpected end-of-file\n",
+    fprintf(stderr, "%s: error - line %d of \"%s\", unexpected end-of-file\n",
 	    myname, lineno, input_file_name);
     done(1);
 }
@@ -74,7 +74,7 @@
 void
 syntax_error(int st_lineno, char *st_line, char *st_cptr)
 {
-    fprintf(stderr, "%s: e - line %d of \"%s\", syntax error\n",
+    fprintf(stderr, "%s: error - line %d of \"%s\", syntax error\n",
 	    myname, st_lineno, input_file_name);
     print_pos(st_line, st_cptr);
     done(1);
@@ -84,7 +84,7 @@
 void
 unterminated_comment(int c_lineno, char *c_line, char *c_cptr)
 {
-    fprintf(stderr, "%s: e - line %d of \"%s\", unmatched /*\n",
+    fprintf(stderr, "%s: error - line %d of \"%s\", unmatched /*\n",
 	    myname, c_lineno, input_file_name);
     print_pos(c_line, c_cptr);
     done(1);
@@ -94,7 +94,7 @@
 void
 unterminated_string(int s_lineno, char *s_line, char *s_cptr)
 {
-    fprintf(stderr, "%s: e - line %d of \"%s\", unterminated string\n",
+    fprintf(stderr, "%s: error - line %d of \"%s\", unterminated string\n",
 	    myname, s_lineno, input_file_name);
     print_pos(s_line, s_cptr);
     done(1);
@@ -104,7 +104,7 @@
 void
 unterminated_text(int t_lineno, char *t_line, char *t_cptr)
 {
-    fprintf(stderr, "%s: e - line %d of \"%s\", unmatched %%{\n",
+    fprintf(stderr, "%s: error - line %d of \"%s\", unmatched %%{\n",
 	    myname, t_lineno, input_file_name);
     print_pos(t_line, t_cptr);
     done(1);
@@ -114,7 +114,7 @@
 void
 unterminated_union(int u_lineno, char *u_line, char *u_cptr)
 {
-    fprintf(stderr, "%s: e - line %d of \"%s\", unterminated %%union \
+    fprintf(stderr, "%s: error - line %d of \"%s\", unterminated %%union \
 declaration\n", myname, u_lineno, input_file_name);
     print_pos(u_line, u_cptr);
     done(1);
@@ -124,7 +124,7 @@
 void
 over_unionized(char *u_cptr)
 {
-    fprintf(stderr, "%s: e - line %d of \"%s\", too many %%union \
+    fprintf(stderr, "%s: error - line %d of \"%s\", too many %%union \
 declarations\n", myname, lineno, input_file_name);
     print_pos(line, u_cptr);
     done(1);
@@ -134,7 +134,7 @@
 void
 illegal_tag(int t_lineno, char *t_line, char *t_cptr)
 {