kernel/vfs: Remove some unused variables.
[dragonfly.git] / sys / vfs / puffs / puffs_msgif.c
CommitLineData
ab5617b3
SW
1/* $NetBSD: puffs_msgif.c,v 1.87 2011/07/03 08:57:43 mrg Exp $ */
2
3/*
4 * Copyright (c) 2005, 2006, 2007 Antti Kantee. All Rights Reserved.
5 *
6 * Development of this software was supported by the
7 * Google Summer of Code program and the Ulla Tuominen Foundation.
8 * The Google SoC project was mentored by Bill Studenmund.
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
20 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
21 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
22 * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
25 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29 * SUCH DAMAGE.
30 */
31
32#include <sys/param.h>
33#include <sys/kthread.h>
34#include <sys/lock.h>
35#include <sys/malloc.h>
36#include <sys/objcache.h>
37#include <sys/mount.h>
38#include <sys/namei.h>
39#include <sys/proc.h>
40#include <sys/signal2.h>
41#include <sys/vnode.h>
42#include <machine/inttypes.h>
43
44#include <dev/misc/putter/putter_sys.h>
45#include <vfs/puffs/puffs_msgif.h>
46#include <vfs/puffs/puffs_sys.h>
47
48/*
49 * waitq data structures
50 */
51
52/*
53 * While a request is going to userspace, park the caller within the
54 * kernel. This is the kernel counterpart of "struct puffs_req".
55 */
56struct puffs_msgpark {
57 struct puffs_req *park_preq; /* req followed by buf */
58
59 size_t park_copylen; /* userspace copylength */
60 size_t park_maxlen; /* max size in comeback */
61
62 struct puffs_req *park_creq; /* non-compat preq */
63 size_t park_creqlen; /* non-compat preq len */
64
65 parkdone_fn park_done; /* "biodone" a'la puffs */
66 void *park_donearg;
67
68 int park_flags;
69 int park_refcount;
70
71 struct cv park_cv;
72 struct lock park_mtx;
73
74 TAILQ_ENTRY(puffs_msgpark) park_entries;
75};
76#define PARKFLAG_WAITERGONE 0x01
77#define PARKFLAG_DONE 0x02
78#define PARKFLAG_ONQUEUE1 0x04
79#define PARKFLAG_ONQUEUE2 0x08
80#define PARKFLAG_CALL 0x10
81#define PARKFLAG_WANTREPLY 0x20
82#define PARKFLAG_HASERROR 0x40
83
84static struct objcache *parkpc;
85#ifdef PUFFSDEBUG
86static int totalpark;
87#endif
88
89static boolean_t
90makepark(void *obj, void *privdata, int flags)
91{
92 struct puffs_msgpark *park = obj;
93
94 lockinit(&park->park_mtx, "puffs park_mtx", 0, 0);
95 cv_init(&park->park_cv, "puffsrpl");
96
97 return TRUE;
98}
99
100static void
101nukepark(void *obj, void *privdata)
102{
103 struct puffs_msgpark *park = obj;
104
105 cv_destroy(&park->park_cv);
106 lockuninit(&park->park_mtx);
107}
108
109void
110puffs_msgif_init(void)
111{
112
113 parkpc = objcache_create_mbacked(M_PUFFS, sizeof(struct puffs_msgpark),
2fce2579 114 0, 0, makepark, nukepark, NULL);
ab5617b3
SW
115}
116
117void
118puffs_msgif_destroy(void)
119{
120
121 objcache_destroy(parkpc);
122}
123
124static struct puffs_msgpark *
125puffs_msgpark_alloc(int waitok)
126{
127 struct puffs_msgpark *park;
128
129 park = objcache_get(parkpc, waitok ? M_WAITOK : M_NOWAIT);
130 if (park == NULL)
131 return park;
132
133 park->park_refcount = 1;
134 park->park_preq = park->park_creq = NULL;
135 park->park_flags = PARKFLAG_WANTREPLY;
136
137#ifdef PUFFSDEBUG
138 totalpark++;
139#endif
140
141 return park;
142}
143
144static void
145puffs_msgpark_reference(struct puffs_msgpark *park)
146{
147
148 KKASSERT(lockstatus(&park->park_mtx, curthread) == LK_EXCLUSIVE);
149 park->park_refcount++;
150}
151
152/*
153 * Release reference to park structure.
154 */
155static void
156puffs_msgpark_release1(struct puffs_msgpark *park, int howmany)
157{
158 struct puffs_req *preq = park->park_preq;
159 struct puffs_req *creq = park->park_creq;
160 int refcnt;
161
162 KKASSERT(lockstatus(&park->park_mtx, curthread) == LK_EXCLUSIVE);
163 refcnt = park->park_refcount -= howmany;
164 lockmgr(&park->park_mtx, LK_RELEASE);
165
166 KKASSERT(refcnt >= 0);
167
168 if (refcnt == 0) {
169 if (preq)
170 kfree(preq, M_PUFFS);
171#if 1
172 if (creq)
173 kfree(creq, M_PUFFS);
174#endif
175 objcache_put(parkpc, park);
176
177#ifdef PUFFSDEBUG
178 totalpark--;
179#endif
180 }
181}
182#define puffs_msgpark_release(a) puffs_msgpark_release1(a, 1)
183
184#ifdef PUFFSDEBUG
185static void
186parkdump(struct puffs_msgpark *park)
187{
188
189 DPRINTF_VERBOSE(("park %p, preq %p, id %" PRIu64 "\n"
190 "\tcopy %zu, max %zu - done: %p/%p\n"
191 "\tflags 0x%08x, refcount %d, cv/mtx: %p/%p\n",
192 park, park->park_preq, park->park_preq->preq_id,
193 park->park_copylen, park->park_maxlen,
194 park->park_done, park->park_donearg,
195 park->park_flags, park->park_refcount,
196 &park->park_cv, &park->park_mtx));
197}
198
199static void
200parkqdump(struct puffs_wq *q, int dumpall)
201{
202 struct puffs_msgpark *park;
203 int total = 0;
204
205 TAILQ_FOREACH(park, q, park_entries) {
206 if (dumpall)
207 parkdump(park);
208 total++;
209 }
210 DPRINTF_VERBOSE(("puffs waitqueue at %p dumped, %d total\n", q, total));
211
212}
213#endif /* PUFFSDEBUG */
214
215/*
216 * A word about locking in the park structures: the lock protects the
217 * fields of the *park* structure (not preq) and acts as an interlock
218 * in cv operations. The lock is always internal to this module and
219 * callers do not need to worry about it.
220 */
221
222int
223puffs_msgmem_alloc(size_t len, struct puffs_msgpark **ppark, void **mem,
224 int cansleep)
225{
226 struct puffs_msgpark *park;
227 void *m;
228
229 m = kmalloc(len, M_PUFFS, M_ZERO | (cansleep ? M_WAITOK : M_NOWAIT));
230 if (m == NULL) {
231 KKASSERT(cansleep == 0);
232 return ENOMEM;
233 }
234
235 park = puffs_msgpark_alloc(cansleep);
236 if (park == NULL) {
237 KKASSERT(cansleep == 0);
238 kfree(m, M_PUFFS);
239 return ENOMEM;
240 }
241
242 park->park_preq = m;
243 park->park_maxlen = park->park_copylen = len;
244
245 *ppark = park;
246 *mem = m;
247
248 return 0;
249}
250
251void
252puffs_msgmem_release(struct puffs_msgpark *park)
253{
254
255 if (park == NULL)
256 return;
257
258 lockmgr(&park->park_mtx, LK_EXCLUSIVE);
259 puffs_msgpark_release(park);
260}
261
262void
263puffs_msg_setfaf(struct puffs_msgpark *park)
264{
265
266 KKASSERT((park->park_flags & PARKFLAG_CALL) == 0);
267 park->park_flags &= ~PARKFLAG_WANTREPLY;
268}
269
270void
271puffs_msg_setdelta(struct puffs_msgpark *park, size_t delta)
272{
273
274 KKASSERT(delta < park->park_maxlen); /* "<=" wouldn't make sense */
275 park->park_copylen = park->park_maxlen - delta;
276}
277
278void
279puffs_msg_setinfo(struct puffs_msgpark *park, int class, int type,
280 puffs_cookie_t ck)
281{
282
283 park->park_preq->preq_opclass = PUFFSOP_OPCLASS(class);
284 park->park_preq->preq_optype = type;
285 park->park_preq->preq_cookie = ck;
286}
287
288void
289puffs_msg_setcall(struct puffs_msgpark *park, parkdone_fn donefn, void *donearg)
290{
291
292 KKASSERT(park->park_flags & PARKFLAG_WANTREPLY);
293 park->park_done = donefn;
294 park->park_donearg = donearg;
295 park->park_flags |= PARKFLAG_CALL;
296}
297
298/*
299 * kernel-user-kernel waitqueues
300 */
301
302static uint64_t
303puffs_getmsgid(struct puffs_mount *pmp)
304{
305 uint64_t rv;
306
307 lockmgr(&pmp->pmp_lock, LK_EXCLUSIVE);
308 rv = pmp->pmp_nextmsgid++;
309 lockmgr(&pmp->pmp_lock, LK_RELEASE);
310
311 return rv;
312}
313
314/*
315 * A word about reference counting of parks. A reference must be taken
316 * when accessing a park and additionally when it is on a queue. So
317 * when taking it off a queue and releasing the access reference, the
318 * reference count is generally decremented by 2.
319 */
320
321void
322puffs_msg_enqueue(struct puffs_mount *pmp, struct puffs_msgpark *park)
323{
324 struct thread *td = curthread;
ab5617b3
SW
325 struct puffs_req *preq;
326 sigset_t ss;
327
328 /*
329 * Some clients reuse a park, so reset some flags. We might
330 * want to provide a caller-side interface for this and add
331 * a few more invariant checks here, but this will do for now.
332 */
333 KKASSERT(pmp != NULL && park != NULL);
334 park->park_flags &= ~(PARKFLAG_DONE | PARKFLAG_HASERROR);
335 KKASSERT((park->park_flags & PARKFLAG_WAITERGONE) == 0);
336
ab5617b3
SW
337 preq = park->park_preq;
338
339 preq->preq_buflen = park->park_maxlen;
340 KKASSERT(preq->preq_id == 0
341 || (preq->preq_opclass & PUFFSOPFLAG_ISRESPONSE));
342
343 if ((park->park_flags & PARKFLAG_WANTREPLY) == 0)
344 preq->preq_opclass |= PUFFSOPFLAG_FAF;
345 else
346 preq->preq_id = puffs_getmsgid(pmp);
347
348 /* fill in caller information */
349 if (td->td_proc == NULL || td->td_lwp == NULL) {
350 DPRINTF_VERBOSE(("puffs_msg_enqueue: no process\n"));
351 preq->preq_pid = 1;
352 preq->preq_lid = 0;
353 goto noproc;
354 }
355 preq->preq_pid = td->td_proc->p_pid;
356 preq->preq_lid = td->td_lwp->lwp_tid;
357
358 /*
359 * To support cv_sig, yet another movie: check if there are signals
360 * pending and we are issueing a non-FAF. If so, return an error
361 * directly UNLESS we are issueing INACTIVE/RECLAIM. In that case,
362 * convert it to a FAF, fire off to the file server and return
363 * an error. Yes, this is bordering disgusting. Barfbags are on me.
364 */
365 ss = lwp_sigpend(td->td_lwp);
366 SIGSETNAND(ss, td->td_lwp->lwp_sigmask);
367 if (__predict_false((park->park_flags & PARKFLAG_WANTREPLY)
368 && (park->park_flags & PARKFLAG_CALL) == 0
369 && SIGNOTEMPTY(ss))) {
370
371 /*
372 * see the comment about signals in puffs_msg_wait.
373 */
374 if (SIGISMEMBER(ss, SIGINT) ||
375 SIGISMEMBER(ss, SIGTERM) ||
376 SIGISMEMBER(ss, SIGKILL) ||
377 SIGISMEMBER(ss, SIGHUP) ||
378 SIGISMEMBER(ss, SIGQUIT)) {
379 park->park_flags |= PARKFLAG_HASERROR;
380 preq->preq_rv = EINTR;
381 if (PUFFSOP_OPCLASS(preq->preq_opclass) == PUFFSOP_VN
382 && (preq->preq_optype == PUFFS_VN_INACTIVE
383 || preq->preq_optype == PUFFS_VN_RECLAIM)) {
384 park->park_preq->preq_opclass |=
385 PUFFSOPFLAG_FAF;
386 park->park_flags &= ~PARKFLAG_WANTREPLY;
387 DPRINTF_VERBOSE(("puffs_msg_enqueue: "
388 "converted to FAF %p\n", park));
389 } else {
390 return;
391 }
392 }
393 }
394
395 noproc:
396 lockmgr(&pmp->pmp_lock, LK_EXCLUSIVE);
397 if (pmp->pmp_status != PUFFSTAT_RUNNING) {
398 lockmgr(&pmp->pmp_lock, LK_RELEASE);
399 park->park_flags |= PARKFLAG_HASERROR;
400 preq->preq_rv = ENXIO;
401 return;
402 }
403
404#ifdef PUFFSDEBUG
405 parkqdump(&pmp->pmp_msg_touser, puffsdebug > 1);
406 parkqdump(&pmp->pmp_msg_replywait, puffsdebug > 1);
407#endif
408
409 /*
410 * Note: we don't need to lock park since we have the only
411 * reference to it at this point.
412 */
413 TAILQ_INSERT_TAIL(&pmp->pmp_msg_touser, park, park_entries);
414 park->park_flags |= PARKFLAG_ONQUEUE1;
415 pmp->pmp_msg_touser_count++;
416 park->park_refcount++;
417 lockmgr(&pmp->pmp_lock, LK_RELEASE);
418
419 cv_broadcast(&pmp->pmp_msg_waiter_cv);
420 putter_notify(pmp->pmp_pi);
421
422 DPRINTF_VERBOSE(("touser: req %" PRIu64 ", preq: %p, park: %p, "
423 "c/t: 0x%x/0x%x, f: 0x%x\n", preq->preq_id, preq, park,
424 preq->preq_opclass, preq->preq_optype, park->park_flags));
425}
426
427int
428puffs_msg_wait(struct puffs_mount *pmp, struct puffs_msgpark *park)
429{
430 struct puffs_req *preq = park->park_preq; /* XXX: hmmm */
431#ifdef XXXDF
432 struct lwp *l = curthread->td_lwp;
433 struct proc *p = curthread->td_proc;
434 sigset_t ss;
435 sigset_t oss;
436#endif
437 int error = 0;
438 int rv;
439
440 KKASSERT(pmp != NULL && park != NULL);
441
442 /*
443 * block unimportant signals.
444 *
445 * The set of "important" signals here was chosen to be same as
446 * nfs interruptible mount.
447 */
448#ifdef XXXDF
449 SIGFILLSET(ss);
450 SIGDELSET(ss, SIGINT);
451 SIGDELSET(ss, SIGTERM);
452 SIGDELSET(ss, SIGKILL);
453 SIGDELSET(ss, SIGHUP);
454 SIGDELSET(ss, SIGQUIT);
455 lockmgr(p->p_lock, LK_EXCLUSIVE);
456 sigprocmask1(l, SIG_BLOCK, &ss, &oss);
457 lockmgr(p->p_lock, LK_RELEASE);
458#endif
459
460 lockmgr(&pmp->pmp_lock, LK_EXCLUSIVE);
461 puffs_mp_reference(pmp);
462 lockmgr(&pmp->pmp_lock, LK_RELEASE);
463
464 lockmgr(&park->park_mtx, LK_EXCLUSIVE);
465 /* did the response beat us to the wait? */
466 if (__predict_false((park->park_flags & PARKFLAG_DONE)
467 || (park->park_flags & PARKFLAG_HASERROR))) {
468 rv = park->park_preq->preq_rv;
469 lockmgr(&park->park_mtx, LK_RELEASE);
470 goto skipwait;
471 }
472
473 if ((park->park_flags & PARKFLAG_WANTREPLY) == 0
474 || (park->park_flags & PARKFLAG_CALL)) {
475 lockmgr(&park->park_mtx, LK_RELEASE);
476 rv = 0;
477 goto skipwait;
478 }
479
480 error = cv_wait_sig(&park->park_cv, &park->park_mtx);
481 DPRINTF_VERBOSE(("puffs_touser: waiter for %p woke up with %d\n",
482 park, error));
483 if (error) {
484 park->park_flags |= PARKFLAG_WAITERGONE;
485 if (park->park_flags & PARKFLAG_DONE) {
486 rv = preq->preq_rv;
487 lockmgr(&park->park_mtx, LK_RELEASE);
488 } else {
489 /*
490 * ok, we marked it as going away, but
491 * still need to do queue ops. take locks
492 * in correct order.
493 *
494 * We don't want to release our reference
495 * if it's on replywait queue to avoid error
496 * to file server. putop() code will DTRT.
497 */
498 lockmgr(&park->park_mtx, LK_RELEASE);
499 lockmgr(&pmp->pmp_lock, LK_EXCLUSIVE);
500 lockmgr(&park->park_mtx, LK_EXCLUSIVE);
501
502 /*
503 * Still on queue1? We can safely remove it
504 * without any consequences since the file
505 * server hasn't seen it. "else" we need to
506 * wait for the response and just ignore it
507 * to avoid signalling an incorrect error to
508 * the file server.
509 */
510 if (park->park_flags & PARKFLAG_ONQUEUE1) {
511 TAILQ_REMOVE(&pmp->pmp_msg_touser,
512 park, park_entries);
513 puffs_msgpark_release(park);
514 pmp->pmp_msg_touser_count--;
515 park->park_flags &= ~PARKFLAG_ONQUEUE1;
516 } else {
517 lockmgr(&park->park_mtx, LK_RELEASE);
518 }
519 lockmgr(&pmp->pmp_lock, LK_RELEASE);
520
521 rv = EINTR;
522 }
523 } else {
524 rv = preq->preq_rv;
525 lockmgr(&park->park_mtx, LK_RELEASE);
526 }
527
528 skipwait:
529 lockmgr(&pmp->pmp_lock, LK_EXCLUSIVE);
530 puffs_mp_release(pmp);
531 lockmgr(&pmp->pmp_lock, LK_RELEASE);
532
533#ifdef XXXDF
534 lockmgr(p->p_lock, LK_EXCLUSIVE);
535 sigprocmask1(l, SIG_SETMASK, &oss, NULL);
536 lockmgr(p->p_lock, LK_RELEASE);
537#endif
538
539 return rv;
540}
541
542/*
543 * XXX: this suuuucks. Hopefully I'll get rid of this lossage once
544 * the whole setback-nonsense gets fixed.
545 */
546int
547puffs_msg_wait2(struct puffs_mount *pmp, struct puffs_msgpark *park,
548 struct puffs_node *pn1, struct puffs_node *pn2)
549{
550 struct puffs_req *preq;
551 int rv;
552
553 rv = puffs_msg_wait(pmp, park);
554
555 preq = park->park_preq;
556 if (pn1 && preq->preq_setbacks & PUFFS_SETBACK_INACT_N1)
557 pn1->pn_stat |= PNODE_DOINACT;
558 if (pn2 && preq->preq_setbacks & PUFFS_SETBACK_INACT_N2)
559 pn2->pn_stat |= PNODE_DOINACT;
560
561 if (pn1 && preq->preq_setbacks & PUFFS_SETBACK_NOREF_N1)
562 pn1->pn_stat |= PNODE_NOREFS;
563 if (pn2 && preq->preq_setbacks & PUFFS_SETBACK_NOREF_N2)
564 pn2->pn_stat |= PNODE_NOREFS;
565
566 return rv;
567
568}
569
570/*
571 * XXX: lazy bum. please, for the love of foie gras, fix me.
572 * This should *NOT* depend on setfaf. Also "memcpy" could
573 * be done more nicely.
574 */
575void
576puffs_msg_sendresp(struct puffs_mount *pmp, struct puffs_req *origpreq, int rv)
577{
578 struct puffs_msgpark *park;
579 struct puffs_req *preq;
580
581 puffs_msgmem_alloc(sizeof(struct puffs_req), &park, (void *)&preq, 1);
582 puffs_msg_setfaf(park); /* XXXXXX: avoids reqid override */
583
584 memcpy(preq, origpreq, sizeof(struct puffs_req));
585 preq->preq_rv = rv;
586 preq->preq_opclass |= PUFFSOPFLAG_ISRESPONSE;
587
588 puffs_msg_enqueue(pmp, park);
589 puffs_msgmem_release(park);
590}
591
592/*
593 * Get next request in the outgoing queue. "maxsize" controls the
594 * size the caller can accommodate and "nonblock" signals if this
595 * should block while waiting for input. Handles all locking internally.
596 */
597int
598puffs_msgif_getout(void *this, size_t maxsize, int nonblock,
599 uint8_t **data, size_t *dlen, void **parkptr)
600{
601 struct puffs_mount *pmp = this;
602 struct puffs_msgpark *park = NULL;
603 struct puffs_req *preq = NULL;
604 int error;
605
606 error = 0;
607 lockmgr(&pmp->pmp_lock, LK_EXCLUSIVE);
608 puffs_mp_reference(pmp);
609 for (;;) {
610 /* RIP? */
611 if (pmp->pmp_status != PUFFSTAT_RUNNING) {
612 error = ENXIO;
613 break;
614 }
615
616 /* need platinum yendorian express card? */
617 if (TAILQ_EMPTY(&pmp->pmp_msg_touser)) {
618 DPRINTF_VERBOSE(("puffs_getout: no outgoing op, "));
619 if (nonblock) {
620 DPRINTF_VERBOSE(("returning EWOULDBLOCK\n"));
621 error = EWOULDBLOCK;
622 break;
623 }
624 DPRINTF_VERBOSE(("waiting ...\n"));
625
626 error = cv_wait_sig(&pmp->pmp_msg_waiter_cv,
627 &pmp->pmp_lock);
628 if (error)
629 break;
630 else
631 continue;
632 }
633
634 park = TAILQ_FIRST(&pmp->pmp_msg_touser);
635 if (park == NULL)
636 continue;
637
638 lockmgr(&park->park_mtx, LK_EXCLUSIVE);
639 puffs_msgpark_reference(park);
640
641 DPRINTF_VERBOSE(("puffs_getout: found park at %p, ", park));
642
643 /* If it's a goner, don't process any furher */
644 if (park->park_flags & PARKFLAG_WAITERGONE) {
645 DPRINTF_VERBOSE(("waitergone!\n"));
646 puffs_msgpark_release(park);
647 continue;
648 }
649 preq = park->park_preq;
650
651#if 0
652 /* check size */
653 /*
654 * XXX: this check is not valid for now, we don't know
655 * the size of the caller's input buffer. i.e. this
656 * will most likely go away
657 */
658 if (maxsize < preq->preq_frhdr.pfr_len) {
659 DPRINTF(("buffer too small\n"));
660 puffs_msgpark_release(park);
661 error = E2BIG;
662 break;
663 }
664#endif
665
666 DPRINTF_VERBOSE(("returning\n"));
667
668 /*
669 * Ok, we found what we came for. Release it from the
670 * outgoing queue but do not unlock. We will unlock
671 * only after we "releaseout" it to avoid complications:
672 * otherwise it is (theoretically) possible for userland
673 * to race us into "put" before we have a change to put
674 * this baby on the receiving queue.
675 */
676 TAILQ_REMOVE(&pmp->pmp_msg_touser, park, park_entries);
677 KKASSERT(park->park_flags & PARKFLAG_ONQUEUE1);
678 park->park_flags &= ~PARKFLAG_ONQUEUE1;
679 lockmgr(&park->park_mtx, LK_RELEASE);
680
681 pmp->pmp_msg_touser_count--;
682 KKASSERT(pmp->pmp_msg_touser_count >= 0);
683
684 break;
685 }
686 puffs_mp_release(pmp);
687 lockmgr(&pmp->pmp_lock, LK_RELEASE);
688
689 if (error == 0) {
690 *data = (uint8_t *)preq;
691 preq->preq_pth.pth_framelen = park->park_copylen;
692 *dlen = preq->preq_pth.pth_framelen;
693 *parkptr = park;
694 }
695
696 return error;
697}
698
699/*
700 * Release outgoing structure. Now, depending on the success of the
701 * outgoing send, it is either going onto the result waiting queue
702 * or the death chamber.
703 */
704void
705puffs_msgif_releaseout(void *this, void *parkptr, int status)
706{
707 struct puffs_mount *pmp = this;
708 struct puffs_msgpark *park = parkptr;
709
710 DPRINTF_VERBOSE(("puffs_releaseout: returning park %p, errno %d: " ,
711 park, status));
712 lockmgr(&pmp->pmp_lock, LK_EXCLUSIVE);
713 lockmgr(&park->park_mtx, LK_EXCLUSIVE);
714 if (park->park_flags & PARKFLAG_WANTREPLY) {
715 if (status == 0) {
716 DPRINTF_VERBOSE(("enqueue replywait\n"));
717 TAILQ_INSERT_TAIL(&pmp->pmp_msg_replywait, park,
718 park_entries);
719 park->park_flags |= PARKFLAG_ONQUEUE2;
720 } else {
721 DPRINTF_VERBOSE(("error path!\n"));
722 park->park_preq->preq_rv = status;
723 park->park_flags |= PARKFLAG_DONE;
724 cv_signal(&park->park_cv);
725 }
726 puffs_msgpark_release(park);
727 } else {
728 DPRINTF_VERBOSE(("release\n"));
729 puffs_msgpark_release1(park, 2);
730 }
731 lockmgr(&pmp->pmp_lock, LK_RELEASE);
732}
733
734size_t
735puffs_msgif_waitcount(void *this)
736{
737 struct puffs_mount *pmp = this;
738 size_t rv;
739
740 lockmgr(&pmp->pmp_lock, LK_EXCLUSIVE);
741 rv = pmp->pmp_msg_touser_count;
742 lockmgr(&pmp->pmp_lock, LK_RELEASE);
743
744 return rv;
745}
746
747/*
748 * XXX: locking with this one?
749 */
750static void
751puffsop_msg(void *this, struct puffs_req *preq)
752{
753 struct puffs_mount *pmp = this;
754 struct putter_hdr *pth = &preq->preq_pth;
755 struct puffs_msgpark *park;
756 int wgone;
757
758 lockmgr(&pmp->pmp_lock, LK_EXCLUSIVE);
759
760 /* Locate waiter */
761 TAILQ_FOREACH(park, &pmp->pmp_msg_replywait, park_entries) {
762 if (park->park_preq->preq_id == preq->preq_id)
763 break;
764 }
765 if (park == NULL) {
766 DPRINTF_VERBOSE(("puffsop_msg: no request: %" PRIu64 "\n",
767 preq->preq_id));
768 lockmgr(&pmp->pmp_lock, LK_RELEASE);
769 return; /* XXX send error */
770 }
771
772 lockmgr(&park->park_mtx, LK_EXCLUSIVE);
773 puffs_msgpark_reference(park);
774 if (pth->pth_framelen > park->park_maxlen) {
775 DPRINTF_VERBOSE(("puffsop_msg: invalid buffer length: "
776 "%" PRIu64 " (req %" PRIu64 ", \n", pth->pth_framelen,
777 preq->preq_id));
778 park->park_preq->preq_rv = EPROTO;
779 cv_signal(&park->park_cv);
780 puffs_msgpark_release1(park, 2);
781 lockmgr(&pmp->pmp_lock, LK_RELEASE);
782 return; /* XXX: error */
783 }
784 wgone = park->park_flags & PARKFLAG_WAITERGONE;
785
786 KKASSERT(park->park_flags & PARKFLAG_ONQUEUE2);
787 TAILQ_REMOVE(&pmp->pmp_msg_replywait, park, park_entries);
788 park->park_flags &= ~PARKFLAG_ONQUEUE2;
789 lockmgr(&pmp->pmp_lock, LK_RELEASE);
790
791 if (wgone) {
792 DPRINTF_VERBOSE(("puffsop_msg: bad service - waiter gone for "
793 "park %p\n", park));
794 } else {
795 memcpy(park->park_preq, preq, pth->pth_framelen);
796
797 if (park->park_flags & PARKFLAG_CALL) {
798 DPRINTF_VERBOSE(("puffsop_msg: call for %p, arg %p\n",
799 park->park_preq, park->park_donearg));
800 park->park_done(pmp, preq, park->park_donearg);
801 }
802 }
803
804 if (!wgone) {
805 DPRINTF_VERBOSE(("puffs_putop: flagging done for "
806 "park %p\n", park));
807 cv_signal(&park->park_cv);
808 }
809
810 park->park_flags |= PARKFLAG_DONE;
811 puffs_msgpark_release1(park, 2);
812}
813
814static void
815puffsop_flush(struct puffs_mount *pmp, struct puffs_flush *pf)
816{
817 struct vnode *vp;
818#ifdef XXXDF
819 voff_t offlo, offhi;
820 int rv, flags = 0;
821#endif
822 int rv;
823
824 KKASSERT(pf->pf_req.preq_pth.pth_framelen == sizeof(struct puffs_flush));
825
826 /* XXX: slurry */
827 if (pf->pf_op == PUFFS_INVAL_NAMECACHE_ALL) {
828#ifdef XXXDF
829 cache_purgevfs(PMPTOMP(pmp));
830 rv = 0;
831#endif
832 rv = ENOTSUP;
833 goto out;
834 }
835
836 /*
837 * Get vnode, don't lock it. Namecache is protected by its own lock
838 * and we have a reference to protect against premature harvesting.
839 *
840 * The node we want here might be locked and the op is in
841 * userspace waiting for us to complete ==> deadlock. Another
842 * reason we need to eventually bump locking to userspace, as we
843 * will need to lock the node if we wish to do flushes.
844 */
845 rv = puffs_cookie2vnode(pmp, pf->pf_cookie, 0, &vp);
846 if (rv) {
847 if (rv == PUFFS_NOSUCHCOOKIE)
848 rv = ENOENT;
849 goto out;
850 }
851
852 switch (pf->pf_op) {
853#if 0
854 /* not quite ready, yet */
855 case PUFFS_INVAL_NAMECACHE_NODE:
856 struct componentname *pf_cn;
857 char *name;
858 /* get comfortab^Wcomponentname */
859 pf_cn = kmem_alloc(componentname);
860 memset(pf_cn, 0, sizeof(struct componentname));
861 break;
862
863#endif
864 case PUFFS_INVAL_NAMECACHE_DIR:
865 if (vp->v_type != VDIR) {
866 rv = EINVAL;
867 break;
868 }
39a5cda3
MD
869#ifdef XXXDF
870 /* deadlocks, needs its own kernel thread */
ab5617b3 871 cache_purge(vp);
39a5cda3 872#endif
ab5617b3
SW
873 break;
874
875#ifdef XXXDF
876 case PUFFS_INVAL_PAGECACHE_NODE_RANGE:
877 flags = PGO_FREE;
878 /*FALLTHROUGH*/
879 case PUFFS_FLUSH_PAGECACHE_NODE_RANGE:
880 if (flags == 0)
881 flags = PGO_CLEANIT;
882
883 if (pf->pf_end > vp->v_size || vp->v_type != VREG) {
884 rv = EINVAL;
885 break;
886 }
887
888 offlo = trunc_page(pf->pf_start);
889 offhi = round_page(pf->pf_end);
890 if (offhi != 0 && offlo >= offhi) {
891 rv = EINVAL;
892 break;
893 }
894
895 lockmgr(&vp->v_uobj.vmobjlock, LK_EXCLUSIVE);
896 rv = VOP_PUTPAGES(vp, offlo, offhi, flags);
897 break;
898#endif
899
900 default:
901 rv = EINVAL;
902 }
903
904 vput(vp);
905
906 out:
907 puffs_msg_sendresp(pmp, &pf->pf_req, rv);
908}
909
910int
911puffs_msgif_dispatch(void *this, struct putter_hdr *pth)
912{
913 struct puffs_mount *pmp = this;
914 struct puffs_req *preq = (struct puffs_req *)pth;
915 struct puffs_sopreq *psopr;
916
917 if (pth->pth_framelen < sizeof(struct puffs_req)) {
918 puffs_msg_sendresp(pmp, preq, EINVAL); /* E2SMALL */
919 return 0;
920 }
921
922 switch (PUFFSOP_OPCLASS(preq->preq_opclass)) {
923 case PUFFSOP_VN:
924 case PUFFSOP_VFS:
925 DPRINTF_VERBOSE(("dispatch: vn/vfs message 0x%x\n",
926 preq->preq_optype));
927 puffsop_msg(pmp, preq);
928 break;
929
930 case PUFFSOP_FLUSH: /* process in sop thread */
931 {
932 struct puffs_flush *pf;
933
934 DPRINTF(("dispatch: flush 0x%x\n", preq->preq_optype));
935
936 if (preq->preq_pth.pth_framelen != sizeof(struct puffs_flush)) {
937 puffs_msg_sendresp(pmp, preq, EINVAL); /* E2SMALL */
938 break;
939 }
940 pf = (struct puffs_flush *)preq;
941
942 psopr = kmalloc(sizeof(*psopr), M_PUFFS, M_WAITOK);
943 memcpy(&psopr->psopr_pf, pf, sizeof(*pf));
944 psopr->psopr_sopreq = PUFFS_SOPREQ_FLUSH;
945
946 lockmgr(&pmp->pmp_sopmtx, LK_EXCLUSIVE);
947 if (pmp->pmp_sopthrcount == 0) {
948 lockmgr(&pmp->pmp_sopmtx, LK_RELEASE);
949 kfree(psopr, M_PUFFS);
950 puffs_msg_sendresp(pmp, preq, ENXIO);
951 } else {
952 TAILQ_INSERT_TAIL(&pmp->pmp_sopreqs,
953 psopr, psopr_entries);
954 cv_signal(&pmp->pmp_sopcv);
955 lockmgr(&pmp->pmp_sopmtx, LK_RELEASE);
956 }
957 break;
958 }
959
960 case PUFFSOP_UNMOUNT: /* process in sop thread */
961 {
962
963 DPRINTF(("dispatch: unmount 0x%x\n", preq->preq_optype));
964
965 psopr = kmalloc(sizeof(*psopr), M_PUFFS, M_WAITOK);
966 psopr->psopr_preq = *preq;
967 psopr->psopr_sopreq = PUFFS_SOPREQ_UNMOUNT;
968
969 lockmgr(&pmp->pmp_sopmtx, LK_EXCLUSIVE);
970 if (pmp->pmp_sopthrcount == 0) {
971 lockmgr(&pmp->pmp_sopmtx, LK_RELEASE);
972 kfree(psopr, M_PUFFS);
973 puffs_msg_sendresp(pmp, preq, ENXIO);
974 } else {
975 TAILQ_INSERT_TAIL(&pmp->pmp_sopreqs,
976 psopr, psopr_entries);
977 cv_signal(&pmp->pmp_sopcv);
978 lockmgr(&pmp->pmp_sopmtx, LK_RELEASE);
979 }
980 break;
981 }
982
983 default:
984 DPRINTF(("dispatch: invalid class 0x%x\n", preq->preq_opclass));
985 puffs_msg_sendresp(pmp, preq, EOPNOTSUPP);
986 break;
987 }
988
989 return 0;
990}
991
992/*
993 * Work loop for thread processing all ops from server which
994 * cannot safely be handled in caller context. This includes
995 * everything which might need a lock currently "held" by the file
996 * server, i.e. a long-term kernel lock which will be released only
997 * once the file server acknowledges a request
998 */
999void
1000puffs_sop_thread(void *arg)
1001{
1002 struct puffs_mount *pmp = arg;
1003 struct mount *mp = PMPTOMP(pmp);
1004 struct puffs_sopreq *psopr;
1005 boolean_t keeprunning;
1006 boolean_t unmountme = FALSE;
1007
1008 lockmgr(&pmp->pmp_sopmtx, LK_EXCLUSIVE);
1009 for (keeprunning = TRUE; keeprunning; ) {
1010 while ((psopr = TAILQ_FIRST(&pmp->pmp_sopreqs)) == NULL)
1011 cv_wait(&pmp->pmp_sopcv, &pmp->pmp_sopmtx);
1012 TAILQ_REMOVE(&pmp->pmp_sopreqs, psopr, psopr_entries);
1013 lockmgr(&pmp->pmp_sopmtx, LK_RELEASE);
1014
1015 switch (psopr->psopr_sopreq) {
1016 case PUFFS_SOPREQSYS_EXIT:
1017 keeprunning = FALSE;
1018 break;
1019 case PUFFS_SOPREQ_FLUSH:
1020 puffsop_flush(pmp, &psopr->psopr_pf);
1021 break;
1022 case PUFFS_SOPREQ_UNMOUNT:
1023 puffs_msg_sendresp(pmp, &psopr->psopr_preq, 0);
1024
1025 unmountme = TRUE;
1026 keeprunning = FALSE;
1027
1028 break;
1029 }
1030
1031 kfree(psopr, M_PUFFS);
1032 lockmgr(&pmp->pmp_sopmtx, LK_EXCLUSIVE);
1033 }
1034
1035 /*
1036 * Purge remaining ops.
1037 */
1038 while ((psopr = TAILQ_FIRST(&pmp->pmp_sopreqs)) != NULL) {
1039 TAILQ_REMOVE(&pmp->pmp_sopreqs, psopr, psopr_entries);
1040 lockmgr(&pmp->pmp_sopmtx, LK_RELEASE);
1041 puffs_msg_sendresp(pmp, &psopr->psopr_preq, ENXIO);
1042 kfree(psopr, M_PUFFS);
1043 lockmgr(&pmp->pmp_sopmtx, LK_EXCLUSIVE);
1044 }
1045
1046 pmp->pmp_sopthrcount--;
1047 cv_broadcast(&pmp->pmp_sopcv);
1048 lockmgr(&pmp->pmp_sopmtx, LK_RELEASE); /* not allowed to access fs after this */
1049
1050 /*
1051 * If unmount was requested, we can now safely do it here, since
1052 * our context is dead from the point-of-view of puffs_unmount()
1053 * and we are just another thread. dounmount() makes internally
1054 * sure that VFS_UNMOUNT() isn't called reentrantly and that it
1055 * is eventually completed.
1056 */
1057 if (unmountme) {
1058 (void)dounmount(mp, MNT_FORCE);
1059 }
1060
1061 kthread_exit();
1062}
1063
1064int
1065puffs_msgif_close(void *this)
1066{
1067 struct puffs_mount *pmp = this;
1068 struct mount *mp = PMPTOMP(pmp);
1069
1070 lockmgr(&pmp->pmp_lock, LK_EXCLUSIVE);
1071 puffs_mp_reference(pmp);
1072
1073 /*
1074 * Free the waiting callers before proceeding any further.
1075 * The syncer might be jogging around in this file system
1076 * currently. If we allow it to go to the userspace of no
1077 * return while trying to get the syncer lock, well ...
1078 */
1079 puffs_userdead(pmp);
1080
1081 /*
1082 * Make sure someone from puffs_unmount() isn't currently in
1083 * userspace. If we don't take this precautionary step,
1084 * they might notice that the mountpoint has disappeared
1085 * from under them once they return. Especially note that we
1086 * cannot simply test for an unmounter before calling
1087 * dounmount(), since it might be possible that that particular
1088 * invocation of unmount was called without MNT_FORCE. Here we
1089 * *must* make sure unmount succeeds. Also, restart is necessary
1090 * since pmp isn't locked. We might end up with PUTTER_DEAD after
1091 * restart and exit from there.
1092 */
1093 if (pmp->pmp_unmounting) {
1094 cv_wait(&pmp->pmp_unmounting_cv, &pmp->pmp_lock);
1095 puffs_mp_release(pmp);
1096 lockmgr(&pmp->pmp_lock, LK_RELEASE);
1097 DPRINTF(("puffs_fop_close: unmount was in progress for pmp %p, "
1098 "restart\n", pmp));
1099 return ERESTART;
1100 }
1101
1102 /* Won't access pmp from here anymore */
1103 puffs_mp_release(pmp);
1104 lockmgr(&pmp->pmp_lock, LK_RELEASE);
1105
1106 /* Detach from VFS. */
1107 (void)dounmount(mp, MNT_FORCE);
1108
1109 return 0;
1110}
1111
1112/*
1113 * We're dead, kaput, RIP, slightly more than merely pining for the
1114 * fjords, belly-up, fallen, lifeless, finished, expired, gone to meet
1115 * our maker, ceased to be, etcetc. YASD. It's a dead FS!
1116 *
1117 * Caller must hold puffs mutex.
1118 */
1119void
1120puffs_userdead(struct puffs_mount *pmp)
1121{
1122 struct puffs_msgpark *park, *park_next;
1123
1124 /*
1125 * Mark filesystem status as dying so that operations don't
1126 * attempt to march to userspace any longer.
1127 */
1128 pmp->pmp_status = PUFFSTAT_DYING;
1129
1130 /* signal waiters on REQUEST TO file server queue */
1131 for (park = TAILQ_FIRST(&pmp->pmp_msg_touser); park; park = park_next) {
ab5617b3
SW
1132 lockmgr(&park->park_mtx, LK_EXCLUSIVE);
1133 puffs_msgpark_reference(park);
1134 park_next = TAILQ_NEXT(park, park_entries);
1135
1136 KKASSERT(park->park_flags & PARKFLAG_ONQUEUE1);
1137 TAILQ_REMOVE(&pmp->pmp_msg_touser, park, park_entries);
1138 park->park_flags &= ~PARKFLAG_ONQUEUE1;
1139 pmp->pmp_msg_touser_count--;
1140
1141 /*
1142 * Even though waiters on QUEUE1 are removed in touser()
1143 * in case of WAITERGONE, it is still possible for us to
1144 * get raced here due to having to retake locks in said
1145 * touser(). In the race case simply "ignore" the item
1146 * on the queue and move on to the next one.
1147 */
1148 if (park->park_flags & PARKFLAG_WAITERGONE) {
1149 KKASSERT((park->park_flags & PARKFLAG_CALL) == 0);
1150 KKASSERT(park->park_flags & PARKFLAG_WANTREPLY);
1151 puffs_msgpark_release(park);
1152
1153 } else {
ab5617b3
SW
1154 park->park_preq->preq_rv = ENXIO;
1155
1156 if (park->park_flags & PARKFLAG_CALL) {
1157 park->park_done(pmp, park->park_preq,
1158 park->park_donearg);
1159 puffs_msgpark_release1(park, 2);
1160 } else if ((park->park_flags & PARKFLAG_WANTREPLY)==0) {
1161 puffs_msgpark_release1(park, 2);
1162 } else {
1163 park->park_preq->preq_rv = ENXIO;
1164 cv_signal(&park->park_cv);
1165 puffs_msgpark_release(park);
1166 }
1167 }
1168 }
1169
1170 /* signal waiters on RESPONSE FROM file server queue */
1171 for (park=TAILQ_FIRST(&pmp->pmp_msg_replywait); park; park=park_next) {
1172 lockmgr(&park->park_mtx, LK_EXCLUSIVE);
1173 puffs_msgpark_reference(park);
1174 park_next = TAILQ_NEXT(park, park_entries);
1175
1176 KKASSERT(park->park_flags & PARKFLAG_ONQUEUE2);
1177 KKASSERT(park->park_flags & PARKFLAG_WANTREPLY);
1178
1179 TAILQ_REMOVE(&pmp->pmp_msg_replywait, park, park_entries);
1180 park->park_flags &= ~PARKFLAG_ONQUEUE2;
1181
1182 if (park->park_flags & PARKFLAG_WAITERGONE) {
1183 KKASSERT((park->park_flags & PARKFLAG_CALL) == 0);
1184 puffs_msgpark_release(park);
1185 } else {
1186 park->park_preq->preq_rv = ENXIO;
1187 if (park->park_flags & PARKFLAG_CALL) {
1188 park->park_done(pmp, park->park_preq,
1189 park->park_donearg);
1190 puffs_msgpark_release1(park, 2);
1191 } else {
1192 cv_signal(&park->park_cv);
1193 puffs_msgpark_release(park);
1194 }
1195 }
1196 }
1197
1198 cv_broadcast(&pmp->pmp_msg_waiter_cv);
1199}