lib/libpuffs/puffs.c

   1 /*      $NetBSD: puffs.c,v 1.91 2008/08/11 16:23:37 pooka 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/cdefs.h>
  33 #if !defined(lint)
  34 __RCSID("$NetBSD: puffs.c,v 1.91 2008/08/11 16:23:37 pooka Exp $");
  35 #endif /* !lint */
  36
  37 #include <sys/param.h>
  38 #include <sys/mount.h>
  39
  40 #include <assert.h>
  41 #include <err.h>
  42 #include <errno.h>
  43 #include <fcntl.h>
  44 #include <mntopts.h>
  45 #include <paths.h>
  46 #include <puffs.h>
  47 #include <stdio.h>
  48 #include <stdlib.h>
  49 #include <string.h>
  50 #include <syslog.h>
  51 #include <unistd.h>
  52
  53 #include "puffs_priv.h"
  54
  55 /* Most file systems want this for opts, so just give it to them */
  56 const struct mntopt puffsmopts[] = {
  57         MOPT_STDOPTS,
  58         PUFFSMOPT_STD,
  59         MOPT_NULL,
  60 };
  61
  62 #ifdef PUFFS_WITH_THREADS
  63 #include <pthread.h>
  64 pthread_mutex_t pu_lock = PTHREAD_MUTEX_INITIALIZER;
  65 #endif
  66
  67 #define FILLOP(lower, upper)                                            \
  68 do {                                                                    \
  69         if (pops->puffs_node_##lower)                                   \
  70                 opmask[PUFFS_VN_##upper] = 1;                           \
  71 } while (/*CONSTCOND*/0)
  72 static void
  73 fillvnopmask(struct puffs_ops *pops, uint8_t *opmask)
  74 {
  75
  76         memset(opmask, 0, PUFFS_VN_MAX);
  77
  78         FILLOP(create,   CREATE);
  79         FILLOP(mknod,    MKNOD);
  80         FILLOP(open,     OPEN);
  81         FILLOP(close,    CLOSE);
  82         FILLOP(access,   ACCESS);
  83         FILLOP(getattr,  GETATTR);
  84         FILLOP(setattr,  SETATTR);
  85         FILLOP(poll,     POLL); /* XXX: not ready in kernel */
  86         FILLOP(mmap,     MMAP);
  87         FILLOP(fsync,    FSYNC);
  88         FILLOP(seek,     SEEK);
  89         FILLOP(remove,   REMOVE);
  90         FILLOP(link,     LINK);
  91         FILLOP(rename,   RENAME);
  92         FILLOP(mkdir,    MKDIR);
  93         FILLOP(rmdir,    RMDIR);
  94         FILLOP(symlink,  SYMLINK);
  95         FILLOP(readdir,  READDIR);
  96         FILLOP(readlink, READLINK);
  97         FILLOP(reclaim,  RECLAIM);
  98         FILLOP(inactive, INACTIVE);
  99         FILLOP(print,    PRINT);
 100         FILLOP(read,     READ);
 101         FILLOP(write,    WRITE);
 102 }
 103 #undef FILLOP
 104
 105 /*
 106  * Go over all framev entries and write everything we can.  This is
 107  * mostly for the benefit of delivering "unmount" to the kernel.
 108  */
 109 static void
 110 finalpush(struct puffs_usermount *pu)
 111 {
 112         struct puffs_fctrl_io *fio;
 113
 114         LIST_FOREACH(fio, &pu->pu_ios, fio_entries) {
 115                 if (fio->stat & FIO_WRGONE)
 116                         continue;
 117
 118                 puffs__framev_output(pu, fio->fctrl, fio);
 119         }
 120 }
 121
 122 /*ARGSUSED*/
 123 static void
 124 puffs_defaulterror(struct puffs_usermount *pu, uint8_t type,
 125         int error, const char *str, puffs_cookie_t cookie)
 126 {
 127
 128         fprintf(stderr, "abort: type %d, error %d, cookie %p (%s)\n",
 129             type, error, cookie, str);
 130         abort();
 131 }
 132
 133 int
 134 puffs_getselectable(struct puffs_usermount *pu)
 135 {
 136
 137         return pu->pu_fd;
 138 }
 139
 140 uint64_t
 141 puffs__nextreq(struct puffs_usermount *pu)
 142 {
 143         uint64_t rv;
 144
 145         PU_LOCK();
 146         rv = pu->pu_nextreq++;
 147         PU_UNLOCK();
 148
 149         return rv;
 150 }
 151
 152 int
 153 puffs_setblockingmode(struct puffs_usermount *pu, int mode)
 154 {
 155         int rv, x;
 156
 157         assert(puffs_getstate(pu) == PUFFS_STATE_RUNNING);
 158
 159         if (mode != PUFFSDEV_BLOCK && mode != PUFFSDEV_NONBLOCK) {
 160                 errno = EINVAL;
 161                 return -1;
 162         }
 163
 164         x = mode;
 165         rv = ioctl(pu->pu_fd, FIONBIO, &x);
 166
 167         if (rv == 0) {
 168                 if (mode == PUFFSDEV_BLOCK)
 169                         pu->pu_state &= ~PU_ASYNCFD;
 170                 else
 171                         pu->pu_state |= PU_ASYNCFD;
 172         }
 173
 174         return rv;
 175 }
 176
 177 int
 178 puffs_getstate(struct puffs_usermount *pu)
 179 {
 180
 181         return pu->pu_state & PU_STATEMASK;
 182 }
 183
 184 void
 185 puffs_setstacksize(struct puffs_usermount *pu, size_t ss)
 186 {
 187         long psize, minsize;
 188         int stackshift;
 189         int bonus;
 190
 191         assert(puffs_getstate(pu) == PUFFS_STATE_BEFOREMOUNT);
 192
 193         psize = sysconf(_SC_PAGESIZE);
 194         minsize = 4*psize;
 195         if (ss < minsize || ss == PUFFS_STACKSIZE_MIN) {
 196                 if (ss != PUFFS_STACKSIZE_MIN)
 197                         fprintf(stderr, "puffs_setstacksize: adjusting "
 198                             "stacksize to minimum %ld\n", minsize);
 199                 ss = 4*psize;
 200         }
 201
 202         stackshift = -1;
 203         bonus = 0;
 204         while (ss) {
 205                 if (ss & 0x1)
 206                         bonus++;
 207                 ss >>= 1;
 208                 stackshift++;
 209         }
 210         if (bonus > 1) {
 211                 stackshift++;
 212                 fprintf(stderr, "puffs_setstacksize: using next power of two: "
 213                     "%d\n", 1<<stackshift);
 214         }
 215
 216         pu->pu_cc_stackshift = stackshift;
 217 }
 218
 219 struct puffs_pathobj *
 220 puffs_getrootpathobj(struct puffs_usermount *pu)
 221 {
 222         struct puffs_node *pnr;
 223
 224         pnr = pu->pu_pn_root;
 225         if (pnr == NULL) {
 226                 errno = ENOENT;
 227                 return NULL;
 228         }
 229
 230         return &pnr->pn_po;
 231 }
 232
 233 void
 234 puffs_setroot(struct puffs_usermount *pu, struct puffs_node *pn)
 235 {
 236
 237         pu->pu_pn_root = pn;
 238 }
 239
 240 struct puffs_node *
 241 puffs_getroot(struct puffs_usermount *pu)
 242 {
 243
 244         return pu->pu_pn_root;
 245 }
 246
 247 void
 248 puffs_setrootinfo(struct puffs_usermount *pu, enum vtype vt,
 249         vsize_t vsize, dev_t rdev)
 250 {
 251         struct puffs_kargs *pargs = pu->pu_kargp;
 252
 253         if (puffs_getstate(pu) != PUFFS_STATE_BEFOREMOUNT) {
 254                 warnx("puffs_setrootinfo: call has effect only "
 255                     "before mount\n");
 256                 return;
 257         }
 258
 259         pargs->pa_root_vtype = vt;
 260         pargs->pa_root_vsize = vsize;
 261         pargs->pa_root_rdev = rdev;
 262 }
 263
 264 void *
 265 puffs_getspecific(struct puffs_usermount *pu)
 266 {
 267
 268         return pu->pu_privdata;
 269 }
 270
 271 size_t
 272 puffs_getmaxreqlen(struct puffs_usermount *pu)
 273 {
 274
 275         return pu->pu_maxreqlen;
 276 }
 277
 278 void
 279 puffs_setmaxreqlen(struct puffs_usermount *pu, size_t reqlen)
 280 {
 281
 282         if (puffs_getstate(pu) != PUFFS_STATE_BEFOREMOUNT)
 283                 warnx("puffs_setmaxreqlen: call has effect only "
 284                     "before mount\n");
 285
 286         pu->pu_kargp->pa_maxmsglen = reqlen;
 287 }
 288
 289 void
 290 puffs_setfhsize(struct puffs_usermount *pu, size_t fhsize, int flags)
 291 {
 292
 293         if (puffs_getstate(pu) != PUFFS_STATE_BEFOREMOUNT)
 294                 warnx("puffs_setfhsize: call has effect only before mount\n");
 295
 296         pu->pu_kargp->pa_fhsize = fhsize;
 297         pu->pu_kargp->pa_fhflags = flags;
 298 }
 299
 300 void
 301 puffs_setncookiehash(struct puffs_usermount *pu, int nhash)
 302 {
 303
 304         if (puffs_getstate(pu) != PUFFS_STATE_BEFOREMOUNT)
 305                 warnx("puffs_setfhsize: call has effect only before mount\n");
 306
 307         pu->pu_kargp->pa_nhashbuckets = nhash;
 308 }
 309
 310 void
 311 puffs_set_pathbuild(struct puffs_usermount *pu, pu_pathbuild_fn fn)
 312 {
 313
 314         pu->pu_pathbuild = fn;
 315 }
 316
 317 void
 318 puffs_set_pathtransform(struct puffs_usermount *pu, pu_pathtransform_fn fn)
 319 {
 320
 321         pu->pu_pathtransform = fn;
 322 }
 323
 324 void
 325 puffs_set_pathcmp(struct puffs_usermount *pu, pu_pathcmp_fn fn)
 326 {
 327
 328         pu->pu_pathcmp = fn;
 329 }
 330
 331 void
 332 puffs_set_pathfree(struct puffs_usermount *pu, pu_pathfree_fn fn)
 333 {
 334
 335         pu->pu_pathfree = fn;
 336 }
 337
 338 void
 339 puffs_set_namemod(struct puffs_usermount *pu, pu_namemod_fn fn)
 340 {
 341
 342         pu->pu_namemod = fn;
 343 }
 344
 345 void
 346 puffs_set_errnotify(struct puffs_usermount *pu, pu_errnotify_fn fn)
 347 {
 348
 349         pu->pu_errnotify = fn;
 350 }
 351
 352 void
 353 puffs_set_cmap(struct puffs_usermount *pu, pu_cmap_fn fn)
 354 {
 355
 356         pu->pu_cmap = fn;
 357 }
 358
 359 void
 360 puffs_ml_setloopfn(struct puffs_usermount *pu, puffs_ml_loop_fn lfn)
 361 {
 362
 363         pu->pu_ml_lfn = lfn;
 364 }
 365
 366 void
 367 puffs_ml_settimeout(struct puffs_usermount *pu, struct timespec *ts)
 368 {
 369
 370         if (ts == NULL) {
 371                 pu->pu_ml_timep = NULL;
 372         } else {
 373                 pu->pu_ml_timeout = *ts;
 374                 pu->pu_ml_timep = &pu->pu_ml_timeout;
 375         }
 376 }
 377
 378 void
 379 puffs_set_prepost(struct puffs_usermount *pu,
 380         pu_prepost_fn pre, pu_prepost_fn pst)
 381 {
 382
 383         pu->pu_oppre = pre;
 384         pu->pu_oppost = pst;
 385 }
 386
 387 void
 388 puffs_setback(struct puffs_cc *pcc, int whatback)
 389 {
 390         struct puffs_req *preq = puffs__framebuf_getdataptr(pcc->pcc_pb);
 391
 392         assert(PUFFSOP_OPCLASS(preq->preq_opclass) == PUFFSOP_VN && (
 393             preq->preq_optype == PUFFS_VN_OPEN ||
 394             preq->preq_optype == PUFFS_VN_MMAP ||
 395             preq->preq_optype == PUFFS_VN_REMOVE ||
 396             preq->preq_optype == PUFFS_VN_RMDIR ||
 397             preq->preq_optype == PUFFS_VN_INACTIVE));
 398
 399         preq->preq_setbacks |= whatback & PUFFS_SETBACK_MASK;
 400 }
 401
 402 int
 403 puffs_daemon(struct puffs_usermount *pu, int nochdir, int noclose)
 404 {
 405         ssize_t n;
 406         int parent, value, fd;
 407
 408         if (pipe(pu->pu_dpipe) == -1)
 409                 return -1;
 410
 411         switch (fork()) {
 412         case -1:
 413                 return -1;
 414         case 0:
 415                 parent = 0;
 416                 break;
 417         default:
 418                 parent = 1;
 419                 break;
 420         }
 421         pu->pu_state |= PU_PUFFSDAEMON;
 422
 423         if (parent) {
 424                 n = read(pu->pu_dpipe[0], &value, sizeof(int));
 425                 if (n == -1)
 426                         err(1, "puffs_daemon");
 427                 assert(n == sizeof(value));
 428                 if (value) {
 429                         errno = value;
 430                         err(1, "puffs_daemon");
 431                 }
 432                 exit(0);
 433         } else {
 434                 if (setsid() == -1)
 435                         goto fail;
 436
 437                 if (!nochdir)
 438                         chdir("/");
 439
 440                 if (!noclose) {
 441                         fd = open(_PATH_DEVNULL, O_RDWR, 0);
 442                         if (fd == -1)
 443                                 goto fail;
 444                         dup2(fd, STDIN_FILENO);
 445                         dup2(fd, STDOUT_FILENO);
 446                         dup2(fd, STDERR_FILENO);
 447                         if (fd > STDERR_FILENO)
 448                                 close(fd);
 449                 }
 450                 return 0;
 451         }
 452
 453  fail:
 454         n = write(pu->pu_dpipe[1], &errno, sizeof(int));
 455         assert(n == 4);
 456         return -1;
 457 }
 458
 459 int
 460 puffs_mount(struct puffs_usermount *pu, const char *dir, int mntflags,
 461         puffs_cookie_t cookie)
 462 {
 463         char rp[MAXPATHLEN];
 464         ssize_t n;
 465         int rv, fd, sverrno;
 466         char *comfd;
 467
 468         pu->pu_kargp->pa_root_cookie = cookie;
 469
 470         /* XXXkludgehere */
 471         /* kauth doesn't provide this service any longer */
 472         if (geteuid() != 0)
 473                 mntflags |= MNT_NOSUID | MNT_NODEV;
 474
 475         if (realpath(dir, rp) == NULL) {
 476                 rv = -1;
 477                 goto out;
 478         }
 479
 480         if (strcmp(dir, rp) != 0) {
 481                 warnx("puffs_mount: \"%s\" is a relative path.", dir);
 482                 warnx("puffs_mount: using \"%s\" instead.", rp);
 483         }
 484
 485         /*
 486          * Undocumented...  Well, documented only here.
 487          *
 488          * This is used for imaginative purposes.  If the env variable is
 489          * set, puffs_mount() doesn't do the regular mount procedure.
 490          * Rather, it crams the mount data down the comfd and sets comfd as
 491          * the puffs descriptor.
 492          *
 493          * This shouldn't be used unless you can read my mind ( ... or write
 494          * it, not to mention execute it, but that's starting to get silly).
 495          */
 496         if ((comfd = getenv("PUFFS_COMFD")) != NULL) {
 497                 size_t len;
 498
 499                 if (sscanf(comfd, "%d", &pu->pu_fd) != 1) {
 500                         errno = EINVAL;
 501                         rv = -1;
 502                         goto out;
 503                 }
 504                 /* check that what we got at least resembles an fd */
 505                 if (fcntl(pu->pu_fd, F_GETFL) == -1) {
 506                         rv = -1;
 507                         goto out;
 508                 }
 509
 510                 len = strlen(dir)+1;
 511
 512 #define allwrite(buf, len)                                              \
 513 do {                                                                    \
 514         ssize_t al_rv;                                                  \
 515         al_rv = write(pu->pu_fd, buf, len);                             \
 516         if (al_rv != len) {                                             \
 517                 if (al_rv != -1)                                        \
 518                         errno = EIO;                                    \
 519                 rv = -1;                                                \
 520                 abort();\
 521                 goto out;                                               \
 522         }                                                               \
 523 } while (/*CONSTCOND*/0)
 524                 allwrite(&len, sizeof(len));
 525                 allwrite(dir, len);
 526                 len = strlen(pu->pu_kargp->pa_mntfromname)+1;
 527                 allwrite(&len, sizeof(len));
 528                 allwrite(pu->pu_kargp->pa_mntfromname, len);
 529                 allwrite(&mntflags, sizeof(mntflags));
 530                 allwrite(pu->pu_kargp, sizeof(*pu->pu_kargp));
 531                 allwrite(&pu->pu_flags, sizeof(pu->pu_flags));
 532 #undef allwrite
 533
 534                 rv = 0;
 535         } else {
 536                 fd = open(_PATH_PUFFS, O_RDWR);
 537                 if (fd == -1) {
 538                         warnx("puffs_mount: cannot open %s", _PATH_PUFFS);
 539                         rv = -1;
 540                         goto out;
 541                 }
 542                 if (fd <= 2)
 543                         warnx("puffs_mount: device fd %d (<= 2), sure this is "
 544                             "what you want?", fd);
 545
 546                 pu->pu_kargp->pa_fd = pu->pu_fd = fd;
 547                 if ((rv = mount(MOUNT_PUFFS, rp, mntflags,
 548                     pu->pu_kargp, sizeof(struct puffs_kargs))) == -1)
 549                         goto out;
 550         }
 551
 552         PU_SETSTATE(pu, PUFFS_STATE_RUNNING);
 553
 554  out:
 555         if (rv != 0)
 556                 sverrno = errno;
 557         else
 558                 sverrno = 0;
 559         free(pu->pu_kargp);
 560         pu->pu_kargp = NULL;
 561
 562         if (pu->pu_state & PU_PUFFSDAEMON) {
 563                 n = write(pu->pu_dpipe[1], &sverrno, sizeof(int));
 564                 assert(n == 4);
 565                 close(pu->pu_dpipe[0]);
 566                 close(pu->pu_dpipe[1]);
 567         }
 568
 569         errno = sverrno;
 570         return rv;
 571 }
 572
 573 struct puffs_usermount *
 574 _puffs_init(int develv, struct puffs_ops *pops, const char *mntfromname,
 575         const char *puffsname, void *priv, uint32_t pflags)
 576 {
 577         struct puffs_usermount *pu;
 578         struct puffs_kargs *pargs;
 579         int sverrno;
 580
 581         if (develv != PUFFS_DEVEL_LIBVERSION) {
 582                 warnx("puffs_init: mounting with lib version %d, need %d",
 583                     develv, PUFFS_DEVEL_LIBVERSION);
 584                 errno = EINVAL;
 585                 return NULL;
 586         }
 587
 588         pu = malloc(sizeof(struct puffs_usermount));
 589         if (pu == NULL)
 590                 goto failfree;
 591         memset(pu, 0, sizeof(struct puffs_usermount));
 592
 593         pargs = pu->pu_kargp = malloc(sizeof(struct puffs_kargs));
 594         if (pargs == NULL)
 595                 goto failfree;
 596         memset(pargs, 0, sizeof(struct puffs_kargs));
 597
 598         pargs->pa_vers = PUFFSDEVELVERS | PUFFSVERSION;
 599         pargs->pa_flags = PUFFS_FLAG_KERN(pflags);
 600         fillvnopmask(pops, pargs->pa_vnopmask);
 601         (void)strlcpy(pargs->pa_typename, puffsname,
 602             sizeof(pargs->pa_typename));
 603         (void)strlcpy(pargs->pa_mntfromname, mntfromname,
 604             sizeof(pargs->pa_mntfromname));
 605
 606         puffs_zerostatvfs(&pargs->pa_svfsb);
 607         pargs->pa_root_cookie = NULL;
 608         pargs->pa_root_vtype = VDIR;
 609         pargs->pa_root_vsize = 0;
 610         pargs->pa_root_rdev = 0;
 611         pargs->pa_maxmsglen = 0;
 612
 613         pu->pu_flags = pflags;
 614         pu->pu_ops = *pops;
 615         free(pops); /* XXX */
 616
 617         pu->pu_privdata = priv;
 618         pu->pu_cc_stackshift = PUFFS_CC_STACKSHIFT_DEFAULT;
 619         LIST_INIT(&pu->pu_pnodelst);
 620         LIST_INIT(&pu->pu_ios);
 621         LIST_INIT(&pu->pu_ios_rmlist);
 622         LIST_INIT(&pu->pu_ccmagazin);
 623         TAILQ_INIT(&pu->pu_sched);
 624
 625         pu->pu_framectrl[PU_FRAMECTRL_FS].rfb = puffs__fsframe_read;
 626         pu->pu_framectrl[PU_FRAMECTRL_FS].wfb = puffs__fsframe_write;
 627         pu->pu_framectrl[PU_FRAMECTRL_FS].cmpfb = puffs__fsframe_cmp;
 628         pu->pu_framectrl[PU_FRAMECTRL_FS].gotfb = puffs__fsframe_gotframe;
 629         pu->pu_framectrl[PU_FRAMECTRL_FS].fdnotfn = puffs_framev_unmountonclose;
 630
 631         /* defaults for some user-settable translation functions */
 632         pu->pu_cmap = NULL; /* identity translation */
 633
 634         pu->pu_pathbuild = puffs_stdpath_buildpath;
 635         pu->pu_pathfree = puffs_stdpath_freepath;
 636         pu->pu_pathcmp = puffs_stdpath_cmppath;
 637         pu->pu_pathtransform = NULL;
 638         pu->pu_namemod = NULL;
 639
 640         pu->pu_errnotify = puffs_defaulterror;
 641
 642         PU_SETSTATE(pu, PUFFS_STATE_BEFOREMOUNT);
 643
 644         return pu;
 645
 646  failfree:
 647         /* can't unmount() from here for obvious reasons */
 648         sverrno = errno;
 649         free(pu);
 650         errno = sverrno;
 651         return NULL;
 652 }
 653
 654 /*
 655  * XXX: there's currently no clean way to request unmount from
 656  * within the user server, so be very brutal about it.
 657  */
 658 /*ARGSUSED1*/
 659 int
 660 puffs_exit(struct puffs_usermount *pu, int force)
 661 {
 662         struct puffs_node *pn;
 663
 664         force = 1; /* currently */
 665
 666         if (pu->pu_fd)
 667                 close(pu->pu_fd);
 668
 669         while ((pn = LIST_FIRST(&pu->pu_pnodelst)) != NULL)
 670                 puffs_pn_put(pn);
 671
 672         finalpush(pu);
 673         puffs__framev_exit(pu);
 674         puffs__cc_exit(pu);
 675         if (pu->pu_state & PU_HASKQ)
 676                 close(pu->pu_kq);
 677         free(pu);
 678
 679         return 0; /* always succesful for now, WILL CHANGE */
 680 }
 681
 682 /*
 683  * Actual mainloop.  This is called from a context which can block.
 684  * It is called either from puffs_mainloop (indirectly, via
 685  * puffs_cc_continue() or from puffs_cc_yield()).
 686  */
 687 void
 688 puffs__theloop(struct puffs_cc *pcc)
 689 {
 690         struct puffs_usermount *pu = pcc->pcc_pu;
 691         struct puffs_framectrl *pfctrl;
 692         struct puffs_fctrl_io *fio;
 693         struct kevent *curev;
 694         size_t nchanges;
 695         int ndone;
 696
 697         while (puffs_getstate(pu) != PUFFS_STATE_UNMOUNTED) {
 698                 /*
 699                  * Schedule existing requests.
 700                  */
 701                 while ((pcc = TAILQ_FIRST(&pu->pu_sched)) != NULL) {
 702                         TAILQ_REMOVE(&pu->pu_sched, pcc, pcc_schedent);
 703                         puffs__goto(pcc);
 704                 }
 705
 706                 if (pu->pu_ml_lfn)
 707                         pu->pu_ml_lfn(pu);
 708
 709                 /* XXX: can we still do these optimizations? */
 710 #if 0
 711                 /*
 712                  * Do this here, because:
 713                  *  a) loopfunc might generate some results
 714                  *  b) it's still "after" event handling (except for round 1)
 715                  */
 716                 if (puffs_req_putput(ppr) == -1)
 717                         goto out;
 718                 puffs_req_resetput(ppr);
 719
 720                 /* micro optimization: skip kevent syscall if possible */
 721                 if (pu->pu_nfds == 1 && pu->pu_ml_timep == NULL
 722                     && (pu->pu_state & PU_ASYNCFD) == 0) {
 723                         pfctrl = XXX->fctrl;
 724                         puffs_framev_input(pu, pfctrl, XXX);
 725                         continue;
 726                 }
 727 #endif
 728
 729                 /* else: do full processing */
 730                 /* Don't bother worrying about O(n) for now */
 731                 LIST_FOREACH(fio, &pu->pu_ios, fio_entries) {
 732                         if (fio->stat & FIO_WRGONE)
 733                                 continue;
 734
 735                         pfctrl = fio->fctrl;
 736
 737                         /*
 738                          * Try to write out everything to avoid the
 739                          * need for enabling EVFILT_WRITE.  The likely
 740                          * case is that we can fit everything into the
 741                          * socket buffer.
 742                          */
 743                         puffs__framev_output(pu, pfctrl, fio);
 744                 }
 745
 746                 /*
 747                  * Build list of which to enable/disable in writecheck.
 748                  */
 749                 nchanges = 0;
 750                 LIST_FOREACH(fio, &pu->pu_ios, fio_entries) {
 751                         if (fio->stat & FIO_WRGONE)
 752                                 continue;
 753
 754                         /* en/disable write checks for kqueue as needed */
 755                         assert((FIO_EN_WRITE(fio) && FIO_RM_WRITE(fio)) == 0);
 756                         if (FIO_EN_WRITE(fio)) {
 757                                 EV_SET(&pu->pu_evs[nchanges], fio->io_fd,
 758                                     EVFILT_WRITE, EV_ENABLE, 0, 0,
 759                                     (uintptr_t)fio);
 760                                 fio->stat |= FIO_WR;
 761                                 nchanges++;
 762                         }
 763                         if (FIO_RM_WRITE(fio)) {
 764                                 EV_SET(&pu->pu_evs[nchanges], fio->io_fd,
 765                                     EVFILT_WRITE, EV_DISABLE, 0, 0,
 766                                     (uintptr_t)fio);
 767                                 fio->stat &= ~FIO_WR;
 768                                 nchanges++;
 769                         }
 770                         assert(nchanges <= pu->pu_nfds);
 771                 }
 772
 773                 ndone = kevent(pu->pu_kq, pu->pu_evs, nchanges,
 774                     pu->pu_evs, 2*pu->pu_nfds, pu->pu_ml_timep);
 775
 776                 if (ndone == -1) {
 777                         if (errno != EINTR)
 778                                 break;
 779                         else
 780                                 continue;
 781                 }
 782
 783                 /* uoptimize */
 784                 if (ndone == 0)
 785                         continue;
 786
 787                 /* iterate over the results */
 788                 for (curev = pu->pu_evs; ndone--; curev++) {
 789                         int what;
 790
 791 #if 0
 792                         /* get & possibly dispatch events from kernel */
 793                         if (curev->ident == puffsfd) {
 794                                 if (puffs_req_handle(pgr, ppr, 0) == -1)
 795                                         goto out;
 796                                 continue;
 797                         }
 798 #endif
 799
 800                         fio = (void *)curev->udata;
 801                         pfctrl = fio->fctrl;
 802                         if (curev->flags & EV_ERROR) {
 803                                 assert(curev->filter == EVFILT_WRITE);
 804                                 fio->stat &= ~FIO_WR;
 805
 806                                 /* XXX: how to know if it's a transient error */
 807                                 puffs__framev_writeclose(pu, fio,
 808                                     (int)curev->data);
 809                                 puffs__framev_notify(fio, PUFFS_FBIO_ERROR);
 810                                 continue;
 811                         }
 812
 813                         what = 0;
 814                         if (curev->filter == EVFILT_READ) {
 815                                 puffs__framev_input(pu, pfctrl, fio);
 816                                 what |= PUFFS_FBIO_READ;
 817                         }
 818
 819                         else if (curev->filter == EVFILT_WRITE) {
 820                                 puffs__framev_output(pu, pfctrl, fio);
 821                                 what |= PUFFS_FBIO_WRITE;
 822                         }
 823                         if (what)
 824                                 puffs__framev_notify(fio, what);
 825                 }
 826
 827                 /*
 828                  * Really free fd's now that we don't have references
 829                  * to them.
 830                  */
 831                 while ((fio = LIST_FIRST(&pu->pu_ios_rmlist)) != NULL) {
 832                         LIST_REMOVE(fio, fio_entries);
 833                         free(fio);
 834                 }
 835         }
 836
 837         if (puffs__cc_restoremain(pu) == -1)
 838                 warn("cannot restore main context.  impending doom");
 839 }
 840
 841 int
 842 puffs_mainloop(struct puffs_usermount *pu)
 843 {
 844         struct puffs_fctrl_io *fio;
 845         struct puffs_cc *pcc;
 846         struct kevent *curev;
 847         int sverrno;
 848
 849         assert(puffs_getstate(pu) >= PUFFS_STATE_RUNNING);
 850
 851         pu->pu_kq = kqueue();
 852         if (pu->pu_kq == -1)
 853                 goto out;
 854         pu->pu_state |= PU_HASKQ;
 855
 856         puffs_setblockingmode(pu, PUFFSDEV_NONBLOCK);
 857         if (puffs__framev_addfd_ctrl(pu, puffs_getselectable(pu),
 858             PUFFS_FBIO_READ | PUFFS_FBIO_WRITE,
 859             &pu->pu_framectrl[PU_FRAMECTRL_FS]) == -1)
 860                 goto out;
 861
 862         curev = realloc(pu->pu_evs, (2*pu->pu_nfds)*sizeof(struct kevent));
 863         if (curev == NULL)
 864                 goto out;
 865         pu->pu_evs = curev;
 866
 867         LIST_FOREACH(fio, &pu->pu_ios, fio_entries) {
 868                 EV_SET(curev, fio->io_fd, EVFILT_READ, EV_ADD,
 869                     0, 0, (uintptr_t)fio);
 870                 curev++;
 871                 EV_SET(curev, fio->io_fd, EVFILT_WRITE, EV_ADD | EV_DISABLE,
 872                     0, 0, (uintptr_t)fio);
 873                 curev++;
 874         }
 875         if (kevent(pu->pu_kq, pu->pu_evs, 2*pu->pu_nfds, NULL, 0, NULL) == -1)
 876                 goto out;
 877
 878         pu->pu_state |= PU_INLOOP;
 879
 880         /*
 881          * Create alternate execution context and jump to it.  Note
 882          * that we come "out" of savemain twice.  Where we come out
 883          * of it depends on the architecture.  If the return address is
 884          * stored on the stack, we jump out from puffs_cc_continue(),
 885          * for a register return address from puffs__cc_savemain().
 886          * PU_MAINRESTORE makes sure we DTRT in both cases.
 887          */
 888         if (puffs__cc_create(pu, puffs__theloop, &pcc) == -1) {
 889                 goto out;
 890         }
 891         if (puffs__cc_savemain(pu) == -1) {
 892                 goto out;
 893         }
 894         if ((pu->pu_state & PU_MAINRESTORE) == 0)
 895                 puffs_cc_continue(pcc);
 896
 897         finalpush(pu);
 898         errno = 0;
 899
 900  out:
 901         /* store the real error for a while */
 902         sverrno = errno;
 903
 904         errno = sverrno;
 905         if (errno)
 906                 return -1;
 907         else
 908                 return 0;
 909 }