Re-implement the client side of rpc.lockd in the kernel. This implementation

provides the correct semantics for flock(2) style locks which are used by the
lockf(1) command line tool and the pidfile(3) library. It also implements
recovery from server restarts and ensures that dirty cache blocks are written
to the server before obtaining locks (allowing multiple clients to use file
locking to safely share data).

Sponsored by:	Isilon Systems
PR:		94256
MFC after:	2 weeks

1 files changed, 117 insertions, 120 deletions

diff --git a/sys/nlm/nlm_prot_clnt.c b/sys/nlm/nlm_prot_clnt.c
index 9a16e32..a268e63 100644
--- a/sys/nlm/nlm_prot_clnt.c
+++ b/sys/nlm/nlm_prot_clnt.c
@@ -17,356 +17,353 @@ __RCSID("$NetBSD: nlm_prot.x,v 1.6 2000/06/07 14:30:15 bouyer Exp $");
 #endif /* not lint */
 __FBSDID("$FreeBSD$");
 
-/* Default timeout can be changed using clnt_control() */
-static struct timeval TIMEOUT = { 25, 0 };
-
 enum clnt_stat 
-nlm_sm_notify_0(struct nlm_sm_status *argp, void *clnt_res, CLIENT *clnt)
+nlm_sm_notify_0(struct nlm_sm_status *argp, void *clnt_res, CLIENT *clnt, struct rpc_callextra *ext, struct timeval timo)
 {
-	return (clnt_call(clnt, NLM_SM_NOTIFY,
+	return (CLNT_CALL_EXT(clnt, ext, NLM_SM_NOTIFY,
 		(xdrproc_t) xdr_nlm_sm_status, (caddr_t) argp,
 		(xdrproc_t) xdr_void, (caddr_t) clnt_res,
-		TIMEOUT));
+		timo));
 }
 
 enum clnt_stat 
-nlm_test_1(struct nlm_testargs *argp, nlm_testres *clnt_res, CLIENT *clnt)
+nlm_test_1(struct nlm_testargs *argp, nlm_testres *clnt_res, CLIENT *clnt, struct rpc_callextra *ext, struct timeval timo)
 {
-	return (clnt_call(clnt, NLM_TEST,
+	return (CLNT_CALL_EXT(clnt, ext, NLM_TEST,
 		(xdrproc_t) xdr_nlm_testargs, (caddr_t) argp,
 		(xdrproc_t) xdr_nlm_testres, (caddr_t) clnt_res,
-		TIMEOUT));
+		timo));
 }
 
 enum clnt_stat 
-nlm_lock_1(struct nlm_lockargs *argp, nlm_res *clnt_res, CLIENT *clnt)
+nlm_lock_1(struct nlm_lockargs *argp, nlm_res *clnt_res, CLIENT *clnt, struct rpc_callextra *ext, struct timeval timo)
 {
-	return (clnt_call(clnt, NLM_LOCK,
+	return (CLNT_CALL_EXT(clnt, ext, NLM_LOCK,
 		(xdrproc_t) xdr_nlm_lockargs, (caddr_t) argp,
 		(xdrproc_t) xdr_nlm_res, (caddr_t) clnt_res,
-		TIMEOUT));
+		timo));
 }
 
 enum clnt_stat 
-nlm_cancel_1(struct nlm_cancargs *argp, nlm_res *clnt_res, CLIENT *clnt)
+nlm_cancel_1(struct nlm_cancargs *argp, nlm_res *clnt_res, CLIENT *clnt, struct rpc_callextra *ext, struct timeval timo)
 {
-	return (clnt_call(clnt, NLM_CANCEL,
+	return (CLNT_CALL_EXT(clnt, ext, NLM_CANCEL,
 		(xdrproc_t) xdr_nlm_cancargs, (caddr_t) argp,
 		(xdrproc_t) xdr_nlm_res, (caddr_t) clnt_res,
-		TIMEOUT));
+		timo));
 }
 
 enum clnt_stat 
