Annotation of prex-old/sys/ipc/msg.c, Revision 1.1.1.1
1.1 nbrk 1: /*-
2: * Copyright (c) 2005-2007, Kohsuke Ohtani
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: * 1. Redistributions of source code must retain the above copyright
9: * notice, this list of conditions and the following disclaimer.
10: * 2. Redistributions in binary form must reproduce the above copyright
11: * notice, this list of conditions and the following disclaimer in the
12: * documentation and/or other materials provided with the distribution.
13: * 3. Neither the name of the author nor the names of any co-contributors
14: * may be used to endorse or promote products derived from this software
15: * without specific prior written permission.
16: *
17: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20: * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
21: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27: * SUCH DAMAGE.
28: */
29:
30: /*
31: * msg.c - routines to transmit a message.
32: */
33:
34: /*
35: * Messages are sent to the specific object by using msg_send().
36: * The transmission of a message is completely synchronous with
37: * this kernel. This means the thread which sent a message is blocked
38: * until it receives a response from another thread. msg_receive()
39: * performs reception of a message. msg_receive() is also blocked
40: * when no message is reached to the target object. The receiver
41: * thread must answer the message using msg_reply() after it finishes
42: * its message processing.
43: *
44: * The receiver thread can not receive another message until it
45: * replies to the sender. In short, a thread can receive only one
46: * message at once. Once the thread receives message, it can send
47: * another message to different object. This mechanism allows threads
48: * to redirect the sender's request to another thread.
49: *
50: * The message is copied from thread to thread directly without any
51: * kernel buffering. If sent message contains a buffer, sender's memory
52: * region is automatically mapped to the receiver's memory in kernel.
53: * Since there is no page out of memory in this system, we can copy the
54: * message data via physical memory at anytime.
55: */
56:
57: #include <kernel.h>
58: #include <queue.h>
59: #include <event.h>
60: #include <kmem.h>
61: #include <sched.h>
62: #include <thread.h>
63: #include <task.h>
64: #include <vm.h>
65: #include <ipc.h>
66:
67: #define min(a,b) (((a) < (b)) ? (a) : (b))
68:
69: /* forward declarations */
70: static thread_t msg_dequeue(queue_t);
71: static void msg_enqueue(queue_t, thread_t);
72:
73: /* event for IPC operation */
74: static struct event ipc_event;
75:
76: /*
77: * msg_send - send a message.
78: * @obj: object ID to send a message.
79: * @msg: pointer to the message buffer
80: * @size: size of the message buffer.
81: *
82: * The current thread will be blocked until any other thread receives
83: * the message and calls msg_reply() for the target object.
84: * When new message has been reached to the object, it will be received
85: * by highest priority thread waiting for that message.
86: * A thread can send a message to any object if it knows the object id.
87: */
88: int
89: msg_send(object_t obj, void *msg, size_t size)
90: {
91: thread_t th;
92: void *kmsg;
93: int rc;
94:
95: if (!user_area(msg))
96: return EFAULT;
97:
98: if (size < sizeof(struct msg_header))
99: return EINVAL;
100:
101: sched_lock();
102:
103: if (!object_valid(obj)) {
104: sched_unlock();
105: return EINVAL;
106: }
107: if (obj->owner != cur_task() && !task_capable(CAP_IPC)) {
108: sched_unlock();
109: return EPERM;
110: }
111: /*
112: * A thread can not send a message when the thread is
113: * already receiving from the target object. This will
114: * obviously cause a deadlock.
115: */
116: if (obj == cur_thread->recv_obj) {
117: sched_unlock();
118: return EDEADLK;
119: }
120: /*
121: * Translate message address to the kernel linear address.
122: * So that a receiver thread can access the message via
123: * kernel pointer. We can catch the page fault here.
124: */
125: if ((kmsg = kmem_map(msg, size)) == NULL) {
126: /* Error - no physical address for the message */
127: sched_unlock();
128: return EFAULT;
129: }
130: /*
131: * Fill sender task ID in the message header.
132: * So, the receiver can trust this ID.
133: */
134: ((struct msg_header *)kmsg)->task = cur_task();
135:
136: /* Save the data for message block. */
137: cur_thread->msg_addr = kmsg;
138: cur_thread->msg_size = size;
139:
140: /*
141: * If receiver already exists, wake it up. Highest priority
142: * thread will get this message.
143: */
144: if (!queue_empty(&obj->recvq)) {
145: th = msg_dequeue(&obj->recvq);
146: sched_unsleep(th, 0);
147: }
148: /*
149: * Sleep until we get a reply message.
150: * Note: we can not touch the data in obj after we wakeup
151: * because it may be deleted during we were sleeping.
152: */
153: cur_thread->send_obj = obj;
154: msg_enqueue(&obj->sendq, cur_thread);
155: rc = sched_sleep(&ipc_event);
156: if (rc == SLP_INTR)
157: queue_remove(&cur_thread->ipc_link);
158: cur_thread->send_obj = NULL;
159:
160: sched_unlock();
161:
162: /*
163: * Check sleep result.
164: */
165: switch (rc) {
166: case SLP_BREAK:
167: return EAGAIN; /* Receiver has been terminated */
168: case SLP_INVAL:
169: return EINVAL; /* Object has been deleted */
170: case SLP_INTR:
171: return EINTR; /* Exception */
172: }
173: return 0;
174: }
175:
176: /*
177: * Receive a message.
178: *
179: * A thread can receive a message from the object which was created
180: * by any thread belongs to same task. If the message has not arrived
181: * yet, it blocks until any message comes in.
182: *
183: * The size argument specifies the "maximum" size of the message
184: * buffer to receive. If the sent message is larger than this size,
185: * the kernel will automatically clip the message to the receive buffer
186: * size.
187: *
188: * When message is received, the sender thread is removed from
189: * object's send queue. So, another thread can receive the subsequent
190: * message from that object. This is important for the multi-thread
191: * server which receives some messages simultaneously.
192: */
193: int
194: msg_receive(object_t obj, void *msg, size_t size)
195: {
196: thread_t th;
197: int err, rc;
198: size_t len;
199:
200: err = 0;
201: if (!user_area(msg))
202: return EFAULT;
203:
204: sched_lock();
205:
206: if (!object_valid(obj)) {
207: err = EINVAL;
208: goto out;
209: }
210: if (obj->owner != cur_task()) {
211: err = EACCES;
212: goto out;
213: }
214: /*
215: * Check if this thread finished previous receive operation.
216: * A thread can not receive different messages at once.
217: */
218: if (cur_thread->recv_obj) {
219: err = EBUSY;
220: goto out;
221: }
222: cur_thread->recv_obj = obj;
223:
224: /*
225: * If no message exists, wait until message arrives.
226: */
227: while (queue_empty(&obj->sendq)) {
228: /*
229: * Sleep until message comes in.
230: */
231: msg_enqueue(&obj->recvq, cur_thread);
232: rc = sched_sleep(&ipc_event);
233: if (rc == 0) {
234: /*
235: * Even if this thread is woken by the sender thread,
236: * the message may be received by another thread
237: * before this thread runs. This can occur when
238: * higher priority thread becomes runnable at that
239: * time. So, it is necessary to check the existence
240: * of the sender here again. The following line must
241: * be "continue" instead of "break" to check the
242: * queue again.
243: */
244: continue;
245: }
246: /*
247: * Receive is failed by some reason.
248: */
249: switch (rc) {
250: case SLP_INVAL:
251: err = EINVAL; /* Object has been deleted */
252: break;
253: case SLP_INTR:
254: queue_remove(&cur_thread->ipc_link);
255: err = EINTR; /* Got exception */
256: break;
257: default:
258: panic("msg_receive");
259: }
260: cur_thread->recv_obj = NULL;
261: goto out;
262: }
263:
264: th = msg_dequeue(&obj->sendq);
265:
266: /*
267: * Copy message to user space.
268: * The smaller buffer size is used as copy length
269: * between sender and receiver thread.
270: */
271: len = min(size, th->msg_size);
272: if (len > 0) {
273: if (umem_copyout(th->msg_addr, msg, len)) {
274: msg_enqueue(&obj->sendq, th);
275: cur_thread->recv_obj = NULL;
276: err = EFAULT;
277: goto out;
278: }
279: }
280: /*
281: * Detach the message from the target object.
282: */
283: cur_thread->sender = th;
284: th->receiver = cur_thread;
285: out:
286: sched_unlock();
287: return err;
288: }
289:
290: /*
291: * Send a reply message.
292: *
293: * The target object must be an appropriate object that current thread
294: * has been received from. Otherwise, this function will be failed.
295: *
296: * Since the target object may already be deleted, we can not access
297: * the data of the object within this routine.
298: */
299: int
300: msg_reply(object_t obj, void *msg, size_t size)
301: {
302: thread_t th;
303: size_t len;
304: int err = 0;
305:
306: if (!user_area(msg))
307: return EFAULT;
308:
309: sched_lock();
310:
311: if (!object_valid(obj) || obj != cur_thread->recv_obj) {
312: sched_unlock();
313: return EINVAL;
314: }
315: /*
316: * Check if sender still exists
317: */
318: if (cur_thread->sender == NULL) {
319: err = EINVAL;
320: goto out;
321: }
322: /*
323: * Copy message to the sender's buffer.
324: */
325: th = cur_thread->sender;
326: len = min(size, th->msg_size);
327: if (len > 0) {
328: if (umem_copyin(msg, th->msg_addr, len)) {
329: sched_unlock();
330: return EFAULT;
331: }
332: }
333: /*
334: * Wakeup sender with no error.
335: */
336: sched_unsleep(th, 0);
337: th->receiver = NULL;
338: out:
339: /* Clear transmit state */
340: cur_thread->sender = NULL;
341: cur_thread->recv_obj = NULL;
342:
343: sched_unlock();
344: return err;
345: }
346:
347: /*
348: * Clean up pending message operation of specified thread in order
349: * to prevent deadlock.
350: * This is called when the thread is killed.
351: * It is necessary to deal with the following conditions.
352: *
353: * If killed thread is sender:
354: * 1. Killed after message is received
355: * -> The received thread will reply to the invalid thread.
356: *
357: * 2. Killed before message is received
358: * -> The thread remains in send queue of the object.
359: *
360: * When thread is receiver:
361: * 3. Killed after message is sent
362: * -> The sender thread continues waiting for reply forever.
363: *
364: * 4. Killed before message is sent
365: * -> The thread remains in receive queue of the object.
366: */
367: void
368: msg_cleanup(thread_t th)
369: {
370:
371: sched_lock();
372:
373: if (th->send_obj) {
374: if (th->receiver)
375: th->receiver->sender = NULL;
376: else
377: queue_remove(&th->ipc_link);
378: }
379: if (th->recv_obj) {
380: if (th->sender) {
381: sched_unsleep(th->sender, SLP_BREAK);
382: th->sender->receiver = NULL;
383: } else
384: queue_remove(&th->ipc_link);
385: }
386: sched_unlock();
387: }
388:
389: /*
390: * Cancel all message operation relevant to the specified object.
391: * This is called when target object is deleted.
392: * All threads in message queue are woken to avoid deadlock.
393: * If the message has already been received, send/reply operation
394: * continue processing normally.
395: */
396: void
397: msg_cancel(object_t obj)
398: {
399: queue_t head, q;
400: thread_t th;
401:
402: sched_lock();
403:
404: /*
405: * Force wakeup all thread in the send queue.
406: */
407: head = &obj->sendq;
408: for (q = queue_first(head); !queue_end(head, q); q = queue_next(q)) {
409: th = queue_entry(q, struct thread, ipc_link);
410: sched_unsleep(th, SLP_INVAL);
411: }
412: /*
413: * Force wakeup all thread waiting for receive.
414: */
415: head = &obj->recvq;
416: for (q = queue_first(head); !queue_end(head, q); q = queue_next(q)) {
417: th = queue_entry(q, struct thread, ipc_link);
418: sched_unsleep(th, SLP_INVAL);
419: }
420: sched_unlock();
421: }
422:
423: /*
424: * Dequeue thread from specified queue.
425: * The most highest priority thread will be chosen.
426: */
427: static thread_t
428: msg_dequeue(queue_t head)
429: {
430: queue_t q;
431: thread_t th, top;
432:
433: q = queue_first(head);
434: top = queue_entry(q, struct thread, ipc_link);
435: while (!queue_end(head, q)) {
436: th = queue_entry(q, struct thread, ipc_link);
437: if (th->prio < top->prio)
438: top = th;
439: q = queue_next(q);
440: }
441: queue_remove(&top->ipc_link);
442: return top;
443: }
444:
445: static void
446: msg_enqueue(queue_t head, thread_t th)
447: {
448:
449: enqueue(head, &th->ipc_link);
450: }
451:
452: void
453: msg_init(void)
454: {
455:
456: event_init(&ipc_event, "ipc");
457: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to msg.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / prex-old / sys / ipc