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
puffs_cc_yield(struct puffs_cc * pcc)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
puffs__cc_cont(struct puffs_cc * pcc)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
puffs_cc_continue(struct puffs_cc * pcc)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
puffs__goto(struct puffs_cc * loanpcc)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
puffs_cc_schedule(struct puffs_cc * pcc)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
puffs_cc_getcaller(struct puffs_cc * pcc,pid_t * pid,lwpid_t * lid)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 *
slowccalloc(struct puffs_usermount * pu)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
puffs__cc_create(struct puffs_usermount * pu,puffs_ccfunc func,struct puffs_cc ** pccp)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
puffs__cc_setcaller(struct puffs_cc * pcc,pid_t pid,lwpid_t lid)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
cc_free(struct puffs_cc * pcc)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
puffs__cc_destroy(struct puffs_cc * pcc,int nonuke)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
puffs__cc_exit(struct puffs_usermount * pu)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 *
puffs_cc_getcc(struct puffs_usermount * pu)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
puffs__cc_savemain(struct puffs_usermount * pu)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
puffs__cc_restoremain(struct puffs_usermount * pu)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