![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ipc_kobject.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / osfmk / kern|
Return to ipc_kobject.c CVS log | Up to [Apple XNU] / XNU / osfmk / kern |
1.1 root 1: /*
2: * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * The contents of this file constitute Original Code as defined in and
7: * are subject to the Apple Public Source License Version 1.1 (the
8: * "License"). You may not use this file except in compliance with the
9: * License. Please obtain a copy of the License at
10: * http://www.apple.com/publicsource and read it before using this file.
11: *
12: * This Original Code and all software distributed under the License are
13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
17: * License for the specific language governing rights and limitations
18: * under the License.
19: *
20: * @APPLE_LICENSE_HEADER_END@
21: */
22: /*
23: * @OSF_COPYRIGHT@
24: */
25: /*
26: * Mach Operating System
27: * Copyright (c) 1991,1990,1989 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: */
52: /*
53: * File: kern/ipc_kobject.c
54: * Author: Rich Draves
55: * Date: 1989
56: *
57: * Functions for letting a port represent a kernel object.
58: */
59:
60: #include <mach_debug.h>
61: #include <mach_ipc_test.h>
62: #include <mach_machine_routines.h>
63: #include <norma_task.h>
64: #include <dipc.h>
65: #include <mach_rt.h>
66: #include <platforms.h>
67: #include <xk_proxy.h>
68:
69: #include <kern/ast.h>
70: #include <mach/port.h>
71: #include <mach/kern_return.h>
72: #include <mach/message.h>
73: #include <mach/mig_errors.h>
74: #include <mach/notify.h>
75: #include <kern/etap_macros.h>
76: #include <kern/ipc_mig.h>
77: #include <kern/ipc_kobject.h>
78: #include <kern/misc_protos.h>
79: #include <ipc/ipc_object.h>
80: #include <ipc/ipc_kmsg.h>
81: #include <ipc/ipc_port.h>
82: #include <kern/counters.h>
83:
84:
85: void
86: def_pager_hash_insert(
87: ipc_port_t name_port);
88: void pager_mux_hash_insert(
89: ipc_port_t port,
90: rpc_subsystem_t rec);
91: void pager_mux_hash_delete(
92: ipc_port_t port);
93: rpc_subsystem_t pager_mux_hash_lookup(
94: ipc_port_t port);
95:
96:
97: /*
98: * Routine: ipc_kobject_notify
99: * Purpose:
100: * Deliver notifications to kobjects that care about them.
101: */
102: boolean_t
103: ipc_kobject_notify(
104: mach_msg_header_t *request_header,
105: mach_msg_header_t *reply_header);
106:
107: #include <mach/ndr.h>
108:
109: typedef struct {
110: mach_msg_id_t num;
111: mig_routine_t routine;
112: int size;
113: #if MACH_COUNTERS
114: mach_counter_t callcount;
115: #endif
116: } mig_hash_t;
117:
118: #define MAX_MIG_ENTRIES 1024
119: #define MIG_HASH(x) (x)
120:
121: #ifndef max
122: #define max(a,b) (((a) > (b)) ? (a) : (b))
123: #endif /* max */
124:
125: mig_hash_t mig_buckets[MAX_MIG_ENTRIES];
126: int mig_table_max_displ;
127: mach_msg_size_t mig_reply_size;
128:
129:
130: #include <mach/mach_port_server.h>
131: #include <mach/mach_host_server.h>
132: #include <mach/host_priv_server.h>
133: #include <mach/host_security_server.h>
134: #include <mach/clock_server.h>
135: #include <mach/clock_priv_server.h>
136: #include <mach/bootstrap_server.h>
137: #include <mach/ledger_server.h>
138: #include <mach/lock_set_server.h>
139: #include <mach/semaphore_server.h>
140: #include <default_pager/default_pager_object_server.h>
141: #include <mach/memory_object_server.h>
142: #include <mach/memory_object_control_server.h>
143: #include <mach/memory_object_default_server.h>
144: #include <mach/memory_object_name_server.h>
145: #include <mach/processor_server.h>
146: #include <mach/processor_set_server.h>
147: #include <mach/task_server.h>
148: #include <mach/vm_task_server.h>
149: #include <mach/thread_act_server.h>
150: #include <device/device_server.h>
151:
152: #if MACH_MACHINE_ROUTINES
153: #include <machine/machine_routines.h>
154: #endif /* MACH_MACHINE_ROUTINES */
155: #if XK_PROXY
156: #include <uk_xkern/xk_uproxy_server.h>
157: #endif /* XK_PROXY */
158:
159:
160: rpc_subsystem_t mig_e[] = {
161: (rpc_subsystem_t)&mach_port_subsystem,
162: (rpc_subsystem_t)&mach_host_subsystem,
163: (rpc_subsystem_t)&host_priv_subsystem,
164: (rpc_subsystem_t)&host_security_subsystem,
165: (rpc_subsystem_t)&clock_subsystem,
166: (rpc_subsystem_t)&clock_priv_subsystem,
167: (rpc_subsystem_t)&processor_subsystem,
168: (rpc_subsystem_t)&processor_set_subsystem,
169: (rpc_subsystem_t)&do_bootstrap_subsystem,
170: (rpc_subsystem_t)&is_iokit_subsystem,
171: (rpc_subsystem_t)&dp_memory_object_subsystem,
172: (rpc_subsystem_t)&dp_memory_object_default_subsystem,
173: (rpc_subsystem_t)&memory_object_name_subsystem,
174: (rpc_subsystem_t)&default_pager_object_subsystem,
175: (rpc_subsystem_t)&semaphore_subsystem,
176: (rpc_subsystem_t)&lock_set_subsystem,
177: (rpc_subsystem_t)&ledger_subsystem,
178: (rpc_subsystem_t)&task_subsystem,
179: (rpc_subsystem_t)&thread_act_subsystem,
180: (rpc_subsystem_t)&vm_task_subsystem,
181:
182: #if XK_PROXY
183: (rpc_subsystem_t)&do_uproxy_xk_uproxy_subsystem,
184: #endif /* XK_PROXY */
185: #if MACH_MACHINE_ROUTINES
186: (rpc_subsystem_t)&MACHINE_SUBSYSTEM,
187: #endif /* MACH_MACHINE_ROUTINES */
188: #if MCMSG && iPSC860
189: (rpc_subsystem_t)&mcmsg_info_subsystem,
190: #endif /* MCMSG && iPSC860 */
191: };
192:
193: void
194: mig_init(void)
195: {
196: register unsigned int i, n = sizeof(mig_e)/sizeof(rpc_subsystem_t);
197: register unsigned int howmany;
198: register mach_msg_id_t j, pos, nentry, range;
199:
200: for (i = 0; i < n; i++) {
201: range = mig_e[i]->end - mig_e[i]->start;
202: if (!mig_e[i]->start || range < 0)
203: panic("the msgh_ids in mig_e[] aren't valid!");
204: mig_reply_size = max(mig_reply_size, mig_e[i]->maxsize);
205:
206: for (j = 0; j < range; j++) {
207: if (mig_e[i]->routine[j].stub_routine) {
208: /* Only put real entries in the table */
209: nentry = j + mig_e[i]->start;
210: for (pos = MIG_HASH(nentry) % MAX_MIG_ENTRIES, howmany = 1;
211: mig_buckets[pos].num;
212: pos = ++pos % MAX_MIG_ENTRIES, howmany++) {
213: if (mig_buckets[pos].num == nentry) {
214: printf("message id = %d\n", nentry);
215: panic("multiple entries with the same msgh_id");
216: }
217: if (howmany == MAX_MIG_ENTRIES)
218: panic("the mig dispatch table is too small");
219: }
220:
221: mig_buckets[pos].num = nentry;
222: mig_buckets[pos].routine = mig_e[i]->routine[j].stub_routine;
223: if (mig_e[i]->routine[j].max_reply_msg)
224: mig_buckets[pos].size = mig_e[i]->routine[j].max_reply_msg;
225: else
226: mig_buckets[pos].size = mig_e[i]->maxsize;
227:
228: mig_table_max_displ = max(howmany, mig_table_max_displ);
229: }
230: }
231: }
232: }
233:
234:
235: #define PAGER_MUX_HASH_COUNT 127
236:
237:
238: struct pager_mux_entry {
239: queue_chain_t links;
240: ipc_port_t name;
241: rpc_subsystem_t pager_object;
242: };
243: typedef struct pager_mux_entry *pager_mux_entry_t;
244:
245: queue_head_t pager_mux_hashtable[PAGER_MUX_HASH_COUNT];
246: zone_t pager_mux_hash_zone;
247:
248: decl_mutex_data(,pager_mux_hash_lock)
249:
250: #define pager_mux_hash(name_port) \
251: (((natural_t)(name_port) & 0xffffff) % PAGER_MUX_HASH_COUNT)
252:
253:
254: rpc_subsystem_t
255: pager_mux_hash_lookup(
256: ipc_port_t name_port)
257: {
258: register queue_t bucket;
259: register pager_mux_entry_t entry;
260: register rpc_subsystem_t pager_object;
261:
262: bucket = &pager_mux_hashtable[pager_mux_hash(name_port)];
263:
264: mutex_lock(&pager_mux_hash_lock);
265: for (entry = (pager_mux_entry_t)queue_first(bucket);
266: !queue_end(bucket, &entry->links);
267: entry = (pager_mux_entry_t)queue_next(&entry->links)) {
268: if (entry->name == name_port) {
269: pager_object = entry->pager_object;
270: /* don't need to reference the object, it can't disappear */
271: /* pager_mux_reference(pager_object); */
272: mutex_unlock(&pager_mux_hash_lock);
273: return (pager_object);
274: }
275: }
276: mutex_unlock(&pager_mux_hash_lock);
277: return (rpc_subsystem_t)0;
278: }
279:
280:
281: void
282: pager_mux_hash_init(void)
283: {
284: register int i;
285: register vm_size_t size;
286:
287: size = sizeof(struct pager_mux_entry);
288: pager_mux_hash_zone = zinit(
289: size,
290: size * 2000,
291: PAGE_SIZE,
292: "pager mux port hash");
293: for (i = 0; i < PAGER_MUX_HASH_COUNT; i++)
294: queue_init(&pager_mux_hashtable[i]);
295: mutex_init(&pager_mux_hash_lock, ETAP_IO_DEV_PAGEH);
296: }
297:
298:
299: void
300: pager_mux_hash_insert(
301: ipc_port_t name_port,
302: rpc_subsystem_t pager_object)
303: {
304: register pager_mux_entry_t new_entry;
305:
306: new_entry = (pager_mux_entry_t) zalloc(pager_mux_hash_zone);
307: new_entry->links.prev = (queue_entry_t) 0;
308: new_entry->links.next = (queue_entry_t) 0;
309: new_entry->name = name_port;
310: new_entry->pager_object = pager_object;
311:
312: mutex_lock(&pager_mux_hash_lock);
313: queue_enter((&pager_mux_hashtable[pager_mux_hash(name_port)]),
314: new_entry, pager_mux_entry_t, links);
315: mutex_unlock(&pager_mux_hash_lock);
316: }
317:
318: void
319: pager_mux_hash_delete(
320: ipc_port_t name_port)
321: {
322: register queue_t bucket;
323: register pager_mux_entry_t entry;
324:
325: bucket = &pager_mux_hashtable[pager_mux_hash(name_port)];
326:
327: mutex_lock(&pager_mux_hash_lock);
328: for (entry = (pager_mux_entry_t)queue_first(bucket);
329: !queue_end(bucket, &entry->links);
330: entry = (pager_mux_entry_t)queue_next(&entry->links)) {
331: if (entry->name == name_port) {
332: queue_remove(bucket, entry, pager_mux_entry_t, links);
333: zfree(pager_mux_hash_zone, (vm_offset_t)entry);
334: break;
335: }
336: }
337: mutex_unlock(&pager_mux_hash_lock);
338: }
339:
340:
341: /*
342: * Routine: ipc_kobject_server
343: * Purpose:
344: * Handle a message sent to the kernel.
345: * Generates a reply message.
346: * Version for Untyped IPC.
347: * Conditions:
348: * Nothing locked.
349: */
350:
351: ipc_kmsg_t
352: ipc_kobject_server(
353: ipc_kmsg_t request)
354: {
355: mach_msg_size_t reply_size;
356: ipc_kmsg_t reply;
357: kern_return_t kr;
358: mig_routine_t routine;
359: ipc_port_t *destp;
360: mach_msg_format_0_trailer_t *trailer;
361: register mig_hash_t *ptr;
362: #if MACH_RT
363: boolean_t reply_rt;
364: #endif /* MACH_RT */
365: unsigned int th;
366:
367: /* Only fetch current thread if ETAP is configured */
368: ETAP_DATA_LOAD(th, current_thread());
369: ETAP_PROBE_DATA(ETAP_P_SYSCALL_MACH,
370: EVENT_BEGIN,
371: ((thread_t) th),
372: &request->ikm_header.msgh_id,
373: sizeof(int));
374: /*
375: * Find out corresponding mig_hash entry if any
376: */
377: {
378: register int key = request->ikm_header.msgh_id;
379: register int i = MIG_HASH(key);
380: register int max_iter = mig_table_max_displ;
381:
382: do
383: ptr = &mig_buckets[i++ % MAX_MIG_ENTRIES];
384: while (key != ptr->num && ptr->num && --max_iter);
385:
386: if (!ptr->routine || key != ptr->num) {
387: ptr = (mig_hash_t *)0;
388: reply_size = mig_reply_size;
389: } else {
390: reply_size = ptr->size;
391: #if MACH_COUNTER
392: ptr->callcount++;
393: #endif
394: }
395: }
396:
397: /* round up for ikm_cache; overhead is added by ikm_alloc */
398: if ((reply_size += MAX_TRAILER_SIZE) < IKM_SAVED_MSG_SIZE)
399: reply_size = IKM_SAVED_MSG_SIZE;
400:
401: #if MACH_RT
402: reply_rt =
403: IP_VALID((ipc_port_t)request->ikm_header.msgh_local_port) ?
404: IP_RT((ipc_port_t)request->ikm_header.msgh_local_port) :
405: FALSE;
406:
407: if (reply_rt)
408: reply = ikm_rtalloc(reply_size);
409: else
410: #endif /* MACH_RT */
411: reply = ikm_alloc(reply_size);
412:
413: if (reply == IKM_NULL) {
414: printf("ipc_kobject_server: dropping request\n");
415: ipc_kmsg_destroy(request);
416: return IKM_NULL;
417: }
418:
419: ikm_init(reply, reply_size);
420: #if DIPC
421: reply->ikm_handle = HANDLE_NULL;
422: #endif /* DIPC */
423:
424: /*
425: * Initialize reply message.
426: */
427: {
428: #define InP ((mach_msg_header_t *) &request->ikm_header)
429: #define OutP ((mig_reply_error_t *) &reply->ikm_header)
430:
431: OutP->NDR = NDR_record;
432: OutP->Head.msgh_size = sizeof(mig_reply_error_t);
433:
434: OutP->Head.msgh_bits =
435: MACH_MSGH_BITS(MACH_MSGH_BITS_LOCAL(InP->msgh_bits), 0);
436: OutP->Head.msgh_remote_port = InP->msgh_local_port;
437: OutP->Head.msgh_local_port = MACH_PORT_NULL;
438: OutP->Head.msgh_id = InP->msgh_id + 100;
439: #if MACH_RT
440: if (reply_rt)
441: KMSG_MARK_RT(reply);
442: #endif /* MACH_RT */
443: #undef InP
444: #undef OutP
445: }
446:
447: /*
448: * Find the routine to call, and call it
449: * to perform the kernel function
450: */
451: {
452: if (ptr) {
453: (*ptr->routine)(&request->ikm_header, &reply->ikm_header);
454: kernel_task->messages_received++;
455: }
456: else {
457: if (!ipc_kobject_notify(&request->ikm_header, &reply->ikm_header)){
458: #if MACH_IPC_TEST
459: printf("ipc_kobject_server: bogus kernel message, id=%d\n",
460: request->ikm_header.msgh_id);
461: #endif /* MACH_IPC_TEST */
462: _MIG_MSGID_INVALID(request->ikm_header.msgh_id);
463:
464: ((mig_reply_error_t *) &reply->ikm_header)->RetCode
465: = MIG_BAD_ID;
466: }
467: else
468: kernel_task->messages_received++;
469: }
470: kernel_task->messages_sent++;
471: }
472:
473: /*
474: * Destroy destination. The following code differs from
475: * ipc_object_destroy in that we release the send-once
476: * right instead of generating a send-once notification
477: * (which would bring us here again, creating a loop).
478: * It also differs in that we only expect send or
479: * send-once rights, never receive rights.
480: *
481: * We set msgh_remote_port to IP_NULL so that the kmsg
482: * destroy routines don't try to destroy the port twice.
483: */
484: destp = (ipc_port_t *) &request->ikm_header.msgh_remote_port;
485: switch (MACH_MSGH_BITS_REMOTE(request->ikm_header.msgh_bits)) {
486: case MACH_MSG_TYPE_PORT_SEND:
487: ipc_port_release_send(*destp);
488: break;
489:
490: case MACH_MSG_TYPE_PORT_SEND_ONCE:
491: ipc_port_release_sonce(*destp);
492: break;
493:
494: default:
495: panic("ipc_object_destroy: strange destination rights");
496: }
497: *destp = IP_NULL;
498:
499: if (!(reply->ikm_header.msgh_bits & MACH_MSGH_BITS_COMPLEX) &&
500: ((mig_reply_error_t *) &reply->ikm_header)->RetCode != KERN_SUCCESS)
501: kr = ((mig_reply_error_t *) &reply->ikm_header)->RetCode;
502: else
503: kr = KERN_SUCCESS;
504:
505: if ((kr == KERN_SUCCESS) || (kr == MIG_NO_REPLY)) {
506: /*
507: * The server function is responsible for the contents
508: * of the message. The reply port right is moved
509: * to the reply message, and we have deallocated
510: * the destination port right, so we just need
511: * to free the kmsg.
512: */
513:
514: /*
515: * Like ipc_kmsg_put, but without the copyout. Also,
516: * messages to the kernel will never have been allocated
517: * from the rt_zone.
518: */
519:
520: ikm_check_initialized(request, request->ikm_size);
521: if (request->ikm_size != IKM_SAVED_KMSG_SIZE ||
522: !ikm_cache_put (request)) {
523: ikm_free(request);
524: }
525: } else {
526: /*
527: * The message contents of the request are intact.
528: * Destroy everthing except the reply port right,
529: * which is needed in the reply message.
530: */
531:
532: request->ikm_header.msgh_local_port = MACH_PORT_NULL;
533: ipc_kmsg_destroy(request);
534: }
535:
536: if (kr == MIG_NO_REPLY) {
537: /*
538: * The server function will send a reply message
539: * using the reply port right, which it has saved.
540: */
541:
542: ikm_free(reply);
543:
544: ETAP_PROBE_DATA(ETAP_P_SYSCALL_MACH,
545: EVENT_END,
546: ((thread_t) th),
547: &request->ikm_header.msgh_id,
548: sizeof(int));
549:
550: return IKM_NULL;
551: } else if (!IP_VALID((ipc_port_t)reply->ikm_header.msgh_remote_port)) {
552: /*
553: * Can't queue the reply message if the destination
554: * (the reply port) isn't valid.
555: */
556:
557: ipc_kmsg_destroy(reply);
558:
559: ETAP_PROBE_DATA(ETAP_P_SYSCALL_MACH,
560: EVENT_END,
561: ((thread_t) th),
562: &request->ikm_header.msgh_id,
563: sizeof(int));
564:
565: return IKM_NULL;
566: }
567:
568: trailer = (mach_msg_format_0_trailer_t *)
569: ((vm_offset_t)&reply->ikm_header + (int)reply->ikm_header.msgh_size);
570: trailer->msgh_sender = KERNEL_SECURITY_TOKEN;
571: trailer->msgh_trailer_type = MACH_MSG_TRAILER_FORMAT_0;
572: trailer->msgh_trailer_size = MACH_MSG_TRAILER_MINIMUM_SIZE;
573:
574: ETAP_PROBE_DATA(ETAP_P_SYSCALL_MACH,
575: EVENT_END,
576: ((thread_t) th),
577: &request->ikm_header.msgh_id,
578: sizeof(int));
579:
580: return reply;
581: }
582:
583: /*
584: * Routine: ipc_kobject_set
585: * Purpose:
586: * Make a port represent a kernel object of the given type.
587: * The caller is responsible for handling refs for the
588: * kernel object, if necessary.
589: * Conditions:
590: * Nothing locked. The port must be active.
591: */
592:
593: void
594: ipc_kobject_set(
595: ipc_port_t port,
596: ipc_kobject_t kobject,
597: ipc_kobject_type_t type)
598: {
599: ip_lock(port);
600: assert(ip_active(port));
601: #if MACH_ASSERT
602: port->ip_spares[2] = (port->ip_bits & IO_BITS_KOTYPE);
603: #endif /* MACH_ASSERT */
604: port->ip_bits = (port->ip_bits &~ IO_BITS_KOTYPE) | type;
605: port->ip_kobject = kobject;
606: ip_unlock(port);
607: }
608:
609: /*
610: * Routine: ipc_kobject_destroy
611: * Purpose:
612: * Release any kernel object resources associated
613: * with the port, which is being destroyed.
614: *
615: * This should only be needed when resources are
616: * associated with a user's port. In the normal case,
617: * when the kernel is the receiver, the code calling
618: * ipc_port_dealloc_kernel should clean up the resources.
619: * Conditions:
620: * The port is not locked, but it is dead.
621: */
622:
623: void
624: ipc_kobject_destroy(
625: ipc_port_t port)
626: {
627: switch (ip_kotype(port)) {
628: case IKOT_NAMED_ENTRY:
629: mach_destroy_memory_entry(port);
630: return;
631: case IKOT_UPL:
632: mach_destroy_upl(port);
633: return;
634: default:
635: vm_object_destroy(port);
636: }
637: }
638:
639:
640: extern int vnode_pager_workaround;
641:
642: boolean_t
643: ipc_kobject_notify(
644: mach_msg_header_t *request_header,
645: mach_msg_header_t *reply_header)
646: {
647: ipc_port_t port = (ipc_port_t) request_header->msgh_remote_port;
648: rpc_subsystem_t paging_subsystem_object;
649: mach_port_seqno_t seqno;
650:
651: ((mig_reply_error_t *) reply_header)->RetCode = MIG_NO_REPLY;
652: switch (request_header->msgh_id) {
653: case MACH_NOTIFY_NO_SENDERS:
654: if(ip_kotype(port) == IKOT_NAMED_ENTRY) {
655: ip_lock(port);
656:
657: /*
658: * Bring the sequence number and mscount in
659: * line with ipc_port_destroy assertion.
660: */
661: port->ip_mscount = 0;
662: port->ip_messages.imq_seqno = 0;
663: ipc_port_destroy(port); /* releases lock */
664: return TRUE;
665: }
666: paging_subsystem_object = pager_mux_hash_lookup(
667: (ipc_port_t)request_header->msgh_remote_port);
668: if(paging_subsystem_object == (rpc_subsystem_t)
669: &dp_memory_object_subsystem) {
670: default_pager_no_senders(
671: (ipc_port_t)request_header->msgh_remote_port,
672: seqno,
673: (mach_port_mscount_t)
674: ((mach_no_senders_notification_t *)
675: request_header)->not_count);
676: (ipc_port_t)reply_header->msgh_remote_port
677: = MACH_PORT_NULL;
678: return TRUE;
679: }
680: if(paging_subsystem_object == (rpc_subsystem_t)
681: &vnode_pager_workaround) {
682: vnode_pager_no_senders(
683: (ipc_port_t)request_header->msgh_remote_port,
684: (mach_port_mscount_t)
685: ((mach_no_senders_notification_t *)
686: request_header)->not_count);
687: (ipc_port_t)reply_header->msgh_remote_port
688: = MACH_PORT_NULL;
689: return TRUE;
690: }
691: break;
692: case MACH_NOTIFY_PORT_DELETED:
693: case MACH_NOTIFY_PORT_DESTROYED:
694: case MACH_NOTIFY_SEND_ONCE:
695: case MACH_NOTIFY_DEAD_NAME:
696: break;
697:
698: default:
699: return FALSE;
700: }
701: switch (ip_kotype(port)) {
702:
703: #ifdef IOKIT
704: case IKOT_IOKIT_OBJECT:
705: case IKOT_IOKIT_CONNECT:
706: case IKOT_IOKIT_SPARE:
707: {
708: extern boolean_t iokit_notify( mach_msg_header_t *msg);
709:
710: return iokit_notify(request_header);
711: }
712: #endif
713: default:
714: return FALSE;
715: }
716: }
717:
718:
719:
720: #include <mach_kdb.h>
721: #if MACH_COUNTERS && MACH_KDB
722:
723: #include <ddb/db_output.h>
724: #include <ddb/db_sym.h>
725:
726: #define printf kdbprintf
727:
728: extern void kobjserver_stats(void);
729: extern void bucket_stats_print(mig_hash_t *bucket);
730:
731: extern void kobjserver_stats_clear(void);
732:
733:
734: void
735: kobjserver_stats_clear(void)
736: {
737: int i;
738: for (i = 0; i < MAX_MIG_ENTRIES; i++) {
739: mig_buckets[i].callcount = 0;
740: }
741: }
742:
743: void
744: kobjserver_stats(void)
745: {
746: register unsigned int i, n = sizeof(mig_e)/sizeof(rpc_subsystem_t);
747: register unsigned int howmany;
748: register mach_msg_id_t j, pos, nentry, range;
749:
750: db_printf("Kobject server call counts:\n");
751: for (i = 0; i < n; i++) {
752: db_printf(" ");
753: db_printsym((vm_offset_t)mig_e[i], DB_STGY_ANY);
754: db_printf(":\n");
755: range = mig_e[i]->end - mig_e[i]->start;
756: if (!mig_e[i]->start || range < 0) continue;
757:
758: for (j = 0; j < range; j++) {
759: nentry = j + mig_e[i]->start;
760: for (pos = MIG_HASH(nentry) % MAX_MIG_ENTRIES, howmany = 1;
761: mig_buckets[pos].num;
762: pos = ++pos % MAX_MIG_ENTRIES, howmany++) {
763: if (mig_buckets[pos].num == nentry)
764: bucket_stats_print(&mig_buckets[pos]);
765: }
766: }
767: }
768: }
769:
770: void
771: bucket_stats_print(mig_hash_t *bucket)
772: {
773: if (bucket->callcount) {
774: db_printf(" ");
775: db_printsym((vm_offset_t)bucket->routine, DB_STGY_ANY);
776: db_printf(" (%d):\t%d\n", bucket->num, bucket->callcount);
777: }
778: }
779:
780:
781: #endif /* MACH_COUNTERS && MACH_KDB */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.