xref: /illumos-gate/usr/src/lib/lib9p/common/request.c (revision aa693e99)
1 /*
2  * Copyright 2016 Jakub Klama <jceel@FreeBSD.org>
3  * All rights reserved
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted providing that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
15  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
16  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
18  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
22  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
23  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
24  * POSSIBILITY OF SUCH DAMAGE.
25  *
26  */
27 
28 #include <stdlib.h>
29 #include <string.h>
30 #include <assert.h>
31 #include <errno.h>
32 #include <sys/param.h>
33 #include <sys/uio.h>
34 #ifdef __illumos__
35 #include <sys/sysmacros.h>
36 #endif
37 #if defined(__FreeBSD__)
38 #include <sys/sbuf.h>
39 #else
40 #include "sbuf/sbuf.h"
41 #endif
42 #include "lib9p.h"
43 #include "lib9p_impl.h"
44 #include "fcall.h"
45 #include "fid.h"
46 #include "hashtable.h"
47 #include "log.h"
48 #include "linux_errno.h"
49 #include "backend/backend.h"
50 #include "threadpool.h"
51 
52 #define N(x)    (sizeof(x) / sizeof(x[0]))
53 
54 static int l9p_dispatch_tversion(struct l9p_request *req);
55 static int l9p_dispatch_tattach(struct l9p_request *req);
56 static int l9p_dispatch_tclunk(struct l9p_request *req);
57 static int l9p_dispatch_tcreate(struct l9p_request *req);
58 static int l9p_dispatch_topen(struct l9p_request *req);
59 static int l9p_dispatch_tread(struct l9p_request *req);
60 static int l9p_dispatch_tremove(struct l9p_request *req);
61 static int l9p_dispatch_tstat(struct l9p_request *req);
62 static int l9p_dispatch_twalk(struct l9p_request *req);
63 static int l9p_dispatch_twrite(struct l9p_request *req);
64 static int l9p_dispatch_twstat(struct l9p_request *req);
65 static int l9p_dispatch_tstatfs(struct l9p_request *req);
66 static int l9p_dispatch_tlopen(struct l9p_request *req);
67 static int l9p_dispatch_tlcreate(struct l9p_request *req);
68 static int l9p_dispatch_tsymlink(struct l9p_request *req);
69 static int l9p_dispatch_tmknod(struct l9p_request *req);
70 static int l9p_dispatch_trename(struct l9p_request *req);
71 static int l9p_dispatch_treadlink(struct l9p_request *req);
72 static int l9p_dispatch_tgetattr(struct l9p_request *req);
73 static int l9p_dispatch_tsetattr(struct l9p_request *req);
74 static int l9p_dispatch_txattrwalk(struct l9p_request *req);
75 static int l9p_dispatch_txattrcreate(struct l9p_request *req);
76 static int l9p_dispatch_treaddir(struct l9p_request *req);
77 static int l9p_dispatch_tfsync(struct l9p_request *req);
78 static int l9p_dispatch_tlock(struct l9p_request *req);
79 static int l9p_dispatch_tgetlock(struct l9p_request *req);
80 static int l9p_dispatch_tlink(struct l9p_request *req);
81 static int l9p_dispatch_tmkdir(struct l9p_request *req);
82 static int l9p_dispatch_trenameat(struct l9p_request *req);
83 static int l9p_dispatch_tunlinkat(struct l9p_request *req);
84 
85 /*
86  * Each Txxx handler has a "must run" flag.  If it is false,
87  * we check for a flush request before calling the handler.
88  * If a flush is already requested we can instantly fail the
89  * request with EINTR.
90  *
91  * Tclunk and Tremove must run because they make their fids
92  * become invalid.  Tversion and Tattach should never get
93  * a flush request applied (it makes no sense as the connection
94  * is not really running yet), so it should be harmless to
95  * set them either way, but for now we have them as must-run.
96  * Flushing a Tflush is not really allowed either so we keep
97  * these as must-run too (although they run without being done
98  * threaded anyway).
99  */
100 struct l9p_handler {
101 	enum l9p_ftype type;
102 	int (*handler)(struct l9p_request *);
103 	bool must_run;
104 };
105 
106 static const struct l9p_handler l9p_handlers_no_version[] = {
107 	{L9P_TVERSION, l9p_dispatch_tversion, true},
108 };
109 
110 static const struct l9p_handler l9p_handlers_base[] = {
111 	{L9P_TVERSION, l9p_dispatch_tversion, true},
112 	{L9P_TATTACH, l9p_dispatch_tattach, true},
113 	{L9P_TCLUNK, l9p_dispatch_tclunk, true},
114 	{L9P_TFLUSH, l9p_threadpool_tflush, true},
115 	{L9P_TCREATE, l9p_dispatch_tcreate, false},
116 	{L9P_TOPEN, l9p_dispatch_topen, false},
117 	{L9P_TREAD, l9p_dispatch_tread, false},
118 	{L9P_TWRITE, l9p_dispatch_twrite, false},
119 	{L9P_TREMOVE, l9p_dispatch_tremove, true},
120 	{L9P_TSTAT, l9p_dispatch_tstat, false},
121 	{L9P_TWALK, l9p_dispatch_twalk, false},
122 	{L9P_TWSTAT, l9p_dispatch_twstat, false}
123 };
124 static const struct l9p_handler l9p_handlers_dotu[] = {
125 	{L9P_TVERSION, l9p_dispatch_tversion, true},
126 	{L9P_TATTACH, l9p_dispatch_tattach, true},
127 	{L9P_TCLUNK, l9p_dispatch_tclunk, true},
128 	{L9P_TFLUSH, l9p_threadpool_tflush, true},
129 	{L9P_TCREATE, l9p_dispatch_tcreate, false},
130 	{L9P_TOPEN, l9p_dispatch_topen, false},
131 	{L9P_TREAD, l9p_dispatch_tread, false},
132 	{L9P_TWRITE, l9p_dispatch_twrite, false},
133 	{L9P_TREMOVE, l9p_dispatch_tremove, true},
134 	{L9P_TSTAT, l9p_dispatch_tstat, false},
135 	{L9P_TWALK, l9p_dispatch_twalk, false},
136 	{L9P_TWSTAT, l9p_dispatch_twstat, false}
137 };
138 static const struct l9p_handler l9p_handlers_dotL[] = {
139 	{L9P_TVERSION, l9p_dispatch_tversion, true},
140 	{L9P_TATTACH, l9p_dispatch_tattach, true},
141 	{L9P_TCLUNK, l9p_dispatch_tclunk, true},
142 	{L9P_TFLUSH, l9p_threadpool_tflush, true},
143 	{L9P_TCREATE, l9p_dispatch_tcreate, false},
144 	{L9P_TOPEN, l9p_dispatch_topen, false},
145 	{L9P_TREAD, l9p_dispatch_tread, false},
146 	{L9P_TWRITE, l9p_dispatch_twrite, false},
147 	{L9P_TREMOVE, l9p_dispatch_tremove, true},
148 	{L9P_TSTAT, l9p_dispatch_tstat, false},
149 	{L9P_TWALK, l9p_dispatch_twalk, false},
150 	{L9P_TWSTAT, l9p_dispatch_twstat, false},
151 	{L9P_TSTATFS, l9p_dispatch_tstatfs, false},
152 	{L9P_TLOPEN, l9p_dispatch_tlopen, false},
153 	{L9P_TLCREATE, l9p_dispatch_tlcreate, false},
154 	{L9P_TSYMLINK, l9p_dispatch_tsymlink, false},
155 	{L9P_TMKNOD, l9p_dispatch_tmknod, false},
156 	{L9P_TRENAME, l9p_dispatch_trename, false},
157 	{L9P_TREADLINK, l9p_dispatch_treadlink, false},
158 	{L9P_TGETATTR, l9p_dispatch_tgetattr, false},
159 	{L9P_TSETATTR, l9p_dispatch_tsetattr, false},
160 	{L9P_TXATTRWALK, l9p_dispatch_txattrwalk, false},
161 	{L9P_TXATTRCREATE, l9p_dispatch_txattrcreate, false},
162 	{L9P_TREADDIR, l9p_dispatch_treaddir, false},
163 	{L9P_TFSYNC, l9p_dispatch_tfsync, false},
164 	{L9P_TLOCK, l9p_dispatch_tlock, true},
165 	{L9P_TGETLOCK, l9p_dispatch_tgetlock, true},
166 	{L9P_TLINK, l9p_dispatch_tlink, false},
167 	{L9P_TMKDIR, l9p_dispatch_tmkdir, false},
168 	{L9P_TRENAMEAT, l9p_dispatch_trenameat, false},
169 	{L9P_TUNLINKAT, l9p_dispatch_tunlinkat, false},
170 };
171 
172 /*
173  * NB: version index 0 is reserved for new connections, and
174  * is a protocol that handles only L9P_TVERSION.  Once we get a
175  * valid version, we start a new session using its dispatch table.
176  */
177 static const struct {
178 	const char *name;
179 	const struct l9p_handler *handlers;
180 	int n_handlers;
181 } l9p_versions[] = {
182 	{ "<none>", l9p_handlers_no_version, N(l9p_handlers_no_version) },
183 	{ "9P2000", l9p_handlers_base, N(l9p_handlers_base) },
184 	{ "9P2000.u", l9p_handlers_dotu, N(l9p_handlers_dotu), },
185 	{ "9P2000.L", l9p_handlers_dotL, N(l9p_handlers_dotL), },
186 };
187 
188 /*
189  * Run the appropriate handler for this request.
190  * It's our caller's responsibility to respond.
191  */
192 int
l9p_dispatch_request(struct l9p_request * req)193 l9p_dispatch_request(struct l9p_request *req)
194 {
195 	struct l9p_connection *conn;
196 #if defined(L9P_DEBUG)
197 	struct sbuf *sb;
198 #endif
199 	size_t i, n;
200 	const struct l9p_handler *handlers, *hp;
201 	bool flush_requested;
202 
203 	conn = req->lr_conn;
204 	flush_requested = req->lr_flushstate == L9P_FLUSH_REQUESTED_PRE_START;
205 
206 	handlers = l9p_versions[conn->lc_version].handlers;
207 	n = (size_t)l9p_versions[conn->lc_version].n_handlers;
208 	for (hp = handlers, i = 0; i < n; hp++, i++)
209 		if (req->lr_req.hdr.type == hp->type)
210 			goto found;
211 	hp = NULL;
212 found:
213 
214 #if defined(L9P_DEBUG)
215 	sb = sbuf_new_auto();
216 	if (flush_requested) {
217 		sbuf_cat(sb, "FLUSH requested pre-dispatch");
218 		if (hp != NULL && hp->must_run)
219 			sbuf_cat(sb, ", but must run");
220 		sbuf_cat(sb, ": ");
221 	}
222 	l9p_describe_fcall(&req->lr_req, conn->lc_version, sb);
223 	sbuf_finish(sb);
224 
225 	L9P_LOG(L9P_DEBUG, "%s", sbuf_data(sb));
226 	sbuf_delete(sb);
227 #endif
228 
229 	if (hp != NULL) {
230 		if (!flush_requested || hp->must_run)
231 			return (hp->handler(req));
232 		return (EINTR);
233 	}
234 
235 	L9P_LOG(L9P_WARNING, "unknown request of type %d",
236 	    req->lr_req.hdr.type);
237 	return (ENOSYS);
238 }
239 
240 /*
241  * Translate BSD errno to 9P2000/9P2000.u errno.
242  */
243 static inline int
e29p(int errnum)244 e29p(int errnum)
245 {
246 	static int const table[] = {
247 		[ENOTEMPTY] = EPERM,
248 		[EDQUOT] = EPERM,
249 		[ENOSYS] = EPERM,	/* ??? */
250 	};
251 
252 	if ((size_t)errnum < N(table) && table[errnum] != 0)
253 		return (table[errnum]);
254 	if (errnum <= ERANGE)
255 		return (errnum);
256 	return (EIO);			/* ??? */
257 }
258 
259 /*
260  * Translate BSD errno to Linux errno.
261  */
262 static inline int
e2linux(int errnum)263 e2linux(int errnum)
264 {
265 	static int const table[] = {
266 		[EDEADLK] = LINUX_EDEADLK,
267 		[EAGAIN] = LINUX_EAGAIN,
268 		[EINPROGRESS] = LINUX_EINPROGRESS,
269 		[EALREADY] = LINUX_EALREADY,
270 		[ENOTSOCK] = LINUX_ENOTSOCK,
271 		[EDESTADDRREQ] = LINUX_EDESTADDRREQ,
272 		[EMSGSIZE] = LINUX_EMSGSIZE,
273 		[EPROTOTYPE] = LINUX_EPROTOTYPE,
274 		[ENOPROTOOPT] = LINUX_ENOPROTOOPT,
275 		[EPROTONOSUPPORT] = LINUX_EPROTONOSUPPORT,
276 		[ESOCKTNOSUPPORT] = LINUX_ESOCKTNOSUPPORT,
277 		[EOPNOTSUPP] = LINUX_EOPNOTSUPP,
278 		[EPFNOSUPPORT] = LINUX_EPFNOSUPPORT,
279 		[EAFNOSUPPORT] = LINUX_EAFNOSUPPORT,
280 		[EADDRINUSE] = LINUX_EADDRINUSE,
281 		[EADDRNOTAVAIL] = LINUX_EADDRNOTAVAIL,
282 		[ENETDOWN] = LINUX_ENETDOWN,
283 		[ENETUNREACH] = LINUX_ENETUNREACH,
284 		[ENETRESET] = LINUX_ENETRESET,
285 		[ECONNABORTED] = LINUX_ECONNABORTED,
286 		[ECONNRESET] = LINUX_ECONNRESET,
287 		[ENOBUFS] = LINUX_ENOBUFS,
288 		[EISCONN] = LINUX_EISCONN,
289 		[ENOTCONN] = LINUX_ENOTCONN,
290 		[ESHUTDOWN] = LINUX_ESHUTDOWN,
291 		[ETOOMANYREFS] = LINUX_ETOOMANYREFS,
292 		[ETIMEDOUT] = LINUX_ETIMEDOUT,
293 		[ECONNREFUSED] = LINUX_ECONNREFUSED,
294 		[ELOOP] = LINUX_ELOOP,
295 		[ENAMETOOLONG] = LINUX_ENAMETOOLONG,
296 		[EHOSTDOWN] = LINUX_EHOSTDOWN,
297 		[EHOSTUNREACH] = LINUX_EHOSTUNREACH,
298 		[ENOTEMPTY] = LINUX_ENOTEMPTY,
299 #ifndef __illumos__
300 		[EPROCLIM] = LINUX_EAGAIN,
301 #endif
302 		[EUSERS] = LINUX_EUSERS,
303 		[EDQUOT] = LINUX_EDQUOT,
304 		[ESTALE] = LINUX_ESTALE,
305 		[EREMOTE] = LINUX_EREMOTE,
306 		/* EBADRPC = unmappable? */
307 		/* ERPCMISMATCH = unmappable? */
308 		/* EPROGUNAVAIL = unmappable? */
309 		/* EPROGMISMATCH = unmappable? */
310 		/* EPROCUNAVAIL = unmappable? */
311 		[ENOLCK] = LINUX_ENOLCK,
312 		[ENOSYS] = LINUX_ENOSYS,
313 		/* EFTYPE = unmappable? */
314 		/* EAUTH = unmappable? */
315 		/* ENEEDAUTH = unmappable? */
316 		[EIDRM] = LINUX_EIDRM,
317 		[ENOMSG] = LINUX_ENOMSG,
318 		[EOVERFLOW] = LINUX_EOVERFLOW,
319 		[ECANCELED] = LINUX_ECANCELED,
320 		[EILSEQ] = LINUX_EILSEQ,
321 		/* EDOOFUS = unmappable? */
322 		[EBADMSG] = LINUX_EBADMSG,
323 		[EMULTIHOP] = LINUX_EMULTIHOP,
324 		[ENOLINK] = LINUX_ENOLINK,
325 		[EPROTO] = LINUX_EPROTO,
326 		/* ENOTCAPABLE = unmappable? */
327 #ifdef ECAPMODE
328 		[ECAPMODE] = EPERM,
329 #endif
330 #ifdef ENOTRECOVERABLE
331 		[ENOTRECOVERABLE] = LINUX_ENOTRECOVERABLE,
332 #endif
333 #ifdef EOWNERDEAD
334 		[EOWNERDEAD] = LINUX_EOWNERDEAD,
335 #endif
336 	};
337 
338 	/*
339 	 * In case we want to return a raw Linux errno, allow negative
340 	 * values a la Linux kernel internals.
341 	 *
342 	 * Values up to ERANGE are shared across systems (see
343 	 * linux_errno.h), except for EAGAIN.
344 	 */
345 	if (errnum < 0)
346 		return (-errnum);
347 
348 	if ((size_t)errnum < N(table) && table[errnum] != 0)
349 		return (table[errnum]);
350 
351 	if (errnum <= ERANGE)
352 		return (errnum);
353 
354 	L9P_LOG(L9P_WARNING, "cannot map errno %d to anything reasonable",
355 	    errnum);
356 
357 	return (LINUX_ENOTRECOVERABLE);	/* ??? */
358 }
359 
360 /*
361  * Send response to request, or possibly just drop request.
362  * We also need to know whether to remove the request from
363  * the tag hash table.
364  */
365 void
l9p_respond(struct l9p_request * req,bool drop,bool rmtag)366 l9p_respond(struct l9p_request *req, bool drop, bool rmtag)
367 {
368 	struct l9p_connection *conn = req->lr_conn;
369 	size_t iosize;
370 #if defined(L9P_DEBUG)
371 	struct sbuf *sb;
372 	const char *ftype;
373 #endif
374 	int error;
375 
376 	req->lr_resp.hdr.tag = req->lr_req.hdr.tag;
377 
378 	error = req->lr_error;
379 	if (error == 0)
380 		req->lr_resp.hdr.type = req->lr_req.hdr.type + 1;
381 	else {
382 		if (conn->lc_version == L9P_2000L) {
383 			req->lr_resp.hdr.type = L9P_RLERROR;
384 			req->lr_resp.error.errnum = (uint32_t)e2linux(error);
385 		} else {
386 			req->lr_resp.hdr.type = L9P_RERROR;
387 			req->lr_resp.error.ename = strerror(error);
388 			req->lr_resp.error.errnum = (uint32_t)e29p(error);
389 		}
390 	}
391 
392 #if defined(L9P_DEBUG)
393 	sb = sbuf_new_auto();
394 	l9p_describe_fcall(&req->lr_resp, conn->lc_version, sb);
395 	sbuf_finish(sb);
396 
397 	switch (req->lr_flushstate) {
398 	case L9P_FLUSH_NONE:
399 	default:
400 		ftype = "";
401 		break;
402 	case L9P_FLUSH_REQUESTED_PRE_START:
403 		ftype = "FLUSH requested pre-dispatch: ";
404 		break;
405 	case L9P_FLUSH_REQUESTED_POST_START:
406 		ftype = "FLUSH requested while running: ";
407 		break;
408 	case L9P_FLUSH_TOOLATE:
409 		ftype = "FLUSH requested too late: ";
410 		break;
411 	}
412 	L9P_LOG(L9P_DEBUG, "%s%s%s",
413 	    drop ? "DROP: " : "", ftype, sbuf_data(sb));
414 	sbuf_delete(sb);
415 #endif
416 
417 	error = drop ? 0 :
418 	    l9p_pufcall(&req->lr_resp_msg, &req->lr_resp, conn->lc_version);
419 	if (rmtag)
420 		ht_remove(&conn->lc_requests, req->lr_req.hdr.tag);
421 	if (error != 0) {
422 		L9P_LOG(L9P_ERROR, "cannot pack response");
423 		drop = true;
424 	}
425 
426 	if (drop) {
427 		conn->lc_lt.lt_drop_response(req,
428 		    req->lr_resp_msg.lm_iov, req->lr_resp_msg.lm_niov,
429 		    conn->lc_lt.lt_aux);
430 	} else {
431 		iosize = req->lr_resp_msg.lm_size;
432 
433 		/*
434 		 * Include I/O size in calculation for Rread and
435 		 * Rreaddir responses.
436 		 */
437 		if (req->lr_resp.hdr.type == L9P_RREAD ||
438 		    req->lr_resp.hdr.type == L9P_RREADDIR)
439 			iosize += req->lr_resp.io.count;
440 
441 		conn->lc_lt.lt_send_response(req,
442 		    req->lr_resp_msg.lm_iov, req->lr_resp_msg.lm_niov,
443 		    iosize, conn->lc_lt.lt_aux);
444 	}
445 
446 	l9p_freefcall(&req->lr_req);
447 	l9p_freefcall(&req->lr_resp);
448 
449 	free(req);
450 }
451 
452 /*
453  * This allows a caller to iterate through the data in a
454  * read or write request (creating the data if packing,
455  * scanning through it if unpacking).  This is used for
456  * writing readdir entries, so mode should be L9P_PACK
457  * (but we allow L9P_UNPACK so that debug code can also scan
458  * through the data later, if desired).
459  *
460  * This relies on the Tread op having positioned the request's
461  * iov to the beginning of the data buffer (note the l9p_seek_iov
462  * in l9p_dispatch_tread).
463  */
464 void
l9p_init_msg(struct l9p_message * msg,struct l9p_request * req,enum l9p_pack_mode mode)465 l9p_init_msg(struct l9p_message *msg, struct l9p_request *req,
466     enum l9p_pack_mode mode)
467 {
468 
469 	msg->lm_size = 0;
470 	msg->lm_mode = mode;
471 	msg->lm_cursor_iov = 0;
472 	msg->lm_cursor_offset = 0;
473 	msg->lm_niov = req->lr_data_niov;
474 	memcpy(msg->lm_iov, req->lr_data_iov,
475 	    sizeof (struct iovec) * req->lr_data_niov);
476 }
477 
478 enum fid_lookup_flags {
479 	F_REQUIRE_OPEN = 0x01,	/* require that the file be marked OPEN */
480 	F_REQUIRE_DIR = 0x02,	/* require that the file be marked ISDIR */
481 	F_REQUIRE_XATTR = 0x04,	/* require that the file be marked XATTR */
482 	F_REQUIRE_AUTH = 0x08,	/* require that the fid be marked AUTH */
483 	F_FORBID_OPEN = 0x10,	/* forbid that the file be marked OPEN */
484 	F_FORBID_DIR = 0x20,	/* forbid that the file be marked ISDIR */
485 	F_FORBID_XATTR = 0x40,	/* forbid that the file be marked XATTR */
486 	F_ALLOW_AUTH = 0x80,	/* allow that the fid be marked AUTH */
487 };
488 
489 /*
490  * Look up a fid.  It must correspond to a valid file, else we return
491  * the given errno (some "not a valid fid" calls must return EIO and
492  * some must return EINVAL and qemu returns ENOENT in other cases and
493  * so on, so we just provide a general "return this error number").
494  *
495  * Callers may also set constraints: fid must be (or not be) open,
496  * must be (or not be) a directory, must be (or not be) an xattr.
497  *
498  * Only one op has a fid that *must* be an auth fid.  Most ops forbid
499  * auth fids  So instead of FORBID we have ALLOW here and the default
500  * is FORBID.
501  */
502 static inline int
fid_lookup(struct l9p_connection * conn,uint32_t fid,int err,int flags,struct l9p_fid ** afile)503 fid_lookup(struct l9p_connection *conn, uint32_t fid, int err, int flags,
504     struct l9p_fid **afile)
505 {
506 	struct l9p_fid *file;
507 
508 	file = ht_find(&conn->lc_files, fid);
509 	if (file == NULL)
510 		return (err);
511 
512 	/*
513 	 * As soon as we go multithreaded / async, this
514 	 * assert has to become "return EINVAL" or "return err".
515 	 *
516 	 * We may also need a way to mark a fid as
517 	 * "in async op" (valid for some purposes, but cannot be
518 	 * used elsewhere until async op is completed or aborted).
519 	 *
520 	 * For now, this serves for bug-detecting.
521 	 */
522 	assert(l9p_fid_isvalid(file));
523 
524 	/*
525 	 * Note that we're inline expanded and flags is constant,
526 	 * so unnecessary tests just drop out entirely.
527 	 */
528 	if ((flags & F_REQUIRE_OPEN) && !l9p_fid_isopen(file))
529 		return (EINVAL);
530 	if ((flags & F_FORBID_OPEN) && l9p_fid_isopen(file))
531 		return (EINVAL);
532 	if ((flags & F_REQUIRE_DIR) && !l9p_fid_isdir(file))
533 		return (ENOTDIR);
534 	if ((flags & F_FORBID_DIR) && l9p_fid_isdir(file))
535 		return (EISDIR);
536 	if ((flags & F_REQUIRE_XATTR) && !l9p_fid_isxattr(file))
537 		return (EINVAL);
538 	if ((flags & F_FORBID_XATTR) && l9p_fid_isxattr(file))
539 		return (EINVAL);
540 	if (l9p_fid_isauth(file)) {
541 		if ((flags & (F_REQUIRE_AUTH | F_ALLOW_AUTH)) == 0)
542 			return (EINVAL);
543 	} else if (flags & F_REQUIRE_AUTH)
544 		return (EINVAL);
545 	*afile = file;
546 	return (0);
547 }
548 
549 /*
550  * Append variable-size stat object and adjust io count.
551  * Returns 0 if the entire stat object was packed, -1 if not.
552  * A fully packed object updates the request's io count.
553  *
554  * Caller must use their own private l9p_message object since
555  * a partially packed object will leave the message object in
556  * a useless state.
557  *
558  * Frees the stat object.
559  */
560 int
l9p_pack_stat(struct l9p_message * msg,struct l9p_request * req,struct l9p_stat * st)561 l9p_pack_stat(struct l9p_message *msg, struct l9p_request *req,
562     struct l9p_stat *st)
563 {
564 	struct l9p_connection *conn = req->lr_conn;
565 	uint16_t size = l9p_sizeof_stat(st, conn->lc_version);
566 	int ret = 0;
567 
568 	assert(msg->lm_mode == L9P_PACK);
569 
570 	if (req->lr_resp.io.count + size > req->lr_req.io.count ||
571 	    l9p_pustat(msg, st, conn->lc_version) < 0)
572 		ret = -1;
573 	else
574 		req->lr_resp.io.count += size;
575 	l9p_freestat(st);
576 	return (ret);
577 }
578 
579 static int
l9p_dispatch_tversion(struct l9p_request * req)580 l9p_dispatch_tversion(struct l9p_request *req)
581 {
582 	struct l9p_connection *conn = req->lr_conn;
583 	struct l9p_server *server = conn->lc_server;
584 	enum l9p_version remote_version = L9P_INVALID_VERSION;
585 	size_t i;
586 	const char *remote_version_name;
587 
588 	for (i = 0; i < N(l9p_versions); i++) {
589 		if (strcmp(req->lr_req.version.version,
590 		    l9p_versions[i].name) == 0) {
591 			remote_version = (enum l9p_version)i;
592 			break;
593 		}
594 	}
595 
596 	if (remote_version == L9P_INVALID_VERSION) {
597 		L9P_LOG(L9P_ERROR, "unsupported remote version: %s",
598 		    req->lr_req.version.version);
599 		return (ENOSYS);
600 	}
601 
602 	remote_version_name = l9p_versions[remote_version].name;
603 	L9P_LOG(L9P_INFO, "remote version: %s", remote_version_name);
604 	L9P_LOG(L9P_INFO, "local version: %s",
605 	    l9p_versions[server->ls_max_version].name);
606 
607 	conn->lc_version = MIN(remote_version, server->ls_max_version);
608 	conn->lc_msize = MIN(req->lr_req.version.msize, conn->lc_msize);
609 	conn->lc_max_io_size = conn->lc_msize - 24;
610 	req->lr_resp.version.version = strdup(remote_version_name);
611 	req->lr_resp.version.msize = conn->lc_msize;
612 	return (0);
613 }
614 
615 static int
l9p_dispatch_tattach(struct l9p_request * req)616 l9p_dispatch_tattach(struct l9p_request *req)
617 {
618 	struct l9p_connection *conn = req->lr_conn;
619 	struct l9p_backend *be;
620 	struct l9p_fid *fid;
621 	int error;
622 
623 	/*
624 	 * We still don't have Tauth yet, but let's code this part
625 	 * anyway.
626 	 *
627 	 * Look up the auth fid first since if it fails we can just
628 	 * return immediately.
629 	 */
630 	if (req->lr_req.tattach.afid != L9P_NOFID) {
631 		error = fid_lookup(conn, req->lr_req.tattach.afid, EINVAL,
632 		    F_REQUIRE_AUTH, &req->lr_fid2);
633 		if (error)
634 			return (error);
635 	} else
636 		req->lr_fid2 = NULL;
637 
638 	fid = l9p_connection_alloc_fid(conn, req->lr_req.hdr.fid);
639 	if (fid == NULL)
640 		return (EINVAL);
641 
642 	be = conn->lc_server->ls_backend;
643 
644 	req->lr_fid = fid;
645 
646 	/* For backend convenience, set NONUNAME on 9P2000. */
647 	if (conn->lc_version == L9P_2000)
648 		req->lr_req.tattach.n_uname = L9P_NONUNAME;
649 	error = be->attach(be->softc, req);
650 
651 	/*
652 	 * On success, fid becomes valid; on failure, disconnect.
653 	 * It certainly *should* be a directory here...
654 	 */
655 	if (error == 0) {
656 		l9p_fid_setvalid(fid);
657 		if (req->lr_resp.rattach.qid.type & L9P_QTDIR)
658 			l9p_fid_setdir(fid);
659 	} else
660 		l9p_connection_remove_fid(conn, fid);
661 	return (error);
662 }
663 
664 static int
l9p_dispatch_tclunk(struct l9p_request * req)665 l9p_dispatch_tclunk(struct l9p_request *req)
666 {
667 	struct l9p_connection *conn = req->lr_conn;
668 	struct l9p_backend *be;
669 	struct l9p_fid *fid;
670 	int error;
671 
672 	/* Note that clunk is the only way to dispose of an auth fid. */
673 	error = fid_lookup(conn, req->lr_req.hdr.fid, ENOENT,
674 	    F_ALLOW_AUTH, &fid);
675 	if (error)
676 		return (error);
677 
678 	be = conn->lc_server->ls_backend;
679 	l9p_fid_unsetvalid(fid);
680 
681 	/*
682 	 * If it's an xattr fid there must, by definition, be an
683 	 * xattrclunk.  The xattrclunk function can only be NULL if
684 	 * xattrwalk and xattrcreate are NULL or always return error.
685 	 *
686 	 * Q: do we want to allow async xattrclunk in case of very
687 	 * large xattr create?  This will make things difficult,
688 	 * so probably not.
689 	 */
690 	if (l9p_fid_isxattr(fid))
691 		error = be->xattrclunk(be->softc, fid);
692 	else
693 		error = be->clunk(be->softc, fid);
694 
695 	/* fid is now gone regardless of any error return */
696 	l9p_connection_remove_fid(conn, fid);
697 	return (error);
698 }
699 
700 static int
l9p_dispatch_tcreate(struct l9p_request * req)701 l9p_dispatch_tcreate(struct l9p_request *req)
702 {
703 	struct l9p_connection *conn = req->lr_conn;
704 	struct l9p_backend *be;
705 	uint32_t dmperm;
706 	int error;
707 
708 	/* Incoming fid must represent a directory that has not been opened. */
709 	error = fid_lookup(conn, req->lr_req.hdr.fid, EINVAL,
710 	    F_REQUIRE_DIR | F_FORBID_OPEN, &req->lr_fid);
711 	if (error)
712 		return (error);
713 
714 	be = conn->lc_server->ls_backend;
715 	dmperm = req->lr_req.tcreate.perm;
716 #define MKDIR_OR_SIMILAR \
717     (L9P_DMDIR | L9P_DMSYMLINK | L9P_DMNAMEDPIPE | L9P_DMSOCKET | L9P_DMDEVICE)
718 
719 	/*
720 	 * TODO:
721 	 *  - check new file name
722 	 *  - break out different kinds of create (file vs mkdir etc)
723 	 *  - add async file-create (leaves req->lr_fid in limbo)
724 	 *
725 	 * A successful file-create changes the fid into an open file.
726 	 */
727 	error = be->create(be->softc, req);
728 	if (error == 0 && (dmperm & MKDIR_OR_SIMILAR) == 0) {
729 		l9p_fid_unsetdir(req->lr_fid);
730 		l9p_fid_setopen(req->lr_fid);
731 	}
732 
733 	return (error);
734 }
735 
736 static int
l9p_dispatch_topen(struct l9p_request * req)737 l9p_dispatch_topen(struct l9p_request *req)
738 {
739 	struct l9p_connection *conn = req->lr_conn;
740 	struct l9p_backend *be;
741 	int error;
742 
743 	error = fid_lookup(conn, req->lr_req.hdr.fid, ENOENT,
744 	    F_FORBID_OPEN | F_FORBID_XATTR, &req->lr_fid);
745 	if (error)
746 		return (error);
747 
748 	be = conn->lc_server->ls_backend;
749 
750 	/*
751 	 * TODO:
752 	 *  - add async open (leaves req->lr_fid in limbo)
753 	 */
754 	error = be->open(be->softc, req);
755 	if (error == 0)
756 		l9p_fid_setopen(req->lr_fid);
757 	return (error);
758 }
759 
760 static int
l9p_dispatch_tread(struct l9p_request * req)761 l9p_dispatch_tread(struct l9p_request *req)
762 {
763 	struct l9p_connection *conn = req->lr_conn;
764 	struct l9p_backend *be;
765 	struct l9p_fid *fid;
766 	int error;
767 
768 	/* Xattr fids are not open, so we need our own tests. */
769 	error = fid_lookup(conn, req->lr_req.hdr.fid, EINVAL, 0, &req->lr_fid);
770 	if (error)
771 		return (error);
772 
773 	/*
774 	 * Adjust so that writing messages (packing data) starts
775 	 * right after the count field in the response.
776 	 *
777 	 * size[4] + Rread[1] + tag[2] + count[4] = 11
778 	 */
779 	l9p_seek_iov(req->lr_resp_msg.lm_iov, req->lr_resp_msg.lm_niov,
780 	    req->lr_data_iov, &req->lr_data_niov, 11);
781 
782 	/*
783 	 * If it's an xattr fid there must, by definition, be an
784 	 * xattrread.  The xattrread function can only be NULL if
785 	 * xattrwalk and xattrcreate are NULL or always return error.
786 	 *
787 	 * TODO:
788 	 *   separate out directory-read
789 	 *   allow async read
790 	 */
791 	be = conn->lc_server->ls_backend;
792 	fid = req->lr_fid;
793 	if (l9p_fid_isxattr(fid)) {
794 		error = be->xattrread(be->softc, req);
795 	} else if (l9p_fid_isopen(fid)) {
796 		error = be->read(be->softc, req);
797 	} else {
798 		error = EINVAL;
799 	}
800 
801 	return (error);
802 }
803 
804 static int
l9p_dispatch_tremove(struct l9p_request * req)805 l9p_dispatch_tremove(struct l9p_request *req)
806 {
807 	struct l9p_connection *conn = req->lr_conn;
808 	struct l9p_backend *be;
809 	struct l9p_fid *fid;
810 	int error;
811 
812 	/*
813 	 * ?? Should we allow Tremove on auth fids? If so, do
814 	 * we pretend it is just a Tclunk?
815 	 */
816 	error = fid_lookup(conn, req->lr_req.hdr.fid, EINVAL, 0, &fid);
817 	if (error)
818 		return (error);
819 
820 	be = conn->lc_server->ls_backend;
821 	l9p_fid_unsetvalid(fid);
822 
823 	error = be->remove(be->softc, fid);
824 	/* fid is now gone regardless of any error return */
825 	l9p_connection_remove_fid(conn, fid);
826 	return (error);
827 }
828 
829 static int
l9p_dispatch_tstat(struct l9p_request * req)830 l9p_dispatch_tstat(struct l9p_request *req)
831 {
832 	struct l9p_connection *conn = req->lr_conn;
833 	struct l9p_backend *be;
834 	struct l9p_fid *fid;
835 	int error;
836 
837 	/* Allow Tstat on auth fid?  Seems harmless enough... */
838 	error = fid_lookup(conn, req->lr_req.hdr.fid, ENOENT,
839 	    F_ALLOW_AUTH, &fid);
840 	if (error)
841 		return (error);
842 
843 	be = conn->lc_server->ls_backend;
844 	req->lr_fid = fid;
845 	error = be->stat(be->softc, req);
846 
847 	if (error == 0) {
848 		if (l9p_fid_isauth(fid))
849 			req->lr_resp.rstat.stat.qid.type |= L9P_QTAUTH;
850 
851 		/* should we check req->lr_resp.rstat.qid.type L9P_QTDIR bit? */
852 		if (req->lr_resp.rstat.stat.qid.type &= L9P_QTDIR)
853 			l9p_fid_setdir(fid);
854 		else
855 			l9p_fid_unsetdir(fid);
856 	}
857 
858 	return (error);
859 }
860 
861 static int
l9p_dispatch_twalk(struct l9p_request * req)862 l9p_dispatch_twalk(struct l9p_request *req)
863 {
864 	struct l9p_connection *conn = req->lr_conn;
865 	struct l9p_backend *be;
866 	struct l9p_fid *fid, *newfid;
867 	uint16_t n;
868 	int error;
869 
870 	/* Can forbid XATTR, but cannot require DIR. */
871 	error = fid_lookup(conn, req->lr_req.hdr.fid, ENOENT,
872 	    F_FORBID_XATTR, &fid);
873 	if (error)
874 		return (error);
875 
876 	if (req->lr_req.twalk.hdr.fid != req->lr_req.twalk.newfid) {
877 		newfid = l9p_connection_alloc_fid(conn,
878 		    req->lr_req.twalk.newfid);
879 		if (newfid == NULL)
880 			return (EINVAL);
881 	} else
882 		newfid = fid;
883 
884 	be = conn->lc_server->ls_backend;
885 	req->lr_fid = fid;
886 	req->lr_newfid = newfid;
887 	error = be->walk(be->softc, req);
888 
889 	/*
890 	 * If newfid == fid, then fid itself has (potentially) changed,
891 	 * but is still valid.  Otherwise set newfid valid on
892 	 * success, and destroy it on error.
893 	 */
894 	if (newfid != fid) {
895 		if (error == 0)
896 			l9p_fid_setvalid(newfid);
897 		else
898 			l9p_connection_remove_fid(conn, newfid);
899 	}
900 
901 	/*
902 	 * If we walked any name elements, the last (n-1'th) qid
903 	 * has the type (dir vs file) for the new fid.  Otherwise
904 	 * the type of newfid is the same as fid.  Of course, if
905 	 * n==0 and fid==newfid, fid is already set up correctly
906 	 * as the whole thing was a big no-op, but it's safe to
907 	 * copy its dir bit to itself.
908 	 */
909 	if (error == 0) {
910 		n = req->lr_resp.rwalk.nwqid;
911 		if (n > 0) {
912 			if (req->lr_resp.rwalk.wqid[n - 1].type & L9P_QTDIR)
913 				l9p_fid_setdir(newfid);
914 		} else {
915 			if (l9p_fid_isdir(fid))
916 				l9p_fid_setdir(newfid);
917 		}
918 	}
919 	return (error);
920 }
921 
922 static int
l9p_dispatch_twrite(struct l9p_request * req)923 l9p_dispatch_twrite(struct l9p_request *req)
924 {
925 	struct l9p_connection *conn = req->lr_conn;
926 	struct l9p_backend *be;
927 	struct l9p_fid *fid;
928 	int error;
929 
930 	/* Cannot require open due to xattr write, but can forbid dir. */
931 	error = fid_lookup(conn, req->lr_req.hdr.fid, EINVAL,
932 	    F_FORBID_DIR, &req->lr_fid);
933 	if (error)
934 		return (error);
935 
936 	/*
937 	 * Adjust to point to the data to be written (a la
938 	 * l9p_dispatch_tread, but we're pointing into the request
939 	 * buffer rather than the response):
940 	 *
941 	 * size[4] + Twrite[1] + tag[2] + fid[4] + offset[8] + count[4] = 23
942 	 */
943 	l9p_seek_iov(req->lr_req_msg.lm_iov, req->lr_req_msg.lm_niov,
944 	    req->lr_data_iov, &req->lr_data_niov, 23);
945 
946 	/*
947 	 * Unlike read, write and xattrwrite are optional (for R/O fs).
948 	 *
949 	 * TODO:
950 	 *   allow async write
951 	 */
952 	be = conn->lc_server->ls_backend;
953 	fid = req->lr_fid;
954 	if (l9p_fid_isxattr(fid)) {
955 		error = be->xattrwrite != NULL ?
956 		    be->xattrwrite(be->softc, req) : ENOSYS;
957 	} else if (l9p_fid_isopen(fid)) {
958 		error = be->write != NULL ?
959 		    be->write(be->softc, req) : ENOSYS;
960 	} else {
961 		error = EINVAL;
962 	}
963 
964 	return (error);
965 }
966 
967 static int
l9p_dispatch_twstat(struct l9p_request * req)968 l9p_dispatch_twstat(struct l9p_request *req)
969 {
970 	struct l9p_connection *conn = req->lr_conn;
971 	struct l9p_backend *be;
972 	int error;
973 
974 	error = fid_lookup(conn, req->lr_req.hdr.fid, EINVAL,
975 	    F_FORBID_XATTR, &req->lr_fid);
976 	if (error)
977 		return (error);
978 
979 	be = conn->lc_server->ls_backend;
980 	error = be->wstat != NULL ? be->wstat(be->softc, req) : ENOSYS;
981 	return (error);
982 }
983 
984 static int
l9p_dispatch_tstatfs(struct l9p_request * req)985 l9p_dispatch_tstatfs(struct l9p_request *req)
986 {
987 	struct l9p_connection *conn = req->lr_conn;
988 	struct l9p_backend *be;
989 	int error;
990 
991 	/* Should we allow statfs on auth fids? */
992 	error = fid_lookup(conn, req->lr_req.hdr.fid, EINVAL, 0, &req->lr_fid);
993 	if (error)
994 		return (error);
995 
996 	be = conn->lc_server->ls_backend;
997 	error = be->statfs(be->softc, req);
998 	return (error);
999 }
1000 
1001 static int
l9p_dispatch_tlopen(struct l9p_request * req)1002 l9p_dispatch_tlopen(struct l9p_request *req)
1003 {
1004 	struct l9p_connection *conn = req->lr_conn;
1005 	struct l9p_backend *be;
1006 	int error;
1007 
1008 	error = fid_lookup(conn, req->lr_req.hdr.fid, ENOENT,
1009 	    F_FORBID_OPEN | F_FORBID_XATTR, &req->lr_fid);
1010 	if (error)
1011 		return (error);
1012 
1013 	be = conn->lc_server->ls_backend;
1014 
1015 	/*
1016 	 * TODO:
1017 	 *  - add async open (leaves req->lr_fid in limbo)
1018 	 */
1019 	error = be->lopen != NULL ? be->lopen(be->softc, req) : ENOSYS;
1020 	if (error == 0)
1021 		l9p_fid_setopen(req->lr_fid);
1022 	return (error);
1023 }
1024 
1025 static int
l9p_dispatch_tlcreate(struct l9p_request * req)1026 l9p_dispatch_tlcreate(struct l9p_request *req)
1027 {
1028 	struct l9p_connection *conn = req->lr_conn;
1029 	struct l9p_backend *be;
1030 	int error;
1031 
1032 	error = fid_lookup(conn, req->lr_req.hdr.fid, ENOENT,
1033 	    F_REQUIRE_DIR | F_FORBID_OPEN, &req->lr_fid);
1034 	if (error)
1035 		return (error);
1036 
1037 	be = conn->lc_server->ls_backend;
1038 
1039 	/*
1040 	 * TODO:
1041 	 *  - check new file name
1042 	 *  - add async create (leaves req->lr_fid in limbo)
1043 	 */
1044 	error = be->lcreate != NULL ? be->lcreate(be->softc, req) : ENOSYS;
1045 	if (error == 0) {
1046 		l9p_fid_unsetdir(req->lr_fid);
1047 		l9p_fid_setopen(req->lr_fid);
1048 	}
1049 	return (error);
1050 }
1051 
1052 static int
l9p_dispatch_tsymlink(struct l9p_request * req)1053 l9p_dispatch_tsymlink(struct l9p_request *req)
1054 {
1055 	struct l9p_connection *conn = req->lr_conn;
1056 	struct l9p_backend *be;
1057 	int error;
1058 
1059 	/* This doesn't affect the containing dir; maybe allow OPEN? */
1060 	error = fid_lookup(conn, req->lr_req.hdr.fid, ENOENT,
1061 	    F_REQUIRE_DIR | F_FORBID_OPEN, &req->lr_fid);
1062 	if (error)
1063 		return (error);
1064 
1065 	be = conn->lc_server->ls_backend;
1066 
1067 	/*
1068 	 * TODO:
1069 	 *  - check new file name
1070 	 */
1071 	error = be->symlink != NULL ? be->symlink(be->softc, req) : ENOSYS;
1072 	return (error);
1073 }
1074 
1075 static int
l9p_dispatch_tmknod(struct l9p_request * req)1076 l9p_dispatch_tmknod(struct l9p_request *req)
1077 {
1078 	struct l9p_connection *conn = req->lr_conn;
1079 	struct l9p_backend *be;
1080 	int error;
1081 
1082 	/* This doesn't affect the containing dir; maybe allow OPEN? */
1083 	error = fid_lookup(conn, req->lr_req.hdr.fid, ENOENT,
1084 	    F_REQUIRE_DIR | F_FORBID_OPEN, &req->lr_fid);
1085 	if (error)
1086 		return (error);
1087 
1088 	be = conn->lc_server->ls_backend;
1089 
1090 	/*
1091 	 * TODO:
1092 	 *  - check new file name
1093 	 */
1094 	error = be->mknod != NULL ? be->mknod(be->softc, req) : ENOSYS;
1095 	return (error);
1096 }
1097 
1098 static int
l9p_dispatch_trename(struct l9p_request * req)1099 l9p_dispatch_trename(struct l9p_request *req)
1100 {
1101 	struct l9p_connection *conn = req->lr_conn;
1102 	struct l9p_backend *be;
1103 	int error;
1104 
1105 	/* Rename directory or file (including symlink etc). */
1106 	error = fid_lookup(conn, req->lr_req.hdr.fid, ENOENT,
1107 	    F_FORBID_XATTR, &req->lr_fid);
1108 	if (error)
1109 		return (error);
1110 
1111 	/* Doesn't affect new dir fid; maybe allow OPEN? */
1112 	error = fid_lookup(conn, req->lr_req.trename.dfid, ENOENT,
1113 	    F_REQUIRE_DIR | F_FORBID_OPEN, &req->lr_fid2);
1114 	if (error)
1115 		return (error);
1116 
1117 	be = conn->lc_server->ls_backend;
1118 
1119 	/*
1120 	 * TODO:
1121 	 *  - check new file name (trename.name)
1122 	 */
1123 	error = be->rename != NULL ? be->rename(be->softc, req) : ENOSYS;
1124 	return (error);
1125 }
1126 
1127 static int
l9p_dispatch_treadlink(struct l9p_request * req)1128 l9p_dispatch_treadlink(struct l9p_request *req)
1129 {
1130 	struct l9p_connection *conn = req->lr_conn;
1131 	struct l9p_backend *be;
1132 	int error;
1133 
1134 	/*
1135 	 * The underlying readlink will fail unless it's a symlink,
1136 	 * and the back end has to check, but we might as well forbid
1137 	 * directories and open files here since it's cheap.
1138 	 */
1139 	error = fid_lookup(conn, req->lr_req.hdr.fid, ENOENT,
1140 	    F_FORBID_DIR | F_FORBID_OPEN, &req->lr_fid);
1141 	if (error)
1142 		return (error);
1143 
1144 	be = conn->lc_server->ls_backend;
1145 
1146 	error = be->readlink != NULL ? be->readlink(be->softc, req) : ENOSYS;
1147 	return (error);
1148 }
1149 
1150 static int
l9p_dispatch_tgetattr(struct l9p_request * req)1151 l9p_dispatch_tgetattr(struct l9p_request *req)
1152 {
1153 	struct l9p_connection *conn = req->lr_conn;
1154 	struct l9p_backend *be;
1155 	int error;
1156 
1157 	error = fid_lookup(conn, req->lr_req.hdr.fid, ENOENT,
1158 	    F_FORBID_XATTR, &req->lr_fid);
1159 	if (error)
1160 		return (error);
1161 
1162 	be = conn->lc_server->ls_backend;
1163 
1164 	error = be->getattr != NULL ? be->getattr(be->softc, req) : ENOSYS;
1165 	return (error);
1166 }
1167 
1168 static int
l9p_dispatch_tsetattr(struct l9p_request * req)1169 l9p_dispatch_tsetattr(struct l9p_request *req)
1170 {
1171 	struct l9p_connection *conn = req->lr_conn;
1172 	struct l9p_backend *be;
1173 	int error;
1174 
1175 	error = fid_lookup(conn, req->lr_req.hdr.fid, ENOENT,
1176 	    F_FORBID_XATTR, &req->lr_fid);
1177 	if (error)
1178 		return (error);
1179 
1180 	be = conn->lc_server->ls_backend;
1181 
1182 	error = be->setattr != NULL ? be->setattr(be->softc, req) : ENOSYS;
1183 	return (error);
1184 }
1185 
1186 static int
l9p_dispatch_txattrwalk(struct l9p_request * req)1187 l9p_dispatch_txattrwalk(struct l9p_request *req)
1188 {
1189 	struct l9p_connection *conn = req->lr_conn;
1190 	struct l9p_backend *be;
1191 	struct l9p_fid *fid, *newfid;
1192 	int error;
1193 
1194 	/*
1195 	 * Not sure if we care if file-or-dir is open or not.
1196 	 * However, the fid argument should always be a file or
1197 	 * dir and the newfid argument must be supplied, must
1198 	 * be different, and always becomes a new xattr,
1199 	 * so this is not very much like Twalk.
1200 	 */
1201 	error = fid_lookup(conn, req->lr_req.hdr.fid, ENOENT,
1202 	    F_FORBID_XATTR, &fid);
1203 	if (error)
1204 		return (error);
1205 
1206 	newfid = l9p_connection_alloc_fid(conn, req->lr_req.txattrwalk.newfid);
1207 	if (newfid == NULL)
1208 		return (EINVAL);
1209 
1210 	be = conn->lc_server->ls_backend;
1211 
1212 	req->lr_fid = fid;
1213 	req->lr_newfid = newfid;
1214 	error = be->xattrwalk != NULL ? be->xattrwalk(be->softc, req) : ENOSYS;
1215 
1216 	/*
1217 	 * Success/fail is similar to Twalk, except that we need
1218 	 * to set the xattr type bit in the new fid.  It's also
1219 	 * much simpler since newfid is always a new fid.
1220 	 */
1221 	if (error == 0) {
1222 		l9p_fid_setvalid(newfid);
1223 		l9p_fid_setxattr(newfid);
1224 	} else {
1225 		l9p_connection_remove_fid(conn, newfid);
1226 	}
1227 	return (error);
1228 }
1229 
1230 static int
l9p_dispatch_txattrcreate(struct l9p_request * req)1231 l9p_dispatch_txattrcreate(struct l9p_request *req)
1232 {
1233 	struct l9p_connection *conn = req->lr_conn;
1234 	struct l9p_backend *be;
1235 	struct l9p_fid *fid;
1236 	int error;
1237 
1238 	/*
1239 	 * Forbid incoming open fid since it's going to become an
1240 	 * xattr fid instead.  If it turns out we need to allow
1241 	 * it, fs code will need to handle this.
1242 	 *
1243 	 * Curiously, qemu 9pfs uses ENOENT for a bad txattrwalk
1244 	 * fid, but EINVAL for txattrcreate (so we do too).
1245 	 */
1246 	error = fid_lookup(conn, req->lr_req.hdr.fid, EINVAL,
1247 	    F_FORBID_XATTR | F_FORBID_OPEN, &fid);
1248 	if (error)
1249 		return (error);
1250 
1251 	be = conn->lc_server->ls_backend;
1252 
1253 	req->lr_fid = fid;
1254 	error = be->xattrcreate != NULL ? be->xattrcreate(be->softc, req) :
1255 	    ENOSYS;
1256 
1257 	/*
1258 	 * On success, fid has changed from a regular (file or dir)
1259 	 * fid to an xattr fid.
1260 	 */
1261 	if (error == 0) {
1262 		l9p_fid_unsetdir(fid);
1263 		l9p_fid_setxattr(fid);
1264 	}
1265 	return (error);
1266 }
1267 
1268 static int
l9p_dispatch_treaddir(struct l9p_request * req)1269 l9p_dispatch_treaddir(struct l9p_request *req)
1270 {
1271 	struct l9p_connection *conn = req->lr_conn;
1272 	struct l9p_backend *be;
1273 	int error;
1274 
1275 	error = fid_lookup(conn, req->lr_req.hdr.fid, ENOENT,
1276 	    F_REQUIRE_DIR | F_REQUIRE_OPEN, &req->lr_fid);
1277 	if (error)
1278 		return (error);
1279 
1280 	/*
1281 	 * Adjust so that writing messages (packing data) starts
1282 	 * right after the count field in the response.
1283 	 *
1284 	 * size[4] + Rreaddir[1] + tag[2] + count[4] = 11
1285 	 */
1286 	l9p_seek_iov(req->lr_resp_msg.lm_iov, req->lr_resp_msg.lm_niov,
1287 	    req->lr_data_iov, &req->lr_data_niov, 11);
1288 
1289 	be = conn->lc_server->ls_backend;
1290 
1291 	error = be->readdir != NULL ? be->readdir(be->softc, req) : ENOSYS;
1292 	return (error);
1293 }
1294 
1295 static int
l9p_dispatch_tfsync(struct l9p_request * req)1296 l9p_dispatch_tfsync(struct l9p_request *req)
1297 {
1298 	struct l9p_connection *conn = req->lr_conn;
1299 	struct l9p_backend *be;
1300 	int error;
1301 
1302 	error = fid_lookup(conn, req->lr_req.hdr.fid, ENOENT,
1303 	    F_REQUIRE_OPEN, &req->lr_fid);
1304 	if (error)
1305 		return (error);
1306 
1307 	be = conn->lc_server->ls_backend;
1308 
1309 	error = be->fsync != NULL ? be->fsync(be->softc, req) : ENOSYS;
1310 	return (error);
1311 }
1312 
1313 static int
l9p_dispatch_tlock(struct l9p_request * req)1314 l9p_dispatch_tlock(struct l9p_request *req)
1315 {
1316 	struct l9p_connection *conn = req->lr_conn;
1317 	struct l9p_backend *be;
1318 	int error;
1319 
1320 	/* Forbid directories? */
1321 	error = fid_lookup(conn, req->lr_req.hdr.fid, ENOENT,
1322 	    F_REQUIRE_OPEN, &req->lr_fid);
1323 	if (error)
1324 		return (error);
1325 
1326 	be = conn->lc_server->ls_backend;
1327 
1328 	/*
1329 	 * TODO: multiple client handling; perhaps async locking.
1330 	 */
1331 	error = be->lock != NULL ? be->lock(be->softc, req) : ENOSYS;
1332 	return (error);
1333 }
1334 
1335 static int
l9p_dispatch_tgetlock(struct l9p_request * req)1336 l9p_dispatch_tgetlock(struct l9p_request *req)
1337 {
1338 	struct l9p_connection *conn = req->lr_conn;
1339 	struct l9p_backend *be;
1340 	int error;
1341 
1342 	error = fid_lookup(conn, req->lr_req.hdr.fid, ENOENT,
1343 	    F_REQUIRE_OPEN, &req->lr_fid);
1344 	if (error)
1345 		return (error);
1346 
1347 	be = conn->lc_server->ls_backend;
1348 
1349 	/*
1350 	 * TODO: multiple client handling; perhaps async locking.
1351 	 */
1352 	error = be->getlock != NULL ? be->getlock(be->softc, req) : ENOSYS;
1353 	return (error);
1354 }
1355 
1356 static int
l9p_dispatch_tlink(struct l9p_request * req)1357 l9p_dispatch_tlink(struct l9p_request *req)
1358 {
1359 	struct l9p_connection *conn = req->lr_conn;
1360 	struct l9p_backend *be;
1361 	int error;
1362 
1363 	/*
1364 	 * Note, dfid goes into fid2 in current scheme.
1365 	 *
1366 	 * Allow open dir?  Target dir fid is not modified...
1367 	 */
1368 	error = fid_lookup(conn, req->lr_req.tlink.dfid, ENOENT,
1369 	    F_REQUIRE_DIR | F_FORBID_OPEN, &req->lr_fid2);
1370 	if (error)
1371 		return (error);
1372 
1373 	error = fid_lookup(conn, req->lr_req.hdr.fid, ENOENT,
1374 	    F_FORBID_DIR | F_FORBID_XATTR, &req->lr_fid);
1375 	if (error)
1376 		return (error);
1377 
1378 	be = conn->lc_server->ls_backend;
1379 
1380 	error = be->link != NULL ? be->link(be->softc, req) : ENOSYS;
1381 	return (error);
1382 }
1383 
1384 static int
l9p_dispatch_tmkdir(struct l9p_request * req)1385 l9p_dispatch_tmkdir(struct l9p_request *req)
1386 {
1387 	struct l9p_connection *conn = req->lr_conn;
1388 	struct l9p_backend *be;
1389 	int error;
1390 
1391 	error = fid_lookup(conn, req->lr_req.hdr.fid, ENOENT,
1392 	    F_REQUIRE_DIR | F_FORBID_OPEN, &req->lr_fid);
1393 	if (error)
1394 		return (error);
1395 
1396 	/* Slashes embedded in the name are not allowed */
1397 	if (strchr(req->lr_req.tlcreate.name, '/') != NULL)
1398 		return (EINVAL);
1399 
1400 	be = conn->lc_server->ls_backend;
1401 	error = be->mkdir != NULL ? be->mkdir(be->softc, req) : ENOSYS;
1402 	return (error);
1403 }
1404 
1405 static int
l9p_dispatch_trenameat(struct l9p_request * req)1406 l9p_dispatch_trenameat(struct l9p_request *req)
1407 {
1408 	struct l9p_connection *conn = req->lr_conn;
1409 	struct l9p_backend *be;
1410 	int error;
1411 
1412 	error = fid_lookup(conn, req->lr_req.hdr.fid, ENOENT,
1413 	    F_REQUIRE_DIR | F_FORBID_OPEN, &req->lr_fid);
1414 	if (error)
1415 		return (error);
1416 
1417 	error = fid_lookup(conn, req->lr_req.trenameat.newdirfid, ENOENT,
1418 	    F_REQUIRE_DIR | F_FORBID_OPEN, &req->lr_fid2);
1419 	if (error)
1420 		return (error);
1421 
1422 	be = conn->lc_server->ls_backend;
1423 
1424 	/* TODO: check old and new names */
1425 	error = be->renameat != NULL ? be->renameat(be->softc, req) : ENOSYS;
1426 	return (error);
1427 }
1428 
1429 static int
l9p_dispatch_tunlinkat(struct l9p_request * req)1430 l9p_dispatch_tunlinkat(struct l9p_request *req)
1431 {
1432 	struct l9p_connection *conn = req->lr_conn;
1433 	struct l9p_backend *be;
1434 	int error;
1435 
1436 	error = fid_lookup(conn, req->lr_req.hdr.fid, ENOENT,
1437 	    F_REQUIRE_DIR | F_FORBID_OPEN, &req->lr_fid);
1438 	if (error)
1439 		return (error);
1440 
1441 	be = conn->lc_server->ls_backend;
1442 
1443 	/* TODO: check dir-or-file name */
1444 	error = be->unlinkat != NULL ? be->unlinkat(be->softc, req) : ENOSYS;
1445 	return (error);
1446 }
1447