sys/vfs/puffs/puffs_msgif.c

   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  */
  56 struct 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
  84 static struct objcache *parkpc;
  85 #ifdef PUFFSDEBUG
  86 static int totalpark;
  87 #endif
  88
  89 static boolean_t
  90 makepark(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
 100 static void
 101 nukepark(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
 109 void
 110 puffs_msgif_init(void)
 111 {
 112
 113         parkpc = objcache_create_mbacked(M_PUFFS, sizeof(struct puffs_msgpark),
 114             NULL, 0, makepark, nukepark, NULL);
 115 }
 116
 117 void
 118 puffs_msgif_destroy(void)
 119 {
 120
 121         objcache_destroy(parkpc);
 122 }
 123
 124 static struct puffs_msgpark *
 125 puffs_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
 144 static void
 145 puffs_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  */
 155 static void
 156 puffs_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
 185 static void
 186 parkdump(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
 199 static void
 200 parkqdump(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
 222 int
 223 puffs_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
 251 void
 252 puffs_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
 262 void
 263 puffs_msg_setfaf(struct puffs_msgpark *park)
 264 {
 265
 266         KKASSERT((park->park_flags & PARKFLAG_CALL) == 0);
 267         park->park_flags &= ~PARKFLAG_WANTREPLY;
 268 }
 269
 270 void
 271 puffs_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
 278 void
 279 puffs_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
 288 void
 289 puffs_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
 302 static uint64_t
 303 puffs_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
 321 void
 322 puffs_msg_enqueue(struct puffs_mount *pmp, struct puffs_msgpark *park)
 323 {
 324         struct thread *td = curthread;
 325         struct mount *mp;
 326         struct puffs_req *preq;
 327         sigset_t ss;
 328
 329         /*
 330          * Some clients reuse a park, so reset some flags.  We might
 331          * want to provide a caller-side interface for this and add
 332          * a few more invariant checks here, but this will do for now.
 333          */
 334         KKASSERT(pmp != NULL && park != NULL);
 335         park->park_flags &= ~(PARKFLAG_DONE | PARKFLAG_HASERROR);
 336         KKASSERT((park->park_flags & PARKFLAG_WAITERGONE) == 0);
 337
 338         mp = PMPTOMP(pmp);
 339         preq = park->park_preq;
 340
 341         preq->preq_buflen = park->park_maxlen;
 342         KKASSERT(preq->preq_id == 0
 343             || (preq->preq_opclass & PUFFSOPFLAG_ISRESPONSE));
 344
 345         if ((park->park_flags & PARKFLAG_WANTREPLY) == 0)
 346                 preq->preq_opclass |= PUFFSOPFLAG_FAF;
 347         else
 348                 preq->preq_id = puffs_getmsgid(pmp);
 349
 350         /* fill in caller information */
 351         if (td->td_proc == NULL || td->td_lwp == NULL) {
 352                 DPRINTF_VERBOSE(("puffs_msg_enqueue: no process\n"));
 353                 preq->preq_pid = 1;
 354                 preq->preq_lid = 0;
 355                 goto noproc;
 356         }
 357         preq->preq_pid = td->td_proc->p_pid;
 358         preq->preq_lid = td->td_lwp->lwp_tid;
 359
 360         /*
 361          * To support cv_sig, yet another movie: check if there are signals
 362          * pending and we are issueing a non-FAF.  If so, return an error
 363          * directly UNLESS we are issueing INACTIVE/RECLAIM.  In that case,
 364          * convert it to a FAF, fire off to the file server and return
 365          * an error.  Yes, this is bordering disgusting.  Barfbags are on me.
 366          */
 367         ss = lwp_sigpend(td->td_lwp);
 368         SIGSETNAND(ss, td->td_lwp->lwp_sigmask);
 369         if (__predict_false((park->park_flags & PARKFLAG_WANTREPLY)
 370            && (park->park_flags & PARKFLAG_CALL) == 0
 371            && SIGNOTEMPTY(ss))) {
 372
 373                 /*
 374                  * see the comment about signals in puffs_msg_wait.
 375                  */
 376                 if (SIGISMEMBER(ss, SIGINT) ||
 377                     SIGISMEMBER(ss, SIGTERM) ||
 378                     SIGISMEMBER(ss, SIGKILL) ||
 379                     SIGISMEMBER(ss, SIGHUP) ||
 380                     SIGISMEMBER(ss, SIGQUIT)) {
 381                         park->park_flags |= PARKFLAG_HASERROR;
 382                         preq->preq_rv = EINTR;
 383                         if (PUFFSOP_OPCLASS(preq->preq_opclass) == PUFFSOP_VN
 384                             && (preq->preq_optype == PUFFS_VN_INACTIVE
 385                              || preq->preq_optype == PUFFS_VN_RECLAIM)) {
 386                                 park->park_preq->preq_opclass |=
 387                                     PUFFSOPFLAG_FAF;
 388                                 park->park_flags &= ~PARKFLAG_WANTREPLY;
 389                                 DPRINTF_VERBOSE(("puffs_msg_enqueue: "
 390                                     "converted to FAF %p\n", park));
 391                         } else {
 392                                 return;
 393                         }
 394                 }
 395         }
 396
 397  noproc:
 398         lockmgr(&pmp->pmp_lock, LK_EXCLUSIVE);
 399         if (pmp->pmp_status != PUFFSTAT_RUNNING) {
 400                 lockmgr(&pmp->pmp_lock, LK_RELEASE);
 401                 park->park_flags |= PARKFLAG_HASERROR;
 402                 preq->preq_rv = ENXIO;
 403                 return;
 404         }
 405
 406 #ifdef PUFFSDEBUG
 407         parkqdump(&pmp->pmp_msg_touser, puffsdebug > 1);
 408         parkqdump(&pmp->pmp_msg_replywait, puffsdebug > 1);
 409 #endif
 410
 411         /*
 412          * Note: we don't need to lock park since we have the only
 413          * reference to it at this point.
 414          */
 415         TAILQ_INSERT_TAIL(&pmp->pmp_msg_touser, park, park_entries);
 416         park->park_flags |= PARKFLAG_ONQUEUE1;
 417         pmp->pmp_msg_touser_count++;
 418         park->park_refcount++;
 419         lockmgr(&pmp->pmp_lock, LK_RELEASE);
 420
 421         cv_broadcast(&pmp->pmp_msg_waiter_cv);
 422         putter_notify(pmp->pmp_pi);
 423
 424         DPRINTF_VERBOSE(("touser: req %" PRIu64 ", preq: %p, park: %p, "
 425             "c/t: 0x%x/0x%x, f: 0x%x\n", preq->preq_id, preq, park,
 426             preq->preq_opclass, preq->preq_optype, park->park_flags));
 427 }
 428
 429 int
 430 puffs_msg_wait(struct puffs_mount *pmp, struct puffs_msgpark *park)
 431 {
 432         struct puffs_req *preq = park->park_preq; /* XXX: hmmm */
 433 #ifdef XXXDF
 434         struct lwp *l = curthread->td_lwp;
 435         struct proc *p = curthread->td_proc;
 436         sigset_t ss;
 437         sigset_t oss;
 438 #endif
 439         int error = 0;
 440         int rv;
 441
 442         KKASSERT(pmp != NULL && park != NULL);
 443
 444         /*
 445          * block unimportant signals.
 446          *
 447          * The set of "important" signals here was chosen to be same as
 448          * nfs interruptible mount.
 449          */
 450 #ifdef XXXDF
 451         SIGFILLSET(ss);
 452         SIGDELSET(ss, SIGINT);
 453         SIGDELSET(ss, SIGTERM);
 454         SIGDELSET(ss, SIGKILL);
 455         SIGDELSET(ss, SIGHUP);
 456         SIGDELSET(ss, SIGQUIT);
 457         lockmgr(p->p_lock, LK_EXCLUSIVE);
 458         sigprocmask1(l, SIG_BLOCK, &ss, &oss);
 459         lockmgr(p->p_lock, LK_RELEASE);
 460 #endif
 461
 462         lockmgr(&pmp->pmp_lock, LK_EXCLUSIVE);
 463         puffs_mp_reference(pmp);
 464         lockmgr(&pmp->pmp_lock, LK_RELEASE);
 465
 466         lockmgr(&park->park_mtx, LK_EXCLUSIVE);
 467         /* did the response beat us to the wait? */
 468         if (__predict_false((park->park_flags & PARKFLAG_DONE)
 469             || (park->park_flags & PARKFLAG_HASERROR))) {
 470                 rv = park->park_preq->preq_rv;
 471                 lockmgr(&park->park_mtx, LK_RELEASE);
 472                 goto skipwait;
 473         }
 474
 475         if ((park->park_flags & PARKFLAG_WANTREPLY) == 0
 476             || (park->park_flags & PARKFLAG_CALL)) {
 477                 lockmgr(&park->park_mtx, LK_RELEASE);
 478                 rv = 0;
 479                 goto skipwait;
 480         }
 481
 482         error = cv_wait_sig(&park->park_cv, &park->park_mtx);
 483         DPRINTF_VERBOSE(("puffs_touser: waiter for %p woke up with %d\n",
 484             park, error));
 485         if (error) {
 486                 park->park_flags |= PARKFLAG_WAITERGONE;
 487                 if (park->park_flags & PARKFLAG_DONE) {
 488                         rv = preq->preq_rv;
 489                         lockmgr(&park->park_mtx, LK_RELEASE);
 490                 } else {
 491                         /*
 492                          * ok, we marked it as going away, but
 493                          * still need to do queue ops.  take locks
 494                          * in correct order.
 495                          *
 496                          * We don't want to release our reference
 497                          * if it's on replywait queue to avoid error
 498                          * to file server.  putop() code will DTRT.
 499                          */
 500                         lockmgr(&park->park_mtx, LK_RELEASE);
 501                         lockmgr(&pmp->pmp_lock, LK_EXCLUSIVE);
 502                         lockmgr(&park->park_mtx, LK_EXCLUSIVE);
 503
 504                         /*
 505                          * Still on queue1?  We can safely remove it
 506                          * without any consequences since the file
 507                          * server hasn't seen it.  "else" we need to
 508                          * wait for the response and just ignore it
 509                          * to avoid signalling an incorrect error to
 510                          * the file server.
 511                          */
 512                         if (park->park_flags & PARKFLAG_ONQUEUE1) {
 513                                 TAILQ_REMOVE(&pmp->pmp_msg_touser,
 514                                     park, park_entries);
 515                                 puffs_msgpark_release(park);
 516                                 pmp->pmp_msg_touser_count--;
 517                                 park->park_flags &= ~PARKFLAG_ONQUEUE1;
 518                         } else {
 519                                 lockmgr(&park->park_mtx, LK_RELEASE);
 520                         }
 521                         lockmgr(&pmp->pmp_lock, LK_RELEASE);
 522
 523                         rv = EINTR;
 524                 }
 525         } else {
 526                 rv = preq->preq_rv;
 527                 lockmgr(&park->park_mtx, LK_RELEASE);
 528         }
 529
 530  skipwait:
 531         lockmgr(&pmp->pmp_lock, LK_EXCLUSIVE);
 532         puffs_mp_release(pmp);
 533         lockmgr(&pmp->pmp_lock, LK_RELEASE);
 534
 535 #ifdef XXXDF
 536         lockmgr(p->p_lock, LK_EXCLUSIVE);
 537         sigprocmask1(l, SIG_SETMASK, &oss, NULL);
 538         lockmgr(p->p_lock, LK_RELEASE);
 539 #endif
 540
 541         return rv;
 542 }
 543
 544 /*
 545  * XXX: this suuuucks.  Hopefully I'll get rid of this lossage once
 546  * the whole setback-nonsense gets fixed.
 547  */
 548 int
 549 puffs_msg_wait2(struct puffs_mount *pmp, struct puffs_msgpark *park,
 550         struct puffs_node *pn1, struct puffs_node *pn2)
 551 {
 552         struct puffs_req *preq;
 553         int rv;
 554
 555         rv = puffs_msg_wait(pmp, park);
 556
 557         preq = park->park_preq;
 558         if (pn1 && preq->preq_setbacks & PUFFS_SETBACK_INACT_N1)
 559                 pn1->pn_stat |= PNODE_DOINACT;
 560         if (pn2 && preq->preq_setbacks & PUFFS_SETBACK_INACT_N2)
 561                 pn2->pn_stat |= PNODE_DOINACT;
 562
 563         if (pn1 && preq->preq_setbacks & PUFFS_SETBACK_NOREF_N1)
 564                 pn1->pn_stat |= PNODE_NOREFS;
 565         if (pn2 && preq->preq_setbacks & PUFFS_SETBACK_NOREF_N2)
 566                 pn2->pn_stat |= PNODE_NOREFS;
 567
 568         return rv;
 569
 570 }
 571
 572 /*
 573  * XXX: lazy bum.  please, for the love of foie gras, fix me.
 574  * This should *NOT* depend on setfaf.  Also "memcpy" could
 575  * be done more nicely.
 576  */
 577 void
 578 puffs_msg_sendresp(struct puffs_mount *pmp, struct puffs_req *origpreq, int rv)
 579 {
 580         struct puffs_msgpark *park;
 581         struct puffs_req *preq;
 582
 583         puffs_msgmem_alloc(sizeof(struct puffs_req), &park, (void *)&preq, 1);
 584         puffs_msg_setfaf(park); /* XXXXXX: avoids reqid override */
 585
 586         memcpy(preq, origpreq, sizeof(struct puffs_req));
 587         preq->preq_rv = rv;
 588         preq->preq_opclass |= PUFFSOPFLAG_ISRESPONSE;
 589
 590         puffs_msg_enqueue(pmp, park);
 591         puffs_msgmem_release(park);
 592 }
 593
 594 /*
 595  * Get next request in the outgoing queue.  "maxsize" controls the
 596  * size the caller can accommodate and "nonblock" signals if this
 597  * should block while waiting for input.  Handles all locking internally.
 598  */
 599 int
 600 puffs_msgif_getout(void *this, size_t maxsize, int nonblock,
 601         uint8_t **data, size_t *dlen, void **parkptr)
 602 {
 603         struct puffs_mount *pmp = this;
 604         struct puffs_msgpark *park = NULL;
 605         struct puffs_req *preq = NULL;
 606         int error;
 607
 608         error = 0;
 609         lockmgr(&pmp->pmp_lock, LK_EXCLUSIVE);
 610         puffs_mp_reference(pmp);
 611         for (;;) {
 612                 /* RIP? */
 613                 if (pmp->pmp_status != PUFFSTAT_RUNNING) {
 614                         error = ENXIO;
 615                         break;
 616                 }
 617
 618                 /* need platinum yendorian express card? */
 619                 if (TAILQ_EMPTY(&pmp->pmp_msg_touser)) {
 620                         DPRINTF_VERBOSE(("puffs_getout: no outgoing op, "));
 621                         if (nonblock) {
 622                                 DPRINTF_VERBOSE(("returning EWOULDBLOCK\n"));
 623                                 error = EWOULDBLOCK;
 624                                 break;
 625                         }
 626                         DPRINTF_VERBOSE(("waiting ...\n"));
 627
 628                         error = cv_wait_sig(&pmp->pmp_msg_waiter_cv,
 629                             &pmp->pmp_lock);
 630                         if (error)
 631                                 break;
 632                         else
 633                                 continue;
 634                 }
 635
 636                 park = TAILQ_FIRST(&pmp->pmp_msg_touser);
 637                 if (park == NULL)
 638                         continue;
 639
 640                 lockmgr(&park->park_mtx, LK_EXCLUSIVE);
 641                 puffs_msgpark_reference(park);
 642
 643                 DPRINTF_VERBOSE(("puffs_getout: found park at %p, ", park));
 644
 645                 /* If it's a goner, don't process any furher */
 646                 if (park->park_flags & PARKFLAG_WAITERGONE) {
 647                         DPRINTF_VERBOSE(("waitergone!\n"));
 648                         puffs_msgpark_release(park);
 649                         continue;
 650                 }
 651                 preq = park->park_preq;
 652
 653 #if 0
 654                 /* check size */
 655                 /*
 656                  * XXX: this check is not valid for now, we don't know
 657                  * the size of the caller's input buffer.  i.e. this
 658                  * will most likely go away
 659                  */
 660                 if (maxsize < preq->preq_frhdr.pfr_len) {
 661                         DPRINTF(("buffer too small\n"));
 662                         puffs_msgpark_release(park);
 663                         error = E2BIG;
 664                         break;
 665                 }
 666 #endif
 667
 668                 DPRINTF_VERBOSE(("returning\n"));
 669
 670                 /*
 671                  * Ok, we found what we came for.  Release it from the
 672                  * outgoing queue but do not unlock.  We will unlock
 673                  * only after we "releaseout" it to avoid complications:
 674                  * otherwise it is (theoretically) possible for userland
 675                  * to race us into "put" before we have a change to put
 676                  * this baby on the receiving queue.
 677                  */
 678                 TAILQ_REMOVE(&pmp->pmp_msg_touser, park, park_entries);
 679                 KKASSERT(park->park_flags & PARKFLAG_ONQUEUE1);
 680                 park->park_flags &= ~PARKFLAG_ONQUEUE1;
 681                 lockmgr(&park->park_mtx, LK_RELEASE);
 682
 683                 pmp->pmp_msg_touser_count--;
 684                 KKASSERT(pmp->pmp_msg_touser_count >= 0);
 685
 686                 break;
 687         }
 688         puffs_mp_release(pmp);
 689         lockmgr(&pmp->pmp_lock, LK_RELEASE);
 690
 691         if (error == 0) {
 692                 *data = (uint8_t *)preq;
 693                 preq->preq_pth.pth_framelen = park->park_copylen;
 694                 *dlen = preq->preq_pth.pth_framelen;
 695                 *parkptr = park;
 696         }
 697
 698         return error;
 699 }
 700
 701 /*
 702  * Release outgoing structure.  Now, depending on the success of the
 703  * outgoing send, it is either going onto the result waiting queue
 704  * or the death chamber.
 705  */
 706 void
 707 puffs_msgif_releaseout(void *this, void *parkptr, int status)
 708 {
 709         struct puffs_mount *pmp = this;
 710         struct puffs_msgpark *park = parkptr;
 711
 712         DPRINTF_VERBOSE(("puffs_releaseout: returning park %p, errno %d: " ,
 713             park, status));
 714         lockmgr(&pmp->pmp_lock, LK_EXCLUSIVE);
 715         lockmgr(&park->park_mtx, LK_EXCLUSIVE);
 716         if (park->park_flags & PARKFLAG_WANTREPLY) {
 717                 if (status == 0) {
 718                         DPRINTF_VERBOSE(("enqueue replywait\n"));
 719                         TAILQ_INSERT_TAIL(&pmp->pmp_msg_replywait, park,
 720                             park_entries);
 721                         park->park_flags |= PARKFLAG_ONQUEUE2;
 722                 } else {
 723                         DPRINTF_VERBOSE(("error path!\n"));
 724                         park->park_preq->preq_rv = status;
 725                         park->park_flags |= PARKFLAG_DONE;
 726                         cv_signal(&park->park_cv);
 727                 }
 728                 puffs_msgpark_release(park);
 729         } else {
 730                 DPRINTF_VERBOSE(("release\n"));
 731                 puffs_msgpark_release1(park, 2);
 732         }
 733         lockmgr(&pmp->pmp_lock, LK_RELEASE);
 734 }
 735
 736 size_t
 737 puffs_msgif_waitcount(void *this)
 738 {
 739         struct puffs_mount *pmp = this;
 740         size_t rv;
 741
 742         lockmgr(&pmp->pmp_lock, LK_EXCLUSIVE);
 743         rv = pmp->pmp_msg_touser_count;
 744         lockmgr(&pmp->pmp_lock, LK_RELEASE);
 745
 746         return rv;
 747 }
 748
 749 /*
 750  * XXX: locking with this one?
 751  */
 752 static void
 753 puffsop_msg(void *this, struct puffs_req *preq)
 754 {
 755         struct puffs_mount *pmp = this;
 756         struct putter_hdr *pth = &preq->preq_pth;
 757         struct puffs_msgpark *park;
 758         int wgone;
 759
 760         lockmgr(&pmp->pmp_lock, LK_EXCLUSIVE);
 761
 762         /* Locate waiter */
 763         TAILQ_FOREACH(park, &pmp->pmp_msg_replywait, park_entries) {
 764                 if (park->park_preq->preq_id == preq->preq_id)
 765                         break;
 766         }
 767         if (park == NULL) {
 768                 DPRINTF_VERBOSE(("puffsop_msg: no request: %" PRIu64 "\n",
 769                     preq->preq_id));
 770                 lockmgr(&pmp->pmp_lock, LK_RELEASE);
 771                 return; /* XXX send error */
 772         }
 773
 774         lockmgr(&park->park_mtx, LK_EXCLUSIVE);
 775         puffs_msgpark_reference(park);
 776         if (pth->pth_framelen > park->park_maxlen) {
 777                 DPRINTF_VERBOSE(("puffsop_msg: invalid buffer length: "
 778                     "%" PRIu64 " (req %" PRIu64 ", \n", pth->pth_framelen,
 779                     preq->preq_id));
 780                 park->park_preq->preq_rv = EPROTO;
 781                 cv_signal(&park->park_cv);
 782                 puffs_msgpark_release1(park, 2);
 783                 lockmgr(&pmp->pmp_lock, LK_RELEASE);
 784                 return; /* XXX: error */
 785         }
 786         wgone = park->park_flags & PARKFLAG_WAITERGONE;
 787
 788         KKASSERT(park->park_flags & PARKFLAG_ONQUEUE2);
 789         TAILQ_REMOVE(&pmp->pmp_msg_replywait, park, park_entries);
 790         park->park_flags &= ~PARKFLAG_ONQUEUE2;
 791         lockmgr(&pmp->pmp_lock, LK_RELEASE);
 792
 793         if (wgone) {
 794                 DPRINTF_VERBOSE(("puffsop_msg: bad service - waiter gone for "
 795                     "park %p\n", park));
 796         } else {
 797                 memcpy(park->park_preq, preq, pth->pth_framelen);
 798
 799                 if (park->park_flags & PARKFLAG_CALL) {
 800                         DPRINTF_VERBOSE(("puffsop_msg: call for %p, arg %p\n",
 801                             park->park_preq, park->park_donearg));
 802                         park->park_done(pmp, preq, park->park_donearg);
 803                 }
 804         }
 805
 806         if (!wgone) {
 807                 DPRINTF_VERBOSE(("puffs_putop: flagging done for "
 808                     "park %p\n", park));
 809                 cv_signal(&park->park_cv);
 810         }
 811
 812         park->park_flags |= PARKFLAG_DONE;
 813         puffs_msgpark_release1(park, 2);
 814 }
 815
 816 static void
 817 puffsop_flush(struct puffs_mount *pmp, struct puffs_flush *pf)
 818 {
 819         struct vnode *vp;
 820 #ifdef XXXDF
 821         voff_t offlo, offhi;
 822         int rv, flags = 0;
 823 #endif
 824         int rv;
 825
 826         KKASSERT(pf->pf_req.preq_pth.pth_framelen == sizeof(struct puffs_flush));
 827
 828         /* XXX: slurry */
 829         if (pf->pf_op == PUFFS_INVAL_NAMECACHE_ALL) {
 830 #ifdef XXXDF
 831                 cache_purgevfs(PMPTOMP(pmp));
 832                 rv = 0;
 833 #endif
 834                 rv = ENOTSUP;
 835                 goto out;
 836         }
 837
 838         /*
 839          * Get vnode, don't lock it.  Namecache is protected by its own lock
 840          * and we have a reference to protect against premature harvesting.
 841          *
 842          * The node we want here might be locked and the op is in
 843          * userspace waiting for us to complete ==> deadlock.  Another
 844          * reason we need to eventually bump locking to userspace, as we
 845          * will need to lock the node if we wish to do flushes.
 846          */
 847         rv = puffs_cookie2vnode(pmp, pf->pf_cookie, 0, &vp);
 848         if (rv) {
 849                 if (rv == PUFFS_NOSUCHCOOKIE)
 850                         rv = ENOENT;
 851                 goto out;
 852         }
 853
 854         switch (pf->pf_op) {
 855 #if 0
 856         /* not quite ready, yet */
 857         case PUFFS_INVAL_NAMECACHE_NODE:
 858         struct componentname *pf_cn;
 859         char *name;
 860                 /* get comfortab^Wcomponentname */
 861                 pf_cn = kmem_alloc(componentname);
 862                 memset(pf_cn, 0, sizeof(struct componentname));
 863                 break;
 864
 865 #endif
 866         case PUFFS_INVAL_NAMECACHE_DIR:
 867                 if (vp->v_type != VDIR) {
 868                         rv = EINVAL;
 869                         break;
 870                 }
 871                 cache_purge(vp);
 872                 break;
 873
 874 #ifdef XXXDF
 875         case PUFFS_INVAL_PAGECACHE_NODE_RANGE:
 876                 flags = PGO_FREE;
 877                 /*FALLTHROUGH*/
 878         case PUFFS_FLUSH_PAGECACHE_NODE_RANGE:
 879                 if (flags == 0)
 880                         flags = PGO_CLEANIT;
 881
 882                 if (pf->pf_end > vp->v_size || vp->v_type != VREG) {
 883                         rv = EINVAL;
 884                         break;
 885                 }
 886
 887                 offlo = trunc_page(pf->pf_start);
 888                 offhi = round_page(pf->pf_end);
 889                 if (offhi != 0 && offlo >= offhi) {
 890                         rv = EINVAL;
 891                         break;
 892                 }
 893
 894                 lockmgr(&vp->v_uobj.vmobjlock, LK_EXCLUSIVE);
 895                 rv = VOP_PUTPAGES(vp, offlo, offhi, flags);
 896                 break;
 897 #endif
 898
 899         default:
 900                 rv = EINVAL;
 901         }
 902
 903         vput(vp);
 904
 905  out:
 906         puffs_msg_sendresp(pmp, &pf->pf_req, rv);
 907 }
 908
 909 int
 910 puffs_msgif_dispatch(void *this, struct putter_hdr *pth)
 911 {
 912         struct puffs_mount *pmp = this;
 913         struct puffs_req *preq = (struct puffs_req *)pth;
 914         struct puffs_sopreq *psopr;
 915
 916         if (pth->pth_framelen < sizeof(struct puffs_req)) {
 917                 puffs_msg_sendresp(pmp, preq, EINVAL); /* E2SMALL */
 918                 return 0;
 919         }
 920
 921         switch (PUFFSOP_OPCLASS(preq->preq_opclass)) {
 922         case PUFFSOP_VN:
 923         case PUFFSOP_VFS:
 924                 DPRINTF_VERBOSE(("dispatch: vn/vfs message 0x%x\n",
 925                     preq->preq_optype));
 926                 puffsop_msg(pmp, preq);
 927                 break;
 928
 929         case PUFFSOP_FLUSH: /* process in sop thread */
 930         {
 931                 struct puffs_flush *pf;
 932
 933                 DPRINTF(("dispatch: flush 0x%x\n", preq->preq_optype));
 934
 935                 if (preq->preq_pth.pth_framelen != sizeof(struct puffs_flush)) {
 936                         puffs_msg_sendresp(pmp, preq, EINVAL); /* E2SMALL */
 937                         break;
 938                 }
 939                 pf = (struct puffs_flush *)preq;
 940
 941                 psopr = kmalloc(sizeof(*psopr), M_PUFFS, M_WAITOK);
 942                 memcpy(&psopr->psopr_pf, pf, sizeof(*pf));
 943                 psopr->psopr_sopreq = PUFFS_SOPREQ_FLUSH;
 944
 945                 lockmgr(&pmp->pmp_sopmtx, LK_EXCLUSIVE);
 946                 if (pmp->pmp_sopthrcount == 0) {
 947                         lockmgr(&pmp->pmp_sopmtx, LK_RELEASE);
 948                         kfree(psopr, M_PUFFS);
 949                         puffs_msg_sendresp(pmp, preq, ENXIO);
 950                 } else {
 951                         TAILQ_INSERT_TAIL(&pmp->pmp_sopreqs,
 952                             psopr, psopr_entries);
 953                         cv_signal(&pmp->pmp_sopcv);
 954                         lockmgr(&pmp->pmp_sopmtx, LK_RELEASE);
 955                 }
 956                 break;
 957         }
 958
 959         case PUFFSOP_UNMOUNT: /* process in sop thread */
 960         {
 961
 962                 DPRINTF(("dispatch: unmount 0x%x\n", preq->preq_optype));
 963
 964                 psopr = kmalloc(sizeof(*psopr), M_PUFFS, M_WAITOK);
 965                 psopr->psopr_preq = *preq;
 966                 psopr->psopr_sopreq = PUFFS_SOPREQ_UNMOUNT;
 967
 968                 lockmgr(&pmp->pmp_sopmtx, LK_EXCLUSIVE);
 969                 if (pmp->pmp_sopthrcount == 0) {
 970                         lockmgr(&pmp->pmp_sopmtx, LK_RELEASE);
 971                         kfree(psopr, M_PUFFS);
 972                         puffs_msg_sendresp(pmp, preq, ENXIO);
 973                 } else {
 974                         TAILQ_INSERT_TAIL(&pmp->pmp_sopreqs,
 975                             psopr, psopr_entries);
 976                         cv_signal(&pmp->pmp_sopcv);
 977                         lockmgr(&pmp->pmp_sopmtx, LK_RELEASE);
 978                 }
 979                 break;
 980         }
 981
 982         default:
 983                 DPRINTF(("dispatch: invalid class 0x%x\n", preq->preq_opclass));
 984                 puffs_msg_sendresp(pmp, preq, EOPNOTSUPP);
 985                 break;
 986         }
 987
 988         return 0;
 989 }
 990
 991 /*
 992  * Work loop for thread processing all ops from server which
 993  * cannot safely be handled in caller context.  This includes
 994  * everything which might need a lock currently "held" by the file
 995  * server, i.e. a long-term kernel lock which will be released only
 996  * once the file server acknowledges a request
 997  */
 998 void
 999 puffs_sop_thread(void *arg)
1000 {
1001         struct puffs_mount *pmp = arg;
1002         struct mount *mp = PMPTOMP(pmp);
1003         struct puffs_sopreq *psopr;
1004         boolean_t keeprunning;
1005         boolean_t unmountme = FALSE;
1006
1007         lockmgr(&pmp->pmp_sopmtx, LK_EXCLUSIVE);
1008         for (keeprunning = TRUE; keeprunning; ) {
1009                 while ((psopr = TAILQ_FIRST(&pmp->pmp_sopreqs)) == NULL)
1010                         cv_wait(&pmp->pmp_sopcv, &pmp->pmp_sopmtx);
1011                 TAILQ_REMOVE(&pmp->pmp_sopreqs, psopr, psopr_entries);
1012                 lockmgr(&pmp->pmp_sopmtx, LK_RELEASE);
1013
1014                 switch (psopr->psopr_sopreq) {
1015                 case PUFFS_SOPREQSYS_EXIT:
1016                         keeprunning = FALSE;
1017                         break;
1018                 case PUFFS_SOPREQ_FLUSH:
1019                         puffsop_flush(pmp, &psopr->psopr_pf);
1020                         break;
1021                 case PUFFS_SOPREQ_UNMOUNT:
1022                         puffs_msg_sendresp(pmp, &psopr->psopr_preq, 0);
1023
1024                         unmountme = TRUE;
1025                         keeprunning = FALSE;
1026
1027                         break;
1028                 }
1029
1030                 kfree(psopr, M_PUFFS);
1031                 lockmgr(&pmp->pmp_sopmtx, LK_EXCLUSIVE);
1032         }
1033
1034         /*
1035          * Purge remaining ops.
1036          */
1037         while ((psopr = TAILQ_FIRST(&pmp->pmp_sopreqs)) != NULL) {
1038                 TAILQ_REMOVE(&pmp->pmp_sopreqs, psopr, psopr_entries);
1039                 lockmgr(&pmp->pmp_sopmtx, LK_RELEASE);
1040                 puffs_msg_sendresp(pmp, &psopr->psopr_preq, ENXIO);
1041                 kfree(psopr, M_PUFFS);
1042                 lockmgr(&pmp->pmp_sopmtx, LK_EXCLUSIVE);
1043         }
1044
1045         pmp->pmp_sopthrcount--;
1046         cv_broadcast(&pmp->pmp_sopcv);
1047         lockmgr(&pmp->pmp_sopmtx, LK_RELEASE); /* not allowed to access fs after this */
1048
1049         /*
1050          * If unmount was requested, we can now safely do it here, since
1051          * our context is dead from the point-of-view of puffs_unmount()
1052          * and we are just another thread.  dounmount() makes internally
1053          * sure that VFS_UNMOUNT() isn't called reentrantly and that it
1054          * is eventually completed.
1055          */
1056         if (unmountme) {
1057                 (void)dounmount(mp, MNT_FORCE);
1058         }
1059
1060         kthread_exit();
1061 }
1062
1063 int
1064 puffs_msgif_close(void *this)
1065 {
1066         struct puffs_mount *pmp = this;
1067         struct mount *mp = PMPTOMP(pmp);
1068
1069         lockmgr(&pmp->pmp_lock, LK_EXCLUSIVE);
1070         puffs_mp_reference(pmp);
1071
1072         /*
1073          * Free the waiting callers before proceeding any further.
1074          * The syncer might be jogging around in this file system
1075          * currently.  If we allow it to go to the userspace of no
1076          * return while trying to get the syncer lock, well ...
1077          */
1078         puffs_userdead(pmp);
1079
1080         /*
1081          * Make sure someone from puffs_unmount() isn't currently in
1082          * userspace.  If we don't take this precautionary step,
1083          * they might notice that the mountpoint has disappeared
1084          * from under them once they return.  Especially note that we
1085          * cannot simply test for an unmounter before calling
1086          * dounmount(), since it might be possible that that particular
1087          * invocation of unmount was called without MNT_FORCE.  Here we
1088          * *must* make sure unmount succeeds.  Also, restart is necessary
1089          * since pmp isn't locked.  We might end up with PUTTER_DEAD after
1090          * restart and exit from there.
1091          */
1092         if (pmp->pmp_unmounting) {
1093                 cv_wait(&pmp->pmp_unmounting_cv, &pmp->pmp_lock);
1094                 puffs_mp_release(pmp);
1095                 lockmgr(&pmp->pmp_lock, LK_RELEASE);
1096                 DPRINTF(("puffs_fop_close: unmount was in progress for pmp %p, "
1097                     "restart\n", pmp));
1098                 return ERESTART;
1099         }
1100
1101         /* Won't access pmp from here anymore */
1102         puffs_mp_release(pmp);
1103         lockmgr(&pmp->pmp_lock, LK_RELEASE);
1104
1105         /* Detach from VFS. */
1106         (void)dounmount(mp, MNT_FORCE);
1107
1108         return 0;
1109 }
1110
1111 /*
1112  * We're dead, kaput, RIP, slightly more than merely pining for the
1113  * fjords, belly-up, fallen, lifeless, finished, expired, gone to meet
1114  * our maker, ceased to be, etcetc.  YASD.  It's a dead FS!
1115  *
1116  * Caller must hold puffs mutex.
1117  */
1118 void
1119 puffs_userdead(struct puffs_mount *pmp)
1120 {
1121         struct puffs_msgpark *park, *park_next;
1122
1123         /*
1124          * Mark filesystem status as dying so that operations don't
1125          * attempt to march to userspace any longer.
1126          */
1127         pmp->pmp_status = PUFFSTAT_DYING;
1128
1129         /* signal waiters on REQUEST TO file server queue */
1130         for (park = TAILQ_FIRST(&pmp->pmp_msg_touser); park; park = park_next) {
1131                 uint8_t opclass;
1132
1133                 lockmgr(&park->park_mtx, LK_EXCLUSIVE);
1134                 puffs_msgpark_reference(park);
1135                 park_next = TAILQ_NEXT(park, park_entries);
1136
1137                 KKASSERT(park->park_flags & PARKFLAG_ONQUEUE1);
1138                 TAILQ_REMOVE(&pmp->pmp_msg_touser, park, park_entries);
1139                 park->park_flags &= ~PARKFLAG_ONQUEUE1;
1140                 pmp->pmp_msg_touser_count--;
1141
1142                 /*
1143                  * Even though waiters on QUEUE1 are removed in touser()
1144                  * in case of WAITERGONE, it is still possible for us to
1145                  * get raced here due to having to retake locks in said
1146                  * touser().  In the race case simply "ignore" the item
1147                  * on the queue and move on to the next one.
1148                  */
1149                 if (park->park_flags & PARKFLAG_WAITERGONE) {
1150                         KKASSERT((park->park_flags & PARKFLAG_CALL) == 0);
1151                         KKASSERT(park->park_flags & PARKFLAG_WANTREPLY);
1152                         puffs_msgpark_release(park);
1153
1154                 } else {
1155                         opclass = park->park_preq->preq_opclass;
1156                         park->park_preq->preq_rv = ENXIO;
1157
1158                         if (park->park_flags & PARKFLAG_CALL) {
1159                                 park->park_done(pmp, park->park_preq,
1160                                     park->park_donearg);
1161                                 puffs_msgpark_release1(park, 2);
1162                         } else if ((park->park_flags & PARKFLAG_WANTREPLY)==0) {
1163                                 puffs_msgpark_release1(park, 2);
1164                         } else {
1165                                 park->park_preq->preq_rv = ENXIO;
1166                                 cv_signal(&park->park_cv);
1167                                 puffs_msgpark_release(park);
1168                         }
1169                 }
1170         }
1171
1172         /* signal waiters on RESPONSE FROM file server queue */
1173         for (park=TAILQ_FIRST(&pmp->pmp_msg_replywait); park; park=park_next) {
1174                 lockmgr(&park->park_mtx, LK_EXCLUSIVE);
1175                 puffs_msgpark_reference(park);
1176                 park_next = TAILQ_NEXT(park, park_entries);
1177
1178                 KKASSERT(park->park_flags & PARKFLAG_ONQUEUE2);
1179                 KKASSERT(park->park_flags & PARKFLAG_WANTREPLY);
1180
1181                 TAILQ_REMOVE(&pmp->pmp_msg_replywait, park, park_entries);
1182                 park->park_flags &= ~PARKFLAG_ONQUEUE2;
1183
1184                 if (park->park_flags & PARKFLAG_WAITERGONE) {
1185                         KKASSERT((park->park_flags & PARKFLAG_CALL) == 0);
1186                         puffs_msgpark_release(park);
1187                 } else {
1188                         park->park_preq->preq_rv = ENXIO;
1189                         if (park->park_flags & PARKFLAG_CALL) {
1190                                 park->park_done(pmp, park->park_preq,
1191                                     park->park_donearg);
1192                                 puffs_msgpark_release1(park, 2);
1193                         } else {
1194                                 cv_signal(&park->park_cv);
1195                                 puffs_msgpark_release(park);
1196                         }
1197                 }
1198         }
1199
1200         cv_broadcast(&pmp->pmp_msg_waiter_cv);
1201 }