![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to message.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / kernel / mach|
Return to message.h CVS log | Up to [Apple Darwin 0.x] / kernel / mach |
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) 1995, 1994, 1993, 1992, 1991, 1990 ! 27: * Open Software Foundation, Inc. ! 28: * ! 29: * Permission to use, copy, modify, and distribute this software and ! 30: * its documentation for any purpose and without fee is hereby granted, ! 31: * provided that the above copyright notice appears in all copies and ! 32: * that both the copyright notice and this permission notice appear in ! 33: * supporting documentation, and that the name of ("OSF") or Open Software ! 34: * Foundation not be used in advertising or publicity pertaining to ! 35: * distribution of the software without specific, written prior permission. ! 36: * ! 37: * OSF DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE ! 38: * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS ! 39: * FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL OSF BE LIABLE FOR ANY ! 40: * SPECIAL, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES ! 41: * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN ! 42: * ACTION OF CONTRACT, NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING ! 43: * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE ! 44: */ ! 45: /* ! 46: * OSF Research Institute MK6.1 (unencumbered) 1/31/1995 ! 47: */ ! 48: /* ! 49: * Mach Operating System ! 50: * Copyright (c) 1992-1987 Carnegie Mellon University ! 51: * All Rights Reserved. ! 52: * ! 53: * Permission to use, copy, modify and distribute this software and its ! 54: * documentation is hereby granted, provided that both the copyright ! 55: * notice and this permission notice appear in all copies of the ! 56: * software, derivative works or modified versions, and any portions ! 57: * thereof, and that both notices appear in supporting documentation. ! 58: * ! 59: * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS" ! 60: * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR ! 61: * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE. ! 62: * ! 63: * Carnegie Mellon requests users of this software to return to ! 64: * ! 65: * Software Distribution Coordinator or [email protected] ! 66: * School of Computer Science ! 67: * Carnegie Mellon University ! 68: * Pittsburgh PA 15213-3890 ! 69: * ! 70: * any improvements or extensions that they make and grant Carnegie Mellon ! 71: * the rights to redistribute these changes. ! 72: */ ! 73: /* ! 74: * File: mach/message.h ! 75: * ! 76: * Mach IPC message and primitive function definitions. ! 77: */ ! 78: ! 79: #ifndef _MACH_MESSAGE_H_ ! 80: #define _MACH_MESSAGE_H_ ! 81: ! 82: #import <mach/kern_return.h> ! 83: #import <mach/port.h> ! 84: ! 85: ! 86: /* ! 87: * The timeout mechanism uses mach_msg_timeout_t values, ! 88: * passed by value. The timeout units are milliseconds. ! 89: * It is controlled with the MACH_SEND_TIMEOUT ! 90: * and MACH_RCV_TIMEOUT options. ! 91: */ ! 92: ! 93: typedef natural_t mach_msg_timeout_t; ! 94: ! 95: /* ! 96: * The value to be used when there is no timeout. ! 97: * (No MACH_SEND_TIMEOUT/MACH_RCV_TIMEOUT option.) ! 98: */ ! 99: ! 100: #define MACH_MSG_TIMEOUT_NONE ((mach_msg_timeout_t) 0) ! 101: ! 102: /* ! 103: * The kernel uses MACH_MSGH_BITS_COMPLEX as a hint. It it isn't on, it ! 104: * assumes the body of the message doesn't contain port rights or OOL ! 105: * data. The field is set in received messages. A user task must ! 106: * use caution in interpreting the body of a message if the bit isn't ! 107: * on, because the mach_msg_type's in the body might "lie" about the ! 108: * contents. If the bit isn't on, but the mach_msg_types ! 109: * in the body specify rights or OOL data, the behaviour is undefined. ! 110: * (Ie, an error may or may not be produced.) ! 111: * ! 112: * The value of MACH_MSGH_BITS_REMOTE determines the interpretation ! 113: * of the msgh_remote_port field. It is handled like a msgt_name. ! 114: * ! 115: * The value of MACH_MSGH_BITS_LOCAL determines the interpretation ! 116: * of the msgh_local_port field. It is handled like a msgt_name. ! 117: * ! 118: * MACH_MSGH_BITS() combines two MACH_MSG_TYPE_* values, for the remote ! 119: * and local fields, into a single value suitable for msgh_bits. ! 120: * ! 121: * MACH_MSGH_BITS_COMPLEX_PORTS, MACH_MSGH_BITS_COMPLEX_DATA, and ! 122: * MACH_MSGH_BITS_CIRCULAR should be zero; they are used internally. ! 123: * ! 124: * The unused bits should be zero. ! 125: */ ! 126: ! 127: #define MACH_MSGH_BITS_ZERO 0x00000000 ! 128: #define MACH_MSGH_BITS_REMOTE_MASK 0x000000ff ! 129: #define MACH_MSGH_BITS_LOCAL_MASK 0x0000ff00 ! 130: #define MACH_MSGH_BITS_COMPLEX 0x80000000U ! 131: #define MACH_MSGH_BITS_CIRCULAR 0x40000000 /* internal use only */ ! 132: #define MACH_MSGH_BITS_COMPLEX_PORTS 0x20000000 /* internal use only */ ! 133: #define MACH_MSGH_BITS_COMPLEX_DATA 0x10000000 /* internal use only */ ! 134: #define MACH_MSGH_BITS_OLD_FORMAT 0x08000000 /* internal use only */ ! 135: #define MACH_MSGH_BITS_NO_TRAILER 0x08000000 /* non standard */ ! 136: #define MACH_MSGH_BITS_UNUSED 0x07ff0000 ! 137: ! 138: #define MACH_MSGH_BITS_PORTS_MASK \ ! 139: (MACH_MSGH_BITS_REMOTE_MASK|MACH_MSGH_BITS_LOCAL_MASK) ! 140: ! 141: #define MACH_MSGH_BITS(remote, local) \ ! 142: ((remote) | ((local) << 8)) ! 143: #define MACH_MSGH_BITS_REMOTE(bits) \ ! 144: ((bits) & MACH_MSGH_BITS_REMOTE_MASK) ! 145: #define MACH_MSGH_BITS_LOCAL(bits) \ ! 146: (((bits) & MACH_MSGH_BITS_LOCAL_MASK) >> 8) ! 147: #define MACH_MSGH_BITS_PORTS(bits) \ ! 148: ((bits) & MACH_MSGH_BITS_PORTS_MASK) ! 149: #define MACH_MSGH_BITS_OTHER(bits) \ ! 150: ((bits) &~ MACH_MSGH_BITS_PORTS_MASK) ! 151: ! 152: /* ! 153: * Every message starts with a message header. ! 154: * Following the message header are zero or more pairs of ! 155: * type descriptors (mach_msg_type_t/mach_msg_type_long_t) and ! 156: * data values. The size of the message must be specified in bytes, ! 157: * and includes the message header, type descriptors, inline ! 158: * data, and inline pointer for out-of-line data. ! 159: * ! 160: * The msgh_remote_port field specifies the destination of the message. ! 161: * It must specify a valid send or send-once right for a port. ! 162: * ! 163: * The msgh_local_port field specifies a "reply port". Normally, ! 164: * This field carries a send-once right that the receiver will use ! 165: * to reply to the message. It may carry the values MACH_PORT_NULL, ! 166: * MACH_PORT_DEAD, a send-once right, or a send right. ! 167: * ! 168: * The msgh_seqno field carries a sequence number associated with the ! 169: * received-from port. A port's sequence number is incremented every ! 170: * time a message is received from it. In sent messages, the field's ! 171: * value is ignored. ! 172: * ! 173: * The msgh_id field is uninterpreted by the message primitives. ! 174: * It normally carries information specifying the format ! 175: * or meaning of the message. ! 176: */ ! 177: ! 178: typedef unsigned int mach_msg_bits_t; ! 179: typedef unsigned int mach_msg_size_t; ! 180: typedef integer_t mach_msg_id_t; ! 181: ! 182: #define MACH_MSG_SIZE_NULL (mach_msg_size_t *) 0 ! 183: ! 184: typedef struct { ! 185: mach_msg_bits_t msgh_bits; ! 186: mach_msg_size_t msgh_size; ! 187: mach_port_t msgh_remote_port; ! 188: mach_port_t msgh_local_port; ! 189: mach_port_seqno_t msgh_seqno; ! 190: #define msgh_reserved msgh_seqno ! 191: mach_msg_id_t msgh_id; ! 192: } mach_msg_header_t; ! 193: ! 194: #define MACH_MSG_NULL (mach_msg_header_t *) 0 ! 195: ! 196: /* ! 197: * There is no fixed upper bound to the size of Mach messages. ! 198: */ ! 199: ! 200: #define MACH_MSG_SIZE_MAX ((mach_msg_size_t) ~0) ! 201: ! 202: /* ! 203: * The msgt_number field specifies the number of data elements. ! 204: * The msgt_size field specifies the size of each data element, in bits. ! 205: * The msgt_name field specifies the type of each data element. ! 206: * If msgt_inline is TRUE, the data follows the type descriptor ! 207: * in the body of the message. If msgt_inline is FALSE, then a pointer ! 208: * to the data should follow the type descriptor, and the data is ! 209: * sent out-of-line. In this case, if msgt_deallocate is TRUE, ! 210: * then the out-of-line data is moved (instead of copied) into the message. ! 211: * If msgt_longform is TRUE, then the type descriptor is actually ! 212: * a mach_msg_type_long_t. ! 213: * ! 214: * The actual amount of inline data following the descriptor must ! 215: * a multiple of the word size. For out-of-line data, this is a ! 216: * pointer. For inline data, the supplied data size (calculated ! 217: * from msgt_number/msgt_size) is rounded up. This guarantees ! 218: * that type descriptors always fall on word boundaries. ! 219: * ! 220: * For port rights, msgt_size must be 8*sizeof(mach_port_t). ! 221: * If the data is inline, msgt_deallocate should be FALSE. ! 222: * The msgt_unused bit should be zero. ! 223: * The msgt_name, msgt_size, msgt_number fields in ! 224: * a mach_msg_type_long_t should be zero. ! 225: */ ! 226: ! 227: typedef unsigned int mach_msg_type_name_t; ! 228: typedef unsigned int mach_msg_type_size_t; ! 229: typedef natural_t mach_msg_type_number_t; ! 230: ! 231: typedef struct { ! 232: unsigned int msgt_name : 8, ! 233: msgt_size : 8, ! 234: msgt_number : 12, ! 235: msgt_inline : 1, ! 236: msgt_longform : 1, ! 237: msgt_deallocate : 1, ! 238: msgt_unused : 1; ! 239: } mach_msg_type_t; ! 240: ! 241: typedef struct { ! 242: mach_msg_type_t msgtl_header; ! 243: unsigned short msgtl_name; ! 244: unsigned short msgtl_size; ! 245: natural_t msgtl_number; ! 246: } mach_msg_type_long_t; ! 247: ! 248: ! 249: /* ! 250: * Known values for the msgt_name field. ! 251: * ! 252: * The only types known to the Mach kernel are ! 253: * the port types, and those types used in the ! 254: * kernel RPC interface. ! 255: */ ! 256: ! 257: #define MACH_MSG_TYPE_UNSTRUCTURED 0 ! 258: #define MACH_MSG_TYPE_BIT 0 ! 259: #define MACH_MSG_TYPE_BOOLEAN 0 ! 260: #define MACH_MSG_TYPE_INTEGER_16 1 ! 261: #define MACH_MSG_TYPE_INTEGER_32 2 ! 262: #define MACH_MSG_TYPE_CHAR 8 ! 263: #define MACH_MSG_TYPE_BYTE 9 ! 264: #define MACH_MSG_TYPE_INTEGER_8 9 ! 265: #define MACH_MSG_TYPE_REAL 10 ! 266: #define MACH_MSG_TYPE_INTEGER_64 11 ! 267: #define MACH_MSG_TYPE_STRING 12 ! 268: #define MACH_MSG_TYPE_STRING_C 12 ! 269: ! 270: /* ! 271: * Values used when sending a port right. ! 272: */ ! 273: ! 274: #define MACH_MSG_TYPE_MOVE_RECEIVE 16 /* Must hold receive rights */ ! 275: #define MACH_MSG_TYPE_MOVE_SEND 17 /* Must hold send rights */ ! 276: #define MACH_MSG_TYPE_MOVE_SEND_ONCE 18 /* Must hold sendonce rights */ ! 277: #define MACH_MSG_TYPE_COPY_SEND 19 /* Must hold send rights */ ! 278: #define MACH_MSG_TYPE_MAKE_SEND 20 /* Must hold receive rights */ ! 279: #define MACH_MSG_TYPE_MAKE_SEND_ONCE 21 /* Must hold receive rights */ ! 280: ! 281: /* ! 282: * Structures which define the body of ! 283: * a message in the untyped IPC. ! 284: */ ! 285: ! 286: typedef unsigned int mach_msg_copy_options_t; ! 287: ! 288: #define MACH_MSG_PHYSICAL_COPY 0 ! 289: #define MACH_MSG_VIRTUAL_COPY 1 ! 290: #define MACH_MSG_ALLOCATE 2 ! 291: #define MACH_MSG_OVERWRITE 3 ! 292: #define MACH_MSG_KALLOC_COPY_T 4 /* used internally */ ! 293: #define MACH_MSG_PAGE_LIST_COPY_T 5 /* used internally */ ! 294: ! 295: ! 296: typedef unsigned int mach_msg_descriptor_type_t; ! 297: ! 298: #define MACH_MSG_PORT_DESCRIPTOR 0 ! 299: #define MACH_MSG_OOL_DESCRIPTOR 1 ! 300: #define MACH_MSG_OOL_PORTS_DESCRIPTOR 2 ! 301: ! 302: typedef struct ! 303: { ! 304: void* pad1; ! 305: mach_msg_size_t pad2; ! 306: unsigned int pad3 :24; ! 307: mach_msg_descriptor_type_t type :8; ! 308: } mach_msg_type_descriptor_t; ! 309: ! 310: typedef struct ! 311: { ! 312: mach_port_t name; ! 313: mach_msg_size_t pad1; ! 314: unsigned int pad2 :16; ! 315: mach_msg_type_name_t disposition :8; ! 316: mach_msg_descriptor_type_t type :8; ! 317: } mach_msg_port_descriptor_t; ! 318: ! 319: typedef struct ! 320: { ! 321: void* address; ! 322: mach_msg_size_t size; ! 323: boolean_t deallocate :8; ! 324: mach_msg_copy_options_t copy :8; ! 325: unsigned int pad1 :8; ! 326: mach_msg_descriptor_type_t type :8; ! 327: } mach_msg_ool_descriptor_t; ! 328: ! 329: typedef struct ! 330: { ! 331: void* address; ! 332: mach_msg_size_t count; ! 333: boolean_t deallocate :8; ! 334: mach_msg_copy_options_t copy :8; ! 335: mach_msg_type_name_t disposition :8; ! 336: mach_msg_descriptor_type_t type :8; ! 337: } mach_msg_ool_ports_descriptor_t; ! 338: ! 339: typedef union ! 340: { ! 341: mach_msg_type_descriptor_t type; ! 342: mach_msg_port_descriptor_t port; ! 343: mach_msg_ool_descriptor_t out_of_line; ! 344: mach_msg_ool_ports_descriptor_t ool_ports; ! 345: } mach_msg_descriptor_t; ! 346: ! 347: #define MACH_MSG_DESCRIPTOR_NULL (mach_msg_descriptor_t *) 0 ! 348: ! 349: typedef struct ! 350: { ! 351: mach_msg_size_t msgh_descriptor_count; ! 352: } mach_msg_body_t; ! 353: ! 354: #define MACH_MSG_BODY_NULL (mach_msg_body_t *) 0 ! 355: ! 356: typedef struct ! 357: { ! 358: mach_msg_header_t header; ! 359: mach_msg_body_t body; ! 360: } mach_msg_base_t; ! 361: ! 362: typedef unsigned int mach_msg_trailer_type_t; ! 363: ! 364: #define MACH_MSG_TRAILER_FORMAT_0 0 ! 365: ! 366: typedef unsigned int mach_msg_trailer_size_t; ! 367: ! 368: typedef struct ! 369: { ! 370: mach_msg_trailer_type_t msgh_trailer_type; ! 371: mach_msg_trailer_size_t msgh_trailer_size; ! 372: } mach_msg_trailer_t; ! 373: ! 374: typedef struct ! 375: { ! 376: mach_msg_trailer_type_t msgh_trailer_type; ! 377: mach_msg_trailer_size_t msgh_trailer_size; ! 378: mach_port_seqno_t msgh_seqno; ! 379: } mach_msg_seqno_trailer_t; ! 380: ! 381: typedef struct ! 382: { ! 383: unsigned int val[2]; ! 384: } security_id_t; ! 385: ! 386: typedef struct ! 387: { ! 388: mach_msg_trailer_type_t msgh_trailer_type; ! 389: mach_msg_trailer_size_t msgh_trailer_size; ! 390: mach_port_seqno_t msgh_seqno; ! 391: security_id_t msgh_sender; ! 392: } mach_msg_security_trailer_t; ! 393: ! 394: typedef mach_msg_security_trailer_t mach_msg_format_0_trailer_t; ! 395: ! 396: #define MACH_MSG_TRAILER_FORMAT_0_SIZE sizeof(mach_msg_format_0_trailer_t) ! 397: #define MACH_MSG_TRAILER_MINIMUM_SIZE sizeof(mach_msg_trailer_t) ! 398: #define MAX_TRAILER_SIZE MACH_MSG_TRAILER_FORMAT_0_SIZE ! 399: ! 400: #define ANONYMOUS_SECURITY_ID_VALUE (security_id_t) { 0, 0 } ! 401: #define KERNEL_SECURITY_ID_VALUE (security_id_t) { 0, 1 } ! 402: ! 403: /* ! 404: * Values received/carried in messages. Tells the receiver what ! 405: * sort of port right he now has. ! 406: * ! 407: * MACH_MSG_TYPE_PORT_NAME is used to transfer a port name ! 408: * which should remain uninterpreted by the kernel. (Port rights ! 409: * are not transferred, just the port name.) ! 410: */ ! 411: ! 412: #define MACH_MSG_TYPE_PORT_NAME 15 ! 413: #define MACH_MSG_TYPE_PORT_RECEIVE MACH_MSG_TYPE_MOVE_RECEIVE ! 414: #define MACH_MSG_TYPE_PORT_SEND MACH_MSG_TYPE_MOVE_SEND ! 415: #define MACH_MSG_TYPE_PORT_SEND_ONCE MACH_MSG_TYPE_MOVE_SEND_ONCE ! 416: ! 417: #define MACH_MSG_TYPE_LAST 22 /* Last assigned */ ! 418: ! 419: /* ! 420: * A dummy value. Mostly used to indicate that the actual value ! 421: * will be filled in later, dynamically. ! 422: */ ! 423: ! 424: #define MACH_MSG_TYPE_POLYMORPHIC ((mach_msg_type_name_t) -1) ! 425: ! 426: /* ! 427: * Is a given item a port type? ! 428: */ ! 429: ! 430: #define MACH_MSG_TYPE_PORT_ANY(x) \ ! 431: (((x) >= MACH_MSG_TYPE_MOVE_RECEIVE) && \ ! 432: ((x) <= MACH_MSG_TYPE_MAKE_SEND_ONCE)) ! 433: ! 434: #define MACH_MSG_TYPE_PORT_ANY_SEND(x) \ ! 435: (((x) >= MACH_MSG_TYPE_MOVE_SEND) && \ ! 436: ((x) <= MACH_MSG_TYPE_MAKE_SEND_ONCE)) ! 437: ! 438: #define MACH_MSG_TYPE_PORT_ANY_RIGHT(x) \ ! 439: (((x) >= MACH_MSG_TYPE_MOVE_RECEIVE) && \ ! 440: ((x) <= MACH_MSG_TYPE_MOVE_SEND_ONCE)) ! 441: ! 442: typedef integer_t mach_msg_option_t; ! 443: ! 444: #define MACH_MSG_OPTION_NONE 0x00000000 ! 445: ! 446: #define MACH_SEND_MSG 0x00000001 ! 447: #define MACH_RCV_MSG 0x00000002 ! 448: ! 449: #define MACH_SEND_TIMEOUT 0x00000010 ! 450: #define MACH_SEND_NOTIFY 0x00000020 /* internal use only */ ! 451: #define MACH_SEND_INTERRUPT 0x00000040 /* libmach implements */ ! 452: #define MACH_SEND_CANCEL 0x00000080 ! 453: #define MACH_SEND_ALWAYS 0x00010000 /* internal use only */ ! 454: #define MACH_SEND_TRAILER 0x00020000 ! 455: #define MACH_SEND_SWITCH 0x00080000 /* internal use only */ ! 456: ! 457: #define MACH_RCV_TIMEOUT 0x00000100 ! 458: #define MACH_RCV_NOTIFY 0x00000200 ! 459: #define MACH_RCV_INTERRUPT 0x00000400 /* libmach implements */ ! 460: #define MACH_RCV_LARGE 0x00000800 ! 461: #define MACH_RCV_OVERWRITE 0x00001000 ! 462: #define MACH_RCV_OLD_FORMAT 0x00008000 /* internal use only */ ! 463: #define MACH_RCV_NO_TRAILER 0x00010000 /* non standard */ ! 464: ! 465: /* ! 466: * NOTE: a 0x00------ RCV mask implies to ask for ! 467: * a MACH_MSG_TRAILER_FORMAT_0 with 0 Elements, ! 468: * which is equivalent to a mach_msg_trailer_t. ! 469: */ ! 470: #define MACH_RCV_TRAILER_NULL 0 ! 471: #define MACH_RCV_TRAILER_SEQNO 1 ! 472: #define MACH_RCV_TRAILER_SENDER 2 ! 473: ! 474: #define MACH_RCV_TRAILER_TYPE(x) (((x) & 0xf) << 28) ! 475: #define MACH_RCV_TRAILER_ELEMENTS(x) (((x) & 0xf) << 24) ! 476: #define MACH_RCV_TRAILER_MASK ((0xff << 24)) ! 477: ! 478: extern mach_msg_size_t trailer_size[]; ! 479: ! 480: #define GET_RCV_ELEMENTS(y) (((y) >> 24) & 0xf) ! 481: #define REQUESTED_TRAILER_SIZE(y) (trailer_size[GET_RCV_ELEMENTS(y)]) ! 482: ! 483: /* ! 484: * Much code assumes that mach_msg_return_t == kern_return_t. ! 485: * This definition is useful for descriptive purposes. ! 486: * ! 487: * See <mach/error.h> for the format of error codes. ! 488: * IPC errors are system 4. Send errors are subsystem 0; ! 489: * receive errors are subsystem 1. The code field is always non-zero. ! 490: * The high bits of the code field communicate extra information ! 491: * for some error codes. MACH_MSG_MASK masks off these special bits. ! 492: */ ! 493: ! 494: typedef kern_return_t mach_msg_return_t; ! 495: ! 496: #define MACH_MSG_SUCCESS 0x00000000 ! 497: ! 498: #define MACH_MSG_MASK 0x00003c00 ! 499: /* All special error code bits defined below. */ ! 500: #define MACH_MSG_IPC_SPACE 0x00002000 ! 501: /* No room in IPC name space for another capability name. */ ! 502: #define MACH_MSG_VM_SPACE 0x00001000 ! 503: /* No room in VM address space for out-of-line memory. */ ! 504: #define MACH_MSG_IPC_KERNEL 0x00000800 ! 505: /* Kernel resource shortage handling an IPC capability. */ ! 506: #define MACH_MSG_VM_KERNEL 0x00000400 ! 507: /* Kernel resource shortage handling out-of-line memory. */ ! 508: ! 509: #define MACH_SEND_IN_PROGRESS 0x10000001 ! 510: /* Thread is waiting to send. (Internal use only.) */ ! 511: #define MACH_SEND_INVALID_DATA 0x10000002 ! 512: /* Bogus in-line data. */ ! 513: #define MACH_SEND_INVALID_DEST 0x10000003 ! 514: /* Bogus destination port. */ ! 515: #define MACH_SEND_TIMED_OUT 0x10000004 ! 516: /* Message not sent before timeout expired. */ ! 517: #define MACH_SEND_WILL_NOTIFY 0x10000005 ! 518: /* Msg-accepted notification will be generated. */ ! 519: #define MACH_SEND_NOTIFY_IN_PROGRESS 0x10000006 ! 520: /* Msg-accepted notification already pending. */ ! 521: #define MACH_SEND_INTERRUPTED 0x10000007 ! 522: /* Software interrupt. */ ! 523: #define MACH_SEND_MSG_TOO_SMALL 0x10000008 ! 524: /* Data doesn't contain a complete message. */ ! 525: #define MACH_SEND_INVALID_REPLY 0x10000009 ! 526: /* Bogus reply port. */ ! 527: #define MACH_SEND_INVALID_RIGHT 0x1000000a ! 528: /* Bogus port rights in the message body. */ ! 529: #define MACH_SEND_INVALID_NOTIFY 0x1000000b ! 530: /* Bogus notify port argument. */ ! 531: #define MACH_SEND_INVALID_MEMORY 0x1000000c ! 532: /* Invalid out-of-line memory pointer. */ ! 533: #define MACH_SEND_NO_BUFFER 0x1000000d ! 534: /* No message buffer is available. */ ! 535: #define MACH_SEND_NO_NOTIFY 0x1000000e ! 536: /* Resource shortage; can't request msg-accepted notif. */ ! 537: #define MACH_SEND_INVALID_TYPE 0x1000000f ! 538: /* Invalid msg-type specification. */ ! 539: #define MACH_SEND_INVALID_HEADER 0x10000010 ! 540: /* A field in the header had a bad value. */ ! 541: #define MACH_SEND_INVALID_TRAILER 0x10000011 ! 542: /* The trailer to be sent does not match kernel format. */ ! 543: ! 544: #define MACH_RCV_IN_PROGRESS 0x10004001 ! 545: /* Thread is waiting for receive. (Internal use only.) */ ! 546: #define MACH_RCV_INVALID_NAME 0x10004002 ! 547: /* Bogus name for receive port/port-set. */ ! 548: #define MACH_RCV_TIMED_OUT 0x10004003 ! 549: /* Didn't get a message within the timeout value. */ ! 550: #define MACH_RCV_TOO_LARGE 0x10004004 ! 551: /* Message buffer is not large enough for inline data. */ ! 552: #define MACH_RCV_INTERRUPTED 0x10004005 ! 553: /* Software interrupt. */ ! 554: #define MACH_RCV_PORT_CHANGED 0x10004006 ! 555: /* Port moved into a set during the receive. */ ! 556: #define MACH_RCV_INVALID_NOTIFY 0x10004007 ! 557: /* Bogus notify port argument. */ ! 558: #define MACH_RCV_INVALID_DATA 0x10004008 ! 559: /* Bogus message buffer for inline data. */ ! 560: #define MACH_RCV_PORT_DIED 0x10004009 ! 561: /* Port/set was sent away/died during receive. */ ! 562: #define MACH_RCV_IN_SET 0x1000400a ! 563: /* Port is a member of a port set. */ ! 564: #define MACH_RCV_HEADER_ERROR 0x1000400b ! 565: /* Error receiving message header. See special bits. */ ! 566: #define MACH_RCV_BODY_ERROR 0x1000400c ! 567: /* Error receiving message body. See special bits. */ ! 568: #define MACH_RCV_INVALID_TYPE 0x1000400d ! 569: /* Invalid msg-type specification in scatter list. */ ! 570: #define MACH_RCV_SCATTER_SMALL 0x1000400e ! 571: /* Out-of-line overwrite region is not large enough */ ! 572: #define MACH_RCV_INVALID_TRAILER 0x1000400f ! 573: /* The trailer type or the number of trailer elements aren't supported */ ! 574: ! 575: extern mach_msg_return_t mach_msg( ! 576: mach_msg_header_t *msg, ! 577: mach_msg_option_t option, ! 578: mach_msg_size_t send_size, ! 579: mach_msg_size_t rcv_limit, ! 580: mach_port_t rcv_name, ! 581: mach_msg_timeout_t timeout, ! 582: mach_port_t notify); ! 583: ! 584: extern mach_msg_return_t mach_msg_overwrite( ! 585: mach_msg_header_t *msg, ! 586: mach_msg_option_t option, ! 587: mach_msg_size_t send_size, ! 588: mach_msg_size_t rcv_limit, ! 589: mach_port_t rcv_name, ! 590: mach_msg_timeout_t timeout, ! 591: mach_port_t notify, ! 592: mach_msg_header_t *rcv_msg, ! 593: mach_msg_size_t rcv_msg_size); ! 594: ! 595: extern mach_msg_return_t mach_msg_simple_trap( ! 596: mach_msg_header_t *msg, ! 597: mach_msg_option_t option, ! 598: mach_msg_size_t send_size, ! 599: mach_msg_size_t rcv_limit, ! 600: mach_port_t rcv_name); ! 601: ! 602: extern mach_msg_return_t mach_msg_trap( ! 603: mach_msg_header_t *msg, ! 604: mach_msg_option_t option, ! 605: mach_msg_size_t send_size, ! 606: mach_msg_size_t rcv_limit, ! 607: mach_port_t rcv_name, ! 608: mach_msg_timeout_t timeout, ! 609: mach_port_t notify); ! 610: ! 611: extern mach_msg_return_t mach_msg_overwrite_trap( ! 612: mach_msg_header_t *msg, ! 613: mach_msg_option_t option, ! 614: mach_msg_size_t send_size, ! 615: mach_msg_size_t rcv_limit, ! 616: mach_port_t rcv_name, ! 617: mach_msg_timeout_t timeout, ! 618: mach_port_t notify, ! 619: mach_msg_header_t *rcv_msg, ! 620: mach_msg_size_t rcv_msg_size); ! 621: ! 622: ! 623: /* Definitions for the old IPC interface. */ ! 624: ! 625: /* ! 626: * Message data structures. ! 627: * ! 628: * Messages consist of two parts: a fixed-size header, immediately ! 629: * followed by a variable-size array of typed data items. ! 630: * ! 631: */ ! 632: ! 633: typedef unsigned int msg_size_t; ! 634: ! 635: typedef struct { ! 636: unsigned int msg_unused : 24, ! 637: msg_simple : 8; ! 638: msg_size_t msg_size; ! 639: integer_t msg_type; ! 640: port_t msg_local_port; ! 641: port_t msg_remote_port; ! 642: integer_t msg_id; ! 643: } msg_header_t; ! 644: ! 645: #define MSG_SIZE_MAX 8192 ! 646: ! 647: /* ! 648: * Known values for the msg_type field. ! 649: * These are Accent holdovers, which should be purged when possible. ! 650: * ! 651: * Only one bit in the msg_type field is used by the kernel. ! 652: * Others are available to user applications. See <msg_type.h> ! 653: * for system application-assigned values. ! 654: */ ! 655: ! 656: #define MSG_TYPE_NORMAL 0 ! 657: #define MSG_TYPE_EMERGENCY 1 ! 658: ! 659: /* ! 660: * Each data item is preceded by a description of that ! 661: * item, including what type of data, how big it is, and ! 662: * how many of them are present. ! 663: * ! 664: * The actual data will either follow this type ! 665: * descriptor ("inline") or will be specified by a pointer. ! 666: * ! 667: * If the type name, size, or number is too large to be encoded ! 668: * in this structure, the "longform" option may be selected, ! 669: * and those fields must immediately follow in full integer fields. ! 670: * ! 671: * For convenience, out-of-line data regions or port rights may ! 672: * be deallocated when the message is sent by specifying the ! 673: * "deallocate" field. Beware: if the data item in question is both ! 674: * out-of-line and contains port rights, then both will be deallocated. ! 675: */ ! 676: ! 677: typedef struct { ! 678: unsigned int msg_type_name : 8, ! 679: /* What kind of data */ ! 680: msg_type_size : 8, ! 681: /* How many bits is each item */ ! 682: msg_type_number : 12, ! 683: /* How many items are there */ ! 684: msg_type_inline : 1, ! 685: /* If true, data follows; else a pointer */ ! 686: msg_type_longform : 1, ! 687: /* Name, size, number follow: see above */ ! 688: msg_type_deallocate : 1, ! 689: /* Deallocate port rights or memory */ ! 690: msg_type_unused : 1; ! 691: } msg_type_t; ! 692: ! 693: typedef struct { ! 694: msg_type_t msg_type_header; ! 695: unsigned short msg_type_long_name; ! 696: unsigned short msg_type_long_size; ! 697: natural_t msg_type_long_number; ! 698: } msg_type_long_t; ! 699: ! 700: /* ! 701: * Known values for the msg_type_name field. ! 702: * ! 703: * The only types known to the Mach kernel are ! 704: * the port types, and those types used in the ! 705: * kernel RPC interface. ! 706: */ ! 707: ! 708: #define MSG_TYPE_UNSTRUCTURED 0 ! 709: #define MSG_TYPE_BIT 0 ! 710: #define MSG_TYPE_BOOLEAN 0 ! 711: #define MSG_TYPE_INTEGER_16 1 ! 712: #define MSG_TYPE_INTEGER_32 2 ! 713: #define MSG_TYPE_PORT_OWNERSHIP 3 /* obsolete */ ! 714: #define MSG_TYPE_PORT_RECEIVE 4 /* obsolete */ ! 715: #define MSG_TYPE_PORT_ALL 5 ! 716: #define MSG_TYPE_PORT 6 ! 717: #define MSG_TYPE_CHAR 8 ! 718: #define MSG_TYPE_BYTE 9 ! 719: #define MSG_TYPE_INTEGER_8 9 ! 720: #define MSG_TYPE_REAL 10 ! 721: #define MSG_TYPE_STRING 12 ! 722: #define MSG_TYPE_STRING_C 12 ! 723: /* MSG_TYPE_INVALID 13 unused */ ! 724: /* 14 unused */ ! 725: ! 726: #define MSG_TYPE_PORT_NAME 15 /* A capability name */ ! 727: #define MSG_TYPE_LAST 16 /* Last assigned */ ! 728: ! 729: #define MSG_TYPE_POLYMORPHIC ((unsigned int) -1) ! 730: ! 731: /* ! 732: * Is a given item a port type? ! 733: */ ! 734: ! 735: #define MSG_TYPE_PORT_ANY(x) \ ! 736: (((x) == MSG_TYPE_PORT) || ((x) == MSG_TYPE_PORT_ALL)) ! 737: ! 738: /* ! 739: * Other basic types ! 740: */ ! 741: ! 742: typedef natural_t msg_timeout_t; ! 743: ! 744: /* ! 745: * Options to IPC primitives. ! 746: * ! 747: * These can be combined by or'ing; the combination RPC call ! 748: * uses both SEND_ and RCV_ options at once. ! 749: */ ! 750: ! 751: typedef integer_t msg_option_t; ! 752: ! 753: #define MSG_OPTION_NONE 0x0000 /* Terminate only when message op works */ ! 754: ! 755: #define SEND_TIMEOUT 0x0001 /* Terminate on timeout elapsed */ ! 756: #define SEND_NOTIFY 0x0002 /* Terminate with reply message if need be */ ! 757: ! 758: #define SEND_INTERRUPT 0x0004 /* Terminate on software interrupt */ ! 759: ! 760: #define SEND_SWITCH 0x0020 /* Use handoff scheduling */ ! 761: ! 762: #define RCV_TIMEOUT 0x0100 /* Terminate on timeout elapsed */ ! 763: #define RCV_NO_SENDERS 0x0200 /* Terminate if I'm the only sender left */ ! 764: #define RCV_INTERRUPT 0x0400 /* Terminate on software interrupt */ ! 765: #define RCV_LARGE 0x1000 ! 766: ! 767: /* ! 768: * Returns from IPC primitives. ! 769: * ! 770: * Values are separate in order to allow RPC users to ! 771: * distinguish which operation failed; for successful completion, ! 772: * this doesn't matter. ! 773: */ ! 774: ! 775: typedef int msg_return_t; ! 776: ! 777: #define SEND_SUCCESS 0 ! 778: ! 779: #define SEND_ERRORS_START -100 ! 780: #define SEND_INVALID_MEMORY -101 /* Message or OOL data invalid */ ! 781: #define SEND_INVALID_PORT -102 /* Reference to inacessible port */ ! 782: #define SEND_TIMED_OUT -103 /* Terminated due to timeout */ ! 783: #define SEND_WILL_NOTIFY -105 /* Msg accepted provisionally */ ! 784: #define SEND_NOTIFY_IN_PROGRESS -106 /* Already awaiting a notification */ ! 785: #define SEND_KERNEL_REFUSED -107 /* Message to the kernel refused */ ! 786: #define SEND_INTERRUPTED -108 /* Software interrupt during send */ ! 787: #define SEND_MSG_TOO_LARGE -109 /* Message specified was too large */ ! 788: #define SEND_MSG_TOO_SMALL -110 /* Data specified exceeds msg size */ ! 789: /* SEND_MSG_SIZE_CHANGE -111 Msg size changed during copy */ ! 790: #define SEND_ERRORS_END -111 ! 791: ! 792: #define msg_return_send(x) ((x) < SEND_ERRORS_START && \ ! 793: (x) > SEND_ERRORS_END) ! 794: ! 795: #define RCV_SUCCESS 0 ! 796: ! 797: #define RCV_ERRORS_START -200 ! 798: #define RCV_INVALID_MEMORY -201 ! 799: #define RCV_INVALID_PORT -202 ! 800: #define RCV_TIMED_OUT -203 ! 801: #define RCV_TOO_LARGE -204 /* Msg structure too small for data */ ! 802: #define RCV_NOT_ENOUGH_MEMORY -205 /* Can't find space for OOL data */ ! 803: #define RCV_ONLY_SENDER -206 /* Receiver is only sender */ ! 804: #define RCV_INTERRUPTED -207 ! 805: #define RCV_PORT_CHANGE -208 /* Port was put in a set */ ! 806: #define RCV_ERRORS_END -209 ! 807: ! 808: #define msg_return_rcv(x) ((x) < RCV_ERRORS_START && \ ! 809: (x) > RCV_ERRORS_END) ! 810: ! 811: #define RPC_SUCCESS 0 ! 812: ! 813: /* ! 814: * The IPC primitive functions themselves ! 815: */ ! 816: ! 817: msg_return_t msg_send( ! 818: msg_header_t *header, ! 819: msg_option_t option, ! 820: msg_timeout_t timeout); ! 821: ! 822: msg_return_t msg_receive( ! 823: msg_header_t *header, ! 824: msg_option_t option, ! 825: msg_timeout_t timeout); ! 826: ! 827: msg_return_t msg_rpc( ! 828: msg_header_t *header, /* in/out */ ! 829: msg_option_t option, ! 830: msg_size_t rcv_size, ! 831: msg_timeout_t send_timeout, ! 832: msg_timeout_t rcv_timeout); ! 833: ! 834: msg_return_t msg_send_trap( ! 835: msg_header_t *header, ! 836: msg_option_t option, ! 837: msg_size_t send_size, ! 838: msg_timeout_t timeout); ! 839: ! 840: msg_return_t msg_receive_trap( ! 841: msg_header_t *header, ! 842: msg_option_t option, ! 843: msg_size_t rcv_size, ! 844: port_name_t rcv_name, ! 845: msg_timeout_t timeout); ! 846: ! 847: msg_return_t msg_rpc_trap( ! 848: msg_header_t *header, /* in/out */ ! 849: msg_option_t option, ! 850: msg_size_t send_size, ! 851: msg_size_t rcv_size, ! 852: msg_timeout_t send_timeout, ! 853: msg_timeout_t rcv_timeout); ! 854: ! 855: #endif /* _MACH_MESSAGE_H_ */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.