2 * Copyright (c) 2003,2004,2006 The DragonFly Project. All rights reserved.
4 * This code is derived from software contributed to The DragonFly Project
5 * by Matthew Dillon <dillon@backplane.com>
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
17 * 3. Neither the name of The DragonFly Project nor the names of its
18 * contributors may be used to endorse or promote products derived
19 * from this software without specific, prior written permission.
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
24 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
25 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
26 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
27 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
28 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
29 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
30 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
31 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34 * $DragonFly: src/sys/kern/kern_upcall.c,v 1.11 2006/09/10 21:35:10 dillon Exp $
38 * Implement upcall registration and dispatch.
41 #include <sys/param.h>
42 #include <sys/systm.h>
43 #include <sys/kernel.h>
45 #include <sys/upcall.h>
46 #include <sys/thread2.h>
47 #include <sys/upcall.h>
48 #include <sys/malloc.h>
49 #include <sys/sysproto.h>
51 #include <sys/signalvar.h>
54 #include <vm/vm_param.h>
55 #include <vm/vm_kern.h>
57 #include <vm/vm_map.h>
59 #include <machine/cpu.h>
61 MALLOC_DEFINE(M_UPCALL
, "upcalls", "upcall registration structures");
66 sigupcall_remote(void *arg
)
69 if (lp
== lwkt_preempted_proc())
78 * Register an upcall context wrapper and procedure. Note that the
79 * upcall context is set globally for the process, not for each upcall.
81 * ARGS(struct upcall *upc, upcall_func_t ctx, upcall_func_t func, void *data)
84 sys_upc_register(struct upc_register_args
*uap
)
86 struct lwp
*lp
= curthread
->td_lwp
;
87 struct vmspace
*vm
= curproc
->p_vmspace
;
90 if (vm
->vm_upccount
>= UPCALL_MAXCOUNT
)
93 vu
= kmalloc(sizeof(struct vmupcall
), M_UPCALL
, M_WAITOK
|M_ZERO
);
94 vu
->vu_ctx
= uap
->ctxfunc
;
95 vu
->vu_func
= uap
->func
;
96 vu
->vu_data
= uap
->data
;
98 lp
->lwp_upcall
= uap
->upc
;
100 if (vm
->vm_upcalls
!= NULL
)
101 vu
->vu_id
= vm
->vm_upcalls
->vu_id
+ 1;
103 vu
->vu_id
= UPC_RESERVED
;
104 vu
->vu_next
= vm
->vm_upcalls
;
107 uap
->sysmsg_result
= vu
->vu_id
;
114 * ARGS(int cmd, int upcid, void *data)
117 sys_upc_control(struct upc_control_args
*uap
)
119 struct lwp
*lp
= curthread
->td_lwp
;
121 struct vmspace
*vms
= curproc
->p_vmspace
;
123 struct vmupcall
*vu_send
;
124 struct vmupcall
**vupp
;
128 case UPC_CONTROL_DISPATCH
:
130 * Dispatch the specified upcall id or the next pending id if -1.
131 * the upcall will be marked pending but an actual upcall will only
132 * occur if userland is not in a critical section and the userland
133 * pending bit is not set.
135 * You can dispatch an upcall associated with your process or another
136 * process sharing the same VM space.
138 error
= (uap
->upcid
== -1) ? 0 : ENOENT
;
139 for (vu
= vms
->vm_upcalls
; vu
; vu
= vu
->vu_next
) {
140 if (vu
->vu_id
== uap
->upcid
||
142 vu
->vu_pending
>= (int)(intptr_t)uap
->data
&& vu
->vu_lwp
== lp
)
144 if (vu
->vu_pending
< (int)(intptr_t)uap
->data
)
145 vu
->vu_pending
= (int)(intptr_t)uap
->data
;
148 targlp
->lwp_proc
->p_flag
|= P_UPCALLPEND
; /* XXX lwp flags */
149 if (targlp
->lwp_proc
->p_flag
& P_UPCALLWAIT
)
150 wakeup(&targlp
->lwp_upcall
);
152 if (targlp
->lwp_thread
->td_gd
!= mycpu
)
153 lwkt_send_ipiq(targlp
->lwp_thread
->td_gd
, sigupcall_remote
, targlp
);
163 case UPC_CONTROL_NEXT
:
165 * This is used by the context code to fetch the next pending upcall.
166 * The context code has two choices: (A) it can drop
167 * upcall->crit_count and set upcall->pending then make this call
168 * unconditionally or * (B) it can drop upcall->crit_count and then
169 * test upcall->pending and only make this call if upcall->pending
170 * is set. If upcall->pending is clear the context code can pop
171 * the upcall stack itself and return without entering into the kernel
172 * again. (B) is more efficient but leaves a small window of
173 * opportunity where multiple upcalls can pushdown the stack.
175 * If another upcall is pending the crit_count will be bumped and
176 * the function, data, and context pointers will be returned in
177 * registers (C cannot call this routine). If no more upcalls are
178 * pending the pending bit will be cleared and the 'data' argument
179 * is expected to be pointing at the upcall context which we will
180 * then pop, returning to the original code that was interrupted
181 * (NOT the context code).
184 for (vu
= vms
->vm_upcalls
; vu
; vu
= vu
->vu_next
) {
185 if (vu
->vu_lwp
== lp
&& vu
->vu_pending
) {
192 * vu_send may be NULL, indicating that no more upcalls are pending
193 * for this cpu. We set the userland pending bit based on whether
194 * additional upcalls are pending or not.
196 error
= fetchupcall(vu_send
, vu
!= NULL
, uap
->data
);
198 case UPC_CONTROL_DELETE
:
200 * Delete the specified upcall id. If the upcall id is -1, delete
201 * all upcall id's associated with the current process.
203 error
= (uap
->upcid
== -1) ? 0 : ENOENT
;
204 vupp
= &vms
->vm_upcalls
;
205 while ((vu
= *vupp
) != NULL
) {
206 if (vu
->vu_id
== uap
->upcid
||
207 (uap
->upcid
== -1 && vu
->vu_lwp
== lp
)
217 case UPC_CONTROL_POLL
:
218 case UPC_CONTROL_POLLANDCLEAR
:
219 case UPC_CONTROL_WAIT
:
221 * If upcid is -1 poll for the first pending upcall and return the
222 * id or 0 if no upcalls are pending.
224 * If upcid is a particular upcall then poll that upcall and return
225 * its pending status (0 or 1). For POLLANDCLEAR, also clear the
226 * pending status. The userland pending bit is not modified by
227 * this call (maybe we should modify it for poll-and-clear).
229 error
= (uap
->upcid
== -1) ? 0 : ENOENT
;
230 for (vu
= vms
->vm_upcalls
; vu
; vu
= vu
->vu_next
) {
231 if (vu
->vu_id
== uap
->upcid
||
233 vu
->vu_pending
>= (int)(intptr_t)uap
->data
&& vu
->vu_lwp
== lp
)
236 if (uap
->upcid
== -1)
237 uap
->sysmsg_result
= vu
->vu_id
;
239 uap
->sysmsg_result
= vu
->vu_pending
;
240 if (uap
->cmd
== UPC_CONTROL_POLLANDCLEAR
)
245 if (uap
->cmd
== UPC_CONTROL_WAIT
&& vu
== NULL
) {
246 lp
->lwp_proc
->p_flag
|= P_UPCALLWAIT
; /* XXX lwp flags */
247 tsleep(&lp
->lwp_upcall
, PCATCH
, "wupcall", 0);
248 lp
->lwp_proc
->p_flag
&= ~P_UPCALLWAIT
; /* XXX lwp flags */
259 upc_release(struct vmspace
*vm
, struct lwp
*lp
)
261 struct vmupcall
**vupp
;
264 vupp
= &vm
->vm_upcalls
;
265 while ((vu
= *vupp
) != NULL
) {
266 if (vu
->vu_lwp
== lp
) {
277 * XXX eventually we should sort by vu_pending priority and dispatch
278 * the highest priority upcall first.
281 postupcall(struct lwp
*lp
)
283 struct vmspace
*vm
= lp
->lwp_proc
->p_vmspace
;
285 struct vmupcall
*vu_send
= NULL
;
287 for (vu
= vm
->vm_upcalls
; vu
; vu
= vu
->vu_next
) {
288 if (vu
->vu_lwp
== lp
&& vu
->vu_pending
) {
297 sendupcall(vu_send
, 0);