![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ipc_mig.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / kernel / kern|
Return to ipc_mig.c CVS log | Up to [Apple Darwin 0.x] / kernel / kern |
1.1 root 1: /*
2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights
7: * Reserved. This file contains Original Code and/or Modifications of
8: * Original Code as defined in and that are subject to the Apple Public
9: * Source License Version 1.1 (the "License"). You may not use this file
10: * except in compliance with the License. Please obtain a copy of the
11: * License at http://www.apple.com/publicsource and read it before using
12: * this file.
13: *
14: * The Original Code and all software distributed under the License are
15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
19: * License for the specific language governing rights and limitations
20: * under the License.
21: *
22: * @APPLE_LICENSE_HEADER_END@
23: */
24:
25: /*
26: * Mach Operating System
27: * Copyright (c) 1991,1990 Carnegie Mellon University
28: * All Rights Reserved.
29: *
30: * Permission to use, copy, modify and distribute this software and its
31: * documentation is hereby granted, provided that both the copyright
32: * notice and this permission notice appear in all copies of the
33: * software, derivative works or modified versions, and any portions
34: * thereof, and that both notices appear in supporting documentation.
35: *
36: * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
37: * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
38: * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
39: *
40: * Carnegie Mellon requests users of this software to return to
41: *
42: * Software Distribution Coordinator or [email protected]
43: * School of Computer Science
44: * Carnegie Mellon University
45: * Pittsburgh PA 15213-3890
46: *
47: * any improvements or extensions that they make and grant Carnegie Mellon
48: * the rights to redistribute these changes.
49: */
50:
51: #include <mach/boolean.h>
52: #include <mach/port.h>
53: #include <mach/message.h>
54: #include <mach/thread_status.h>
55: #include <kern/ast.h>
56: #include <kern/ipc_tt.h>
57: #include <kern/thread.h>
58: #include <kern/task.h>
59: #include <kern/ipc_kobject.h>
60: #include <vm/vm_map.h>
61: #include <vm/vm_user.h>
62: #include <ipc/port.h>
63: #include <ipc/ipc_kmsg.h>
64: #include <ipc/ipc_entry.h>
65: #include <ipc/ipc_object.h>
66: #include <ipc/ipc_mqueue.h>
67: #include <ipc/ipc_space.h>
68: #include <ipc/ipc_port.h>
69: #include <ipc/ipc_pset.h>
70: #include <ipc/ipc_thread.h>
71:
72:
73: /*
74: * Routine: mach_msg_send_from_kernel
75: * Purpose:
76: * Send a message from the kernel.
77: *
78: * This is used by the client side of KernelUser interfaces
79: * to implement SimpleRoutines. Currently, this includes
80: * device_reply and memory_object messages.
81: * Conditions:
82: * Nothing locked.
83: * Returns:
84: * MACH_MSG_SUCCESS Sent the message.
85: * MACH_SEND_INVALID_DATA Bad destination port.
86: */
87:
88: mach_msg_return_t
89: mach_msg_send_from_kernel(msg, send_size)
90: mach_msg_header_t *msg;
91: mach_msg_size_t send_size;
92: {
93: ipc_kmsg_t kmsg;
94: mach_msg_return_t mr;
95:
96: if (!MACH_PORT_VALID(msg->msgh_remote_port))
97: return MACH_SEND_INVALID_DEST;
98:
99: mr = ipc_kmsg_get_from_kernel(msg, MACH_MSG_OPTION_NONE,
100: send_size, MAX_TRAILER_SIZE,
101: &kmsg);
102: if (mr != MACH_MSG_SUCCESS)
103: panic("mach_msg_send_from_kernel");
104:
105: ipc_kmsg_copyin_from_kernel(kmsg);
106: ipc_mqueue_send_always(kmsg);
107:
108: return MACH_MSG_SUCCESS;
109: }
110:
111: /*
112: * Routine: mach_msg_abort_rpc
113: * Purpose:
114: * Destroy the thread's ith_rpc_reply port.
115: * This will interrupt a mach_msg_rpc_from_kernel
116: * with a MACH_RCV_PORT_DIED return code.
117: * Conditions:
118: * Nothing locked.
119: */
120:
121: void
122: mach_msg_abort_rpc(thread)
123: ipc_thread_t thread;
124: {
125: ipc_port_t reply = IP_NULL;
126:
127: ith_lock(thread);
128: if (thread->ith_self != IP_NULL) {
129: reply = thread->ith_rpc_reply;
130: thread->ith_rpc_reply = IP_NULL;
131: }
132: ith_unlock(thread);
133:
134: if (reply != IP_NULL)
135: ipc_port_dealloc_reply(reply);
136: }
137:
138: msg_return_t
139: msg_send_from_kernel(msg, option, time_out)
140: msg_header_t *msg;
141: msg_option_t option;
142: msg_timeout_t time_out;
143: {
144: msg_size_t send_size = msg->msg_size;
145: ipc_kmsg_t kmsg;
146: integer_t send_delta = send_size;
147: mach_msg_return_t mr;
148:
149: send_size = (send_size + 3) & ~3; /* round up */
150: send_delta -= send_size;
151:
152: mr = ipc_kmsg_get_from_kernel((mach_msg_header_t *) msg,
153: MACH_MSG_OPTION_NONE,
154: (mach_msg_size_t) send_size,
155: send_delta,
156: &kmsg);
157: if (mr != MACH_MSG_SUCCESS)
158: return msg_return_translate(mr);
159:
160: ipc_kmsg_copyin_compat_from_kernel(kmsg);
161: if (option & SEND_NOTIFY) {
162: panic("msg_send_from_kernel");
163: } else
164: mr = ipc_mqueue_send(kmsg,
165: ((option & SEND_TIMEOUT) ?
166: MACH_SEND_TIMEOUT :
167: MACH_MSG_OPTION_NONE) |
168: MACH_SEND_ALWAYS | MACH_SEND_SWITCH,
169: (mach_msg_timeout_t) time_out,
170: IMQ_NULL_CONTINUE);
171:
172: if (mr != MACH_MSG_SUCCESS)
173: ipc_kmsg_destroy(kmsg);
174:
175: return msg_return_translate(mr);
176: }
177:
178: msg_return_t
179: msg_send(msg, option, time_out)
180: msg_header_t *msg;
181: msg_option_t option;
182: msg_timeout_t time_out;
183: {
184: ipc_space_t space = current_space();
185: vm_map_t map = current_map();
186: msg_size_t send_size = msg->msg_size;
187: ipc_kmsg_t kmsg;
188: integer_t send_delta = send_size;
189: mach_msg_return_t mr;
190:
191: send_size = (send_size + 3) & ~3; /* round up */
192: send_delta -= send_size;
193:
194: if (send_size > MSG_SIZE_MAX)
195: return SEND_MSG_TOO_LARGE;
196:
197: mr = ipc_kmsg_get_from_kernel((mach_msg_header_t *) msg,
198: MACH_MSG_OPTION_NONE,
199: (mach_msg_size_t) send_size,
200: send_delta,
201: &kmsg);
202: if (mr != MACH_MSG_SUCCESS)
203: return msg_return_translate(mr);
204:
205: mr = ipc_kmsg_copyin_compat(kmsg, space, map);
206: if (mr != MACH_MSG_SUCCESS) {
207: ikm_free(kmsg);
208: return msg_return_translate(mr);
209: }
210: if (option & SEND_NOTIFY) {
211: panic("msg_send notify");
212: } else
213: do {
214: if (option & SEND_SWITCH)
215: mr = ipc_mqueue_send(kmsg,
216: ((option & SEND_TIMEOUT) ?
217: MACH_SEND_TIMEOUT :
218: MACH_MSG_OPTION_NONE) |
219: MACH_SEND_SWITCH,
220: (mach_msg_timeout_t) time_out,
221: IMQ_NULL_CONTINUE);
222: else
223: mr = ipc_mqueue_send(kmsg,
224: ((option & SEND_TIMEOUT) ?
225: MACH_SEND_TIMEOUT :
226: MACH_MSG_OPTION_NONE),
227: (mach_msg_timeout_t) time_out,
228: IMQ_NULL_CONTINUE);
229: if (mr == MACH_SEND_INTERRUPTED) {
230: while (thread_should_halt(current_thread()))
231: thread_halt_self_with_continuation(
232: (void (*)(void)) 0);
233:
234: if (option & SEND_INTERRUPT)
235: break;
236: }
237: } while (mr == MACH_SEND_INTERRUPTED);
238:
239: if (mr != MACH_MSG_SUCCESS)
240: ipc_kmsg_destroy(kmsg);
241:
242: return msg_return_translate(mr);
243: }
244:
245: msg_return_t
246: msg_receive(msg, option, time_out)
247: msg_header_t *msg;
248: msg_option_t option;
249: msg_timeout_t time_out;
250: {
251: ipc_space_t space = current_space();
252: vm_map_t map = current_map();
253: port_name_t rcv_name = msg->msg_local_port;
254: msg_size_t rcv_size = msg->msg_size;
255: ipc_object_t object;
256: ipc_mqueue_t mqueue;
257: ipc_kmsg_t kmsg;
258: mach_port_seqno_t seqno;
259: mach_msg_return_t mr;
260:
261: do {
262: mr = ipc_mqueue_copyin(space, (mach_port_t) rcv_name,
263: &mqueue, &object);
264: if (mr != MACH_MSG_SUCCESS)
265: return msg_return_translate(mr);
266: /* hold ref for object; mqueue is locked */
267:
268: mr = ipc_mqueue_receive(mqueue,
269: ((option & RCV_TIMEOUT) ?
270: MACH_RCV_TIMEOUT :
271: MACH_MSG_OPTION_NONE) |
272: MACH_RCV_OLD_FORMAT,
273: (option & RCV_LARGE) ?
274: (mach_msg_size_t) rcv_size :
275: MACH_MSG_SIZE_MAX,
276: (mach_msg_timeout_t) time_out,
277: FALSE, IMQ_NULL_CONTINUE,
278: &kmsg, &seqno, 0);
279: /* mqueue is unlocked */
280: ipc_object_release(object);
281: if (mr == MACH_RCV_INTERRUPTED) {
282: while (thread_should_halt(current_thread()))
283: thread_halt_self_with_continuation(
284: (void (*)(void)) 0);
285:
286: if (option & RCV_INTERRUPT)
287: break;
288: }
289: } while (mr == MACH_RCV_INTERRUPTED);
290: if (mr != MACH_MSG_SUCCESS) {
291: if (mr == MACH_RCV_TOO_LARGE) {
292: msg_size_t real_size =
293: (msg_size_t) (mach_msg_size_t) kmsg;
294:
295: assert(real_size > rcv_size);
296:
297: msg->msg_size = real_size;
298: }
299:
300: return msg_return_translate(mr);
301: }
302:
303: if (kmsg->ikm_header.msgh_size > (mach_msg_size_t) rcv_size) {
304: assert(!(option & RCV_LARGE));
305:
306: ipc_kmsg_destroy(kmsg);
307: return msg_return_translate(MACH_RCV_TOO_LARGE);
308: }
309:
310: assert(kmsg->ikm_header.msgh_size <= (mach_msg_size_t) rcv_size);
311:
312: mr = ipc_kmsg_copyout_compat(kmsg, space, map);
313: assert(mr == MACH_MSG_SUCCESS);
314:
315: kmsg->ikm_header.msgh_size += kmsg->ikm_delta;
316: ipc_kmsg_put_to_kernel((mach_msg_header_t *) msg, kmsg,
317: kmsg->ikm_header.msgh_size);
318: return msg_return_translate(mr);
319: }
320:
321: msg_return_t
322: msg_rpc(msg, option, rcv_size, send_timeout, rcv_timeout)
323: msg_header_t *msg; /* in/out */
324: msg_option_t option;
325: msg_size_t rcv_size;
326: msg_timeout_t send_timeout;
327: msg_timeout_t rcv_timeout;
328: {
329: ipc_space_t space = current_space();
330: vm_map_t map = current_map();
331: msg_size_t send_size = msg->msg_size;
332: ipc_port_t reply;
333: ipc_pset_t pset;
334: ipc_mqueue_t mqueue;
335: ipc_kmsg_t kmsg;
336: integer_t send_delta = send_size;
337: mach_port_seqno_t seqno;
338: mach_msg_return_t mr;
339:
340: /*
341: * Instead of using msg_send and msg_receive,
342: * we implement msg_rpc directly. The difference
343: * is how the reply port is handled. Instead of using
344: * ipc_mqueue_copyin, we save a reference for the reply
345: * port carried in the sent message. For example,
346: * consider a rename kernel call which changes the name
347: * of the call's own reply port. This is the behaviour
348: * of the Mach 2.5 msg_rpc_trap.
349: */
350:
351: send_size = (send_size + 3) & ~3; /* round up */
352: send_delta -= send_size;
353:
354: if (send_size > MSG_SIZE_MAX)
355: return SEND_MSG_TOO_LARGE;
356:
357: mr = ipc_kmsg_get_from_kernel((mach_msg_header_t *) msg,
358: MACH_MSG_OPTION_NONE,
359: (mach_msg_size_t) send_size,
360: send_delta,
361: &kmsg);
362: if (mr != MACH_MSG_SUCCESS)
363: return msg_return_translate(mr);
364:
365: mr = ipc_kmsg_copyin_compat(kmsg, space, map);
366: if (mr != MACH_MSG_SUCCESS) {
367: ikm_free(kmsg);
368: return msg_return_translate(mr);
369: }
370:
371: reply = (ipc_port_t)kmsg->ikm_header.msgh_local_port;
372: if (IP_VALID(reply)) {
373: ipc_port_t dest = (ipc_port_t)
374: kmsg->ikm_header.msgh_remote_port;
375:
376: ipc_port_reference(reply);
377: assert(IP_VALID(dest));
378:
379: ip_lock(dest);
380:
381: if (dest->ip_receiver == ipc_space_kernel) {
382: ipc_mqueue_t mqueue;
383:
384: assert(ip_active(dest));
385: ip_unlock(dest);
386:
387: kmsg = ipc_kobject_server(kmsg);
388: if (kmsg == IKM_NULL)
389: goto receive_reply;
390:
391: ip_lock(reply);
392:
393: if ((!ip_active(reply)) ||
394: (reply->ip_receiver != space) ||
395: (reply->ip_pset != IPS_NULL) ||
396: (rcv_size < (kmsg->ikm_header.msgh_size +
397: kmsg->ikm_delta)))
398: {
399: ip_unlock(reply);
400: ipc_mqueue_send_always(kmsg);
401: goto receive_reply;
402: }
403:
404: mqueue = &reply->ip_messages;
405: imq_lock(mqueue);
406:
407: if ((ipc_thread_queue_first(&mqueue->imq_threads)
408: != ITH_NULL) ||
409: (ipc_kmsg_queue_first(&mqueue->imq_messages)
410: != IKM_NULL))
411: {
412: imq_unlock(mqueue);
413: ip_unlock(reply);
414: ipc_mqueue_send_always(kmsg);
415: goto receive_reply;
416: }
417:
418: assert(kmsg->ikm_marequest == IMAR_NULL);
419: assert(ipc_thread_queue_first(&reply->ip_blocked)
420: == ITH_NULL);
421:
422: reply->ip_seqno++;
423: imq_unlock(mqueue);
424:
425: ip_release(reply);
426: ip_unlock(reply);
427:
428: goto copyout_reply;
429: }
430:
431: ip_unlock(dest);
432: }
433:
434: if (option & SEND_NOTIFY) {
435: panic("msg_rpc notify");
436: } else
437: do {
438: if (option & SEND_SWITCH)
439: mr = ipc_mqueue_send(kmsg,
440: ((option & SEND_TIMEOUT) ?
441: MACH_SEND_TIMEOUT :
442: MACH_MSG_OPTION_NONE) |
443: MACH_SEND_SWITCH,
444: (mach_msg_timeout_t)
445: send_timeout,
446: IMQ_NULL_CONTINUE);
447: else
448: mr = ipc_mqueue_send(kmsg,
449: ((option & SEND_TIMEOUT) ?
450: MACH_SEND_TIMEOUT :
451: MACH_MSG_OPTION_NONE),
452: (mach_msg_timeout_t)
453: send_timeout,
454: IMQ_NULL_CONTINUE);
455: if (mr == MACH_SEND_INTERRUPTED) {
456: while (thread_should_halt(current_thread()))
457: thread_halt_self_with_continuation(
458: (void (*)(void)) 0);
459:
460: if (option & SEND_INTERRUPT)
461: break;
462: }
463: } while (mr == MACH_SEND_INTERRUPTED);
464:
465: if (mr != MACH_MSG_SUCCESS) {
466: ipc_kmsg_destroy(kmsg);
467: if (IP_VALID(reply))
468: ipc_port_release(reply);
469: return msg_return_translate(mr);
470: }
471:
472: receive_reply:
473: if (!IP_VALID(reply))
474: return RCV_INVALID_PORT;
475:
476: ip_lock(reply);
477: if (reply->ip_receiver != space) {
478: ip_release(reply);
479: ip_check_unlock(reply);
480: return RCV_INVALID_PORT;
481: }
482:
483: assert(ip_active(reply));
484: pset = reply->ip_pset;
485:
486: if (pset != IPS_NULL) {
487: ips_lock(pset);
488: if (ips_active(pset)) {
489: ips_unlock(pset);
490: ip_release(reply);
491: ip_unlock(reply);
492: return RCV_INVALID_PORT;
493: }
494:
495: ipc_pset_remove(pset, reply);
496: ips_check_unlock(pset);
497: assert(reply->ip_pset == IPS_NULL);
498: }
499:
500: mqueue = &reply->ip_messages;
501: imq_lock(mqueue);
502: ip_unlock(reply);
503:
504: mr = ipc_mqueue_receive(mqueue,
505: ((option & RCV_TIMEOUT) ?
506: MACH_RCV_TIMEOUT :
507: MACH_MSG_OPTION_NONE) |
508: MACH_RCV_OLD_FORMAT,
509: (option & RCV_LARGE) ?
510: (mach_msg_size_t) rcv_size :
511: MACH_MSG_SIZE_MAX,
512: (mach_msg_timeout_t) rcv_timeout,
513: FALSE, IMQ_NULL_CONTINUE,
514: &kmsg, &seqno, 0);
515: /* mqueue is unlocked */
516: ipc_port_release(reply);
517: if (mr != MACH_MSG_SUCCESS) {
518: if (mr == MACH_RCV_INTERRUPTED) {
519: while (thread_should_halt(current_thread()))
520: thread_halt_self_with_continuation(
521: (void (*)(void)) 0);
522:
523: msg->msg_size = rcv_size; /* XXX */
524:
525: if (!(option & RCV_INTERRUPT))
526: return msg_receive(msg, option, rcv_timeout);
527: } else if (mr == MACH_RCV_TOO_LARGE) {
528: msg_size_t real_size =
529: (msg_size_t) (mach_msg_size_t) kmsg;
530:
531: assert(real_size > rcv_size);
532:
533: msg->msg_size = real_size;
534: }
535:
536: return msg_return_translate(mr);
537: }
538:
539: if (kmsg->ikm_header.msgh_size > (mach_msg_size_t) rcv_size) {
540: assert(!(option & RCV_LARGE));
541:
542: ipc_kmsg_destroy(kmsg);
543: return msg_return_translate(MACH_RCV_TOO_LARGE);
544: }
545:
546: copyout_reply:
547: assert(kmsg->ikm_header.msgh_size <= (mach_msg_size_t) rcv_size);
548:
549: mr = ipc_kmsg_copyout_compat(kmsg, space, map);
550: assert(mr == MACH_MSG_SUCCESS);
551:
552: kmsg->ikm_header.msgh_size += kmsg->ikm_delta;
553: ipc_kmsg_put_to_kernel((mach_msg_header_t *) msg, kmsg,
554: kmsg->ikm_header.msgh_size);
555: return msg_return_translate(mr);
556:
557: }
558:
559: /*
560: * Routine: mig_get_reply_port
561: * Purpose:
562: * Called by client side interfaces living in the kernel
563: * to get a reply port. This port is used for
564: * mach_msg() calls which are kernel calls.
565: */
566:
567: mach_port_t
568: mig_get_reply_port()
569: {
570: ipc_thread_t self = current_thread();
571:
572: if (self->ith_mig_reply == MACH_PORT_NULL)
573: self->ith_mig_reply = mach_reply_port();
574:
575: return self->ith_mig_reply;
576: }
577:
578: /*
579: * Routine: mig_dealloc_reply_port
580: * Purpose:
581: * Called by client side interfaces to get rid of a reply port.
582: * Shouldn't ever be called inside the kernel, because
583: * kernel calls shouldn't prompt Mig to call it.
584: */
585:
586: void
587: mig_dealloc_reply_port()
588: {
589: panic("mig_dealloc_reply_port");
590: }
591:
592: /*
593: * mig_strncpy.c - by Joshua Block
594: *
595: * mig_strncp -- Bounded string copy. Does what the library routine strncpy
596: * OUGHT to do: Copies the (null terminated) string in src into dest, a
597: * buffer of length len. Assures that the copy is still null terminated
598: * and doesn't overflow the buffer, truncating the copy if necessary.
599: *
600: * Parameters:
601: *
602: * dest - Pointer to destination buffer.
603: *
604: * src - Pointer to source string.
605: *
606: * len - Length of destination buffer.
607: */
608: vm_size_t mig_strncpy(
609: char *dest,
610: const char *src,
611: vm_size_t len)
612: {
613: vm_size_t i;
614:
615: if (len <= 0)
616: return 0;
617:
618: for (i=1; i<len; i++)
619: if (! (*dest++ = *src++))
620: return i;
621:
622: *dest = '\0';
623: return i;
624: }
625:
626: #if 0
627:
628: #define fast_send_right_lookup(name, port, abort) \
629: MACRO_BEGIN \
630: register ipc_space_t space = current_space(); \
631: register ipc_entry_t entry; \
632: register mach_port_index_t index = MACH_PORT_INDEX(name); \
633: \
634: is_read_lock(space); \
635: assert(space->is_active); \
636: \
637: if ((index >= space->is_table_size) || \
638: (((entry = &space->is_table[index])->ie_bits & \
639: (IE_BITS_GEN_MASK|MACH_PORT_TYPE_SEND)) != \
640: (MACH_PORT_GEN(name) | MACH_PORT_TYPE_SEND))) { \
641: is_read_unlock(space); \
642: abort; \
643: } \
644: \
645: port = (ipc_port_t) entry->ie_object; \
646: assert(port != IP_NULL); \
647: \
648: ip_lock(port); \
649: /* can safely unlock space now that port is locked */ \
650: is_read_unlock(space); \
651: MACRO_END
652:
653: thread_t
654: port_name_to_thread(name)
655: mach_port_t name;
656: {
657: register ipc_port_t port;
658:
659: fast_send_right_lookup(name, port, goto abort);
660: /* port is locked */
661:
662: if (ip_active(port) &&
663: (ip_kotype(port) == IKOT_THREAD)) {
664: register thread_t thread;
665:
666: thread = (thread_t) port->ip_kobject;
667: assert(thread != THREAD_NULL);
668:
669: /* thread referencing is a bit complicated,
670: so don't bother to expand inline */
671: thread_reference(thread);
672: ip_unlock(port);
673:
674: return thread;
675: }
676:
677: ip_unlock(port);
678: return THREAD_NULL;
679:
680: abort: {
681: thread_t thread;
682: ipc_port_t kern_port;
683: kern_return_t kr;
684:
685: kr = ipc_object_copyin(current_space(), name,
686: MACH_MSG_TYPE_COPY_SEND,
687: (ipc_object_t *) &kern_port);
688: if (kr != KERN_SUCCESS)
689: return THREAD_NULL;
690:
691: thread = convert_port_to_thread(kern_port);
692: if (IP_VALID(kern_port))
693: ipc_port_release_send(kern_port);
694:
695: return thread;
696: }
697: }
698:
699: task_t
700: port_name_to_task(name)
701: mach_port_t name;
702: {
703: register ipc_port_t port;
704:
705: fast_send_right_lookup(name, port, goto abort);
706: /* port is locked */
707:
708: if (ip_active(port) &&
709: (ip_kotype(port) == IKOT_TASK)) {
710: register task_t task;
711:
712: task = (task_t) port->ip_kobject;
713: assert(task != TASK_NULL);
714:
715: task_lock(task);
716: /* can safely unlock port now that task is locked */
717: ip_unlock(port);
718:
719: task->ref_count++;
720: task_unlock(task);
721:
722: return task;
723: }
724:
725: ip_unlock(port);
726: return TASK_NULL;
727:
728: abort: {
729: task_t task;
730: ipc_port_t kern_port;
731: kern_return_t kr;
732:
733: kr = ipc_object_copyin(current_space(), name,
734: MACH_MSG_TYPE_COPY_SEND,
735: (ipc_object_t *) &kern_port);
736: if (kr != KERN_SUCCESS)
737: return TASK_NULL;
738:
739: task = convert_port_to_task(kern_port);
740: if (IP_VALID(kern_port))
741: ipc_port_release_send(kern_port);
742:
743: return task;
744: }
745: }
746:
747: vm_map_t
748: port_name_to_map(name)
749: mach_port_t name;
750: {
751: register ipc_port_t port;
752:
753: fast_send_right_lookup(name, port, goto abort);
754: /* port is locked */
755:
756: if (ip_active(port) &&
757: (ip_kotype(port) == IKOT_TASK)) {
758: register vm_map_t map;
759:
760: map = ((task_t) port->ip_kobject)->map;
761: assert(map != VM_MAP_NULL);
762:
763: simple_lock(&map->ref_lock);
764: /* can safely unlock port now that map is locked */
765: ip_unlock(port);
766:
767: map->ref_count++;
768: simple_unlock(&map->ref_lock);
769:
770: return map;
771: }
772:
773: ip_unlock(port);
774: return VM_MAP_NULL;
775:
776: abort: {
777: vm_map_t map;
778: ipc_port_t kern_port;
779: kern_return_t kr;
780:
781: kr = ipc_object_copyin(current_space(), name,
782: MACH_MSG_TYPE_COPY_SEND,
783: (ipc_object_t *) &kern_port);
784: if (kr != KERN_SUCCESS)
785: return VM_MAP_NULL;
786:
787: map = convert_port_to_map(kern_port);
788: if (IP_VALID(kern_port))
789: ipc_port_release_send(kern_port);
790:
791: return map;
792: }
793: }
794:
795: ipc_space_t
796: port_name_to_space(name)
797: mach_port_t name;
798: {
799: register ipc_port_t port;
800:
801: fast_send_right_lookup(name, port, goto abort);
802: /* port is locked */
803:
804: if (ip_active(port) &&
805: (ip_kotype(port) == IKOT_TASK)) {
806: register ipc_space_t space;
807:
808: space = ((task_t) port->ip_kobject)->itk_space;
809: assert(space != IS_NULL);
810:
811: simple_lock(&space->is_ref_lock_data);
812: /* can safely unlock port now that space is locked */
813: ip_unlock(port);
814:
815: space->is_references++;
816: simple_unlock(&space->is_ref_lock_data);
817:
818: return space;
819: }
820:
821: ip_unlock(port);
822: return IS_NULL;
823:
824: abort: {
825: ipc_space_t space;
826: ipc_port_t kern_port;
827: kern_return_t kr;
828:
829: kr = ipc_object_copyin(current_space(), name,
830: MACH_MSG_TYPE_COPY_SEND,
831: (ipc_object_t *) &kern_port);
832: if (kr != KERN_SUCCESS)
833: return IS_NULL;
834:
835: space = convert_port_to_space(kern_port);
836: if (IP_VALID(kern_port))
837: ipc_port_release_send(kern_port);
838:
839: return space;
840: }
841: }
842:
843: /*
844: * Hack to translate a thread port to a thread pointer for calling
845: * thread_get_state and thread_set_state. This is only necessary
846: * because the IPC message for these two operations overflows the
847: * kernel stack.
848: *
849: * AARGH!
850: */
851:
852: kern_return_t thread_get_state_KERNEL(thread_port, flavor,
853: old_state, old_state_count)
854: mach_port_t thread_port; /* port right for thread */
855: int flavor;
856: thread_state_t old_state; /* pointer to OUT array */
857: natural_t *old_state_count; /* IN/OUT */
858: {
859: thread_t thread;
860: kern_return_t result;
861:
862: thread = port_name_to_thread(thread_port);
863: result = thread_get_state(thread, flavor, old_state, old_state_count);
864: thread_deallocate(thread);
865:
866: return result;
867: }
868:
869: kern_return_t thread_set_state_KERNEL(thread_port, flavor,
870: new_state, new_state_count)
871: mach_port_t thread_port; /* port right for thread */
872: int flavor;
873: thread_state_t new_state;
874: natural_t new_state_count;
875: {
876: thread_t thread;
877: kern_return_t result;
878:
879: thread = port_name_to_thread(thread_port);
880: result = thread_set_state(thread, flavor, new_state, new_state_count);
881: thread_deallocate(thread);
882:
883: return result;
884: }
885:
886: /*
887: * Things to keep in mind:
888: *
889: * The idea here is to duplicate the semantics of the true kernel RPC.
890: * The destination port/object should be checked first, before anything
891: * that the user might notice (like ipc_object_copyin). Return
892: * MACH_SEND_INTERRUPTED if it isn't correct, so that the user stub
893: * knows to fall back on an RPC. For other return values, it won't
894: * retry with an RPC. The retry might get a different (incorrect) rc.
895: * Return values are only set (and should only be set, with copyout)
896: * on successfull calls.
897: */
898:
899: kern_return_t syscall_vm_map(
900: target_map,
901: address, size, mask, anywhere,
902: memory_object, offset,
903: copy,
904: cur_protection, max_protection, inheritance)
905: mach_port_t target_map;
906: vm_offset_t *address;
907: vm_size_t size;
908: vm_offset_t mask;
909: boolean_t anywhere;
910: mach_port_t memory_object;
911: vm_offset_t offset;
912: boolean_t copy;
913: vm_prot_t cur_protection;
914: vm_prot_t max_protection;
915: vm_inherit_t inheritance;
916: {
917: vm_map_t map;
918: ipc_port_t port;
919: vm_offset_t addr;
920: kern_return_t result;
921:
922: map = port_name_to_map(target_map);
923: if (map == VM_MAP_NULL)
924: return MACH_SEND_INTERRUPTED;
925:
926: if (MACH_PORT_VALID(memory_object)) {
927: result = ipc_object_copyin(current_space(), memory_object,
928: MACH_MSG_TYPE_COPY_SEND,
929: (ipc_object_t *) &port);
930: if (result != KERN_SUCCESS) {
931: vm_map_deallocate(map);
932: return result;
933: }
934: } else
935: port = (ipc_port_t) memory_object;
936:
937: copyin((char *)address, (char *)&addr, sizeof(vm_offset_t));
938: result = vm_map(map, &addr, size, mask, anywhere,
939: port, offset, copy,
940: cur_protection, max_protection, inheritance);
941: if (result == KERN_SUCCESS)
942: copyout((char *)&addr, (char *)address, sizeof(vm_offset_t));
943: if (IP_VALID(port))
944: ipc_port_release_send(port);
945: vm_map_deallocate(map);
946:
947: return result;
948: }
949:
950: kern_return_t syscall_vm_allocate(target_map, address, size, anywhere)
951: mach_port_t target_map;
952: vm_offset_t *address;
953: vm_size_t size;
954: boolean_t anywhere;
955: {
956: vm_map_t map;
957: vm_offset_t addr;
958: kern_return_t result;
959:
960: map = port_name_to_map(target_map);
961: if (map == VM_MAP_NULL)
962: return MACH_SEND_INTERRUPTED;
963:
964: copyin((char *)address, (char *)&addr, sizeof(vm_offset_t));
965: result = vm_allocate(map, &addr, size, anywhere);
966: if (result == KERN_SUCCESS)
967: copyout((char *)&addr, (char *)address, sizeof(vm_offset_t));
968: vm_map_deallocate(map);
969:
970: return result;
971: }
972:
973: kern_return_t syscall_vm_deallocate(target_map, start, size)
974: mach_port_t target_map;
975: vm_offset_t start;
976: vm_size_t size;
977: {
978: vm_map_t map;
979: kern_return_t result;
980:
981: map = port_name_to_map(target_map);
982: if (map == VM_MAP_NULL)
983: return MACH_SEND_INTERRUPTED;
984:
985: result = vm_deallocate(map, start, size);
986: vm_map_deallocate(map);
987:
988: return result;
989: }
990:
991: kern_return_t syscall_task_create(parent_task, inherit_memory, child_task)
992: mach_port_t parent_task;
993: boolean_t inherit_memory;
994: mach_port_t *child_task; /* OUT */
995: {
996: task_t t, c;
997: ipc_port_t port;
998: mach_port_t name;
999: kern_return_t result;
1000:
1001: t = port_name_to_task(parent_task);
1002: if (t == TASK_NULL)
1003: return MACH_SEND_INTERRUPTED;
1004:
1005: result = task_create(t, inherit_memory, &c);
1006: if (result == KERN_SUCCESS) {
1007: port = (ipc_port_t) convert_task_to_port(c);
1008: /* always returns a name, even for non-success return codes */
1009: (void) ipc_kmsg_copyout_object(current_space(),
1010: (ipc_object_t) port,
1011: MACH_MSG_TYPE_PORT_SEND, &name);
1012: copyout((char *)&name, (char *)child_task,
1013: sizeof(mach_port_t));
1014: }
1015: task_deallocate(t);
1016:
1017: return result;
1018: }
1019:
1020: kern_return_t syscall_task_terminate(task)
1021: mach_port_t task;
1022: {
1023: task_t t;
1024: kern_return_t result;
1025:
1026: t = port_name_to_task(task);
1027: if (t == TASK_NULL)
1028: return MACH_SEND_INTERRUPTED;
1029:
1030: result = task_terminate(t);
1031: task_deallocate(t);
1032:
1033: return result;
1034: }
1035:
1036: kern_return_t syscall_task_suspend(task)
1037: mach_port_t task;
1038: {
1039: task_t t;
1040: kern_return_t result;
1041:
1042: t = port_name_to_task(task);
1043: if (t == TASK_NULL)
1044: return MACH_SEND_INTERRUPTED;
1045:
1046: result = task_suspend(t);
1047: task_deallocate(t);
1048:
1049: return result;
1050: }
1051:
1052: kern_return_t syscall_task_set_special_port(task, which_port, port_name)
1053: mach_port_t task;
1054: int which_port;
1055: mach_port_t port_name;
1056: {
1057: task_t t;
1058: ipc_port_t port;
1059: kern_return_t result;
1060:
1061: t = port_name_to_task(task);
1062: if (t == TASK_NULL)
1063: return MACH_SEND_INTERRUPTED;
1064:
1065: if (MACH_PORT_VALID(port_name)) {
1066: result = ipc_object_copyin(current_space(), port_name,
1067: MACH_MSG_TYPE_COPY_SEND,
1068: (ipc_object_t *) &port);
1069: if (result != KERN_SUCCESS) {
1070: task_deallocate(t);
1071: return result;
1072: }
1073: } else
1074: port = (ipc_port_t) port_name;
1075:
1076: result = task_set_special_port(t, which_port, port);
1077: if ((result != KERN_SUCCESS) && IP_VALID(port))
1078: ipc_port_release_send(port);
1079: task_deallocate(t);
1080:
1081: return result;
1082: }
1083:
1084: kern_return_t
1085: syscall_mach_port_allocate(task, right, namep)
1086: mach_port_t task;
1087: mach_port_right_t right;
1088: mach_port_t *namep;
1089: {
1090: ipc_space_t space;
1091: mach_port_t name;
1092: kern_return_t kr;
1093:
1094: space = port_name_to_space(task);
1095: if (space == IS_NULL)
1096: return MACH_SEND_INTERRUPTED;
1097:
1098: kr = mach_port_allocate(space, right, &name);
1099: if (kr == KERN_SUCCESS)
1100: copyout((char *)&name, (char *)namep, sizeof(mach_port_t));
1101: is_release(space);
1102:
1103: return kr;
1104: }
1105:
1106: kern_return_t
1107: syscall_mach_port_allocate_name(task, right, name)
1108: mach_port_t task;
1109: mach_port_right_t right;
1110: mach_port_t name;
1111: {
1112: ipc_space_t space;
1113: kern_return_t kr;
1114:
1115: space = port_name_to_space(task);
1116: if (space == IS_NULL)
1117: return MACH_SEND_INTERRUPTED;
1118:
1119: kr = mach_port_allocate_name(space, right, name);
1120: is_release(space);
1121:
1122: return kr;
1123: }
1124:
1125: kern_return_t
1126: syscall_mach_port_deallocate(task, name)
1127: mach_port_t task;
1128: mach_port_t name;
1129: {
1130: ipc_space_t space;
1131: kern_return_t kr;
1132:
1133: space = port_name_to_space(task);
1134: if (space == IS_NULL)
1135: return MACH_SEND_INTERRUPTED;
1136:
1137: kr = mach_port_deallocate(space, name);
1138: is_release(space);
1139:
1140: return kr;
1141: }
1142:
1143: kern_return_t
1144: syscall_mach_port_insert_right(task, name, right, rightType)
1145: mach_port_t task;
1146: mach_port_t name;
1147: mach_port_t right;
1148: mach_msg_type_name_t rightType;
1149: {
1150: ipc_space_t space;
1151: ipc_object_t object;
1152: mach_msg_type_name_t newtype;
1153: kern_return_t kr;
1154:
1155: space = port_name_to_space(task);
1156: if (space == IS_NULL)
1157: return MACH_SEND_INTERRUPTED;
1158:
1159: if (!MACH_MSG_TYPE_PORT_ANY(rightType)) {
1160: is_release(space);
1161: return KERN_INVALID_VALUE;
1162: }
1163:
1164: if (MACH_PORT_VALID(right)) {
1165: kr = ipc_object_copyin(current_space(), right, rightType,
1166: &object);
1167: if (kr != KERN_SUCCESS) {
1168: is_release(space);
1169: return kr;
1170: }
1171: } else
1172: object = (ipc_object_t) right;
1173: newtype = ipc_object_copyin_type(rightType);
1174:
1175: kr = mach_port_insert_right(space, name, object, newtype);
1176: if ((kr != KERN_SUCCESS) && IO_VALID(object))
1177: ipc_object_destroy(object, newtype);
1178: is_release(space);
1179:
1180: return kr;
1181: }
1182:
1183: kern_return_t syscall_thread_depress_abort(thread)
1184: mach_port_t thread;
1185: {
1186: thread_t t;
1187: kern_return_t result;
1188:
1189: t = port_name_to_thread(thread);
1190: if (t == THREAD_NULL)
1191: return MACH_SEND_INTERRUPTED;
1192:
1193: result = thread_depress_abort(t);
1194: thread_deallocate(t);
1195:
1196: return result;
1197: }
1198:
1199: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.