-nlm_unlock_1(struct nlm_unlockargs *argp, nlm_res *clnt_res, CLIENT *clnt)
+nlm_unlock_1(struct nlm_unlockargs *argp, nlm_res *clnt_res, CLIENT *clnt, struct rpc_callextra *ext, struct timeval timo)
 {
-	return (clnt_call(clnt, NLM_UNLOCK,
+	return (CLNT_CALL_EXT(clnt, ext, NLM_UNLOCK,
 		(xdrproc_t) xdr_nlm_unlockargs, (caddr_t) argp,
 		(xdrproc_t) xdr_nlm_res, (caddr_t) clnt_res,
-		TIMEOUT));
+		timo));
 }
 
 enum clnt_stat 
-nlm_granted_1(struct nlm_testargs *argp, nlm_res *clnt_res, CLIENT *clnt)
+nlm_granted_1(struct nlm_testargs *argp, nlm_res *clnt_res, CLIENT *clnt, struct rpc_callextra *ext, struct timeval timo)
 {
-	return (clnt_call(clnt, NLM_GRANTED,
+	return (CLNT_CALL_EXT(clnt, ext, NLM_GRANTED,
 		(xdrproc_t) xdr_nlm_testargs, (caddr_t) argp,
 		(xdrproc_t) xdr_nlm_res, (caddr_t) clnt_res,
-		TIMEOUT));
+		timo));
 }
 
 enum clnt_stat 
-nlm_test_msg_1(struct nlm_testargs *argp, void *clnt_res, CLIENT *clnt)
+nlm_test_msg_1(struct nlm_testargs *argp, void *clnt_res, CLIENT *clnt, struct rpc_callextra *ext, struct timeval timo)
 {
-	return (clnt_call(clnt, NLM_TEST_MSG,
+	return (CLNT_CALL_EXT(clnt, ext, NLM_TEST_MSG,
 		(xdrproc_t) xdr_nlm_testargs, (caddr_t) argp,
 		(xdrproc_t) xdr_void, (caddr_t) clnt_res,
-		TIMEOUT));
+		timo));
 }
 
 enum clnt_stat 
-nlm_lock_msg_1(struct nlm_lockargs *argp, void *clnt_res, CLIENT *clnt)
+nlm_lock_msg_1(struct nlm_lockargs *argp, void *clnt_res, CLIENT *clnt, struct rpc_callextra *ext, struct timeval timo)
 {
-	return (clnt_call(clnt, NLM_LOCK_MSG,
+	return (CLNT_CALL_EXT(clnt, ext, NLM_LOCK_MSG,
 		(xdrproc_t) xdr_nlm_lockargs, (caddr_t) argp,
 		(xdrproc_t) xdr_void, (caddr_t) clnt_res,
-		TIMEOUT));
+		timo));
 }
 
 enum clnt_stat 
-nlm_cancel_msg_1(struct nlm_cancargs *argp, void *clnt_res, CLIENT *clnt)
+nlm_cancel_msg_1(struct nlm_cancargs *argp, void *clnt_res, CLIENT *clnt, struct rpc_callextra *ext, struct timeval timo)
 {
-	return (clnt_call(clnt, NLM_CANCEL_MSG,
+	return (CLNT_CALL_EXT(clnt, ext, NLM_CANCEL_MSG,
 		(xdrproc_t) xdr_nlm_cancargs, (caddr_t) argp,
 		(xdrproc_t) xdr_void, (caddr_t) clnt_res,
-		TIMEOUT));
+		timo));
 }
 
 enum clnt_stat 
-nlm_unlock_msg_1(struct nlm_unlockargs *argp, void *clnt_res, CLIENT *clnt)
+nlm_unlock_msg_1(struct nlm_unlockargs *argp, void *clnt_res, CLIENT *clnt, struct rpc_callextra *ext, struct timeval timo)
 {
-	return (clnt_call(clnt, NLM_UNLOCK_MSG,
+	return (CLNT_CALL_EXT(clnt, ext, NLM_UNLOCK_MSG,
 		(xdrproc_t) xdr_nlm_unlockargs, (caddr_t) argp,
 		(xdrproc_t) xdr_void, (caddr_t) clnt_res,
-		TIMEOUT));
+		timo));
 }
 
 enum clnt_stat 
