lib/libpuffs/callcontext.c

   1 /*      $NetBSD: callcontext.c,v 1.22 2008/08/11 15:59:01 pooka Exp $   */
   2
   3 /*
   4  * Copyright (c) 2006, 2007, 2008 Antti Kantee.  All Rights Reserved.
   5  *
   6  * Development of this software was supported by the
   7  * Research Foundation of Helsinki University of Technology
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in the
  16  *    documentation and/or other materials provided with the distribution.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
  19  * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  20  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  21  * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  22  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  23  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  24  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  25  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  26  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  27  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  28  * SUCH DAMAGE.
  29  */
  30
  31 #include <sys/cdefs.h>
  32 #if !defined(lint)
  33 __RCSID("$NetBSD: callcontext.c,v 1.22 2008/08/11 15:59:01 pooka Exp $");
  34 #endif /* !lint */
  35
  36 #include <sys/types.h>
  37 #include <sys/mman.h>
  38
  39 #include <assert.h>
  40 #include <errno.h>
  41 #include <puffs.h>
  42 #include <stdio.h>
  43 #include <stdlib.h>
  44 #include <string.h>
  45 #include <ucontext.h>
  46 #include <unistd.h>
  47
  48 #include "puffs_priv.h"
  49
  50 #if 0
  51 #define DPRINTF(x) printf x
  52 #else
  53 #define DPRINTF(x)
  54 #endif
  55
  56 /*
  57  * Set the following to 1 to not handle each request on a separate
  58  * stack.  This is highly volatile kludge, therefore no external
  59  * interface.
  60  */
  61 int puffs_fakecc;
  62
  63 /*
  64  * user stuff
  65  */
  66
  67 /*
  68  * So, we need to get back to where we came from.  This can happen in two
  69  * different ways:
  70  *  1) PCC_MLCONT is set, in which case we need to go to the mainloop
  71  *  2) It is not set, and we simply jump to pcc_uc_ret.
  72  */
  73 void
  74 puffs_cc_yield(struct puffs_cc *pcc)
  75 {
  76         struct puffs_cc *jumpcc;
  77         int rv;
  78
  79         assert(puffs_fakecc == 0);
  80
  81         pcc->pcc_flags &= ~PCC_BORROWED;
  82
  83         /* romanes eunt domus */
  84         DPRINTF(("puffs_cc_yield: "));
  85         if ((pcc->pcc_flags & PCC_MLCONT) == 0) {
  86                 DPRINTF(("no mlcont, pcc %p\n", pcc));
  87                 swapcontext(&pcc->pcc_uc, &pcc->pcc_uc_ret);
  88         } else {
  89                 DPRINTF(("mlcont, pcc %p\n", pcc));
  90                 pcc->pcc_flags &= ~PCC_MLCONT;
  91                 rv = puffs__cc_create(pcc->pcc_pu, puffs__theloop, &jumpcc);
  92                 if (rv)
  93                         abort(); /* p-p-p-pa-pa-panic (XXX: fixme) */
  94                 swapcontext(&pcc->pcc_uc, &jumpcc->pcc_uc);
  95                 DPRINTF(("puffs_cc_yield: post swap pcc %p\n", pcc));
  96         }
  97 }
  98
  99 /*
 100  * Internal continue routine.  This has slightly different semantics.
 101  * We simply make our cc available in the freelist and jump to the
 102  * indicated pcc.
 103  */
 104 void
 105 puffs__cc_cont(struct puffs_cc *pcc)
 106 {
 107         struct puffs_cc *mycc;
 108
 109         mycc = puffs_cc_getcc(pcc->pcc_pu);
 110         DPRINTF(("puffs__cc_cont: pcc %p, mycc %p\n", pcc, mycc));
 111
 112         /*
 113          * XXX: race between setcontenxt() and recycle if
 114          * we go multithreaded
 115          */
 116         puffs__cc_destroy(mycc, 1);
 117         pcc->pcc_flags |= PCC_MLCONT;
 118         setcontext(&pcc->pcc_uc);
 119 }
 120
 121 void
 122 puffs_cc_continue(struct puffs_cc *pcc)
 123 {
 124
 125         /* ramble on */
 126         DPRINTF(("puffs_cc_continue: pcc %p\n", pcc));
 127         if (puffs_fakecc) {
 128                 pcc->pcc_func(pcc->pcc_farg);
 129         } else {
 130                 swapcontext(&pcc->pcc_uc_ret, &pcc->pcc_uc);
 131         }
 132 }
 133
 134 /*
 135  * "Borrows" pcc, *NOT* called from pcc owner.  Acts like continue.
 136  * So the idea is to use this, give something the context back to
 137  * run to completion and then jump back to where ever this was called
 138  * from after the op dispatching is complete (or if the pcc decides to
 139  * yield again).
 140  */
 141 void
 142 puffs__goto(struct puffs_cc *loanpcc)
 143 {
 144
 145         loanpcc->pcc_flags |= PCC_BORROWED;
 146
 147         swapcontext(&loanpcc->pcc_uc_ret, &loanpcc->pcc_uc);
 148 }
 149
 150 void
 151 puffs_cc_schedule(struct puffs_cc *pcc)
 152 {
 153         struct puffs_usermount *pu = pcc->pcc_pu;
 154
 155         assert(pu->pu_state & PU_INLOOP);
 156         TAILQ_INSERT_TAIL(&pu->pu_sched, pcc, pcc_schedent);
 157 }
 158
 159 int
 160 puffs_cc_getcaller(struct puffs_cc *pcc, pid_t *pid, lwpid_t *lid)
 161 {
 162
 163         if ((pcc->pcc_flags & PCC_HASCALLER) == 0) {
 164                 errno = ESRCH;
 165                 return -1;
 166         }
 167
 168         if (pid)
 169                 *pid = pcc->pcc_pid;
 170         if (lid)
 171                 *lid = pcc->pcc_lid;
 172         return 0;
 173 }
 174
 175 static struct puffs_cc fakecc;
 176
 177 static struct puffs_cc *
 178 slowccalloc(struct puffs_usermount *pu)
 179 {
 180         struct puffs_cc *volatile pcc;
 181         void *sp;
 182         size_t stacksize = 1<<pu->pu_cc_stackshift;
 183         long psize = sysconf(_SC_PAGESIZE);
 184
 185         if (puffs_fakecc)
 186                 return &fakecc;
 187
 188         sp = mmap(NULL, stacksize, PROT_READ|PROT_WRITE,
 189             MAP_ANON|MAP_PRIVATE|MAP_ALIGNED(pu->pu_cc_stackshift), -1, 0);
 190         if (sp == MAP_FAILED)
 191                 return NULL;
 192
 193         pcc = sp;
 194         memset(pcc, 0, sizeof(struct puffs_cc));
 195
 196         mprotect((uint8_t *)sp + psize, (size_t)psize, PROT_NONE);
 197
 198         /* initialize both ucontext's */
 199         if (getcontext(&pcc->pcc_uc) == -1) {
 200                 munmap(pcc, stacksize);
 201                 return NULL;
 202         }
 203         if (getcontext(&pcc->pcc_uc_ret) == -1) {
 204                 munmap(pcc, stacksize);
 205                 return NULL;
 206         }
 207
 208         return pcc;
 209 }
 210
 211 int
 212 puffs__cc_create(struct puffs_usermount *pu, puffs_ccfunc func,
 213         struct puffs_cc **pccp)
 214 {
 215         struct puffs_cc *pcc;
 216         size_t stacksize = 1<<pu->pu_cc_stackshift;
 217         stack_t *st;
 218
 219         /* Do we have a cached copy? */
 220         if (pu->pu_cc_nstored == 0) {
 221                 pcc = slowccalloc(pu);
 222                 if (pcc == NULL)
 223                         return -1;
 224                 pcc->pcc_pu = pu;
 225                 DPRINTF(("puffs__cc_create: allocated pcc %p\n", pcc));
 226         } else {
 227                 pcc = LIST_FIRST(&pu->pu_ccmagazin);
 228                 assert(pcc != NULL);
 229
 230                 LIST_REMOVE(pcc, pcc_rope);
 231                 pu->pu_cc_nstored--;
 232                 DPRINTF(("puffs__cc_create: magazin pcc %p\n", pcc));
 233         }
 234         assert(pcc->pcc_pu == pu);
 235
 236         if (puffs_fakecc) {
 237                 pcc->pcc_func = func;
 238                 pcc->pcc_farg = pcc;
 239         } else {
 240                 /* link context */
 241                 pcc->pcc_uc.uc_link = &pcc->pcc_uc_ret;
 242
 243                 /* setup stack
 244                  *
 245                  * XXX: I guess this should theoretically be preserved by
 246                  * swapcontext().  However, it gets lost.  So reinit it.
 247                  */
 248                 st = &pcc->pcc_uc.uc_stack;
 249                 st->ss_sp = pcc;
 250                 st->ss_size = stacksize;
 251                 st->ss_flags = 0;
 252
 253                 /*
 254                  * Give us an initial context to jump to.
 255                  *
 256                  * Our manual page says that portable code shouldn't
 257                  * rely on being able to pass pointers through makecontext().
 258                  * kjk says that NetBSD code doesn't need to worry about this.
 259                  * uwe says it would be like putting a "keep away from
 260                  * children" sign on a box of toys.
 261                  */
 262                 makecontext(&pcc->pcc_uc, (void *)func, 1, (uintptr_t)pcc);
 263         }
 264
 265         *pccp = pcc;
 266         return 0;
 267 }
 268
 269 void
 270 puffs__cc_setcaller(struct puffs_cc *pcc, pid_t pid, lwpid_t lid)
 271 {
 272
 273         pcc->pcc_pid = pid;
 274         pcc->pcc_lid = lid;
 275         pcc->pcc_flags |= PCC_HASCALLER;
 276 }
 277
 278 static void
 279 cc_free(struct puffs_cc *pcc)
 280 {
 281         struct puffs_usermount *pu = pcc->pcc_pu;
 282         size_t stacksize = 1<<pu->pu_cc_stackshift;
 283
 284         DPRINTF(("invalidating pcc %p\n", pcc));
 285         assert(!puffs_fakecc);
 286         munmap(pcc, stacksize);
 287 }
 288
 289 void
 290 puffs__cc_destroy(struct puffs_cc *pcc, int nonuke)
 291 {
 292         struct puffs_usermount *pu = pcc->pcc_pu;
 293
 294         assert(pcc->pcc_flags == 0);
 295         assert(!puffs_fakecc);
 296
 297         /* not over limit?  stuff away in the store, otherwise nuke */
 298         if (nonuke || pu->pu_cc_nstored < PUFFS_CCMAXSTORE) {
 299                 pcc->pcc_pb = NULL;
 300                 DPRINTF(("puffs__cc_destroy: storing pcc %p\n", pcc));
 301                 LIST_INSERT_HEAD(&pu->pu_ccmagazin, pcc, pcc_rope);
 302                 pu->pu_cc_nstored++;
 303         } else {
 304                 cc_free(pcc);
 305         }
 306 }
 307
 308 void
 309 puffs__cc_exit(struct puffs_usermount *pu)
 310 {
 311         struct puffs_cc *pcc;
 312
 313         while ((pcc = LIST_FIRST(&pu->pu_ccmagazin)) != NULL) {
 314                 LIST_REMOVE(pcc, pcc_rope);
 315                 cc_free(pcc);
 316         }
 317 }
 318
 319 struct puffs_cc *
 320 puffs_cc_getcc(struct puffs_usermount *pu)
 321 {
 322         size_t stacksize = 1<<pu->pu_cc_stackshift;
 323         uintptr_t bottom;
 324
 325         if (puffs_fakecc)
 326                 return &fakecc;
 327
 328         bottom = ((uintptr_t)&bottom) & ~(stacksize-1);
 329         return (struct puffs_cc *)bottom;
 330 }
 331
 332 int
 333 puffs__cc_savemain(struct puffs_usermount *pu)
 334 {
 335
 336         if (puffs_fakecc)
 337                 return 0;
 338
 339         PU_CLRSFLAG(pu, PU_MAINRESTORE);
 340         return getcontext(&pu->pu_mainctx);
 341 }
 342
 343 int
 344 puffs__cc_restoremain(struct puffs_usermount *pu)
 345 {
 346
 347         if (puffs_fakecc)
 348                 return 0;
 349
 350         puffs__cc_destroy(puffs_cc_getcc(pu), 1);
 351         PU_SETSFLAG(pu, PU_MAINRESTORE);
 352         return setcontext(&pu->pu_mainctx);
 353 }