Home | History | Annotate | Line # | Download | only in libpuffs
puffs.c revision 1.92.4.1 
      1 /*	$NetBSD: puffs.c,v 1.92.4.1 2009/10/16 12:07:23 sborrill 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.92.4.1 2009/10/16 12:07:23 sborrill 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 void
    272 puffs_setspecific(struct puffs_usermount *pu, void *privdata)
    273 {
    274 
    275 	pu->pu_privdata = privdata;
    276 }
    277 
    278 size_t
    279 puffs_getmaxreqlen(struct puffs_usermount *pu)
    280 {
    281 
    282 	return pu->pu_maxreqlen;
    283 }
    284 
    285 void
    286 puffs_setmaxreqlen(struct puffs_usermount *pu, size_t reqlen)
    287 {
    288 
    289 	if (puffs_getstate(pu) != PUFFS_STATE_BEFOREMOUNT)
    290 		warnx("puffs_setmaxreqlen: call has effect only "
    291 		    "before mount\n");
    292 
    293 	pu->pu_kargp->pa_maxmsglen = reqlen;
    294 }
    295 
    296 void
    297 puffs_setfhsize(struct puffs_usermount *pu, size_t fhsize, int flags)
    298 {
    299 
    300 	if (puffs_getstate(pu) != PUFFS_STATE_BEFOREMOUNT)
    301 		warnx("puffs_setfhsize: call has effect only before mount\n");
    302 
    303 	pu->pu_kargp->pa_fhsize = fhsize;
    304 	pu->pu_kargp->pa_fhflags = flags;
    305 }
    306 
    307 void
    308 puffs_setncookiehash(struct puffs_usermount *pu, int nhash)
    309 {
    310 
    311 	if (puffs_getstate(pu) != PUFFS_STATE_BEFOREMOUNT)
    312 		warnx("puffs_setfhsize: call has effect only before mount\n");
    313 
    314 	pu->pu_kargp->pa_nhashbuckets = nhash;
    315 }
    316 
    317 void
    318 puffs_set_pathbuild(struct puffs_usermount *pu, pu_pathbuild_fn fn)
    319 {
    320 
    321 	pu->pu_pathbuild = fn;
    322 }
    323 
    324 void
    325 puffs_set_pathtransform(struct puffs_usermount *pu, pu_pathtransform_fn fn)
    326 {
    327 
    328 	pu->pu_pathtransform = fn;
    329 }
    330 
    331 void
    332 puffs_set_pathcmp(struct puffs_usermount *pu, pu_pathcmp_fn fn)
    333 {
    334 
    335 	pu->pu_pathcmp = fn;
    336 }
    337 
    338 void
    339 puffs_set_pathfree(struct puffs_usermount *pu, pu_pathfree_fn fn)
    340 {
    341 
    342 	pu->pu_pathfree = fn;
    343 }
    344 
    345 void
    346 puffs_set_namemod(struct puffs_usermount *pu, pu_namemod_fn fn)
    347 {
    348 
    349 	pu->pu_namemod = fn;
    350 }
    351 
    352 void
    353 puffs_set_errnotify(struct puffs_usermount *pu, pu_errnotify_fn fn)
    354 {
    355 
    356 	pu->pu_errnotify = fn;
    357 }
    358 
    359 void
    360 puffs_set_cmap(struct puffs_usermount *pu, pu_cmap_fn fn)
    361 {
    362 
    363 	pu->pu_cmap = fn;
    364 }
    365 
    366 void
    367 puffs_ml_setloopfn(struct puffs_usermount *pu, puffs_ml_loop_fn lfn)
    368 {
    369 
    370 	pu->pu_ml_lfn = lfn;
    371 }
    372 
    373 void
    374 puffs_ml_settimeout(struct puffs_usermount *pu, struct timespec *ts)
    375 {
    376 
    377 	if (ts == NULL) {
    378 		pu->pu_ml_timep = NULL;
    379 	} else {
    380 		pu->pu_ml_timeout = *ts;
    381 		pu->pu_ml_timep = &pu->pu_ml_timeout;
    382 	}
    383 }
    384 
    385 void
    386 puffs_set_prepost(struct puffs_usermount *pu,
    387 	pu_prepost_fn pre, pu_prepost_fn pst)
    388 {
    389 
    390 	pu->pu_oppre = pre;
    391 	pu->pu_oppost = pst;
    392 }
    393 
    394 void
    395 puffs_setback(struct puffs_cc *pcc, int whatback)
    396 {
    397 	struct puffs_req *preq = puffs__framebuf_getdataptr(pcc->pcc_pb);
    398 
    399 	assert(PUFFSOP_OPCLASS(preq->preq_opclass) == PUFFSOP_VN && (
    400 	    preq->preq_optype == PUFFS_VN_OPEN ||
    401 	    preq->preq_optype == PUFFS_VN_MMAP ||
    402 	    preq->preq_optype == PUFFS_VN_REMOVE ||
    403 	    preq->preq_optype == PUFFS_VN_RMDIR ||
    404 	    preq->preq_optype == PUFFS_VN_INACTIVE));
    405 
    406 	preq->preq_setbacks |= whatback & PUFFS_SETBACK_MASK;
    407 }
    408 
    409 int
    410 puffs_daemon(struct puffs_usermount *pu, int nochdir, int noclose)
    411 {
    412 	ssize_t n;
    413 	int parent, value, fd;
    414 
    415 	if (pipe(pu->pu_dpipe) == -1)
    416 		return -1;
    417 
    418 	switch (fork()) {
    419 	case -1:
    420 		return -1;
    421 	case 0:
    422 		parent = 0;
    423 		break;
    424 	default:
    425 		parent = 1;
    426 		break;
    427 	}
    428 	pu->pu_state |= PU_PUFFSDAEMON;
    429 
    430 	if (parent) {
    431 		n = read(pu->pu_dpipe[0], &value, sizeof(int));
    432 		if (n == -1)
    433 			err(1, "puffs_daemon");
    434 		assert(n == sizeof(value));
    435 		if (value) {
    436 			errno = value;
    437 			err(1, "puffs_daemon");
    438 		}
    439 		exit(0);
    440 	} else {
    441 		if (setsid() == -1)
    442 			goto fail;
    443 
    444 		if (!nochdir)
    445 			chdir("/");
    446 
    447 		if (!noclose) {
    448 			fd = open(_PATH_DEVNULL, O_RDWR, 0);
    449 			if (fd == -1)
    450 				goto fail;
    451 			dup2(fd, STDIN_FILENO);
    452 			dup2(fd, STDOUT_FILENO);
    453 			dup2(fd, STDERR_FILENO);
    454 			if (fd > STDERR_FILENO)
    455 				close(fd);
    456 		}
    457 		return 0;
    458 	}
    459 
    460  fail:
    461 	n = write(pu->pu_dpipe[1], &errno, sizeof(int));
    462 	assert(n == 4);
    463 	return -1;
    464 }
    465 
    466 int
    467 puffs_mount(struct puffs_usermount *pu, const char *dir, int mntflags,
    468 	puffs_cookie_t cookie)
    469 {
    470 	char rp[MAXPATHLEN];
    471 	ssize_t n;
    472 	int rv, fd, sverrno;
    473 	char *comfd;
    474 
    475 	pu->pu_kargp->pa_root_cookie = cookie;
    476 
    477 	/* XXXkludgehere */
    478 	/* kauth doesn't provide this service any longer */
    479 	if (geteuid() != 0)
    480 		mntflags |= MNT_NOSUID | MNT_NODEV;
    481 
    482 	if (realpath(dir, rp) == NULL) {
    483 		rv = -1;
    484 		goto out;
    485 	}
    486 
    487 	if (strcmp(dir, rp) != 0) {
    488 		warnx("puffs_mount: \"%s\" is a relative path.", dir);
    489 		warnx("puffs_mount: using \"%s\" instead.", rp);
    490 	}
    491 
    492 	/*
    493 	 * Undocumented...  Well, documented only here.
    494 	 *
    495 	 * This is used for imaginative purposes.  If the env variable is
    496 	 * set, puffs_mount() doesn't do the regular mount procedure.
    497 	 * Rather, it crams the mount data down the comfd and sets comfd as
    498 	 * the puffs descriptor.
    499 	 *
    500 	 * This shouldn't be used unless you can read my mind ( ... or write
    501 	 * it, not to mention execute it, but that's starting to get silly).
    502 	 */
    503 	if ((comfd = getenv("PUFFS_COMFD")) != NULL) {
    504 		size_t len;
    505 
    506 		if (sscanf(comfd, "%d", &pu->pu_fd) != 1) {
    507 			errno = EINVAL;
    508 			rv = -1;
    509 			goto out;
    510 		}
    511 		/* check that what we got at least resembles an fd */
    512 		if (fcntl(pu->pu_fd, F_GETFL) == -1) {
    513 			rv = -1;
    514 			goto out;
    515 		}
    516 
    517 		len = strlen(dir)+1;
    518 
    519 #define allwrite(buf, len)						\
    520 do {									\
    521 	ssize_t al_rv;							\
    522 	al_rv = write(pu->pu_fd, buf, len);				\
    523 	if (al_rv != len) {						\
    524 		if (al_rv != -1)					\
    525 			errno = EIO;					\
    526 		rv = -1;						\
    527 		abort();\
    528 		goto out;						\
    529 	}								\
    530 } while (/*CONSTCOND*/0)
    531 		allwrite(&len, sizeof(len));
    532 		allwrite(dir, len);
    533 		len = strlen(pu->pu_kargp->pa_mntfromname)+1;
    534 		allwrite(&len, sizeof(len));
    535 		allwrite(pu->pu_kargp->pa_mntfromname, len);
    536 		allwrite(&mntflags, sizeof(mntflags));
    537 		allwrite(pu->pu_kargp, sizeof(*pu->pu_kargp));
    538 		allwrite(&pu->pu_flags, sizeof(pu->pu_flags));
    539 #undef allwrite
    540 
    541 		rv = 0;
    542 	} else {
    543 		fd = open(_PATH_PUFFS, O_RDWR);
    544 		if (fd == -1) {
    545 			warnx("puffs_mount: cannot open %s", _PATH_PUFFS);
    546 			rv = -1;
    547 			goto out;
    548 		}
    549 		if (fd <= 2)
    550 			warnx("puffs_mount: device fd %d (<= 2), sure this is "
    551 			    "what you want?", fd);
    552 
    553 		pu->pu_kargp->pa_fd = pu->pu_fd = fd;
    554 		if ((rv = mount(MOUNT_PUFFS, rp, mntflags,
    555 		    pu->pu_kargp, sizeof(struct puffs_kargs))) == -1)
    556 			goto out;
    557 	}
    558 
    559 	PU_SETSTATE(pu, PUFFS_STATE_RUNNING);
    560 
    561  out:
    562 	if (rv != 0)
    563 		sverrno = errno;
    564 	else
    565 		sverrno = 0;
    566 	free(pu->pu_kargp);
    567 	pu->pu_kargp = NULL;
    568 
    569 	if (pu->pu_state & PU_PUFFSDAEMON) {
    570 		n = write(pu->pu_dpipe[1], &sverrno, sizeof(int));
    571 		assert(n == 4);
    572 		close(pu->pu_dpipe[0]);
    573 		close(pu->pu_dpipe[1]);
    574 	}
    575 
    576 	errno = sverrno;
    577 	return rv;
    578 }
    579 
    580 struct puffs_usermount *
    581 _puffs_init(int develv, struct puffs_ops *pops, const char *mntfromname,
    582 	const char *puffsname, void *priv, uint32_t pflags)
    583 {
    584 	struct puffs_usermount *pu;
    585 	struct puffs_kargs *pargs;
    586 	int sverrno;
    587 
    588 	if (develv != PUFFS_DEVEL_LIBVERSION) {
    589 		warnx("puffs_init: mounting with lib version %d, need %d",
    590 		    develv, PUFFS_DEVEL_LIBVERSION);
    591 		errno = EINVAL;
    592 		return NULL;
    593 	}
    594 
    595 	pu = malloc(sizeof(struct puffs_usermount));
    596 	if (pu == NULL)
    597 		goto failfree;
    598 	memset(pu, 0, sizeof(struct puffs_usermount));
    599 
    600 	pargs = pu->pu_kargp = malloc(sizeof(struct puffs_kargs));
    601 	if (pargs == NULL)
    602 		goto failfree;
    603 	memset(pargs, 0, sizeof(struct puffs_kargs));
    604 
    605 	pargs->pa_vers = PUFFSDEVELVERS | PUFFSVERSION;
    606 	pargs->pa_flags = PUFFS_FLAG_KERN(pflags);
    607 	fillvnopmask(pops, pargs->pa_vnopmask);
    608 	(void)strlcpy(pargs->pa_typename, puffsname,
    609 	    sizeof(pargs->pa_typename));
    610 	(void)strlcpy(pargs->pa_mntfromname, mntfromname,
    611 	    sizeof(pargs->pa_mntfromname));
    612 
    613 	puffs_zerostatvfs(&pargs->pa_svfsb);
    614 	pargs->pa_root_cookie = NULL;
    615 	pargs->pa_root_vtype = VDIR;
    616 	pargs->pa_root_vsize = 0;
    617 	pargs->pa_root_rdev = 0;
    618 	pargs->pa_maxmsglen = 0;
    619 
    620 	pu->pu_flags = pflags;
    621 	pu->pu_ops = *pops;
    622 	free(pops); /* XXX */
    623 
    624 	pu->pu_privdata = priv;
    625 	pu->pu_cc_stackshift = PUFFS_CC_STACKSHIFT_DEFAULT;
    626 	LIST_INIT(&pu->pu_pnodelst);
    627 	LIST_INIT(&pu->pu_ios);
    628 	LIST_INIT(&pu->pu_ios_rmlist);
    629 	LIST_INIT(&pu->pu_ccmagazin);
    630 	TAILQ_INIT(&pu->pu_sched);
    631 
    632 	pu->pu_framectrl[PU_FRAMECTRL_FS].rfb = puffs__fsframe_read;
    633 	pu->pu_framectrl[PU_FRAMECTRL_FS].wfb = puffs__fsframe_write;
    634 	pu->pu_framectrl[PU_FRAMECTRL_FS].cmpfb = puffs__fsframe_cmp;
    635 	pu->pu_framectrl[PU_FRAMECTRL_FS].gotfb = puffs__fsframe_gotframe;
    636 	pu->pu_framectrl[PU_FRAMECTRL_FS].fdnotfn = puffs_framev_unmountonclose;
    637 
    638 	/* defaults for some user-settable translation functions */
    639 	pu->pu_cmap = NULL; /* identity translation */
    640 
    641 	pu->pu_pathbuild = puffs_stdpath_buildpath;
    642 	pu->pu_pathfree = puffs_stdpath_freepath;
    643 	pu->pu_pathcmp = puffs_stdpath_cmppath;
    644 	pu->pu_pathtransform = NULL;
    645 	pu->pu_namemod = NULL;
    646 
    647 	pu->pu_errnotify = puffs_defaulterror;
    648 
    649 	PU_SETSTATE(pu, PUFFS_STATE_BEFOREMOUNT);
    650 
    651 	return pu;
    652 
    653  failfree:
    654 	/* can't unmount() from here for obvious reasons */
    655 	sverrno = errno;
    656 	free(pu);
    657 	errno = sverrno;
    658 	return NULL;
    659 }
    660 
    661 /*
    662  * XXX: there's currently no clean way to request unmount from
    663  * within the user server, so be very brutal about it.
    664  */
    665 /*ARGSUSED1*/
    666 int
    667 puffs_exit(struct puffs_usermount *pu, int force)
    668 {
    669 	struct puffs_node *pn;
    670 
    671 	force = 1; /* currently */
    672 
    673 	if (pu->pu_fd)
    674 		close(pu->pu_fd);
    675 
    676 	while ((pn = LIST_FIRST(&pu->pu_pnodelst)) != NULL)
    677 		puffs_pn_put(pn);
    678 
    679 	finalpush(pu);
    680 	puffs__framev_exit(pu);
    681 	puffs__cc_exit(pu);
    682 	if (pu->pu_state & PU_HASKQ)
    683 		close(pu->pu_kq);
    684 	free(pu);
    685 
    686 	return 0; /* always succesful for now, WILL CHANGE */
    687 }
    688 
    689 /*
    690  * Actual mainloop.  This is called from a context which can block.
    691  * It is called either from puffs_mainloop (indirectly, via
    692  * puffs_cc_continue() or from puffs_cc_yield()).
    693  */
    694 void
    695 puffs__theloop(struct puffs_cc *pcc)
    696 {
    697 	struct puffs_usermount *pu = pcc->pcc_pu;
    698 	struct puffs_framectrl *pfctrl;
    699 	struct puffs_fctrl_io *fio;
    700 	struct kevent *curev;
    701 	size_t nchanges;
    702 	int ndone;
    703 
    704 	while (puffs_getstate(pu) != PUFFS_STATE_UNMOUNTED) {
    705 		/*
    706 		 * Schedule existing requests.
    707 		 */
    708 		while ((pcc = TAILQ_FIRST(&pu->pu_sched)) != NULL) {
    709 			TAILQ_REMOVE(&pu->pu_sched, pcc, pcc_schedent);
    710 			puffs__goto(pcc);
    711 		}
    712 
    713 		if (pu->pu_ml_lfn)
    714 			pu->pu_ml_lfn(pu);
    715 
    716 		/* XXX: can we still do these optimizations? */
    717 #if 0
    718 		/*
    719 		 * Do this here, because:
    720 		 *  a) loopfunc might generate some results
    721 		 *  b) it's still "after" event handling (except for round 1)
    722 		 */
    723 		if (puffs_req_putput(ppr) == -1)
    724 			goto out;
    725 		puffs_req_resetput(ppr);
    726 
    727 		/* micro optimization: skip kevent syscall if possible */
    728 		if (pu->pu_nfds == 1 && pu->pu_ml_timep == NULL
    729 		    && (pu->pu_state & PU_ASYNCFD) == 0) {
    730 			pfctrl = XXX->fctrl;
    731 			puffs_framev_input(pu, pfctrl, XXX);
    732 			continue;
    733 		}
    734 #endif
    735 
    736 		/* else: do full processing */
    737 		/* Don't bother worrying about O(n) for now */
    738 		LIST_FOREACH(fio, &pu->pu_ios, fio_entries) {
    739 			if (fio->stat & FIO_WRGONE)
    740 				continue;
    741 
    742 			pfctrl = fio->fctrl;
    743 
    744 			/*
    745 			 * Try to write out everything to avoid the
    746 			 * need for enabling EVFILT_WRITE.  The likely
    747 			 * case is that we can fit everything into the
    748 			 * socket buffer.
    749 			 */
    750 			puffs__framev_output(pu, pfctrl, fio);
    751 		}
    752 
    753 		/*
    754 		 * Build list of which to enable/disable in writecheck.
    755 		 */
    756 		nchanges = 0;
    757 		LIST_FOREACH(fio, &pu->pu_ios, fio_entries) {
    758 			if (fio->stat & FIO_WRGONE)
    759 				continue;
    760 
    761 			/* en/disable write checks for kqueue as needed */
    762 			assert((FIO_EN_WRITE(fio) && FIO_RM_WRITE(fio)) == 0);
    763 			if (FIO_EN_WRITE(fio)) {
    764 				EV_SET(&pu->pu_evs[nchanges], fio->io_fd,
    765 				    EVFILT_WRITE, EV_ENABLE, 0, 0,
    766 				    (uintptr_t)fio);
    767 				fio->stat |= FIO_WR;
    768 				nchanges++;
    769 			}
    770 			if (FIO_RM_WRITE(fio)) {
    771 				EV_SET(&pu->pu_evs[nchanges], fio->io_fd,
    772 				    EVFILT_WRITE, EV_DISABLE, 0, 0,
    773 				    (uintptr_t)fio);
    774 				fio->stat &= ~FIO_WR;
    775 				nchanges++;
    776 			}
    777 			assert(nchanges <= pu->pu_nfds);
    778 		}
    779 
    780 		ndone = kevent(pu->pu_kq, pu->pu_evs, nchanges,
    781 		    pu->pu_evs, 2*pu->pu_nfds, pu->pu_ml_timep);
    782 
    783 		if (ndone == -1) {
    784 			if (errno != EINTR)
    785 				break;
    786 			else
    787 				continue;
    788 		}
    789 
    790 		/* uoptimize */
    791 		if (ndone == 0)
    792 			continue;
    793 
    794 		/* iterate over the results */
    795 		for (curev = pu->pu_evs; ndone--; curev++) {
    796 			int what;
    797 
    798 #if 0
    799 			/* get & possibly dispatch events from kernel */
    800 			if (curev->ident == puffsfd) {
    801 				if (puffs_req_handle(pgr, ppr, 0) == -1)
    802 					goto out;
    803 				continue;
    804 			}
    805 #endif
    806 
    807 			fio = (void *)curev->udata;
    808 			pfctrl = fio->fctrl;
    809 			if (curev->flags & EV_ERROR) {
    810 				assert(curev->filter == EVFILT_WRITE);
    811 				fio->stat &= ~FIO_WR;
    812 
    813 				/* XXX: how to know if it's a transient error */
    814 				puffs__framev_writeclose(pu, fio,
    815 				    (int)curev->data);
    816 				puffs__framev_notify(fio, PUFFS_FBIO_ERROR);
    817 				continue;
    818 			}
    819 
    820 			what = 0;
    821 			if (curev->filter == EVFILT_READ) {
    822 				puffs__framev_input(pu, pfctrl, fio);
    823 				what |= PUFFS_FBIO_READ;
    824 			}
    825 
    826 			else if (curev->filter == EVFILT_WRITE) {
    827 				puffs__framev_output(pu, pfctrl, fio);
    828 				what |= PUFFS_FBIO_WRITE;
    829 			}
    830 			if (what)
    831 				puffs__framev_notify(fio, what);
    832 		}
    833 
    834 		/*
    835 		 * Really free fd's now that we don't have references
    836 		 * to them.
    837 		 */
    838 		while ((fio = LIST_FIRST(&pu->pu_ios_rmlist)) != NULL) {
    839 			LIST_REMOVE(fio, fio_entries);
    840 			free(fio);
    841 		}
    842 	}
    843 
    844 	if (puffs__cc_restoremain(pu) == -1)
    845 		warn("cannot restore main context.  impending doom");
    846 }
    847 
    848 int
    849 puffs_mainloop(struct puffs_usermount *pu)
    850 {
    851 	struct puffs_fctrl_io *fio;
    852 	struct puffs_cc *pcc;
    853 	struct kevent *curev;
    854 	int sverrno;
    855 
    856 	assert(puffs_getstate(pu) >= PUFFS_STATE_RUNNING);
    857 
    858 	pu->pu_kq = kqueue();
    859 	if (pu->pu_kq == -1)
    860 		goto out;
    861 	pu->pu_state |= PU_HASKQ;
    862 
    863 	puffs_setblockingmode(pu, PUFFSDEV_NONBLOCK);
    864 	if (puffs__framev_addfd_ctrl(pu, puffs_getselectable(pu),
    865 	    PUFFS_FBIO_READ | PUFFS_FBIO_WRITE,
    866 	    &pu->pu_framectrl[PU_FRAMECTRL_FS]) == -1)
    867 		goto out;
    868 
    869 	curev = realloc(pu->pu_evs, (2*pu->pu_nfds)*sizeof(struct kevent));
    870 	if (curev == NULL)
    871 		goto out;
    872 	pu->pu_evs = curev;
    873 
    874 	LIST_FOREACH(fio, &pu->pu_ios, fio_entries) {
    875 		EV_SET(curev, fio->io_fd, EVFILT_READ, EV_ADD,
    876 		    0, 0, (uintptr_t)fio);
    877 		curev++;
    878 		EV_SET(curev, fio->io_fd, EVFILT_WRITE, EV_ADD | EV_DISABLE,
    879 		    0, 0, (uintptr_t)fio);
    880 		curev++;
    881 	}
    882 	if (kevent(pu->pu_kq, pu->pu_evs, 2*pu->pu_nfds, NULL, 0, NULL) == -1)
    883 		goto out;
    884 
    885 	pu->pu_state |= PU_INLOOP;
    886 
    887 	/*
    888 	 * Create alternate execution context and jump to it.  Note
    889 	 * that we come "out" of savemain twice.  Where we come out
    890 	 * of it depends on the architecture.  If the return address is
    891 	 * stored on the stack, we jump out from puffs_cc_continue(),
    892 	 * for a register return address from puffs__cc_savemain().
    893 	 * PU_MAINRESTORE makes sure we DTRT in both cases.
    894 	 */
    895 	if (puffs__cc_create(pu, puffs__theloop, &pcc) == -1) {
    896 		goto out;
    897 	}
    898 	if (puffs__cc_savemain(pu) == -1) {
    899 		goto out;
    900 	}
    901 	if ((pu->pu_state & PU_MAINRESTORE) == 0)
    902 		puffs_cc_continue(pcc);
    903 
    904 	finalpush(pu);
    905 	errno = 0;
    906 
    907  out:
    908 	/* store the real error for a while */
    909 	sverrno = errno;
    910 
    911 	errno = sverrno;
    912 	if (errno)
    913 		return -1;
    914 	else
    915 		return 0;
    916 }
    917