-nlm_granted_msg_1(struct nlm_testargs *argp, void *clnt_res, CLIENT *clnt)
+nlm_granted_msg_1(struct nlm_testargs *argp, void *clnt_res, CLIENT *clnt, struct rpc_callextra *ext, struct timeval timo)
 {
-	return (clnt_call(clnt, NLM_GRANTED_MSG,
+	return (CLNT_CALL_EXT(clnt, ext, NLM_GRANTED_MSG,
 		(xdrproc_t) xdr_nlm_testargs, (caddr_t) argp,
 		(xdrproc_t) xdr_void, (caddr_t) clnt_res,
-		TIMEOUT));
+		timo));
 }
 
 enum clnt_stat 
-nlm_test_res_1(nlm_testres *argp, void *clnt_res, CLIENT *clnt)
+nlm_test_res_1(nlm_testres *argp, void *clnt_res, CLIENT *clnt, struct rpc_callextra *ext, struct timeval timo)
 {
-	return (clnt_call(clnt, NLM_TEST_RES,
+	return (CLNT_CALL_EXT(clnt, ext, NLM_TEST_RES,
 		(xdrproc_t) xdr_nlm_testres, (caddr_t) argp,
 		(xdrproc_t) xdr_void, (caddr_t) clnt_res,
-		TIMEOUT));
+		timo));
 }
 
 enum clnt_stat 
-nlm_lock_res_1(nlm_res *argp, void *clnt_res, CLIENT *clnt)
+nlm_lock_res_1(nlm_res *argp, void *clnt_res, CLIENT *clnt, struct rpc_callextra *ext, struct timeval timo)
 {
-	return (clnt_call(clnt, NLM_LOCK_RES,
+	return (CLNT_CALL_EXT(clnt, ext, NLM_LOCK_RES,
 		(xdrproc_t) xdr_nlm_res, (caddr_t) argp,
 		(xdrproc_t) xdr_void, (caddr_t) clnt_res,
-		TIMEOUT));
+		timo));
 }
 
 enum clnt_stat 
-nlm_cancel_res_1(nlm_res *argp, void *clnt_res, CLIENT *clnt)
+nlm_cancel_res_1(nlm_res *argp, void *clnt_res, CLIENT *clnt, struct rpc_callextra *ext, struct timeval timo)
 {
-	return (clnt_call(clnt, NLM_CANCEL_RES,
+	return (CLNT_CALL_EXT(clnt, ext, NLM_CANCEL_RES,
 		(xdrproc_t) xdr_nlm_res, (caddr_t) argp,
 		(xdrproc_t) xdr_void, (caddr_t) clnt_res,
-		TIMEOUT));
+		timo));
 }
 
 enum clnt_stat 
-nlm_unlock_res_1(nlm_res *argp, void *clnt_res, CLIENT *clnt)
+nlm_unlock_res_1(nlm_res *argp, void *clnt_res, CLIENT *clnt, struct rpc_callextra *ext, struct timeval timo)
 {
-	return (clnt_call(clnt, NLM_UNLOCK_RES,
+	return (CLNT_CALL_EXT(clnt, ext, NLM_UNLOCK_RES,
 		(xdrproc_t) xdr_nlm_res, (caddr_t) argp,
 		(xdrproc_t) xdr_void, (caddr_t) clnt_res,
-		TIMEOUT));
+		timo));
 }
 
 enum clnt_stat 
-nlm_granted_res_1(nlm_res *argp, void *clnt_res, CLIENT *clnt)
+nlm_granted_res_1(nlm_res *argp, void *clnt_res, CLIENT *clnt, struct rpc_callextra *ext, struct timeval timo)
 {
-	return (clnt_call(clnt, NLM_GRANTED_RES,
+	return (CLNT_CALL_EXT(clnt, ext, NLM_GRANTED_RES,
 		(xdrproc_t) xdr_nlm_res, (caddr_t) argp,
 		(xdrproc_t) xdr_void, (caddr_t) clnt_res,
-		TIMEOUT));
+		timo));
 }
 
 enum clnt_stat 
