Rev 3370 | Rev 4155 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
955 | palkovsky | 1 | /* |
2071 | jermar | 2 | * Copyright (c) 2006 Ondrej Palkovsky |
955 | palkovsky | 3 | * All rights reserved. |
4 | * |
||
5 | * Redistribution and use in source and binary forms, with or without |
||
6 | * modification, are permitted provided that the following conditions |
||
7 | * are met: |
||
8 | * |
||
9 | * - Redistributions of source code must retain the above copyright |
||
10 | * notice, this list of conditions and the following disclaimer. |
||
11 | * - Redistributions in binary form must reproduce the above copyright |
||
12 | * notice, this list of conditions and the following disclaimer in the |
||
13 | * documentation and/or other materials provided with the distribution. |
||
14 | * - The name of the author may not be used to endorse or promote products |
||
15 | * derived from this software without specific prior written permission. |
||
16 | * |
||
17 | * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
||
18 | * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
||
19 | * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
||
20 | * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
||
21 | * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
||
22 | * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||
23 | * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||
24 | * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||
25 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
||
26 | * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||
27 | */ |
||
28 | |||
1888 | jermar | 29 | /** @addtogroup genericipc |
1702 | cejka | 30 | * @{ |
31 | */ |
||
32 | /** @file |
||
33 | */ |
||
34 | |||
1877 | jermar | 35 | #ifndef KERN_IPC_H_ |
36 | #define KERN_IPC_H_ |
||
955 | palkovsky | 37 | |
965 | palkovsky | 38 | /* Length of data being transfered with IPC call */ |
39 | /* - the uspace may not be able to utilize full length */ |
||
2614 | jermar | 40 | #define IPC_CALL_LEN 6 |
955 | palkovsky | 41 | |
998 | palkovsky | 42 | /** Maximum active async calls per thread */ |
1643 | palkovsky | 43 | #ifdef CONFIG_DEBUG |
2471 | jermar | 44 | #define IPC_MAX_ASYNC_CALLS 4 |
1643 | palkovsky | 45 | #else |
2471 | jermar | 46 | #define IPC_MAX_ASYNC_CALLS 4000 |
1643 | palkovsky | 47 | #endif |
998 | palkovsky | 48 | |
955 | palkovsky | 49 | /* Flags for calls */ |
965 | palkovsky | 50 | |
2106 | jermar | 51 | /** This is answer to a call */ |
52 | #define IPC_CALL_ANSWERED (1 << 0) |
||
53 | /** This call will not be freed on error */ |
||
54 | #define IPC_CALL_STATIC_ALLOC (1 << 1) |
||
55 | /** Answer will not be passed to userspace, will be discarded */ |
||
56 | #define IPC_CALL_DISCARD_ANSWER (1 << 2) |
||
57 | /** Call was forwarded */ |
||
58 | #define IPC_CALL_FORWARDED (1 << 3) |
||
59 | /** Identify connect_me_to answer */ |
||
60 | #define IPC_CALL_CONN_ME_TO (1 << 4) |
||
61 | /** Interrupt notification */ |
||
62 | #define IPC_CALL_NOTIF (1 << 5) |
||
63 | |||
2471 | jermar | 64 | /* |
65 | * Bits used in call hashes. |
||
66 | * The addresses are aligned at least to 4 that is why we can use the 2 least |
||
67 | * significant bits of the call address. |
||
1086 | palkovsky | 68 | */ |
2471 | jermar | 69 | /** Type of this call is 'answer' */ |
2106 | jermar | 70 | #define IPC_CALLID_ANSWERED 1 |
2471 | jermar | 71 | /** Type of this call is 'notification' */ |
2106 | jermar | 72 | #define IPC_CALLID_NOTIFICATION 2 |
965 | palkovsky | 73 | |
2471 | jermar | 74 | /* Return values from sys_ipc_call_async(). */ |
2106 | jermar | 75 | #define IPC_CALLRET_FATAL -1 |
76 | #define IPC_CALLRET_TEMPORARY -2 |
||
965 | palkovsky | 77 | |
78 | |||
79 | /* Macros for manipulating calling data */ |
||
2106 | jermar | 80 | #define IPC_SET_RETVAL(data, retval) ((data).args[0] = (retval)) |
81 | #define IPC_SET_METHOD(data, val) ((data).args[0] = (val)) |
||
82 | #define IPC_SET_ARG1(data, val) ((data).args[1] = (val)) |
||
83 | #define IPC_SET_ARG2(data, val) ((data).args[2] = (val)) |
||
84 | #define IPC_SET_ARG3(data, val) ((data).args[3] = (val)) |
||
2614 | jermar | 85 | #define IPC_SET_ARG4(data, val) ((data).args[4] = (val)) |
86 | #define IPC_SET_ARG5(data, val) ((data).args[5] = (val)) |
||
965 | palkovsky | 87 | |
2106 | jermar | 88 | #define IPC_GET_METHOD(data) ((data).args[0]) |
89 | #define IPC_GET_RETVAL(data) ((data).args[0]) |
||
965 | palkovsky | 90 | |
2106 | jermar | 91 | #define IPC_GET_ARG1(data) ((data).args[1]) |
92 | #define IPC_GET_ARG2(data) ((data).args[2]) |
||
93 | #define IPC_GET_ARG3(data) ((data).args[3]) |
||
2614 | jermar | 94 | #define IPC_GET_ARG4(data) ((data).args[4]) |
95 | #define IPC_GET_ARG5(data) ((data).args[5]) |
||
965 | palkovsky | 96 | |
97 | /* Well known phone descriptors */ |
||
2106 | jermar | 98 | #define PHONE_NS 0 |
965 | palkovsky | 99 | |
2622 | jermar | 100 | /* Forwarding flags. */ |
101 | #define IPC_FF_NONE 0 |
||
2623 | jermar | 102 | /** |
103 | * The call will be routed as though it was initially sent via the phone used to |
||
104 | * forward it. This feature is intended to support the situation in which the |
||
105 | * forwarded call needs to be handled by the same connection fibril as any other |
||
106 | * calls that were initially sent by the forwarder to the same destination. This |
||
107 | * flag has no imapct on routing replies. |
||
108 | */ |
||
109 | #define IPC_FF_ROUTE_FROM_ME (1 << 0) |
||
2622 | jermar | 110 | |
1027 | palkovsky | 111 | /* System-specific methods - only through special syscalls |
112 | * These methods have special behaviour |
||
113 | */ |
||
114 | /** Protocol for CONNECT - TO - ME |
||
115 | * |
||
116 | * Calling process asks the callee to create a callback connection, |
||
117 | * so that it can start initiating new messages. |
||
118 | * |
||
1040 | palkovsky | 119 | * The protocol for negotiating is: |
2527 | jermar | 120 | * - sys_connect_to_me - sends a message IPC_M_CONNECT_TO_ME |
2638 | jermar | 121 | * - recipient - upon receipt tries to allocate new phone |
1027 | palkovsky | 122 | * - if it fails, responds with ELIMIT |
123 | * - passes call to userspace. If userspace |
||
124 | * responds with error, phone is deallocated and |
||
125 | * error is sent back to caller. Otherwise |
||
126 | * the call is accepted and the response is sent back. |
||
1040 | palkovsky | 127 | * - the allocated phoneid is passed to userspace |
2637 | cejka | 128 | * (on the receiving side) as ARG5 of the call. |
1027 | palkovsky | 129 | */ |
2471 | jermar | 130 | #define IPC_M_CONNECT_TO_ME 1 |
1040 | palkovsky | 131 | /** Protocol for CONNECT - ME - TO |
132 | * |
||
133 | * Calling process asks the callee to create for him a new connection. |
||
134 | * E.g. the caller wants a name server to connect him to print server. |
||
135 | * |
||
136 | * The protocol for negotiating is: |
||
137 | * - sys_connect_me_to - send a synchronous message to name server |
||
138 | * indicating that it wants to be connected to some |
||
139 | * service |
||
2635 | cejka | 140 | * - arg1/2/3 are user specified, arg5 contains |
1060 | palkovsky | 141 | * address of the phone that should be connected |
142 | * (TODO: it leaks to userspace) |
||
2638 | jermar | 143 | * - recipient - if ipc_answer == 0, then accept connection |
1040 | palkovsky | 144 | * - otherwise connection refused |
2638 | jermar | 145 | * - recepient may forward message. |
1040 | palkovsky | 146 | * |
147 | */ |
||
2471 | jermar | 148 | #define IPC_M_CONNECT_ME_TO 2 |
1086 | palkovsky | 149 | /** This message is sent to answerbox when the phone |
150 | * is hung up |
||
1040 | palkovsky | 151 | */ |
2471 | jermar | 152 | #define IPC_M_PHONE_HUNGUP 3 |
1428 | palkovsky | 153 | |
2494 | jermar | 154 | /** Send as_area over IPC. |
155 | * - ARG1 - source as_area base address |
||
156 | * - ARG2 - size of source as_area (filled automatically by kernel) |
||
2025 | jermar | 157 | * - ARG3 - flags of the as_area being sent |
158 | * |
||
2494 | jermar | 159 | * on answer, the recipient must set: |
2025 | jermar | 160 | * - ARG1 - dst as_area base adress |
1329 | palkovsky | 161 | */ |
2677 | jermar | 162 | #define IPC_M_SHARE_OUT 4 |
1027 | palkovsky | 163 | |
2494 | jermar | 164 | /** Receive as_area over IPC. |
165 | * - ARG1 - destination as_area base address |
||
166 | * - ARG2 - destination as_area size |
||
2025 | jermar | 167 | * - ARG3 - user defined argument |
168 | * |
||
2494 | jermar | 169 | * on answer, the recipient must set: |
2025 | jermar | 170 | * |
2494 | jermar | 171 | * - ARG1 - source as_area base address |
2025 | jermar | 172 | * - ARG2 - flags that will be used for sharing |
1428 | palkovsky | 173 | */ |
2677 | jermar | 174 | #define IPC_M_SHARE_IN 5 |
1027 | palkovsky | 175 | |
2494 | jermar | 176 | /** Send data to another address space over IPC. |
2676 | jermar | 177 | * - ARG1 - source address space virtual address |
178 | * - ARG2 - size of data to be copied, may be overriden by the recipient |
||
2494 | jermar | 179 | * |
180 | * on answer, the recipient must set: |
||
181 | * |
||
182 | * - ARG1 - final destination address space virtual address |
||
2676 | jermar | 183 | * - ARG2 - final size of data to be copied |
2494 | jermar | 184 | */ |
2660 | jermar | 185 | #define IPC_M_DATA_WRITE 6 |
1428 | palkovsky | 186 | |
2660 | jermar | 187 | /** Receive data from another address space over IPC. |
188 | * - ARG1 - destination virtual address in the source address space |
||
189 | * - ARG2 - size of data to be received, may be cropped by the recipient |
||
190 | * |
||
191 | * on answer, the recipient must set: |
||
192 | * |
||
193 | * - ARG1 - source virtual address in the destination address space |
||
194 | * - ARG2 - final size of data to be copied |
||
195 | */ |
||
196 | #define IPC_M_DATA_READ 7 |
||
197 | |||
1027 | palkovsky | 198 | /* Well-known methods */ |
2471 | jermar | 199 | #define IPC_M_LAST_SYSTEM 511 |
200 | #define IPC_M_PING 512 |
||
1027 | palkovsky | 201 | /* User methods */ |
2550 | cejka | 202 | #define IPC_FIRST_USER_METHOD 1024 |
1027 | palkovsky | 203 | |
955 | palkovsky | 204 | #ifdef KERNEL |
205 | |||
2105 | decky | 206 | #define IPC_MAX_PHONES 16 |
955 | palkovsky | 207 | |
3020 | jermar | 208 | #include <synch/spinlock.h> |
209 | #include <synch/mutex.h> |
||
2105 | decky | 210 | #include <synch/waitq.h> |
211 | |||
212 | struct answerbox; |
||
213 | struct task; |
||
214 | |||
215 | typedef enum { |
||
2106 | jermar | 216 | /** Phone is free and can be allocated */ |
217 | IPC_PHONE_FREE = 0, |
||
218 | /** Phone is connecting somewhere */ |
||
219 | IPC_PHONE_CONNECTING, |
||
220 | /** Phone is connected */ |
||
221 | IPC_PHONE_CONNECTED, |
||
222 | /** Phone is hung up, waiting for answers to come */ |
||
223 | IPC_PHONE_HUNGUP, |
||
224 | /** Phone was hungup from server */ |
||
225 | IPC_PHONE_SLAMMED |
||
2105 | decky | 226 | } ipc_phone_state_t; |
227 | |||
228 | /** Structure identifying phone (in TASK structure) */ |
||
955 | palkovsky | 229 | typedef struct { |
3020 | jermar | 230 | mutex_t lock; |
2105 | decky | 231 | link_t link; |
232 | struct answerbox *callee; |
||
233 | ipc_phone_state_t state; |
||
234 | atomic_t active_calls; |
||
235 | } phone_t; |
||
236 | |||
237 | typedef struct answerbox { |
||
238 | SPINLOCK_DECLARE(lock); |
||
239 | |||
240 | struct task *task; |
||
241 | |||
242 | waitq_t wq; |
||
243 | |||
2471 | jermar | 244 | /** Phones connected to this answerbox. */ |
2106 | jermar | 245 | link_t connected_phones; |
2471 | jermar | 246 | /** Received calls. */ |
2106 | jermar | 247 | link_t calls; |
2105 | decky | 248 | link_t dispatched_calls; /* Should be hash table in the future */ |
249 | |||
2471 | jermar | 250 | /** Answered calls. */ |
2106 | jermar | 251 | link_t answers; |
2105 | decky | 252 | |
253 | SPINLOCK_DECLARE(irq_lock); |
||
2471 | jermar | 254 | /** Notifications from IRQ handlers. */ |
2106 | jermar | 255 | link_t irq_notifs; |
256 | /** IRQs with notifications to this answerbox. */ |
||
257 | link_t irq_head; |
||
2105 | decky | 258 | } answerbox_t; |
259 | |||
260 | typedef struct { |
||
1780 | jermar | 261 | unative_t args[IPC_CALL_LEN]; |
1086 | palkovsky | 262 | phone_t *phone; |
3362 | jermar | 263 | /* |
264 | * The forward operation can masquerade the caller phone. For those |
||
265 | * cases, we must keep it aside so that the answer is processed |
||
266 | * correctly. |
||
267 | */ |
||
268 | phone_t *caller_phone; |
||
1888 | jermar | 269 | } ipc_data_t; |
955 | palkovsky | 270 | |
1086 | palkovsky | 271 | typedef struct { |
1573 | palkovsky | 272 | link_t link; |
1086 | palkovsky | 273 | |
274 | int flags; |
||
275 | |||
2471 | jermar | 276 | /** Identification of the caller. */ |
2105 | decky | 277 | struct task *sender; |
2471 | jermar | 278 | /** The caller box is different from sender->answerbox for synchronous |
279 | * calls. */ |
||
1086 | palkovsky | 280 | answerbox_t *callerbox; |
281 | |||
2471 | jermar | 282 | /** Private data to internal IPC. */ |
2106 | jermar | 283 | unative_t priv; |
1090 | palkovsky | 284 | |
2471 | jermar | 285 | /** Data passed from/to userspace. */ |
2106 | jermar | 286 | ipc_data_t data; |
2494 | jermar | 287 | |
2662 | jermar | 288 | /** Buffer for IPC_M_DATA_WRITE and IPC_M_DATA_READ. */ |
2494 | jermar | 289 | uint8_t *buffer; |
1888 | jermar | 290 | } call_t; |
1086 | palkovsky | 291 | |
955 | palkovsky | 292 | extern void ipc_init(void); |
2802 | jermar | 293 | extern call_t * ipc_wait_for_call(answerbox_t *, uint32_t, int); |
294 | extern void ipc_answer(answerbox_t *, call_t *); |
||
295 | extern int ipc_call(phone_t *, call_t *); |
||
3370 | jermar | 296 | extern int ipc_call_sync(phone_t *, call_t *); |
2802 | jermar | 297 | extern void ipc_phone_init(phone_t *); |
298 | extern void ipc_phone_connect(phone_t *, answerbox_t *); |
||
299 | extern void ipc_call_free(call_t *); |
||
300 | extern call_t * ipc_call_alloc(int); |
||
301 | extern void ipc_answerbox_init(answerbox_t *, struct task *); |
||
302 | extern void ipc_call_static_init(call_t *); |
||
1060 | palkovsky | 303 | extern void task_print_list(void); |
2802 | jermar | 304 | extern int ipc_forward(call_t *, phone_t *, answerbox_t *, int); |
2523 | jermar | 305 | extern void ipc_cleanup(void); |
2802 | jermar | 306 | extern int ipc_phone_hangup(phone_t *); |
307 | extern void ipc_backsend_err(phone_t *, call_t *, unative_t); |
||
308 | extern void ipc_print_task(task_id_t); |
||
955 | palkovsky | 309 | |
1090 | palkovsky | 310 | extern answerbox_t *ipc_phone_0; |
311 | |||
955 | palkovsky | 312 | #endif |
313 | |||
314 | #endif |
||
1702 | cejka | 315 | |
1877 | jermar | 316 | /** @} |
1702 | cejka | 317 | */ |