lib/libpuffs/callcontext.c

   1 /*      $NetBSD: callcontext.c,v 1.27 2011/12/06 21:15:39 skrll 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.27 2011/12/06 21:15:39 skrll 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         if ((~pcc->pcc_flags & (PCC_BORROWED|PCC_DONE)) == 0) {
  82                 pcc->pcc_flags &= ~(PCC_BORROWED|PCC_DONE);
  83                 /*
  84                  * see the XXX comment in puffs__cc_cont
  85                  */
  86                 puffs__cc_destroy(pcc, 1);
  87                 setcontext(&pcc->pcc_uc_ret);
  88         }
  89         pcc->pcc_flags &= ~PCC_BORROWED;
  90
  91         /* romanes eunt domus */
  92         DPRINTF(("puffs_cc_yield: "));
  93         if ((pcc->pcc_flags & PCC_MLCONT) == 0) {
  94                 DPRINTF(("no mlcont, pcc %p\n", pcc));
  95                 swapcontext(&pcc->pcc_uc, &pcc->pcc_uc_ret);
  96         } else {
  97                 DPRINTF(("mlcont, pcc %p\n", pcc));
  98                 pcc->pcc_flags &= ~PCC_MLCONT;
  99                 rv = puffs__cc_create(pcc->pcc_pu, puffs__theloop, &jumpcc);
 100                 if (rv)
 101                         abort(); /* p-p-p-pa-pa-panic (XXX: fixme) */
 102                 swapcontext(&pcc->pcc_uc, &jumpcc->pcc_uc);
 103                 DPRINTF(("puffs_cc_yield: post swap pcc %p\n", pcc));
 104         }
 105 }
 106
 107 /*
 108  * Internal continue routine.  This has slightly different semantics.
 109  * We simply make our cc available in the freelist and jump to the
 110  * indicated pcc.
 111  */
 112 void
 113 puffs__cc_cont(struct puffs_cc *pcc)
 114 {
 115         struct puffs_cc *mycc;
 116
 117         mycc = puffs_cc_getcc(pcc->pcc_pu);
 118         DPRINTF(("puffs__cc_cont: pcc %p, mycc %p\n", pcc, mycc));
 119
 120         /*
 121          * XXX: race between setcontext() and recycle if
 122          * we go multithreaded
 123          */
 124         puffs__cc_destroy(mycc, 1);
 125         pcc->pcc_flags |= PCC_MLCONT;
 126         setcontext(&pcc->pcc_uc);
 127 }
 128
 129 void
 130 puffs_cc_continue(struct puffs_cc *pcc)
 131 {
 132
 133         /* ramble on */
 134         DPRINTF(("puffs_cc_continue: pcc %p\n", pcc));
 135         if (puffs_fakecc) {
 136                 pcc->pcc_func(pcc->pcc_farg);
 137         } else {
 138                 swapcontext(&pcc->pcc_uc_ret, &pcc->pcc_uc);
 139         }
 140 }
 141
 142 /*
 143  * "Borrows" pcc, *NOT* called from pcc owner.  Acts like continue.
 144  * So the idea is to use this, give something the context back to
 145  * run to completion and then jump back to where ever this was called
 146  * from after the op dispatching is complete (or if the pcc decides to
 147  * yield again).
 148  */
 149 void
 150 puffs__goto(struct puffs_cc *loanpcc)
 151 {
 152
 153         loanpcc->pcc_flags |= PCC_BORROWED;
 154
 155         swapcontext(&loanpcc->pcc_uc_ret, &loanpcc->pcc_uc);
 156 }
 157
 158 void
 159 puffs_cc_schedule(struct puffs_cc *pcc)
 160 {
 161         struct puffs_usermount *pu = pcc->pcc_pu;
 162
 163         assert(pu->pu_state & PU_INLOOP);
 164         TAILQ_INSERT_TAIL(&pu->pu_sched, pcc, pcc_schedent);
 165 }
 166
 167 int
 168 puffs_cc_getcaller(struct puffs_cc *pcc, pid_t *pid, lwpid_t *lid)
 169 {
 170
 171         if ((pcc->pcc_flags & PCC_HASCALLER) == 0) {
 172                 errno = ESRCH;
 173                 return -1;
 174         }
 175
 176         if (pid)
 177                 *pid = pcc->pcc_pid;
 178         if (lid)
 179                 *lid = pcc->pcc_lid;
 180         return 0;
 181 }
 182
 183 static struct puffs_cc fakecc;
 184
 185 static struct puffs_cc *
 186 slowccalloc(struct puffs_usermount *pu)
 187 {
 188         struct puffs_cc *volatile pcc;
 189         void *sp;
 190         size_t stacksize = 1<<pu->pu_cc_stackshift;
 191
 192         if (puffs_fakecc)
 193                 return &fakecc;
 194
 195         sp = mmap(NULL, stacksize, PROT_READ|PROT_WRITE,
 196             MAP_ANON|MAP_PRIVATE, -1, 0);
 197         if (sp == MAP_FAILED)
 198                 return NULL;
 199
 200         pcc = sp;
 201         memset(pcc, 0, sizeof(struct puffs_cc));
 202
 203         /* initialize both ucontext's */
 204         if (getcontext(&pcc->pcc_uc) == -1) {
 205                 munmap(pcc, stacksize);
 206                 return NULL;
 207         }
 208         if (getcontext(&pcc->pcc_uc_ret) == -1) {
 209                 munmap(pcc, stacksize);
 210                 return NULL;
 211         }
 212
 213         return pcc;
 214 }
 215
 216 int
 217 puffs__cc_create(struct puffs_usermount *pu, puffs_ccfunc func,
 218         struct puffs_cc **pccp)
 219 {
 220         struct puffs_cc *pcc;
 221         size_t stacksize = 1<<pu->pu_cc_stackshift;
 222         stack_t *st;
 223
 224         /* Do we have a cached copy? */
 225         if (pu->pu_cc_nstored == 0) {
 226                 pcc = slowccalloc(pu);
 227                 if (pcc == NULL)
 228                         return -1;
 229                 pcc->pcc_pu = pu;
 230                 DPRINTF(("puffs__cc_create: allocated pcc %p\n", pcc));
 231         } else {
 232                 pcc = LIST_FIRST(&pu->pu_ccmagazin);
 233                 assert(pcc != NULL);
 234
 235                 LIST_REMOVE(pcc, pcc_rope);
 236                 pu->pu_cc_nstored--;
 237                 DPRINTF(("puffs__cc_create: magazin pcc %p\n", pcc));
 238         }
 239         assert(pcc->pcc_pu == pu);
 240
 241         if (puffs_fakecc) {
 242                 pcc->pcc_func = func;
 243                 pcc->pcc_farg = pcc;
 244         } else {
 245                 /* link context */
 246                 pcc->pcc_uc.uc_link = &pcc->pcc_uc_ret;
 247
 248                 /* setup stack
 249                  *
 250                  * XXX: I guess this should theoretically be preserved by
 251                  * swapcontext().  However, it gets lost.  So reinit it.
 252                  */
 253                 st = &pcc->pcc_uc.uc_stack;
 254                 st->ss_sp = pcc;
 255                 st->ss_size = stacksize;
 256                 st->ss_flags = 0;
 257
 258                 /*
 259                  * Give us an initial context to jump to.
 260                  *
 261                  * Our manual page says that portable code shouldn't
 262                  * rely on being able to pass pointers through makecontext().
 263                  * kjk says that NetBSD code doesn't need to worry about this.
 264                  * uwe says it would be like putting a "keep away from
 265                  * children" sign on a box of toys.
 266                  */
 267                 makecontext(&pcc->pcc_uc, (void *)func, 1, (uintptr_t)pcc);
 268         }
 269
 270         *pccp = pcc;
 271         return 0;
 272 }
 273
 274 void
 275 puffs__cc_setcaller(struct puffs_cc *pcc, pid_t pid, lwpid_t lid)
 276 {
 277
 278         pcc->pcc_pid = pid;
 279         pcc->pcc_lid = lid;
 280         pcc->pcc_flags |= PCC_HASCALLER;
 281 }
 282
 283 static void
 284 cc_free(struct puffs_cc *pcc)
 285 {
 286         struct puffs_usermount *pu = pcc->pcc_pu;
 287         size_t stacksize = 1<<pu->pu_cc_stackshift;
 288
 289         DPRINTF(("invalidating pcc %p\n", pcc));
 290         assert(!puffs_fakecc);
 291         munmap(pcc, stacksize);
 292 }
 293
 294 void
 295 puffs__cc_destroy(struct puffs_cc *pcc, int nonuke)
 296 {
 297         struct puffs_usermount *pu = pcc->pcc_pu;
 298
 299         pcc->pcc_flags &= ~PCC_HASCALLER;
 300         assert(pcc->pcc_flags == 0);
 301         assert(!puffs_fakecc);
 302
 303         /* not over limit?  stuff away in the store, otherwise nuke */
 304         if (nonuke || pu->pu_cc_nstored < PUFFS_CCMAXSTORE) {
 305                 pcc->pcc_pb = NULL;
 306                 DPRINTF(("puffs__cc_destroy: storing pcc %p\n", pcc));
 307                 LIST_INSERT_HEAD(&pu->pu_ccmagazin, pcc, pcc_rope);
 308                 pu->pu_cc_nstored++;
 309         } else {
 310                 cc_free(pcc);
 311         }
 312 }
 313
 314 void
 315 puffs__cc_exit(struct puffs_usermount *pu)
 316 {
 317         struct puffs_cc *pcc;
 318
 319         while ((pcc = LIST_FIRST(&pu->pu_ccmagazin)) != NULL) {
 320                 LIST_REMOVE(pcc, pcc_rope);
 321                 cc_free(pcc);
 322         }
 323 }
 324
 325 struct puffs_cc *
 326 puffs_cc_getcc(struct puffs_usermount *pu)
 327 {
 328         size_t stacksize = 1<<pu->pu_cc_stackshift;
 329         uintptr_t bottom;
 330
 331         if (puffs_fakecc)
 332                 return &fakecc;
 333
 334         bottom = ((uintptr_t)&bottom) & ~(stacksize-1);
 335         return (struct puffs_cc *)bottom;
 336 }
 337
 338 int
 339 puffs__cc_savemain(struct puffs_usermount *pu)
 340 {
 341
 342         if (puffs_fakecc)
 343                 return 0;
 344
 345         PU_CLRSFLAG(pu, PU_MAINRESTORE);
 346         return getcontext(&pu->pu_mainctx);
 347 }
 348
 349 int
 350 puffs__cc_restoremain(struct puffs_usermount *pu)
 351 {
 352
 353         if (puffs_fakecc)
 354                 return 0;
 355
 356         puffs__cc_destroy(puffs_cc_getcc(pu), 1);
 357         PU_SETSFLAG(pu, PU_MAINRESTORE);
 358         return setcontext(&pu->pu_mainctx);
 359 }