Home | History | Annotate | Line # | Download | only in libpuffs 
      1 /*	$NetBSD: callcontext.c,v 1.30 2018/07/09 00:47:47 christos 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.30 2018/07/09 00:47:47 christos 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 	const long psize = sysconf(_SC_PAGESIZE);
    192 
    193 	if (puffs_fakecc)
    194 		return &fakecc;
    195 
    196 	sp = mmap(NULL, stacksize, PROT_READ|PROT_WRITE,
    197 	    MAP_ANON|MAP_PRIVATE|MAP_ALIGNED(pu->pu_cc_stackshift), -1, 0);
    198 	if (sp == MAP_FAILED)
    199 		return NULL;
    200 
    201 	pcc = sp;
    202 	memset(pcc, 0, sizeof(struct puffs_cc));
    203 
    204 #ifndef __MACHINE_STACK_GROWS_UP
    205 	mprotect((uint8_t *)sp + psize, (size_t)psize, PROT_NONE);
    206 #else
    207 	mprotect((uint8_t *)sp + stacksize - psize, (size_t)psize, PROT_NONE);
    208 #endif
    209 
    210 	/* initialize both ucontext's */
    211 	if (getcontext(&pcc->pcc_uc) == -1) {
    212 		munmap(pcc, stacksize);
    213 		return NULL;
    214 	}
    215 	if (getcontext(&pcc->pcc_uc_ret) == -1) {
    216 		munmap(pcc, stacksize);
    217 		return NULL;
    218 	}
    219 
    220 	return pcc;
    221 }
    222 
    223 int
    224 puffs__cc_create(struct puffs_usermount *pu, puffs_ccfunc func,
    225 	struct puffs_cc **pccp)
    226 {
    227 	struct puffs_cc *pcc;
    228 	size_t stacksize = 1<<pu->pu_cc_stackshift;
    229 	stack_t *st;
    230 
    231 	/* Do we have a cached copy? */
    232 	if (pu->pu_cc_nstored == 0) {
    233 		pcc = slowccalloc(pu);
    234 		if (pcc == NULL)
    235 			return -1;
    236 		pcc->pcc_pu = pu;
    237 		DPRINTF(("puffs__cc_create: allocated pcc %p\n", pcc));
    238 	} else {
    239 		pcc = LIST_FIRST(&pu->pu_ccmagazin);
    240 		assert(pcc != NULL);
    241 
    242 		LIST_REMOVE(pcc, pcc_rope);
    243 		pu->pu_cc_nstored--;
    244 		DPRINTF(("puffs__cc_create: magazin pcc %p\n", pcc));
    245 	}
    246 	assert(pcc->pcc_pu == pu);
    247 
    248 	if (puffs_fakecc) {
    249 		pcc->pcc_func = func;
    250 		pcc->pcc_farg = pcc;
    251 	} else {
    252 		const long psize = sysconf(_SC_PAGESIZE);
    253 
    254 		/* link context */
    255 		pcc->pcc_uc.uc_link = &pcc->pcc_uc_ret;
    256 
    257 		/* setup stack
    258 		 *
    259 		 * XXX: I guess this should theoretically be preserved by
    260 		 * swapcontext().  However, it gets lost.  So reinit it.
    261 		 */
    262 		st = &pcc->pcc_uc.uc_stack;
    263 		st->ss_sp = ((uint8_t *)(void *)pcc) + psize;
    264 		st->ss_size = stacksize - psize;
    265 		st->ss_flags = 0;
    266 
    267 		/*
    268 		 * Give us an initial context to jump to.
    269 		 *
    270 		 * Our manual page says that portable code shouldn't
    271 		 * rely on being able to pass pointers through makecontext().
    272 		 * kjk says that NetBSD code doesn't need to worry about this.
    273 		 * uwe says it would be like putting a "keep away from
    274 		 * children" sign on a box of toys.
    275 		 */
    276 		makecontext(&pcc->pcc_uc, (void *)func, 1, (uintptr_t)pcc);
    277 	}
    278 
    279 	*pccp = pcc;
    280 	return 0;
    281 }
    282 
    283 void
    284 puffs__cc_setcaller(struct puffs_cc *pcc, pid_t pid, lwpid_t lid)
    285 {
    286 
    287 	pcc->pcc_pid = pid;
    288 	pcc->pcc_lid = lid;
    289 	pcc->pcc_flags |= PCC_HASCALLER;
    290 }
    291 
    292 static void
    293 cc_free(struct puffs_cc *pcc)
    294 {
    295 	struct puffs_usermount *pu = pcc->pcc_pu;
    296 	size_t stacksize = 1<<pu->pu_cc_stackshift;
    297 
    298 	DPRINTF(("invalidating pcc %p\n", pcc));
    299 	assert(!puffs_fakecc);
    300 	munmap(pcc, stacksize);
    301 }
    302 
    303 void
    304 puffs__cc_destroy(struct puffs_cc *pcc, int nonuke)
    305 {
    306 	struct puffs_usermount *pu = pcc->pcc_pu;
    307 
    308 	pcc->pcc_flags &= ~PCC_HASCALLER;
    309 	assert(pcc->pcc_flags == 0);
    310 	assert(!puffs_fakecc);
    311 
    312 	/* not over limit?  stuff away in the store, otherwise nuke */
    313 	if (nonuke || pu->pu_cc_nstored < PUFFS_CCMAXSTORE) {
    314 		pcc->pcc_pb = NULL;
    315 		DPRINTF(("puffs__cc_destroy: storing pcc %p\n", pcc));
    316 		LIST_INSERT_HEAD(&pu->pu_ccmagazin, pcc, pcc_rope);
    317 		pu->pu_cc_nstored++;
    318 	} else {
    319 		cc_free(pcc);
    320 	}
    321 }
    322 
    323 void
    324 puffs__cc_exit(struct puffs_usermount *pu)
    325 {
    326 	struct puffs_cc *pcc;
    327 
    328 	while ((pcc = LIST_FIRST(&pu->pu_ccmagazin)) != NULL) {
    329 		LIST_REMOVE(pcc, pcc_rope);
    330 		cc_free(pcc);
    331 	}
    332 }
    333 
    334 struct puffs_cc *
    335 puffs_cc_getcc(struct puffs_usermount *pu)
    336 {
    337 	size_t stacksize = 1<<pu->pu_cc_stackshift;
    338 	uintptr_t bottom;
    339 
    340 	if (puffs_fakecc)
    341 		return &fakecc;
    342 
    343 	bottom = ((uintptr_t)&bottom) & ~(stacksize-1);
    344 	return (struct puffs_cc *)bottom;
    345 }
    346 
    347 int
    348 puffs__cc_savemain(struct puffs_usermount *pu)
    349 {
    350 
    351 	if (puffs_fakecc)
    352 		return 0;
    353 
    354 	PU_CLRSFLAG(pu, PU_MAINRESTORE);
    355 	return getcontext(&pu->pu_mainctx);
    356 }
    357 
    358 int
    359 puffs__cc_restoremain(struct puffs_usermount *pu)
    360 {
    361 
    362 	if (puffs_fakecc)
    363 		return 0;
    364 
    365 	puffs__cc_destroy(puffs_cc_getcc(pu), 1);
    366 	PU_SETSFLAG(pu, PU_MAINRESTORE);
    367 	return setcontext(&pu->pu_mainctx);
    368 }
    369