xref: /dflybsd-src/sys/vfs/nfs/nfs_iod.c (revision f354e0e64689159f00d07d7caa59dab0cea92fcb)
152e1cf57SMatthew Dillon /*
252e1cf57SMatthew Dillon  * Copyright (c) 2009 The DragonFly Project.  All rights reserved.
352e1cf57SMatthew Dillon  *
452e1cf57SMatthew Dillon  * This code is derived from software contributed to The DragonFly Project
552e1cf57SMatthew Dillon  * by Matthew Dillon <dillon@backplane.com>
652e1cf57SMatthew Dillon  *
752e1cf57SMatthew Dillon  * Redistribution and use in source and binary forms, with or without
852e1cf57SMatthew Dillon  * modification, are permitted provided that the following conditions
952e1cf57SMatthew Dillon  * are met:
1052e1cf57SMatthew Dillon  *
1152e1cf57SMatthew Dillon  * 1. Redistributions of source code must retain the above copyright
1252e1cf57SMatthew Dillon  *    notice, this list of conditions and the following disclaimer.
1352e1cf57SMatthew Dillon  * 2. Redistributions in binary form must reproduce the above copyright
1452e1cf57SMatthew Dillon  *    notice, this list of conditions and the following disclaimer in
1552e1cf57SMatthew Dillon  *    the documentation and/or other materials provided with the
1652e1cf57SMatthew Dillon  *    distribution.
1752e1cf57SMatthew Dillon  * 3. Neither the name of The DragonFly Project nor the names of its
1852e1cf57SMatthew Dillon  *    contributors may be used to endorse or promote products derived
1952e1cf57SMatthew Dillon  *    from this software without specific, prior written permission.
2052e1cf57SMatthew Dillon  *
2152e1cf57SMatthew Dillon  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
2252e1cf57SMatthew Dillon  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
2352e1cf57SMatthew Dillon  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
2452e1cf57SMatthew Dillon  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
2552e1cf57SMatthew Dillon  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
2652e1cf57SMatthew Dillon  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
2752e1cf57SMatthew Dillon  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
2852e1cf57SMatthew Dillon  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
2952e1cf57SMatthew Dillon  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
3052e1cf57SMatthew Dillon  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
3152e1cf57SMatthew Dillon  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
3252e1cf57SMatthew Dillon  * SUCH DAMAGE.
3352e1cf57SMatthew Dillon  */
3452e1cf57SMatthew Dillon /*
3552e1cf57SMatthew Dillon  * NFSIOD operations - now built into the kernel.
3652e1cf57SMatthew Dillon  */
3752e1cf57SMatthew Dillon #include <sys/param.h>
3852e1cf57SMatthew Dillon #include <sys/systm.h>
3952e1cf57SMatthew Dillon #include <sys/proc.h>
4052e1cf57SMatthew Dillon #include <sys/malloc.h>
4152e1cf57SMatthew Dillon #include <sys/mount.h>
4252e1cf57SMatthew Dillon #include <sys/kernel.h>
4352e1cf57SMatthew Dillon #include <sys/mbuf.h>
4452e1cf57SMatthew Dillon #include <sys/vnode.h>
4552e1cf57SMatthew Dillon #include <sys/fcntl.h>
4652e1cf57SMatthew Dillon #include <sys/protosw.h>
4752e1cf57SMatthew Dillon #include <sys/resourcevar.h>
4852e1cf57SMatthew Dillon #include <sys/socket.h>
4952e1cf57SMatthew Dillon #include <sys/socketvar.h>
5052e1cf57SMatthew Dillon #include <sys/socketops.h>
5152e1cf57SMatthew Dillon #include <sys/syslog.h>
5252e1cf57SMatthew Dillon #include <sys/thread.h>
5352e1cf57SMatthew Dillon #include <sys/tprintf.h>
5452e1cf57SMatthew Dillon #include <sys/sysctl.h>
5552e1cf57SMatthew Dillon #include <sys/signalvar.h>
5652e1cf57SMatthew Dillon 
5752e1cf57SMatthew Dillon #include <sys/signal2.h>
5852e1cf57SMatthew Dillon 
5952e1cf57SMatthew Dillon #include <netinet/in.h>
6052e1cf57SMatthew Dillon #include <netinet/tcp.h>
6152e1cf57SMatthew Dillon 
6252e1cf57SMatthew Dillon #include "rpcv2.h"
6352e1cf57SMatthew Dillon #include "nfsproto.h"
6452e1cf57SMatthew Dillon #include "nfs.h"
6552e1cf57SMatthew Dillon #include "xdr_subs.h"
6652e1cf57SMatthew Dillon #include "nfsm_subs.h"
6752e1cf57SMatthew Dillon #include "nfsmount.h"
6852e1cf57SMatthew Dillon #include "nfsnode.h"
6952e1cf57SMatthew Dillon #include "nfsrtt.h"
7052e1cf57SMatthew Dillon 
71c9e9fb21SMatthew Dillon /*
72c9e9fb21SMatthew Dillon  * nfs service connection reader thread
73c9e9fb21SMatthew Dillon  */
7452e1cf57SMatthew Dillon void
nfssvc_iod_reader(void * arg)7552e1cf57SMatthew Dillon nfssvc_iod_reader(void *arg)
7652e1cf57SMatthew Dillon {
7752e1cf57SMatthew Dillon 	struct nfsmount *nmp = arg;
78edb90c22SMatthew Dillon 	struct nfsm_info *info;
79edb90c22SMatthew Dillon 	struct nfsreq *req;
80edb90c22SMatthew Dillon 	int error;
8152e1cf57SMatthew Dillon 
82c6b43e93SMatthew Dillon 	lwkt_gettoken(&nmp->nm_token);
83c9e9fb21SMatthew Dillon 
8452e1cf57SMatthew Dillon 	if (nmp->nm_rxstate == NFSSVC_INIT)
8552e1cf57SMatthew Dillon 		nmp->nm_rxstate = NFSSVC_PENDING;
8652e1cf57SMatthew Dillon 	for (;;) {
8752e1cf57SMatthew Dillon 		if (nmp->nm_rxstate == NFSSVC_WAITING) {
88edb90c22SMatthew Dillon 			if (TAILQ_FIRST(&nmp->nm_reqq) == NULL &&
89edb90c22SMatthew Dillon 			    TAILQ_FIRST(&nmp->nm_reqrxq) == NULL) {
9052e1cf57SMatthew Dillon 				tsleep(&nmp->nm_rxstate, 0, "nfsidl", 0);
91edb90c22SMatthew Dillon 			} else {
92edb90c22SMatthew Dillon 				/*
93edb90c22SMatthew Dillon 				 * This can happen during shutdown, we don't
94edb90c22SMatthew Dillon 				 * want to hardloop.
95edb90c22SMatthew Dillon 				 */
96edb90c22SMatthew Dillon 				error = nfs_reply(nmp, NULL);
97edb90c22SMatthew Dillon 				if (error && error != EWOULDBLOCK) {
98edb90c22SMatthew Dillon 					tsleep(&nmp->nm_rxstate, 0,
99edb90c22SMatthew Dillon 						"nfsxxx", hz / 10);
100edb90c22SMatthew Dillon 				}
101edb90c22SMatthew Dillon 			}
10252e1cf57SMatthew Dillon 			continue;
10352e1cf57SMatthew Dillon 		}
10452e1cf57SMatthew Dillon 		if (nmp->nm_rxstate != NFSSVC_PENDING)
10552e1cf57SMatthew Dillon 			break;
10652e1cf57SMatthew Dillon 		nmp->nm_rxstate = NFSSVC_WAITING;
10752e1cf57SMatthew Dillon 
108edb90c22SMatthew Dillon 		/*
109edb90c22SMatthew Dillon 		 * Process requests which have received replies.  Only
110edb90c22SMatthew Dillon 		 * process the post-reply states.  If we get EINPROGRESS
111edb90c22SMatthew Dillon 		 * it means the request went back to an auth or retransmit
112edb90c22SMatthew Dillon 		 * state and we let the iod_writer thread deal with it.
113edb90c22SMatthew Dillon 		 *
114f8565b0fSMatthew Dillon 		 * Any lock on the request is strictly temporary due to
115f8565b0fSMatthew Dillon 		 * MP races (XXX).
116f8565b0fSMatthew Dillon 		 *
117edb90c22SMatthew Dillon 		 * If the request completes we run the info->done call
118edb90c22SMatthew Dillon 		 * to finish up the I/O.
119edb90c22SMatthew Dillon 		 */
120edb90c22SMatthew Dillon 		while ((req = TAILQ_FIRST(&nmp->nm_reqrxq)) != NULL) {
121f8565b0fSMatthew Dillon 			if (req->r_flags & R_LOCKED) {
122f8565b0fSMatthew Dillon 				while (req->r_flags & R_LOCKED) {
123f8565b0fSMatthew Dillon 					req->r_flags |= R_WANTED;
124f8565b0fSMatthew Dillon 					tsleep(req, 0, "nfstrac", 0);
125f8565b0fSMatthew Dillon 				}
126f8565b0fSMatthew Dillon 				continue;
127f8565b0fSMatthew Dillon 			}
128edb90c22SMatthew Dillon 			TAILQ_REMOVE(&nmp->nm_reqrxq, req, r_chain);
129edb90c22SMatthew Dillon 			info = req->r_info;
130edb90c22SMatthew Dillon 			KKASSERT(info);
131edb90c22SMatthew Dillon 			info->error = nfs_request(info,
132edb90c22SMatthew Dillon 						  NFSM_STATE_PROCESSREPLY,
133edb90c22SMatthew Dillon 						  NFSM_STATE_DONE);
134edb90c22SMatthew Dillon 			if (info->error == EINPROGRESS) {
135edb90c22SMatthew Dillon 				kprintf("rxq: move info %p back to txq\n", info);
136edb90c22SMatthew Dillon 				TAILQ_INSERT_TAIL(&nmp->nm_reqtxq, req, r_chain);
137edb90c22SMatthew Dillon 				nfssvc_iod_writer_wakeup(nmp);
138edb90c22SMatthew Dillon 			} else {
139f8565b0fSMatthew Dillon 				atomic_subtract_int(&nmp->nm_bioqlen, 1);
140edb90c22SMatthew Dillon 				info->done(info);
141edb90c22SMatthew Dillon 			}
142edb90c22SMatthew Dillon 		}
14352e1cf57SMatthew Dillon 	}
14452e1cf57SMatthew Dillon 	nmp->nm_rxthread = NULL;
14552e1cf57SMatthew Dillon 	nmp->nm_rxstate = NFSSVC_DONE;
146c6b43e93SMatthew Dillon 
147c6b43e93SMatthew Dillon 	lwkt_reltoken(&nmp->nm_token);
14852e1cf57SMatthew Dillon 	wakeup(&nmp->nm_rxthread);
14952e1cf57SMatthew Dillon }
15052e1cf57SMatthew Dillon 
15152e1cf57SMatthew Dillon /*
152c9e9fb21SMatthew Dillon  * nfs service connection writer thread
153c9e9fb21SMatthew Dillon  *
15452e1cf57SMatthew Dillon  * The writer sits on the send side of the client's socket and
15552e1cf57SMatthew Dillon  * does both the initial processing of BIOs and also transmission
15652e1cf57SMatthew Dillon  * and retransmission of nfsreq's.
157edb90c22SMatthew Dillon  *
158edb90c22SMatthew Dillon  * The writer processes both new BIOs from nm_bioq and retransmit
159edb90c22SMatthew Dillon  * or state machine jumpbacks from nm_reqtxq
16052e1cf57SMatthew Dillon  */
16152e1cf57SMatthew Dillon void
nfssvc_iod_writer(void * arg)16252e1cf57SMatthew Dillon nfssvc_iod_writer(void *arg)
16352e1cf57SMatthew Dillon {
16452e1cf57SMatthew Dillon 	struct nfsmount *nmp = arg;
16552e1cf57SMatthew Dillon 	struct bio *bio;
166edb90c22SMatthew Dillon 	struct nfsreq *req;
16752e1cf57SMatthew Dillon 	struct vnode *vp;
168edb90c22SMatthew Dillon 	nfsm_info_t info;
16952e1cf57SMatthew Dillon 
170c6b43e93SMatthew Dillon 	lwkt_gettoken(&nmp->nm_token);
171c9e9fb21SMatthew Dillon 
17252e1cf57SMatthew Dillon 	if (nmp->nm_txstate == NFSSVC_INIT)
17352e1cf57SMatthew Dillon 		nmp->nm_txstate = NFSSVC_PENDING;
174c9e9fb21SMatthew Dillon 
17552e1cf57SMatthew Dillon 	for (;;) {
17652e1cf57SMatthew Dillon 		if (nmp->nm_txstate == NFSSVC_WAITING) {
17752e1cf57SMatthew Dillon 			tsleep(&nmp->nm_txstate, 0, "nfsidl", 0);
17852e1cf57SMatthew Dillon 			continue;
17952e1cf57SMatthew Dillon 		}
18052e1cf57SMatthew Dillon 		if (nmp->nm_txstate != NFSSVC_PENDING)
18152e1cf57SMatthew Dillon 			break;
18252e1cf57SMatthew Dillon 		nmp->nm_txstate = NFSSVC_WAITING;
18352e1cf57SMatthew Dillon 
184cc7d050eSMatthew Dillon 		/*
185cc7d050eSMatthew Dillon 		 * Eep, we could blow out the mbuf allocator if we just
186cc7d050eSMatthew Dillon 		 * did everything the kernel wanted us to do.
187cc7d050eSMatthew Dillon 		 */
188f8565b0fSMatthew Dillon 		while ((bio = TAILQ_FIRST(&nmp->nm_bioq)) != NULL) {
189*b9a7a2bdSMatthew Dillon 			if (nmp->nm_reqqlen > nfs_maxasyncbio)
190cc7d050eSMatthew Dillon 				break;
19152e1cf57SMatthew Dillon 			TAILQ_REMOVE(&nmp->nm_bioq, bio, bio_act);
19252e1cf57SMatthew Dillon 			vp = bio->bio_driver_info;
193edb90c22SMatthew Dillon 			nfs_startio(vp, bio, NULL);
194edb90c22SMatthew Dillon 		}
195edb90c22SMatthew Dillon 
196edb90c22SMatthew Dillon 		/*
197edb90c22SMatthew Dillon 		 * Process reauths & retransmits.  If we get an EINPROGRESS
198edb90c22SMatthew Dillon 		 * it means the state transitioned to WAITREPLY or later.
199edb90c22SMatthew Dillon 		 * Otherwise the request completed (probably with an error
200edb90c22SMatthew Dillon 		 * since we didn't get to a replied state).
201edb90c22SMatthew Dillon 		 */
202edb90c22SMatthew Dillon 		while ((req = TAILQ_FIRST(&nmp->nm_reqtxq)) != NULL) {
203edb90c22SMatthew Dillon 			TAILQ_REMOVE(&nmp->nm_reqtxq, req, r_chain);
204edb90c22SMatthew Dillon 			info = req->r_info;
205edb90c22SMatthew Dillon 			KKASSERT(info);
206edb90c22SMatthew Dillon 			info->error = nfs_request(info,
207edb90c22SMatthew Dillon 						  NFSM_STATE_AUTH,
208edb90c22SMatthew Dillon 						  NFSM_STATE_WAITREPLY);
209edb90c22SMatthew Dillon 			if (info->error == EINPROGRESS) {
210f8565b0fSMatthew Dillon 				;
211edb90c22SMatthew Dillon 			} else {
212f8565b0fSMatthew Dillon 				atomic_subtract_int(&nmp->nm_bioqlen, 1);
213edb90c22SMatthew Dillon 				info->done(info);
214edb90c22SMatthew Dillon 			}
21552e1cf57SMatthew Dillon 		}
21652e1cf57SMatthew Dillon 	}
21752e1cf57SMatthew Dillon 	nmp->nm_txthread = NULL;
21852e1cf57SMatthew Dillon 	nmp->nm_txstate = NFSSVC_DONE;
219c6b43e93SMatthew Dillon 	lwkt_reltoken(&nmp->nm_token);
22052e1cf57SMatthew Dillon 	wakeup(&nmp->nm_txthread);
22152e1cf57SMatthew Dillon }
22252e1cf57SMatthew Dillon 
22352e1cf57SMatthew Dillon void
nfssvc_iod_stop1(struct nfsmount * nmp)22413ddc895SMatthew Dillon nfssvc_iod_stop1(struct nfsmount *nmp)
22552e1cf57SMatthew Dillon {
22652e1cf57SMatthew Dillon 	nmp->nm_txstate = NFSSVC_STOPPING;
22713ddc895SMatthew Dillon 	nmp->nm_rxstate = NFSSVC_STOPPING;
22813ddc895SMatthew Dillon }
22913ddc895SMatthew Dillon 
23013ddc895SMatthew Dillon void
nfssvc_iod_stop2(struct nfsmount * nmp)23113ddc895SMatthew Dillon nfssvc_iod_stop2(struct nfsmount *nmp)
23213ddc895SMatthew Dillon {
23352e1cf57SMatthew Dillon 	wakeup(&nmp->nm_txstate);
23452e1cf57SMatthew Dillon 	while (nmp->nm_txthread)
235a63246d1SMatthew Dillon 		tsleep(&nmp->nm_txthread, 0, "nfssttx", hz*2);
23652e1cf57SMatthew Dillon 	wakeup(&nmp->nm_rxstate);
23752e1cf57SMatthew Dillon 	while (nmp->nm_rxthread)
238a63246d1SMatthew Dillon 		tsleep(&nmp->nm_rxthread, 0, "nfsstrx", hz*2);
23952e1cf57SMatthew Dillon }
24052e1cf57SMatthew Dillon 
24152e1cf57SMatthew Dillon void
nfssvc_iod_writer_wakeup(struct nfsmount * nmp)24252e1cf57SMatthew Dillon nfssvc_iod_writer_wakeup(struct nfsmount *nmp)
24352e1cf57SMatthew Dillon {
24452e1cf57SMatthew Dillon 	if (nmp->nm_txstate == NFSSVC_WAITING) {
24552e1cf57SMatthew Dillon 		nmp->nm_txstate = NFSSVC_PENDING;
24652e1cf57SMatthew Dillon 		wakeup(&nmp->nm_txstate);
24752e1cf57SMatthew Dillon 	}
24852e1cf57SMatthew Dillon }
249edb90c22SMatthew Dillon 
250edb90c22SMatthew Dillon void
nfssvc_iod_reader_wakeup(struct nfsmount * nmp)251edb90c22SMatthew Dillon nfssvc_iod_reader_wakeup(struct nfsmount *nmp)
252edb90c22SMatthew Dillon {
253edb90c22SMatthew Dillon 	if (nmp->nm_rxstate == NFSSVC_WAITING) {
254edb90c22SMatthew Dillon 		nmp->nm_rxstate = NFSSVC_PENDING;
255edb90c22SMatthew Dillon 		wakeup(&nmp->nm_rxstate);
256edb90c22SMatthew Dillon 	}
257edb90c22SMatthew Dillon }
258