![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to kern_server.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / kernel / kernserv|
Return to kern_server.c CVS log | Up to [Apple Darwin 0.x] / kernel / kernserv |
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: * Copyright (c) 1989 NeXT, Inc. ! 27: * ! 28: * HISTORY ! 29: * 4-Jun-91 Gregg Kellogg (gk) at NeXT ! 30: * Abort server_thread before calling thread_dowait when trying to ! 31: * service callouts. ! 32: * ! 33: * 27-Aug-90 Gregg Kellogg (gk) at NeXT ! 34: * Fixed bugs in kern_serv_callout. ! 35: * Remove compatibility for servers < version 2. ! 36: * ! 37: * 12-Jul-90 Gregg Kellogg (gk) at NeXT ! 38: * Don't allocate MSG_SIZE_MAX for in and out messages. Only allocate ! 39: * a minimal amount fo input message and use RCV_TOO_LARGE logic ! 40: * to allocate more. Output message is only allocated for servers ! 41: * and older style handlers. ! 42: * ! 43: * 23-May-90 Gregg kellogg (gk) at NeXT ! 44: * Changed to use thread_reply port instead of bootstrap port. ! 45: * Checks to see if it's running in the kernel_task and uses ! 46: * kernel_ipc_space accordingly. ! 47: * Terminates on shutdown, doesn't suspend. ! 48: * Doesn't depend on being in a separate task now. ! 49: * ! 50: * 06-Feb-89 Gregg Kellogg (gk) at NeXT ! 51: * Created. ! 52: * ! 53: */ ! 54: ! 55: /* ! 56: * Generic Kernel Server for loaded server tasks. ! 57: * ! 58: * This code is run by dynamically loaded Mach kernel servers. It recieves ! 59: * instructions from it's boot port server to set up it's local environment ! 60: * and enter the server loop to do per-server processing. ! 61: * ! 62: * The server basically exists to dispatch messages recieved on ports ! 63: * to procedures. Any un-handled messages are either thrown away or handled ! 64: * directly by the server. Handled messages are either acked, or not acked. ! 65: * If the return status is > 0, then any resources passed (other than ports) ! 66: * are deallocated from the message as well. ! 67: */ ! 68: ! 69: #import <mach/mig_errors.h> ! 70: #import <sys/callout.h> ! 71: #import <mach/notify.h> ! 72: #import <kern/kern_port.h> ! 73: #import <kern/sched_prim.h> ! 74: #import <mach/mach_traps.h> ! 75: #import <kern/kalloc.h> ! 76: #import <kernserv/kern_notify.h> ! 77: #import <mach/vm_param.h> ! 78: #import "kernobjc.h" ! 79: #import <kern/thread_call.h> ! 80: ! 81: #import <machine/spl.h> ! 82: ! 83: #import <kernserv/kern_server_handler.h> ! 84: #import <kernserv/kern_server_reply.h> ! 85: ! 86: #define panic(s) (curipl() == 0 ? kern_serv_panic(ksp->bootstrap_port, s) \ ! 87: : printf("can't panic: %s\n", s)) ! 88: ! 89: /* Now a per server static port_t kernel_port; */ ! 90: ! 91: /* ! 92: * Use internal version of thread_terminate. ! 93: */ ! 94: #undef thread_terminate ! 95: ! 96: /* ! 97: * Locally used functions ! 98: */ ! 99: static kern_return_t kern_serv_dispatch ( ! 100: msg_header_t *in_msg, ! 101: kern_server_t ksp); ! 102: ! 103: static void kern_serv_send_log(void *arg); ! 104: static void kern_serv_log_init ( // initialize server's log buffer ! 105: log_t *log, // uninitialized log struct ! 106: int num_entries); // size of log ! 107: ! 108: static void kern_serv_log_free (log_t *log); // deallocate log structure ! 109: static void kern_serv_interrupt_server(thread_t thread); ! 110: ! 111: const kern_serv_t kern_serv_proto = { ! 112: 0, // arg to be filled in ! 113: 0, // don't wait for message to be sent ! 114: kern_serv_instance_loc, ! 115: kern_serv_boot_port, ! 116: kern_serv_wire_range, ! 117: kern_serv_unwire_range, ! 118: kern_serv_port_proc, ! 119: kern_serv_port_death_proc, ! 120: kern_serv_call_proc, ! 121: kern_serv_shutdown, ! 122: kern_serv_log_level, ! 123: kern_serv_get_log, ! 124: kern_serv_port_serv, ! 125: kern_serv_version, ! 126: kern_serv_load_objc}; ! 127: ! 128: /* ! 129: * Prototypes for kernel functions not yet prototyped. ! 130: */ ! 131: int bcopy(void *to, void *from, int size); ! 132: int curipl(void); ! 133: kern_return_t vm_map_pageable( ! 134: vm_map_t map, ! 135: vm_offset_t start, ! 136: vm_offset_t end, ! 137: boolean_t new_pageable); ! 138: #if DEBUG ! 139: void xpr(char *msg, ...); ! 140: #endif DEBUG ! 141: ! 142: #if DEBUG ! 143: static boolean_t kserv_debug = TRUE; ! 144: #define ks_log(s) {if (kserv_debug) XPR(XPR_LDD, s); } ! 145: #define ks_log2(s) ks_log(s) ! 146: void kern_server_main1(void); ! 147: void kern_server_main2(void); ! 148: #else DEBUG ! 149: #define ks_log(s) ! 150: #define ks_log2(s) ! 151: #endif DEBUG ! 152: ! 153: /* ! 154: * Entry point to kernel server, set up task environment. ! 155: */ ! 156: void kern_server_main(void) ! 157: { ! 158: #if DEBUG ! 159: int foo[10]; ! 160: kern_server_main1(); ! 161: } ! 162: void kern_server_main1(void) ! 163: { ! 164: int foo[10]; ! 165: kern_server_main2(); ! 166: } ! 167: void kern_server_main2(void) ! 168: { ! 169: #endif DEBUG ! 170: kern_return_t r; ! 171: kern_server_t ksp = (kern_server_t)kalloc(sizeof *ksp); ! 172: port_t boot_listener_port; ! 173: port_t reply_port; ! 174: port_set_name_t port_set; ! 175: msg_header_t *in_msg; ! 176: int error; ! 177: register int i, s; ! 178: kern_serv_t kern_serv = kern_serv_proto; ! 179: ! 180: #if 0 ! 181: volatile int instr; ! 182: ! 183: /* ! 184: * Write to the loaded text so that the debugger can set break-points. ! 185: */ ! 186: instr = *(int *)&kern_server_main2; ! 187: *(int *)&kern_server_main2 = instr; ! 188: #endif 0 ! 189: ! 190: kern_serv.arg = (void *)&ksp; ! 191: ! 192: /* ! 193: * Find out who we are. ! 194: */ ! 195: ! 196: if (current_task() != kernel_task) { ! 197: current_task()->kernel_vm_space = TRUE; ! 198: } ! 199: ! 200: bzero((char *)ksp, sizeof(*ksp)); ! 201: ksp->version = -1; ! 202: ! 203: /* ! 204: * Our task port. ! 205: */ ! 206: ksp->task_port = task_self(); ! 207: ! 208: /* ! 209: * Our thread structure. ! 210: */ ! 211: ksp->server_thread = current_thread(); ! 212: simple_lock_init(&ksp->slock); ! 213: ! 214: /* ! 215: * Initialize message send queue. ! 216: */ ! 217: queue_init(&ksp->msg_callout_q); ! 218: queue_init(&ksp->msg_callout_fq); ! 219: queue_init(&ksp->notify_q); ! 220: for ( i = sizeof(ksp->msg_send_array)/sizeof(ksp->msg_send_array[0])-1 ! 221: ; i >= 0 ! 222: ; i--) ! 223: { ! 224: queue_enter(&ksp->msg_callout_fq, &ksp->msg_send_array[i], ! 225: struct msg_send_entry *, link); ! 226: } ! 227: ! 228: /* ! 229: * Use our thread_reply port as the bootstrap port. This is ! 230: * claimed by the kern_loader before we startup, so there's no ! 231: * race condition. ! 232: */ ! 233: r = thread_get_special_port(thread_self(), THREAD_REPLY_PORT, ! 234: &boot_listener_port); ! 235: if (r != KERN_SUCCESS || boot_listener_port == PORT_NULL) { ! 236: printf("k_server: can't find listener port..terminating\n"); ! 237: thread_terminate(current_thread()); ! 238: thread_halt_self(); ! 239: } ! 240: ksp->boot_listener_port = boot_listener_port; ! 241: ! 242: /* ! 243: * Allocate a new reply port. ! 244: */ ! 245: r = port_allocate(task_self(), &reply_port); ! 246: if (r != KERN_SUCCESS) { ! 247: printf("k_server: can't allocate reply port..terminating\n"); ! 248: thread_terminate(current_thread()); ! 249: thread_halt_self(); ! 250: } ! 251: ! 252: r = thread_set_special_port(thread_self(), THREAD_REPLY_PORT, ! 253: reply_port); ! 254: if (r != KERN_SUCCESS) { ! 255: printf("k_server: can't set reply port..terminating\n"); ! 256: thread_terminate(current_thread()); ! 257: thread_halt_self(); ! 258: } ! 259: ! 260: /* ! 261: * Forget the reply_port we were using so that it isn't ! 262: * cached anymore. ! 263: */ ! 264: ! 265: /* ! 266: * Allocate the basic set of ports we need for communication ! 267: * (notify port). ! 268: */ ! 269: r = port_set_allocate(task_self(), &port_set); ! 270: if (r != KERN_SUCCESS) { ! 271: printf("k_server: can't allocate port set..terminating\n"); ! 272: thread_terminate(current_thread()); ! 273: thread_halt_self(); ! 274: } ! 275: ksp->port_set = port_set; ! 276: ! 277: /* ! 278: * Add boot listener port to the port set. ! 279: */ ! 280: if ( port_set_add(task_self(), port_set, boot_listener_port) ! 281: != KERN_SUCCESS) ! 282: { ! 283: printf("k_server: can't add listener port\n"); ! 284: thread_terminate(current_thread()); ! 285: thread_halt_self(); ! 286: } ! 287: ! 288: /* ! 289: * Allocate and set up the notify port. ! 290: */ ! 291: r = port_allocate(ksp->task_port, &ksp->notify_port); ! 292: if (r == KERN_SUCCESS) ! 293: (void) port_set_add(ksp->task_port, ksp->port_set, ! 294: ksp->notify_port); ! 295: else ! 296: kern_serv_panic(ksp->bootstrap_port, ! 297: "k_server: can't get notify port"); ! 298: ! 299: if (current_task() != kernel_task) { ! 300: /* ! 301: * Set this port as our task's notify port. ! 302: */ ! 303: (void) task_set_special_port(task_self(), ! 304: TASK_NOTIFY_PORT, ksp->notify_port); ! 305: } ! 306: ! 307: kern_serv_notify(&ksp, ksp->notify_port, ksp->bootstrap_port); ! 308: ! 309: /* ! 310: * The kernel's task port. ! 311: */ ! 312: ksp->kernel_port = kern_serv_kernel_task_port(); ! 313: ! 314: /* ! 315: * Service loop... receive messages and process them. ! 316: */ ! 317: ! 318: in_msg = (msg_header_t *)kalloc(kern_servMaxRequestSize); ! 319: ksp->msg = in_msg; ! 320: ksp->msg_size = kern_servMaxRequestSize; ! 321: for (;;) { ! 322: /* ! 323: * Look for things to do that need to be done ! 324: * from this task/thread. ! 325: * Send messages. ! 326: */ ! 327: s = splhigh(); ! 328: simple_lock(&ksp->slock); ! 329: ! 330: while (!queue_empty(&ksp->msg_callout_q)) { ! 331: struct msg_send_entry *msep; ! 332: ! 333: queue_remove_first(&ksp->msg_callout_q, ! 334: msep, struct msg_send_entry *, link); ! 335: ! 336: simple_unlock(&ksp->slock); ! 337: splx(s); ! 338: ! 339: ks_log(("kern_server_main: qed callout func 0x%x\n", ! 340: msep->func)); ! 341: (*msep->func)(msep->arg); ! 342: ! 343: s = splhigh(); ! 344: simple_lock(&ksp->slock); ! 345: ! 346: queue_enter(&ksp->msg_callout_fq, msep, ! 347: struct msg_send_entry *, link); ! 348: } ! 349: ! 350: simple_unlock(&ksp->slock); ! 351: splx(s); ! 352: ! 353: /* ! 354: * Wait for the next request. ! 355: */ ! 356: receive: ! 357: in_msg->msg_local_port = port_set; ! 358: in_msg->msg_size = ksp->msg_size; ! 359: r = msg_receive(in_msg, RCV_TIMEOUT|RCV_INTERRUPT|RCV_LARGE, ! 360: 1000); ! 361: ! 362: /* ! 363: * If our receive was interrupted, go back to it. ! 364: */ ! 365: switch (r) { ! 366: case RCV_INTERRUPTED: ! 367: break; ! 368: case RCV_TIMED_OUT: ! 369: continue; ! 370: case RCV_TOO_LARGE: ! 371: { ! 372: vm_size_t new_msg_size = ksp->msg->msg_size; ! 373: /* ! 374: * We need to allocate a larger message to return. ! 375: */ ! 376: kfree(ksp->msg, ksp->msg_size); ! 377: ksp->msg_size = new_msg_size; ! 378: ksp->msg = (void *)kalloc(ksp->msg_size); ! 379: in_msg = ksp->msg; ! 380: goto receive; ! 381: } ! 382: ! 383: case KERN_SUCCESS: ! 384: break; ! 385: default: ! 386: kern_serv_panic(ksp->bootstrap_port, ! 387: "kern_server_main: received return bad return" ! 388: " from msg_receive"); ! 389: break; ! 390: } ! 391: ! 392: ks_log(("kern_server_main: received msgid %d " ! 393: "on port %d\n", in_msg->msg_id, ! 394: in_msg->msg_local_port)); ! 395: ! 396: /* ! 397: * Dispatch the message based on it's port. ! 398: */ ! 399: if (in_msg->msg_local_port == ksp->notify_port) { ! 400: notification_t *n = (notification_t *) in_msg; ! 401: switch(in_msg->msg_id) { ! 402: case NOTIFY_PORT_DELETED: ! 403: /* ! 404: * Give loaded code a chance to handle it ! 405: */ ! 406: if (ksp->pd_proc) { ! 407: if ((*ksp->pd_proc)(n->notify_port)) ! 408: break; ! 409: } else if (ksp->pn_proc) ! 410: (*ksp->pn_proc)(n->notify_port, ! 411: in_msg->msg_id); ! 412: kern_serv_port_gone(&ksp, n->notify_port); ! 413: break; ! 414: default: ! 415: if (ksp->pn_proc) ! 416: (*ksp->pn_proc)(n->notify_port, ! 417: in_msg->msg_id); ! 418: break; ! 419: } ! 420: continue; ! 421: } else if ( in_msg->msg_id >= NOTIFY_FIRST ! 422: && in_msg->msg_id < NOTIFY_LAST) ! 423: { ! 424: notification_t *n = (notification_t *) in_msg; ! 425: ks_notify_t *np; ! 426: ! 427: /* ! 428: * If we have a notify request on this port, forward ! 429: * the message to the requested port. ! 430: */ ! 431: for ( np = (ks_notify_t *)queue_first(&ksp->notify_q) ! 432: ; !queue_end(&ksp->notify_q, (queue_entry_t)np) ! 433: ; np = (ks_notify_t *)queue_next(&np->link)) ! 434: if (np->req_port == n->notify_port) { ! 435: in_msg->msg_remote_port = ! 436: np->reply_port; ! 437: ks_log2(("kern_server_main: " ! 438: "forwarding notification " ! 439: "request to port %d\n", ! 440: np->reply_port)); ! 441: msg_send(in_msg, MSG_OPTION_NONE, 0); ! 442: queue_remove(&ksp->notify_q, np, ! 443: ks_notify_t *, link); ! 444: kfree(np, sizeof(*np)); ! 445: continue; ! 446: } ! 447: } ! 448: ! 449: ksp->local_port = in_msg->msg_local_port; ! 450: ! 451: error = kern_serv_dispatch(in_msg, ksp); ! 452: ks_log2(("kern_server_main: return from ks_disp %d\n", ! 453: error)); ! 454: ! 455: if ( error == MIG_BAD_ID ! 456: && in_msg->msg_local_port == boot_listener_port) ! 457: { ! 458: error = kern_serv_handler(in_msg, &kern_serv); ! 459: ks_log2(("kern_server_main: " ! 460: "return from ks_server %d\n", ! 461: error)); ! 462: } ! 463: } ! 464: } ! 465: ! 466: typedef struct { ! 467: msg_header_t Head; ! 468: msg_type_t RetCodeType; ! 469: kern_return_t RetCode; ! 470: } Reply; ! 471: ! 472: static kern_return_t kern_serv_port_proc_call ( ! 473: msg_header_t *in_msg, ! 474: port_proc_map_t *pp) ! 475: { ! 476: Reply *out_msg; ! 477: kern_return_t ret_code; ! 478: port_t local_port; ! 479: ! 480: if (pp->type == PP_handler) ! 481: return (*pp->proc)(in_msg, pp->uarg); ! 482: ! 483: out_msg = (Reply *)kalloc(MSG_SIZE_MAX); ! 484: local_port = in_msg->msg_local_port; ! 485: in_msg->msg_local_port = (port_t)pp->uarg; ! 486: ! 487: (*((port_map_serv_t)pp->proc))(in_msg, (msg_header_t *)out_msg); ! 488: ret_code = out_msg->RetCode; ! 489: ! 490: if (out_msg->RetCode == MIG_NO_REPLY) ! 491: ret_code = KERN_SUCCESS; ! 492: else ! 493: ret_code = msg_send(&out_msg->Head, MSG_OPTION_NONE, 0); ! 494: ! 495: kfree(out_msg, MSG_SIZE_MAX); ! 496: ! 497: return ret_code; ! 498: } ! 499: ! 500: #define RCV_IN_PROGRESS RCV_ERRORS_START ! 501: /* ! 502: * Call a proc indirectly based on the port. ! 503: */ ! 504: static kern_return_t kern_serv_dispatch ( ! 505: msg_header_t *in_msg, ! 506: kern_server_t ksp) ! 507: { ! 508: int i = ksp->last_rec_index; ! 509: kern_return_t r = RCV_IN_PROGRESS; ! 510: ! 511: if (!ksp) ! 512: return MIG_BAD_ID; ! 513: ! 514: if (in_msg->msg_local_port == ksp->last_unrec_port) { ! 515: ks_log2(("kern_serv_dispatch: port %d was unrec\n", ! 516: in_msg->msg_local_port)); ! 517: r = MIG_BAD_ID; ! 518: } else if (in_msg->msg_local_port == ksp->last_rec_port) { ! 519: ks_log2(("kern_serv_dispatch: port %d was rec(%d), " ! 520: "proc 0x%x(%d)\n", ! 521: in_msg->msg_local_port, i, ksp->port_proc[i].proc, ! 522: ksp->port_proc[i].uarg)); ! 523: r = kern_serv_port_proc_call(in_msg, &ksp->port_proc[i]); ! 524: } else { ! 525: for ( i = 0 ! 526: ; i < KERN_SERVER_NPORTPROC ! 527: && ksp->port_proc[i].port != in_msg->msg_local_port ! 528: ; i++) ! 529: ; ! 530: ! 531: if (i != KERN_SERVER_NPORTPROC) { ! 532: ksp->last_rec_port = in_msg->msg_local_port; ! 533: ksp->last_rec_index = i; ! 534: ks_log2(("kern_serv_dispatch: port %d now rec(%d), " ! 535: "proc 0x%x(%d)\n", ! 536: in_msg->msg_local_port, i, ! 537: ksp->port_proc[i].proc, ! 538: ksp->port_proc[i].uarg)); ! 539: r = kern_serv_port_proc_call(in_msg, ! 540: &ksp->port_proc[i]); ! 541: } ! 542: } ! 543: ! 544: if (r == RCV_IN_PROGRESS) { ! 545: ks_log2(("kern_serv_dispatch: port %d now unrec\n", ! 546: in_msg->msg_local_port)); ! 547: ksp->last_unrec_port = in_msg->msg_local_port; ! 548: r = MIG_BAD_ID; ! 549: } ! 550: ! 551: return r; ! 552: } ! 553: ! 554: /* ! 555: * Got notification that port we have send rights on has gone away, clean up. ! 556: */ ! 557: void kern_serv_port_gone ( ! 558: kern_server_t *kspp, ! 559: port_name_t port) ! 560: { ! 561: kern_server_t ksp = *kspp; ! 562: register int i; ! 563: ! 564: if (ksp == 0) ! 565: return; ! 566: ! 567: if (ksp->last_rec_port == port) ! 568: ksp->last_rec_port = PORT_NULL; ! 569: ! 570: /* ! 571: * If this is the log port, don't try to send anything to it. ! 572: */ ! 573: if (ksp->log_port && port == ksp->log_port) ! 574: ksp->log_port == PORT_NULL; ! 575: ! 576: /* ! 577: * Free up port/proc pairs ! 578: */ ! 579: for (i = 0; i < KERN_SERVER_NPORTPROC; i++) ! 580: if (ksp->port_proc[i].port == port) { ! 581: ksp->port_proc[i].port = PORT_NULL; ! 582: ksp->port_proc[i].proc = 0; ! 583: break; ! 584: } ! 585: return; ! 586: } ! 587: ! 588: kern_return_t kern_serv_instance_loc ( ! 589: void *arg, ! 590: vm_address_t instance_loc) ! 591: { ! 592: kern_server_t ksp = *((kern_server_t *)arg); ! 593: kern_server_t *kspp = (kern_server_t *)instance_loc; ! 594: ! 595: ks_log(("kern_serv_instance_loc: 0x%x\n", instance_loc)); ! 596: *kspp = ksp; ! 597: ! 598: return KERN_SUCCESS; ! 599: } ! 600: ! 601: /* ! 602: * Specify user's version of system user compiled with. ! 603: */ ! 604: kern_return_t kern_serv_version ( ! 605: void *arg, ! 606: int version) ! 607: { ! 608: kern_server_t ksp = *((kern_server_t *)arg); ! 609: ! 610: if (version < KS_COMPAT) ! 611: return KERN_SERVER_BAD_VERSION; ! 612: ksp->version = version; ! 613: ! 614: return KERN_SUCCESS; ! 615: } ! 616: kern_return_t kern_serv_load_objc( ! 617: void *arg, ! 618: vm_address_t header) ! 619: { ! 620: kern_server_t ksp = *((kern_server_t *)arg); ! 621: int error; ! 622: ! 623: #if KERNOBJC ! 624: ksp->mach_header = (struct mach_header *) header; ! 625: error = objc_registerModule (ksp->mach_header, 0); ! 626: #endif KERNOBJC ! 627: return KERN_SUCCESS; ! 628: } ! 629: ! 630: ! 631: kern_return_t kern_serv_boot_port ( // how to talk to loader ! 632: void *arg, ! 633: port_t boot_port) ! 634: { ! 635: kern_server_t ksp = *((kern_server_t *)arg); ! 636: ! 637: ksp->bootstrap_port = boot_port; ! 638: return KERN_SUCCESS; ! 639: } ! 640: ! 641: /* ! 642: * Kernel version of kern_serv_notify, doesn't contact kern_loader, uses ! 643: * internal port_request_notification facility. ! 644: */ ! 645: kern_return_t kern_serv_notify ( ! 646: kern_server_t *kspp, ! 647: port_t reply_port, ! 648: port_t req_port) ! 649: { ! 650: kern_server_t ksp; ! 651: port_t bootstrap_port; ! 652: kern_return_t r; ! 653: kern_port_t rp, np; ! 654: ! 655: ksp = *kspp; ! 656: bootstrap_port = ksp->bootstrap_port; ! 657: ! 658: if (current_task() != kernel_task) { ! 659: ks_notify_t *np; ! 660: ! 661: if (reply_port == ksp->notify_port) ! 662: /* ! 663: * Notification will happen automatically. ! 664: */ ! 665: return KERN_SUCCESS; ! 666: ! 667: /* ! 668: * Make sure that an entry doesn't already exist for this ! 669: * pair. ! 670: */ ! 671: for ( np = (ks_notify_t *)queue_first(&ksp->notify_q) ! 672: ; !queue_end(&ksp->notify_q, (queue_entry_t)np) ! 673: ; np = (ks_notify_t *)queue_next(&np->link)) ! 674: if ( np->reply_port == reply_port ! 675: && np->req_port == req_port) ! 676: return KERN_FAILURE; ! 677: ! 678: np = (kern_port_t)kalloc(sizeof *np); ! 679: np->reply_port = reply_port; ! 680: np->req_port = req_port; ! 681: queue_enter(&ksp->notify_q, np, ks_notify_t *, link); ! 682: ! 683: /* ! 684: * Notification will be forwarded from kern_server. ! 685: */ ! 686: return KERN_SUCCESS; ! 687: } ! 688: ! 689: r = get_kern_port(current_task(), req_port, &rp); ! 690: if (r != KERN_SUCCESS) ! 691: return r; ! 692: r = get_kern_port(current_task(), reply_port, &np); ! 693: if (r != KERN_SUCCESS) ! 694: return r; ! 695: port_request_notification(rp, np); ! 696: return KERN_SUCCESS; ! 697: } ! 698: ! 699: kern_return_t kern_serv_wire_range ( // wire the specified range or memory ! 700: void *arg, ! 701: vm_address_t addr, ! 702: vm_size_t size) ! 703: { ! 704: kern_server_t ksp = *((kern_server_t *)arg); ! 705: ! 706: ks_log(("kern_serv_wire_range: addr 0x%x for 0x%x bytes\n", ! 707: addr, size)); ! 708: #if DIAGNOSTIC ! 709: printf("kern_server: wiring 0x%x to 0x%x\n", trunc_page(addr), ! 710: round_page(addr+size)); ! 711: #endif ! 712: return vm_map_pageable(kernel_task->map, trunc_page(addr), ! 713: round_page(addr+size), FALSE); ! 714: } ! 715: ! 716: kern_return_t kern_serv_unwire_range ( // unwire the specified range or memory ! 717: void *arg, ! 718: vm_address_t addr, ! 719: vm_size_t size) ! 720: { ! 721: kern_server_t ksp = *((kern_server_t *)arg); ! 722: ! 723: ks_log(("kern_serv_unwire_range: addr 0x%x for 0x%x bytes\n", ! 724: addr, size)); ! 725: #if DIAGNOSTIC ! 726: printf("kern_server: unwiring 0x%x to 0x%x\n", trunc_page(addr), ! 727: round_page(addr+size)); ! 728: #endif ! 729: return vm_map_pageable(kernel_task->map, trunc_page(addr), ! 730: round_page(addr+size), TRUE); ! 731: } ! 732: ! 733: /* ! 734: * Map messages coming on on the specified port to call the specified proc. ! 735: * If this mapping can't be made FALSE is returned. ! 736: * The port is added to the portset for this server. ! 737: */ ! 738: kern_return_t kern_serv_port_proc ( // map a message on port to proc/arg ! 739: void *arg, // record into structure ! 740: port_all_t port, // port to map (all rights passed) ! 741: port_map_proc_t proc, // proc to call ! 742: int uarg) // replace local_port with uarg ! 743: { ! 744: register int i; ! 745: kern_return_t r; ! 746: kern_server_t ksp = *((kern_server_t *)arg); ! 747: ! 748: ks_log(("kern_serv_port_proc: port %d proc 0x%x uarg %d\n", ! 749: port, proc, uarg)); ! 750: ! 751: if (ksp->last_unrec_port == port) ! 752: ksp->last_unrec_port = PORT_NULL; ! 753: ! 754: for (i = 0; i < KERN_SERVER_NPORTPROC; i++) ! 755: if (ksp->port_proc[i].port == port) ! 756: ksp->port_proc[i].port = PORT_NULL; ! 757: ! 758: for (i = 0; i < KERN_SERVER_NPORTPROC; i++) ! 759: if (ksp->port_proc[i].port == PORT_NULL) ! 760: break; ! 761: ! 762: r = KERN_RESOURCE_SHORTAGE; ! 763: if ( i == KERN_SERVER_NPORTPROC ! 764: || (r = port_set_add(ksp->task_port, ksp->port_set, port)) ! 765: != KERN_SUCCESS) ! 766: return r; ! 767: ! 768: ksp->port_proc[i].port = port; ! 769: ksp->port_proc[i].proc = proc; ! 770: ksp->port_proc[i].uarg = (void *)uarg; ! 771: ksp->port_proc[i].type = PP_handler; ! 772: ! 773: return KERN_SUCCESS; ! 774: } ! 775: ! 776: /* ! 777: * Map messages coming on on the specified port to call the specified proc. ! 778: * If this mapping can't be made FALSE is returned. ! 779: * The port is added to the portset for this server. ! 780: */ ! 781: kern_return_t kern_serv_port_serv ( // map a message on port to proc/arg ! 782: void *arg, // record into structure ! 783: port_all_t port, // port to map (all rights passed) ! 784: port_map_proc_t proc, // proc to call ! 785: int uarg) // replace local_port with uarg ! 786: { ! 787: register int i; ! 788: kern_return_t r; ! 789: kern_server_t ksp = *((kern_server_t *)arg); ! 790: ! 791: ks_log(("kern_serv_port_serv: port %d proc 0x%x uarg %d\n", ! 792: port, proc, uarg)); ! 793: ! 794: if (ksp->last_unrec_port == port) ! 795: ksp->last_unrec_port = PORT_NULL; ! 796: ! 797: for (i = 0; i < KERN_SERVER_NPORTPROC; i++) ! 798: if (ksp->port_proc[i].port == port) ! 799: ksp->port_proc[i].port = PORT_NULL; ! 800: ! 801: for (i = 0; i < KERN_SERVER_NPORTPROC; i++) ! 802: if (ksp->port_proc[i].port == PORT_NULL) ! 803: break; ! 804: ! 805: r = KERN_RESOURCE_SHORTAGE; ! 806: if ( i == KERN_SERVER_NPORTPROC ! 807: || (r = port_set_add(ksp->task_port, ksp->port_set, port)) ! 808: != KERN_SUCCESS) ! 809: return r; ! 810: ! 811: ksp->port_proc[i].port = port; ! 812: ksp->port_proc[i].proc = proc; ! 813: ksp->port_proc[i].uarg = (void *)uarg; ! 814: ksp->port_proc[i].type = PP_server; ! 815: ! 816: return KERN_SUCCESS; ! 817: } ! 818: ! 819: kern_return_t kern_serv_port_death_proc ( // specify port death handler ! 820: void *arg, // record into structure ! 821: port_death_proc_t proc) // record into structure ! 822: { ! 823: kern_server_t ksp = *((kern_server_t *)arg); ! 824: ! 825: ksp->pd_proc = proc; ! 826: return KERN_SUCCESS; ! 827: } ! 828: ! 829: kern_return_t kern_serv_call_proc ( // call procedure with argument ! 830: void *arg, // record into structure ! 831: call_proc_t proc, // record into structure ! 832: int uarg) // arg to supply ! 833: { ! 834: kern_server_t ksp = *((kern_server_t *)arg); ! 835: ! 836: ks_log(("kern_serv_call_proc: proc 0x%x uarg %d\n", ! 837: proc, uarg)); ! 838: ! 839: if (proc) { ! 840: (*proc)(uarg); ! 841: return KERN_SUCCESS; ! 842: } ! 843: return KERN_SERVER_ERROR; ! 844: } ! 845: ! 846: kern_return_t kern_serv_shutdown ( ! 847: void *arg) ! 848: { ! 849: kern_server_t ksp = *((kern_server_t *)arg); ! 850: int i; ! 851: ! 852: ks_log(("kern_serv_shutdown\n")); ! 853: ! 854: #if KERNOBJC ! 855: /* ! 856: * Detach from Objective-C runtime. ! 857: */ ! 858: if (ksp->mach_header) ! 859: objc_unregisterModule (ksp->mach_header, 0); ! 860: #endif KERNOBJC ! 861: ! 862: /* ! 863: * Stop logging and free the data ! 864: * if we were logging. ! 865: */ ! 866: if (ksp->log.level) { ! 867: kern_serv_log_free(&ksp->log); ! 868: ksp->log.level = 0; ! 869: } ! 870: ! 871: /* ! 872: * Deallocate all the port mappings we have. ! 873: */ ! 874: for (i = 0; i < KERN_SERVER_NPORTPROC; i++) ! 875: if (ksp->port_proc[i].port != PORT_NULL) { ! 876: port_deallocate(ksp->task_port, ! 877: ksp->port_proc[i].port); ! 878: ksp->port_proc[i].port = PORT_NULL; ! 879: ksp->port_proc[i].proc = 0; ! 880: } ! 881: ! 882: /* ! 883: * Deallocate our boot_listener and notify ports. ! 884: */ ! 885: port_deallocate(ksp->task_port, ksp->boot_listener_port); ! 886: port_deallocate(ksp->task_port, ksp->notify_port); ! 887: ! 888: /* ! 889: * Deallocate our port_set ! 890: */ ! 891: port_set_deallocate(ksp->task_port, ksp->port_set); ! 892: ! 893: /* ! 894: * Deallocate our message frame. ! 895: */ ! 896: kfree(ksp->msg, ksp->msg_size); ! 897: kfree(ksp, sizeof *ksp); ! 898: thread_terminate(current_thread()); ! 899: while (1) ! 900: /* ! 901: * Wait to be killed. ! 902: */ ! 903: thread_halt_self(); ! 904: ! 905: return KERN_SUCCESS; ! 906: } ! 907: ! 908: // log level from message on port ! 909: kern_return_t kern_serv_log_level ( ! 910: void *arg, ! 911: int log_level) ! 912: { ! 913: kern_server_t ksp = *((kern_server_t *)arg); ! 914: int old_level = ksp->log.level; ! 915: ! 916: ksp->log.level = log_level; ! 917: ! 918: /* ! 919: * Only keep space around for the log ! 920: * if we need it. ! 921: */ ! 922: if (old_level == 0 && ksp->log.level) ! 923: kern_serv_log_init(&ksp->log, ! 924: KERN_SERVER_LOG_SIZE); ! 925: else if (ksp->log.level == 0 && old_level) ! 926: kern_serv_log_free(&ksp->log); ! 927: ! 928: return KERN_SUCCESS; ! 929: } ! 930: ! 931: kern_return_t kern_serv_get_log ( ! 932: void *arg, ! 933: port_t reply_port) // port to send log information to ! 934: { ! 935: int s, n; ! 936: kern_server_t ksp = *((kern_server_t *)arg); ! 937: ! 938: if (ksp->log.level == 0) { ! 939: port_deallocate(ksp->task_port, reply_port); ! 940: return KERN_SERVER_NOTLOGGING; ! 941: } ! 942: ! 943: if (ksp->log.ptr == ksp->log.base) { ! 944: ksp->log_port = reply_port; ! 945: return KERN_SUCCESS; ! 946: } else { ! 947: vm_size_t size = ! 948: round_page((char *)ksp->log.ptr - (char *)ksp->log.base); ! 949: pointer_t ldata; ! 950: unsigned int ldata_count; ! 951: kern_return_t r; ! 952: ! 953: ASSERT( (void *)ksp->log.base ! 954: == (void *)round_page(ksp->log.base)); ! 955: r = vm_read(ksp->kernel_port, ! 956: (vm_address_t)ksp->log.base, size, &ldata, ! 957: &ldata_count); ! 958: ASSERT(r == KERN_SUCCESS); ! 959: kern_serv_log_data(reply_port, ! 960: (log_entry_t *)ldata, ! 961: ksp->log.ptr - ksp->log.base); ! 962: ! 963: port_deallocate(ksp->task_port, reply_port); ! 964: vm_deallocate(ksp->task_port, ldata, size); ! 965: } ! 966: ! 967: s = splhigh(); ! 968: simple_lock(&ksp->slock); ! 969: ksp->log.ptr = ksp->log.base; ! 970: simple_unlock(&ksp->slock); ! 971: splx(s); ! 972: ! 973: return KERN_SUCCESS; ! 974: } ! 975: ! 976: void kern_serv_log ( // log a message ! 977: kern_server_t *kspp, // kern_server instance vars ! 978: int log_level, // level to log at ! 979: char *msg, // what to log (followed by args) ! 980: int arg1, ! 981: int arg2, ! 982: int arg3, ! 983: int arg4, ! 984: int arg5) ! 985: { ! 986: kern_server_t ksp = *kspp; ! 987: register int s; ! 988: log_entry_t *x; ! 989: ! 990: if (log_level > ksp->log.level || ksp->log.base == 0) ! 991: return; ! 992: ! 993: s = splhigh(); ! 994: simple_lock(&ksp->slock); ! 995: ! 996: x = ksp->log.ptr++; ! 997: if (ksp->log.ptr == ksp->log.last) { ! 998: ksp->log.ptr--; ! 999: simple_unlock(&ksp->slock); ! 1000: splx(s); ! 1001: return; ! 1002: } ! 1003: simple_unlock(&ksp->slock); ! 1004: splx(s); ! 1005: ! 1006: x->msg = msg; ! 1007: x->arg1 = arg1; ! 1008: x->arg2 = arg2; ! 1009: x->arg3 = arg3; ! 1010: x->arg4 = arg4; ! 1011: x->arg5 = arg5; ! 1012: x->timestamp = XPR_TIMESTAMP; ! 1013: x->cpuinfo = log_level; ! 1014: ! 1015: if (ksp->log_port) ! 1016: kern_serv_callout(kspp, kern_serv_send_log, (void *)ksp); ! 1017: } ! 1018: ! 1019: /* ! 1020: * Send the log back to the user. Have to copy the log into our address ! 1021: * space. ! 1022: */ ! 1023: static void kern_serv_send_log(void *arg) ! 1024: { ! 1025: kern_server_t ksp = (kern_server_t)arg; ! 1026: port_name_t log_port; ! 1027: int s; ! 1028: vm_size_t size = ! 1029: round_page((char *)ksp->log.ptr - (char *)ksp->log.base); ! 1030: pointer_t ldata; ! 1031: unsigned int ldata_count; ! 1032: kern_return_t r; ! 1033: ! 1034: s = splhigh(); ! 1035: simple_lock(&ksp->slock); ! 1036: ! 1037: log_port = ksp->log_port; ! 1038: ksp->log_port = PORT_NULL; ! 1039: ! 1040: simple_unlock(&ksp->slock); ! 1041: splx(s); ! 1042: if (log_port == PORT_NULL) ! 1043: return; ! 1044: ! 1045: ASSERT((void *)ksp->log.base == (void *)round_page(ksp->log.base)); ! 1046: r = vm_read(ksp->kernel_port, (vm_address_t)ksp->log.base, ! 1047: size, &ldata, &ldata_count); ! 1048: ASSERT(r == KERN_SUCCESS); ! 1049: kern_serv_log_data(log_port, (log_entry_t *)ldata, ! 1050: ksp->log.ptr - ksp->log.base); ! 1051: ! 1052: port_deallocate(ksp->task_port, log_port); ! 1053: vm_deallocate(ksp->task_port, ldata, size); ! 1054: ! 1055: s = splhigh(); ! 1056: simple_lock(&ksp->slock); ! 1057: ! 1058: ksp->log.ptr = ksp->log.base; ! 1059: ! 1060: simple_unlock(&ksp->slock); ! 1061: splx(s); ! 1062: ! 1063: } ! 1064: ! 1065: /* ! 1066: * Ensure that the number of entries is rounded up to a page boundary. ! 1067: */ ! 1068: static void kern_serv_log_init ( // initialize server's log buffer ! 1069: log_t *log, // uninitialized log struct ! 1070: int num_entries) // size of log ! 1071: { ! 1072: vm_size_t size = round_page(sizeof(log_entry_t)*num_entries); ! 1073: num_entries = size / sizeof(log_entry_t); ! 1074: ! 1075: log->base = (log_entry_t *)kalloc(size); ! 1076: ! 1077: log->last = log->base + num_entries; ! 1078: log->ptr = log->base; ! 1079: #if DIAGNOSTIC ! 1080: printf("kern_serv_log_init: log 0x%x log.last 0x%x, log.base 0x%x\n", ! 1081: log, log->last, log->base); ! 1082: #endif ! 1083: } ! 1084: ! 1085: static void kern_serv_log_free (log_t *log) // deallocate log structure ! 1086: { ! 1087: kfree(log->base, round_page((char *)log->last - (char *)log->base)); ! 1088: log->base = log->last = log->ptr = 0; ! 1089: } ! 1090: ! 1091: kern_return_t kern_serv_callout ( ! 1092: kern_server_t *kspp, ! 1093: void (*proc)(void *arg), ! 1094: void * arg) ! 1095: { ! 1096: kern_server_t ksp = *kspp; ! 1097: struct msg_send_entry *msep; ! 1098: int s; ! 1099: ! 1100: /* ! 1101: * Just call this guy directly if the conditions are right. ! 1102: */ ! 1103: if ( ! 1104: curipl() == 0 ! 1105: && task_self() == ksp->task_port) { ! 1106: (*proc)(arg); ! 1107: return KERN_SUCCESS; ! 1108: } ! 1109: ! 1110: s = splhigh(); ! 1111: simple_lock(&ksp->slock); ! 1112: ! 1113: if (queue_empty(&ksp->msg_callout_fq)) { ! 1114: #if DIAGNOSTIC ! 1115: printf("kern_serv_callout: no free messages"); ! 1116: #endif ! 1117: simple_unlock(&ksp->slock); ! 1118: splx(s); ! 1119: return KERN_RESOURCE_SHORTAGE; ! 1120: } ! 1121: ! 1122: queue_remove_first(&ksp->msg_callout_fq, msep, struct msg_send_entry *, ! 1123: link); ! 1124: ks_log(("kern_serv_send: (queue) proc 0x%x\n", proc)); ! 1125: ! 1126: msep->func = proc; ! 1127: msep->arg = arg; ! 1128: queue_enter(&ksp->msg_callout_q, msep, struct msg_send_entry *, link); ! 1129: ! 1130: simple_unlock(&ksp->slock); ! 1131: splx(s); ! 1132: ! 1133: /* ! 1134: * Interrupt the server thread to that it'll look at this sucker. ! 1135: */ ! 1136: thread_call_func( ! 1137: (thread_call_func_t)kern_serv_interrupt_server, ! 1138: (thread_call_spec_t)ksp->server_thread, TRUE); ! 1139: ! 1140: return KERN_SUCCESS; ! 1141: } ! 1142: ! 1143: static void kern_serv_interrupt_server(thread_t thread) ! 1144: { ! 1145: /* ! 1146: * Sending the guy a message sounds like the best way to ensure ! 1147: * that he see's that there's something to do. ! 1148: */ ! 1149: send_notification(thread->task, NOTIFY_MSG_ACCEPTED, PORT_NULL); ! 1150: } ! 1151: ! 1152: /* ! 1153: * Structure access functions. ! 1154: */ ! 1155: port_t kern_serv_local_port(kern_server_t *ksp) ! 1156: { ! 1157: return (*ksp)->local_port; ! 1158: } ! 1159: ! 1160: port_t kern_serv_bootstrap_port(kern_server_t *ksp) ! 1161: { ! 1162: return (*ksp)->bootstrap_port; ! 1163: } ! 1164: ! 1165: port_t kern_serv_notify_port(kern_server_t *ksp) ! 1166: { ! 1167: return (*ksp)->notify_port; ! 1168: } ! 1169: ! 1170: port_set_name_t kern_serv_port_set(kern_server_t *ksp) ! 1171: { ! 1172: return (*ksp)->port_set; ! 1173: } ! 1174: ! 1175: /* Get the kernel task port. */ ! 1176: port_t kern_serv_kernel_task_port(void) ! 1177: { ! 1178: extern task_t kernel_task; // global kernel variable. ! 1179: port_t my_kernel_port; ! 1180: ! 1181: task_reference(kernel_task); ! 1182: my_kernel_port = convert_task_to_port(kernel_task); ! 1183: if (my_kernel_port == PORT_NULL) ! 1184: return PORT_NULL; ! 1185: ! 1186: object_copyout(current_task(), my_kernel_port, MSG_TYPE_PORT, ! 1187: &my_kernel_port); ! 1188: return my_kernel_port; ! 1189: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.