-nlm_share_3(nlm_shareargs *argp, nlm_shareres *clnt_res, CLIENT *clnt)
+nlm_share_3(nlm_shareargs *argp, nlm_shareres *clnt_res, CLIENT *clnt, struct rpc_callextra *ext, struct timeval timo)
 {
-	return (clnt_call(clnt, NLM_SHARE,
+	return (CLNT_CALL_EXT(clnt, ext, NLM_SHARE,
 		(xdrproc_t) xdr_nlm_shareargs, (caddr_t) argp,
 		(xdrproc_t) xdr_nlm_shareres, (caddr_t) clnt_res,
-		TIMEOUT));
+		timo));
 }
 
 enum clnt_stat 
-nlm_unshare_3(nlm_shareargs *argp, nlm_shareres *clnt_res, CLIENT *clnt)
+nlm_unshare_3(nlm_shareargs *argp, nlm_shareres *clnt_res, CLIENT *clnt, struct rpc_callextra *ext, struct timeval timo)
 {
-	return (clnt_call(clnt, NLM_UNSHARE,
+	return (CLNT_CALL_EXT(clnt, ext, NLM_UNSHARE,
 		(xdrproc_t) xdr_nlm_shareargs, (caddr_t) argp,
 		(xdrproc_t) xdr_nlm_shareres, (caddr_t) clnt_res,
-		TIMEOUT));
+		timo));
 }
 
 enum clnt_stat 
-nlm_nm_lock_3(nlm_lockargs *argp, nlm_res *clnt_res, CLIENT *clnt)
+nlm_nm_lock_3(nlm_lockargs *argp, nlm_res *clnt_res, CLIENT *clnt, struct rpc_callextra *ext, struct timeval timo)
 {
-	return (clnt_call(clnt, NLM_NM_LOCK,
+	return (CLNT_CALL_EXT(clnt, ext, NLM_NM_LOCK,
 		(xdrproc_t) xdr_nlm_lockargs, (caddr_t) argp,
 		(xdrproc_t) xdr_nlm_res, (caddr_t) clnt_res,
-		TIMEOUT));
+		timo));
 }
 
 enum clnt_stat 
-nlm_free_all_3(nlm_notify *argp, void *clnt_res, CLIENT *clnt)
+nlm_free_all_3(nlm_notify *argp, void *clnt_res, CLIENT *clnt, struct rpc_callextra *ext, struct timeval timo)
 {
-	return (clnt_call(clnt, NLM_FREE_ALL,
+	return (CLNT_CALL_EXT(clnt, ext, NLM_FREE_ALL,
 		(xdrproc_t) xdr_nlm_notify, (caddr_t) argp,
 		(xdrproc_t) xdr_void, (caddr_t) clnt_res,
-		TIMEOUT));
+		timo));
 }
 
 enum clnt_stat 
-nlm4_test_4(nlm4_testargs *argp, nlm4_testres *clnt_res, CLIENT *clnt)
+nlm4_test_4(nlm4_testargs *argp, nlm4_testres *clnt_res, CLIENT *clnt, struct rpc_callextra *ext, struct timeval timo)
 {
-	return (clnt_call(clnt, NLM4_TEST,
+	return (CLNT_CALL_EXT(clnt, ext, NLM4_TEST,
 		(xdrproc_t) xdr_nlm4_testargs, (caddr_t) argp,
 		(xdrproc_t) xdr_nlm4_testres, (caddr_t) clnt_res,
-		TIMEOUT));
+		timo));
 }
 
 enum clnt_stat 
-nlm4_lock_4(nlm4_lockargs *argp, nlm4_res *clnt_res, CLIENT *clnt)
+nlm4_lock_4(nlm4_lockargs *argp, nlm4_res *clnt_res, CLIENT *clnt, struct rpc_callextra *ext, struct timeval timo)
 {
-	return (clnt_call(clnt, NLM4_LOCK,
+	return (CLNT_CALL_EXT(clnt, ext, NLM4_LOCK,
 		(xdrproc_t) xdr_nlm4_lockargs, (caddr_t) argp,
 		(xdrproc_t) xdr_nlm4_res, (caddr_t) clnt_res,
-		TIMEOUT));
+		timo));
 }
 
 enum clnt_stat 
