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