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