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