-nlm4_cancel_4(nlm4_cancargs *argp, nlm4_res *clnt_res, CLIENT *clnt)
+nlm4_cancel_4(nlm4_cancargs *argp, nlm4_res *clnt_res, CLIENT *clnt, struct rpc_callextra *ext, struct timeval timo)
 {
-	return (clnt_call(clnt, NLM4_CANCEL,
+	return (CLNT_CALL_EXT(clnt, ext, NLM4_CANCEL,
 		(xdrproc_t) xdr_nlm4_cancargs, (caddr_t) argp,
 		(xdrproc_t) xdr_nlm4_res, (caddr_t) clnt_res,
-		TIMEOUT));
+		timo));
 }
 
 enum clnt_stat 
-nlm4_unlock_4(nlm4_unlockargs *argp, nlm4_res *clnt_res, CLIENT *clnt)
+nlm4_unlock_4(nlm4_unlockargs *argp, nlm4_res *clnt_res, CLIENT *clnt, struct rpc_callextra *ext, struct timeval timo)
 {
-	return (clnt_call(clnt, NLM4_UNLOCK,
+	return (CLNT_CALL_EXT(clnt, ext, NLM4_UNLOCK,
 		(xdrproc_t) xdr_nlm4_unlockargs, (caddr_t) argp,
 		(xdrproc_t) xdr_nlm4_res, (caddr_t) clnt_res,
-		TIMEOUT));
+		timo));
 }
 
 enum clnt_stat 
-nlm4_granted_4(nlm4_testargs *argp, nlm4_res *clnt_res, CLIENT *clnt)
+nlm4_granted_4(nlm4_testargs *argp, nlm4_res *clnt_res, CLIENT *clnt, struct rpc_callextra *ext, struct timeval timo)
 {
-	return (clnt_call(clnt, NLM4_GRANTED,
+	return (CLNT_CALL_EXT(clnt, ext, NLM4_GRANTED,
 		(xdrproc_t) xdr_nlm4_testargs, (caddr_t) argp,
 		(xdrproc_t) xdr_nlm4_res, (caddr_t) clnt_res,
-		TIMEOUT));
+		timo));
 }
 
 enum clnt_stat 
-nlm4_test_msg_4(nlm4_testargs *argp, void *clnt_res, CLIENT *clnt)
+nlm4_test_msg_4(nlm4_testargs *argp, void *clnt_res, CLIENT *clnt, struct rpc_callextra *ext, struct timeval timo)
 {
-	return (clnt_call(clnt, NLM4_TEST_MSG,
+	return (CLNT_CALL_EXT(clnt, ext, NLM4_TEST_MSG,
 		(xdrproc_t) xdr_nlm4_testargs, (caddr_t) argp,
 		(xdrproc_t) xdr_void, (caddr_t) clnt_res,
-		TIMEOUT));
+		timo));
 }
 
 enum clnt_stat 
-nlm4_lock_msg_4(nlm4_lockargs *argp, void *clnt_res, CLIENT *clnt)
+nlm4_lock_msg_4(nlm4_lockargs *argp, void *clnt_res, CLIENT *clnt, struct rpc_callextra *ext, struct timeval timo)
 {
-	return (clnt_call(clnt, NLM4_LOCK_MSG,
+	return (CLNT_CALL_EXT(clnt, ext, NLM4_LOCK_MSG,
 		(xdrproc_t) xdr_nlm4_lockargs, (caddr_t) argp,
 		(xdrproc_t) xdr_void, (caddr_t) clnt_res,
-		TIMEOUT));
+		timo));
 }
 
 enum clnt_stat 
