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