diff --git a/src/dev/devAiTestAsyn.c b/src/dev/devAiTestAsyn.c
index 5bfaf6cf3..1b244a25d 100644
--- a/src/dev/devAiTestAsyn.c
+++ b/src/dev/devAiTestAsyn.c
@@ -48,6 +48,7 @@
 #include	<recSup.h>
 #include	<devSup.h>
 #include	<link.h>
+#include	<dbCommon.h>
 #include	<aiRecord.h>
 
 /* Create the dset for devAiTestAsyn */
@@ -72,23 +73,21 @@ struct {
 
 /* control block for callback*/
 struct callback {
-	void (*callback)();
-	int priority;
-	struct dbCommon *prec;
+	CALLBACK	callback;
+	struct dbCommon *precord;
 	WDOG_ID wd_id;
 };
 
-void callbackRequest();
 
 static void myCallback(pcallback)
     struct callback *pcallback;
 {
-    struct aiRecord *pai=(struct aiRecord *)(pcallback->prec);
-    struct rset     *prset=(struct rset *)(pai->rset);
+    struct dbCommon *precord=pcallback->precord;
+    struct rset     *prset=(struct rset *)(precord->rset);
 
-    dbScanLock((struct dbCommon *)pai);
-    (*prset->process)(pai);
-    dbScanUnlock((struct dbCommon *)pai);
+    dbScanLock(precord);
+    (*prset->process)(precord);
+    dbScanUnlock(precord);
 }
     
     
@@ -103,10 +102,9 @@ static long init_record(pai)
     switch (pai->inp.type) {
     case (CONSTANT) :
 	pcallback = (struct callback *)(calloc(1,sizeof(struct callback)));
-	pai->dpvt = (caddr_t)pcallback;
-	pcallback->callback = myCallback;
-	pcallback->priority = priorityLow;
-	pcallback->prec = (struct dbCommon *)pai;
+	pai->dpvt = (void *)pcallback;
+	callbackSetCallback(myCallback,pcallback);
+	pcallback->precord = (struct dbCommon *)pai;
 	pcallback->wd_id = wdCreate();
 	pai->val = pai->inp.value.value;
 	pai->udf = FALSE;
@@ -137,6 +135,7 @@ static long read_ai(pai)
 	} else {
 		wait_time = (int)(pai->disv * vxTicksPerSecond);
 		if(wait_time<=0) return(0);
+		callbackSetPriority(pai->prio,pcallback);
 		printf("%s Starting asynchronous processing\n",pai->name);
 		wdStart(pcallback->wd_id,wait_time,callbackRequest,(int)pcallback);
 		return(1);
diff --git a/src/dev/devAoTestAsyn.c b/src/dev/devAoTestAsyn.c
index 33e4ef75c..d5b5440e0 100644
--- a/src/dev/devAoTestAsyn.c
+++ b/src/dev/devAoTestAsyn.c
@@ -50,6 +50,7 @@
 #include	<recSup.h>
 #include	<devSup.h>
 #include	<link.h>
+#include	<dbCommon.h>
 #include	<aoRecord.h>
 
 /* Create the dset for devAoTestAsyn */
@@ -74,22 +75,20 @@ struct {
 
 /* control block for callback*/
 struct callback {
-	void (*callback)();
-	int priority;
-	struct dbCommon *prec;
+	CALLBACK        callback;
+	struct dbCommon *precord;
 	WDOG_ID wd_id;
 };
-void callbackRequest();
 
 static void myCallback(pcallback)
     struct callback *pcallback;
 {
-    struct aoRecord *pao=(struct aoRecord *)(pcallback->prec);
-    struct rset     *prset=(struct rset *)(pao->rset);
+    struct dbCommon *precord=pcallback->precord;
+    struct rset     *prset=(struct rset *)(precord->rset);
 
-    dbScanLock((struct dbCommon *)pao);
-    (*prset->process)(pao);
-    dbScanUnlock((struct dbCommon *)pao);
+    dbScanLock(precord);
+    (*prset->process)(precord);
+    dbScanUnlock(precord);
 }
     
     
@@ -104,10 +103,9 @@ static long init_record(pao)
     switch (pao->out.type) {
     case (CONSTANT) :
 	pcallback = (struct callback *)(calloc(1,sizeof(struct callback)));
-	pao->dpvt = (caddr_t)pcallback;
-	pcallback->callback = myCallback;
-	pcallback->priority = priorityLow;
-	pcallback->prec = (struct dbCommon *)pao;
+	pao->dpvt = (void *)pcallback;
+	callbackSetCallback(myCallback,pcallback);
+	pcallback->precord = (struct dbCommon *)pao;
 	pcallback->wd_id = wdCreate();
 	break;
     default :
@@ -136,6 +134,7 @@ static long write_ao(pao)
 	} else {
 		wait_time = (int)(pao->disv * vxTicksPerSecond);
 		if(wait_time<=0) return(0);
+		callbackSetPriority(pao->prio,pcallback);
 		printf("%s Starting asynchronous processing\n",pao->name);
 		wdStart(pcallback->wd_id,wait_time,callbackRequest,(int)pcallback);
 		return(1);
diff --git a/src/dev/devBiTestAsyn.c b/src/dev/devBiTestAsyn.c
index a336fa878..99a3f74b0 100644
--- a/src/dev/devBiTestAsyn.c
+++ b/src/dev/devBiTestAsyn.c
@@ -49,6 +49,7 @@
 #include	<recSup.h>
 #include	<devSup.h>
 #include	<link.h>
+#include	<dbCommon.h>
 #include	<biRecord.h>
 
 /* Create the dset for devBiTestAsyn */
@@ -73,27 +74,23 @@ struct {
 
 /* control block for callback*/
 struct callback {
-	void (*callback)();
-	int priority;
-	struct dbCommon *prec;
+	CALLBACK        callback;
+	struct dbCommon *precord;
 	WDOG_ID wd_id;
-	void (*process)();
 };
 
-void callbackRequest();
 
 static void myCallback(pcallback)
     struct callback *pcallback;
 {
-    struct biRecord *pbi=(struct biRecord *)(pcallback->prec);
-    struct rset     *prset=(struct rset *)(pbi->rset);
+    struct dbCommon *precord=pcallback->precord;
+    struct rset     *prset=(struct rset *)(precord->rset);
 
-    dbScanLock((struct dbCommon *)pbi);
-    (*prset->process)(pbi);
-    dbScanUnlock((struct dbCommon *)pbi);
+    dbScanLock(precord);
+    (*prset->process)(precord);
+    dbScanUnlock(precord);
 }
     
-    
 
 static long init_record(pbi)
     struct biRecord	*pbi;
@@ -105,10 +102,9 @@ static long init_record(pbi)
     switch (pbi->inp.type) {
     case (CONSTANT) :
 	pcallback = (struct callback *)(calloc(1,sizeof(struct callback)));
-	pbi->dpvt = (caddr_t)pcallback;
-	pcallback->callback = myCallback;
-	pcallback->priority = priorityLow;
-	pcallback->prec = (struct dbCommon *)pbi;
+	pbi->dpvt = (void *)pcallback;
+	callbackSetCallback(myCallback,pcallback);
+	pcallback->precord = (struct dbCommon *)pbi;
 	pcallback->wd_id = wdCreate();
 	pbi->val = pbi->inp.value.value;
 	pbi->udf = FALSE;
@@ -139,6 +135,7 @@ static long read_bi(pbi)
 	} else {
 		wait_time = (int)(pbi->disv * vxTicksPerSecond);
 		if(wait_time<=0) return(0);
+		callbackSetPriority(pbi->prio,pcallback);
 		printf("%s Starting asynchronous processing\n",pbi->name);
 		wdStart(pcallback->wd_id,wait_time,callbackRequest,(int)pcallback);
 		return(1);
diff --git a/src/dev/devBoTestAsyn.c b/src/dev/devBoTestAsyn.c
index 11c58c9a3..1f6860632 100644
--- a/src/dev/devBoTestAsyn.c
+++ b/src/dev/devBoTestAsyn.c
@@ -51,6 +51,7 @@
 #include	<recSup.h>
 #include	<devSup.h>
 #include	<link.h>
+#include	<dbCommon.h>
 #include	<boRecord.h>
 
 /* Create the dset for devBoTestAsyn */
@@ -75,25 +76,22 @@ struct {
 
 /* control block for callback*/
 struct callback {
-	void (*callback)();
-	int priority;
-	struct dbCommon *prec;
-	WDOG_ID wd_id;
+        CALLBACK        callback;
+        struct dbCommon *precord;
+        WDOG_ID wd_id;
 };
-void callbackRequest();
 
 static void myCallback(pcallback)
     struct callback *pcallback;
 {
-    struct boRecord *pbo=(struct boRecord *)(pcallback->prec);
-    struct rset     *prset=(struct rset *)(pbo->rset);
+    struct dbCommon *precord=pcallback->precord;
+    struct rset     *prset=(struct rset *)(precord->rset);
 
-    dbScanLock((struct dbCommon *)pbo);
-    (*prset->process)(pbo);
-    dbScanUnlock((struct dbCommon *)pbo);
+    dbScanLock(precord);
+    (*prset->process)(precord);
+    dbScanUnlock(precord);
 }
-    
-    
+
 
 static long init_record(pbo)
     struct boRecord	*pbo;
@@ -105,10 +103,9 @@ static long init_record(pbo)
     switch (pbo->out.type) {
     case (CONSTANT) :
 	pcallback = (struct callback *)(calloc(1,sizeof(struct callback)));
-	pbo->dpvt = (caddr_t)pcallback;
-	pcallback->callback = myCallback;
-	pcallback->priority = priorityLow;
-	pcallback->prec = (struct dbCommon *)pbo;
+	pbo->dpvt = (void *)pcallback;
+	callbackSetCallback(myCallback,pcallback);
+	pcallback->precord = (struct dbCommon *)pbo;
 	pcallback->wd_id = wdCreate();
 	break;
     default :
@@ -137,6 +134,7 @@ static long write_bo(pbo)
 	} else {
 		wait_time = (int)(pbo->disv * vxTicksPerSecond);
 		if(wait_time<=0) return(0);
+		callbackSetPriority(pbo->prio,pcallback);
 		printf("%s Starting asynchronous processing\n",pbo->name);
 		wdStart(pcallback->wd_id,wait_time,callbackRequest,(int)pcallback);
 		return(1);
diff --git a/src/dev/devHistogramTestAsyn.c b/src/dev/devHistogramTestAsyn.c
index 6d3cdd053..936ac8f83 100644
--- a/src/dev/devHistogramTestAsyn.c
+++ b/src/dev/devHistogramTestAsyn.c
@@ -48,6 +48,7 @@
 #include	<recSup.h>
 #include	<devSup.h>
 #include	<link.h>
+#include	<dbCommon.h>
 #include	<histogramRecord.h>
 
 /* Create the dset for devHistogramTestAsyn */
@@ -72,24 +73,20 @@ struct {
 
 /* control block for callback*/
 struct callback {
-	void (*callback)();
-	int priority;
-	struct dbCommon *prec;
-	WDOG_ID wd_id;
+        CALLBACK        callback;
+        struct dbCommon *precord;
+        WDOG_ID wd_id;
 };
-
-void callbackRequest();
 
 static void myCallback(pcallback)
     struct callback *pcallback;
 {
-    struct histogramRecord *phistogram=(struct histogramRecord *)(pcallback->prec);
-    struct rset     *prset=(struct rset *)(phistogram->rset);
+    struct dbCommon *precord=pcallback->precord;
+    struct rset     *prset=(struct rset *)(precord->rset);
 
-    dbScanLock((struct dbCommon *)phistogram);
-    (*prset->process)(phistogram);
-    dbScanUnlock((struct dbCommon *)phistogram);
-    return;
+    dbScanLock(precord);
+    (*prset->process)(precord);
+    dbScanUnlock(precord);
 }
 
 static long init_record(phistogram)
@@ -102,10 +99,9 @@ static long init_record(phistogram)
     switch (phistogram->svl.type) {
     case (CONSTANT) :
 	pcallback = (struct callback *)(calloc(1,sizeof(struct callback)));
-	phistogram->dpvt = (caddr_t)pcallback;
-	pcallback->callback = myCallback;
-	pcallback->priority = priorityLow;
-        pcallback->prec = (struct dbCommon *)phistogram;
+	phistogram->dpvt = (void *)pcallback;
+	callbackSetCallback(myCallback,pcallback);
+        pcallback->precord = (struct dbCommon *)phistogram;
 	pcallback->wd_id = wdCreate();
 	phistogram->sgnl = phistogram->svl.value.value;
 	break;
@@ -135,6 +131,7 @@ static long read_histogram(phistogram)
 	} else {
 		wait_time = (int)(phistogram->disv * vxTicksPerSecond);
 		if(wait_time<=0) return(0);
+		callbackSetPriority(phistogram->prio,pcallback);
 		printf("%s Starting asynchronous processing\n",phistogram->name);
 		wdStart(pcallback->wd_id,wait_time,callbackRequest,(int)pcallback);
 		return(1);
diff --git a/src/dev/devMbbiTestAsyn.c b/src/dev/devMbbiTestAsyn.c
index 038b86d9b..61b240795 100644
--- a/src/dev/devMbbiTestAsyn.c
+++ b/src/dev/devMbbiTestAsyn.c
@@ -49,6 +49,7 @@
 #include	<recSup.h>
 #include	<devSup.h>
 #include	<link.h>
+#include	<dbCommon.h>
 #include	<mbbiRecord.h>
 
 /* Create the dset for devMbbiTestAsyn */
@@ -73,26 +74,22 @@ struct {
 
 /* control block for callback*/
 struct callback {
-	void (*callback)();
-	int priority;
-	struct dbCommon *prec;
-	WDOG_ID wd_id;
+        CALLBACK        callback;
+        struct dbCommon *precord;
+        WDOG_ID wd_id;
 };
-
-void callbackRequest();
 
 static void myCallback(pcallback)
     struct callback *pcallback;
 {
-    struct mbbiRecord *pmbbi=(struct mbbiRecord *)(pcallback->prec);
-    struct rset     *prset=(struct rset *)(pmbbi->rset);
+    struct dbCommon *precord=pcallback->precord;
+    struct rset     *prset=(struct rset *)(precord->rset);
 
-    dbScanLock((struct dbCommon *)pmbbi);
-    (*prset->process)(pmbbi);
-    dbScanUnlock((struct dbCommon *)pmbbi);
+    dbScanLock(precord);
+    (*prset->process)(precord);
+    dbScanUnlock(precord);
 }
     
-    
 
 static long init_record(pmbbi)
     struct mbbiRecord	*pmbbi;
@@ -104,10 +101,9 @@ static long init_record(pmbbi)
     switch (pmbbi->inp.type) {
     case (CONSTANT) :
 	pcallback = (struct callback *)(calloc(1,sizeof(struct callback)));
-	pmbbi->dpvt = (caddr_t)pcallback;
-	pcallback->callback = myCallback;
-	pcallback->priority = priorityLow;
-        pcallback->prec = (struct dbCommon *)pmbbi;
+	pmbbi->dpvt = (void *)pcallback;
+	callbackSetCallback(myCallback,pcallback);
+        pcallback->precord = (struct dbCommon *)pmbbi;
 	pcallback->wd_id = wdCreate();
 	pmbbi->val = pmbbi->inp.value.value;
 	pmbbi->udf = FALSE;
@@ -138,6 +134,7 @@ static long read_mbbi(pmbbi)
 	} else {
 		wait_time = (int)(pmbbi->disv * vxTicksPerSecond);
 		if(wait_time<=0) return(0);
+		callbackSetPriority(pmbbi->prio,pcallback);
 		printf("%s Starting asynchronous processing\n",pmbbi->name);
 		wdStart(pcallback->wd_id,wait_time,callbackRequest,(int)pcallback);
 		return(1);
diff --git a/src/dev/devMbboTestAsyn.c b/src/dev/devMbboTestAsyn.c
index 6d6ea456a..84b98a7fb 100644
--- a/src/dev/devMbboTestAsyn.c
+++ b/src/dev/devMbboTestAsyn.c
@@ -50,6 +50,7 @@
 #include	<recSup.h>
 #include	<devSup.h>
 #include	<link.h>
+#include	<dbCommon.h>
 #include	<mbboRecord.h>
 
 /* Create the dset for devMbboTestAsyn */
@@ -74,22 +75,20 @@ struct {
 
 /* control block for callback*/
 struct callback {
-	void (*callback)();
-	int priority;
-	struct dbCommon *prec;
-	WDOG_ID wd_id;
+        CALLBACK        callback;
+        struct dbCommon *precord;
+        WDOG_ID wd_id;
 };
-void callbackRequest();
 
 static void myCallback(pcallback)
     struct callback *pcallback;
 {
-    struct mbboRecord *pmbbo=(struct mbboRecord *)(pcallback->prec);
-    struct rset     *prset=(struct rset *)(pmbbo->rset);
+    struct dbCommon *precord=pcallback->precord;
+    struct rset     *prset=(struct rset *)(precord->rset);
 
-    dbScanLock((struct dbCommon *)pmbbo);
-    (*prset->process)(pmbbo);
-    dbScanUnlock((struct dbCommon *)pmbbo);
+    dbScanLock(precord);
+    (*prset->process)(precord);
+    dbScanUnlock(precord);
 }
     
     
@@ -104,10 +103,9 @@ static long init_record(pmbbo)
     switch (pmbbo->out.type) {
     case (CONSTANT) :
 	pcallback = (struct callback *)(calloc(1,sizeof(struct callback)));
-	pmbbo->dpvt = (caddr_t)pcallback;
-	pcallback->callback = myCallback;
-	pcallback->priority = priorityLow;
-        pcallback->prec = (struct dbCommon *)pmbbo;
+	pmbbo->dpvt = (void *)pcallback;
+	callbackSetCallback(myCallback,pcallback);
+        pcallback->precord = (struct dbCommon *)pmbbo;
 	pcallback->wd_id = wdCreate();
 	break;
     default :
@@ -136,6 +134,7 @@ static long write_mbbo(pmbbo)
 	} else {
 		wait_time = (int)(pmbbo->disv * vxTicksPerSecond);
 		if(wait_time<=0) return(0);
+		callbackSetPriority(pmbbo->prio,pcallback);
 		printf("%s Starting asynchronous processing\n",pmbbo->name);
 		wdStart(pcallback->wd_id,wait_time,callbackRequest,(int)pcallback);
 		return(1);
diff --git a/src/dev/devSiTestAsyn.c b/src/dev/devSiTestAsyn.c
index f6f471780..479e4c250 100644
--- a/src/dev/devSiTestAsyn.c
+++ b/src/dev/devSiTestAsyn.c
@@ -48,6 +48,7 @@
 #include	<recSup.h>
 #include	<devSup.h>
 #include	<link.h>
+#include	<dbCommon.h>
 #include	<stringinRecord.h>
 
 /* Create the dset for devSiTestAsyn */
@@ -72,26 +73,22 @@ struct {
 
 /* control block for callback*/
 struct callback {
-	void (*callback)();
-	int priority;
-	struct dbCommon *prec;
-	WDOG_ID wd_id;
+        CALLBACK        callback;
+        struct dbCommon *precord;
+        WDOG_ID wd_id;
 };
-
-void callbackRequest();
 
 static void myCallback(pcallback)
     struct callback *pcallback;
 {
-    struct stringinRecord *pstringin=(struct stringinRecord *)(pcallback->prec);
-    struct rset     *prset=(struct rset *)(pstringin->rset);
+    struct dbCommon *precord=pcallback->precord;
+    struct rset     *prset=(struct rset *)(precord->rset);
 
-    dbScanLock((struct dbCommon *)pstringin);
-    (*prset->process)(pstringin);
-    dbScanUnlock((struct dbCommon *)pstringin);
+    dbScanLock(precord);
+    (*prset->process)(precord);
+    dbScanUnlock(precord);
 }
     
-    
 
 static long init_record(pstringin)
     struct stringinRecord	*pstringin;
@@ -103,10 +100,9 @@ static long init_record(pstringin)
     switch (pstringin->inp.type) {
     case (CONSTANT) :
 	pcallback = (struct callback *)(calloc(1,sizeof(struct callback)));
-	pstringin->dpvt = (caddr_t)pcallback;
-	pcallback->callback = myCallback;
-	pcallback->priority = priorityLow;
-        pcallback->prec = (struct dbCommon *)pstringin;
+	pstringin->dpvt = (void *)pcallback;
+	callbackSetCallback(myCallback,pcallback);
+        pcallback->precord = (struct dbCommon *)pstringin;
 	pcallback->wd_id = wdCreate();
 	if (pstringin->inp.value.value!=0.0) {
         	sprintf(pstringin->val,"%-14.7g",pstringin->inp.value.value);
@@ -139,6 +135,7 @@ static long read_stringin(pstringin)
 	} else {
 		wait_time = (int)(pstringin->disv * vxTicksPerSecond);
 		if(wait_time<=0) return(0);
+		callbackSetPriority(pstringin->prio,pcallback);
 		printf("%s Starting asynchronous processing\n",pstringin->name);
 		wdStart(pcallback->wd_id,wait_time,callbackRequest,(int)pcallback);
 		return(1);
diff --git a/src/dev/devSoTestAsyn.c b/src/dev/devSoTestAsyn.c
index 7f8349485..3a88637e1 100644
--- a/src/dev/devSoTestAsyn.c
+++ b/src/dev/devSoTestAsyn.c
@@ -49,6 +49,7 @@
 #include	<recSup.h>
 #include	<devSup.h>
 #include	<link.h>
+#include	<dbCommon.h>
 #include	<stringoutRecord.h>
 
 /* Create the dset for devSoTestAsyn */
@@ -73,25 +74,22 @@ struct {
 
 /* control block for callback*/
 struct callback {
-	void (*callback)();
-	int priority;
-	struct dbCommon *prec;
-	WDOG_ID wd_id;
+        CALLBACK        callback;
+        struct dbCommon *precord;
+        WDOG_ID wd_id;
 };
-void callbackRequest();
 
 static void myCallback(pcallback)
     struct callback *pcallback;
 {
-    struct stringoutRecord *pstringout=(struct stringoutRecord *)(pcallback->prec);
-    struct rset     *prset=(struct rset *)(pstringout->rset);
+    struct dbCommon *precord=pcallback->precord;
+    struct rset     *prset=(struct rset *)(precord->rset);
 
-    dbScanLock((struct dbCommon *)pstringout);
-    (*prset->process)(pstringout);
-    dbScanUnlock((struct dbCommon *)pstringout);
+    dbScanLock(precord);
+    (*prset->process)(precord);
+    dbScanUnlock(precord);
 }
     
-    
 
 static long init_record(pstringout)
     struct stringoutRecord	*pstringout;
@@ -103,10 +101,9 @@ static long init_record(pstringout)
     switch (pstringout->out.type) {
     case (CONSTANT) :
 	pcallback = (struct callback *)(calloc(1,sizeof(struct callback)));
-	pstringout->dpvt = (caddr_t)pcallback;
-	pcallback->callback = myCallback;
-	pcallback->priority = priorityLow;
-        pcallback->prec = (struct dbCommon *)pstringout;
+	pstringout->dpvt = (void *)pcallback;
+	callbackSetCallback(myCallback,pcallback);
+        pcallback->precord = (struct dbCommon *)pstringout;
 	pcallback->wd_id = wdCreate();
 	break;
     default :
@@ -135,6 +132,7 @@ static long write_stringout(pstringout)
 	} else {
 		wait_time = (int)(pstringout->disv * vxTicksPerSecond);
 		if(wait_time<=0) return(0);
+		callbackSetPriority(pstringout->prio,pcallback);
 		printf("%s Starting asynchronous processing\n",pstringout->name);
 		wdStart(pcallback->wd_id,wait_time,callbackRequest,(int)pcallback);
 		return(1);
diff --git a/src/dev/devWfTestAsyn.c b/src/dev/devWfTestAsyn.c
index 0662284b3..26918894f 100644
--- a/src/dev/devWfTestAsyn.c
+++ b/src/dev/devWfTestAsyn.c
@@ -49,6 +49,7 @@
 #include        <recSup.h>
 #include	<devSup.h>
 #include	<link.h>
+#include	<dbCommon.h>
 #include	<waveformRecord.h>
 
 /* Create the dset for devWfTestAsyn */
@@ -73,23 +74,22 @@ struct {
 
 /* control block for callback*/
 struct callback {
-	void (*callback)();
-	int priority;
-	struct dbCommon *prec;
-	WDOG_ID wd_id;
+        CALLBACK        callback;
+        struct dbCommon *precord;
+        WDOG_ID wd_id;
 };
-void callbackRequest();
 
 static void myCallback(pcallback)
     struct callback *pcallback;
 {
-    struct waveformRecord *pwf=(struct waveformRecord *)(pcallback->prec);
-    struct rset     *prset=(struct rset *)(pwf->rset);
+    struct dbCommon *precord=pcallback->precord;
+    struct rset     *prset=(struct rset *)(precord->rset);
 
-    dbScanLock((struct dbCommon *)pwf);
-    (*prset->process)(pwf);
-    dbScanUnlock((struct dbCommon *)pwf);
+    dbScanLock(precord);
+    (*prset->process)(precord);
+    dbScanUnlock(precord);
 }
+
 static long init_record(pwf)
     struct waveformRecord	*pwf;
 {
@@ -100,10 +100,9 @@ static long init_record(pwf)
     switch (pwf->inp.type) {
     case (CONSTANT) :
 	pcallback = (struct callback *)(calloc(1,sizeof(struct callback)));
-	pwf->dpvt = (caddr_t)pcallback;
-	pcallback->callback = myCallback;
-	pcallback->priority = priorityLow;
-        pcallback->prec = (struct dbCommon *)pwf;
+	pwf->dpvt = (void *)pcallback;
+	callbackSetCallback(myCallback,pcallback);
+        pcallback->precord = (struct dbCommon *)pwf;
 	pcallback->wd_id = wdCreate();
 	pwf->nord = 0;
 	break;
@@ -133,6 +132,7 @@ static long read_wf(pwf)
 	} else {
 		wait_time = (int)(pwf->disv * vxTicksPerSecond);
 		if(wait_time<=0) return(0);
+		callbackSetPriority(pwf->prio,pcallback);
 		printf("%s Starting asynchronous processing\n",pwf->name);
 		wdStart(pcallback->wd_id,wait_time,callbackRequest,(int)pcallback);
 		return(1);