-nlm4_cancel_msg_4(nlm4_cancargs *argp, void *clnt_res, CLIENT *clnt)
+nlm4_cancel_msg_4(nlm4_cancargs *argp, void *clnt_res, CLIENT *clnt, struct rpc_callextra *ext, struct timeval timo)
 {
-	return (clnt_call(clnt, NLM4_CANCEL_MSG,
+	return (CLNT_CALL_EXT(clnt, ext, NLM4_CANCEL_MSG,
 		(xdrproc_t) xdr_nlm4_cancargs, (caddr_t) argp,
 		(xdrproc_t) xdr_void, (caddr_t) clnt_res,
-		TIMEOUT));
+		timo));
 }
 
 enum clnt_stat 
-nlm4_unlock_msg_4(nlm4_unlockargs *argp, void *clnt_res, CLIENT *clnt)
+nlm4_unlock_msg_4(nlm4_unlockargs *argp, void *clnt_res, CLIENT *clnt, struct rpc_callextra *ext, struct timeval timo)
 {
-	return (clnt_call(clnt, NLM4_UNLOCK_MSG,
+	return (CLNT_CALL_EXT(clnt, ext, NLM4_UNLOCK_MSG,
 		(xdrproc_t) xdr_nlm4_unlockargs, (caddr_t) argp,
 		(xdrproc_t) xdr_void, (caddr_t) clnt_res,
-		TIMEOUT));
+		timo));
 }
 
 enum clnt_stat 
-nlm4_granted_msg_4(nlm4_testargs *argp, void *clnt_res, CLIENT *clnt)
+nlm4_granted_msg_4(nlm4_testargs *argp, void *clnt_res, CLIENT *clnt, struct rpc_callextra *ext, struct timeval timo)
 {
-	return (clnt_call(clnt, NLM4_GRANTED_MSG,
+	return (CLNT_CALL_EXT(clnt, ext, NLM4_GRANTED_MSG,
 		(xdrproc_t) xdr_nlm4_testargs, (caddr_t) argp,
 		(xdrproc_t) xdr_void, (caddr_t) clnt_res,
-		TIMEOUT));
+		timo));
 }
 
 enum clnt_stat 
-nlm4_test_res_4(nlm4_testres *argp, void *clnt_res, CLIENT *clnt)
+nlm4_test_res_4(nlm4_testres *argp, void *clnt_res, CLIENT *clnt, struct rpc_callextra *ext, struct timeval timo)
 {
-	return (clnt_call(clnt, NLM4_TEST_RES,
+	return (CLNT_CALL_EXT(clnt, ext, NLM4_TEST_RES,
 		(xdrproc_t) xdr_nlm4_testres, (caddr_t) argp,
 		(xdrproc_t) xdr_void, (caddr_t) clnt_res,
-		TIMEOUT));
+		timo));
 }
 
 enum clnt_stat 
-nlm4_lock_res_4(nlm4_res *argp, void *clnt_res, CLIENT *clnt)
+nlm4_lock_res_4(nlm4_res *argp, void *clnt_res, CLIENT *clnt, struct rpc_callextra *ext, struct timeval timo)
 {
-	return (clnt_call(clnt, NLM4_LOCK_RES,
+	return (CLNT_CALL_EXT(clnt, ext, NLM4_LOCK_RES,
 		(xdrproc_t) xdr_nlm4_res, (caddr_t) argp,
 		(xdrproc_t) xdr_void, (caddr_t) clnt_res,
-		TIMEOUT));
+		timo));
 }
 
 enum clnt_stat 
-nlm4_cancel_res_4(nlm4_res *argp, void *clnt_res, CLIENT *clnt)
+nlm4_cancel_res_4(nlm4_res *argp, void *clnt_res, CLIENT *clnt, struct rpc_callextra *ext, struct timeval timo)
 {
-	return (clnt_call(clnt, NLM4_CANCEL_RES,
+	return (CLNT_CALL_EXT(clnt, ext, NLM4_CANCEL_RES,
 		(xdrproc_t) xdr_nlm4_res, (caddr_t) argp,
 		(xdrproc_t) xdr_void, (caddr_t) clnt_res,
-		TIMEOUT));
+		timo));
 }
 
 enum clnt_stat 
-nlm4_unlock_res_4(nlm4_res *argp, void *clnt_res, CLIENT *clnt)
+nlm4_unlock_res_4(nlm4_res *argp, void *clnt_res, CLIENT *clnt, struct rpc_callextra *ext, struct timeval timo)
 {
-	return (clnt_call(clnt, NLM4_UNLOCK_RES,
+	return (CLNT_CALL_EXT(clnt, ext, NLM4_UNLOCK_RES,
 		(xdrproc_t) xdr_nlm4_res, (caddr_t) argp,
 		(xdrproc_t) xdr_void, (caddr_t) clnt_res,
-		TIMEOUT));
+		timo));
 }
 
 enum clnt_stat 
-nlm4_granted_res_4(nlm4_res *argp, void *clnt_res, CLIENT *clnt)
+nlm4_granted_res_4(nlm4_res *argp, void *clnt_res, CLIENT *clnt, struct rpc_callextra *ext, struct timeval timo)
 {
-	return (clnt_call(clnt, NLM4_GRANTED_RES,
+	return (CLNT_CALL_EXT(clnt, ext, NLM4_GRANTED_RES,
 		(xdrproc_t) xdr_nlm4_res, (caddr_t) argp,
 		(xdrproc_t) xdr_void, (caddr_t) clnt_res,
-		TIMEOUT));
+		timo));
 }
 
 enum clnt_stat 
-nlm4_share_4(nlm4_shareargs *argp, nlm4_shareres *clnt_res, CLIENT *clnt)
+nlm4_share_4(nlm4_shareargs *argp, nlm4_shareres *clnt_res, CLIENT *clnt, struct rpc_callextra *ext, struct timeval timo)
 {
-	return (clnt_call(clnt, NLM4_SHARE,
+	return (CLNT_CALL_EXT(clnt, ext, NLM4_SHARE,
 		(xdrproc_t) xdr_nlm4_shareargs, (caddr_t) argp,
 		(xdrproc_t) xdr_nlm4_shareres, (caddr_t) clnt_res,
-		TIMEOUT));
+		timo));
 }
 
 enum clnt_stat 
-nlm4_unshare_4(nlm4_shareargs *argp, nlm4_shareres *clnt_res, CLIENT *clnt)
+nlm4_unshare_4(nlm4_shareargs *argp, nlm4_shareres *clnt_res, CLIENT *clnt, struct rpc_callextra *ext, struct timeval timo)
 {
-	return (clnt_call(clnt, NLM4_UNSHARE,
+	return (CLNT_CALL_EXT(clnt, ext, NLM4_UNSHARE,
 		(xdrproc_t) xdr_nlm4_shareargs, (caddr_t) argp,
 		(xdrproc_t) xdr_nlm4_shareres, (caddr_t) clnt_res,
-		TIMEOUT));
+		timo));
 }
 
 enum clnt_stat 
-nlm4_nm_lock_4(nlm4_lockargs *argp, nlm4_res *clnt_res, CLIENT *clnt)
+nlm4_nm_lock_4(nlm4_lockargs *argp, nlm4_res *clnt_res, CLIENT *clnt, struct rpc_callextra *ext, struct timeval timo)
 {
-	return (clnt_call(clnt, NLM4_NM_LOCK,
+	return (CLNT_CALL_EXT(clnt, ext, NLM4_NM_LOCK,
 		(xdrproc_t) xdr_nlm4_lockargs, (caddr_t) argp,
 		(xdrproc_t) xdr_nlm4_res, (caddr_t) clnt_res,
-		TIMEOUT));
+		timo));
 }
 
 enum clnt_stat 
-nlm4_free_all_4(nlm4_notify *argp, void *clnt_res, CLIENT *clnt)
+nlm4_free_all_4(nlm4_notify *argp, void *clnt_res, CLIENT *clnt, struct rpc_callextra *ext, struct timeval timo)
 {
-	return (clnt_call(clnt, NLM4_FREE_ALL,
+	return (CLNT_CALL_EXT(clnt, ext, NLM4_FREE_ALL,
 		(xdrproc_t) xdr_nlm4_notify, (caddr_t) argp,
 		(xdrproc_t) xdr_void, (caddr_t) clnt_res,
-		TIMEOUT));
+		timo));
 }