Formerly ../mach/hello.c.~4~
[kopensolaris-gnu/glibc.git] / mach / msg-destroy.c
1 /* 
2  * Mach Operating System
3  * Copyright (c) 1991,1990 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  Software.Distribution@CS.CMU.EDU
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  * HISTORY
28  * $Log$
29  * Revision 1.1  1991/10/23 12:49:45  roland
30  * Initial revision
31  *
32  * Revision 2.4  91/05/14  17:53:15  mrt
33  *      Correcting copyright
34  * 
35  * Revision 2.3  91/02/14  14:17:43  mrt
36  *      Added new Mach copyright
37  *      [91/02/13  12:44:15  mrt]
38  * 
39  * Revision 2.2  90/08/06  17:24:22  rpd
40  *      Created.
41  * 
42  */
43
44 #include <mach/port.h>
45 #include <mach/message.h>
46 #include <mach_init.h>
47
48 static void mach_msg_destroy_port();
49 static void mach_msg_destroy_memory();
50
51 /*
52  *      Routine:        mach_msg_destroy
53  *      Purpose:
54  *              Deallocates all port rights and out-of-line memory
55  *              found in a received message.
56  */
57
58 void
59 __mach_msg_destroy(msg)
60     mach_msg_header_t *msg;
61 {
62     mach_msg_bits_t mbits = msg->msgh_bits;
63
64     /*
65      *  The msgh_local_port field doesn't hold a port right.
66      *  The receive operation consumes the destination port right.
67      */
68
69     mach_msg_destroy_port(msg->msgh_remote_port, MACH_MSGH_BITS_REMOTE(mbits));
70
71     if (mbits & MACH_MSGH_BITS_COMPLEX) {
72         vm_offset_t saddr;
73         vm_offset_t eaddr;
74
75         saddr = (vm_offset_t) (msg + 1);
76         eaddr = (vm_offset_t) msg + msg->msgh_size;
77
78         while (saddr < eaddr) {
79             mach_msg_type_long_t *type;
80             mach_msg_type_name_t name;
81             mach_msg_type_size_t size;
82             mach_msg_type_number_t number;
83             boolean_t is_inline;
84             vm_size_t length;
85             vm_offset_t addr;
86
87             type = (mach_msg_type_long_t *) saddr;
88             is_inline = type->msgtl_header.msgt_inline;
89             if (type->msgtl_header.msgt_longform) {
90                     name = type->msgtl_name;
91                     size = type->msgtl_size;
92                     number = type->msgtl_number;
93                     saddr += sizeof(mach_msg_type_long_t);
94             } else {
95                     name = type->msgtl_header.msgt_name;
96                     size = type->msgtl_header.msgt_size;
97                     number = type->msgtl_header.msgt_number;
98                     saddr += sizeof(mach_msg_type_t);
99             }
100
101             /* calculate length of data in bytes, rounding up */
102             length = ((((number * size) + 7) >> 3) + 3) &~ 3;
103
104             addr = is_inline ? saddr : * (vm_offset_t *) saddr;
105
106             if (MACH_MSG_TYPE_PORT_ANY(name)) {
107                 mach_port_t *ports = (mach_port_t *) addr;
108                 mach_msg_type_number_t i;
109
110                 for (i = 0; i < number; i++)
111                     mach_msg_destroy_port(*ports++, name);
112             }
113
114             if (is_inline) {
115                 /* inline data sizes round up to int boundaries */
116                 saddr += length;
117             } else {
118                 mach_msg_destroy_memory(addr, length);
119                 saddr += sizeof(vm_offset_t);
120             }
121         }
122     }
123 }
124
125 static void
126 mach_msg_destroy_port(port, type)
127     mach_port_t port;
128     mach_msg_type_name_t type;
129 {
130     if (MACH_PORT_VALID(port)) switch (type) {
131       case MACH_MSG_TYPE_PORT_SEND:
132       case MACH_MSG_TYPE_PORT_SEND_ONCE:
133         (void) __mach_port_deallocate(__mach_task_self(), port);
134         break;
135
136       case MACH_MSG_TYPE_PORT_RECEIVE:
137         (void) __mach_port_mod_refs(__mach_task_self(), port,
138                                     MACH_PORT_RIGHT_RECEIVE, -1);
139         break;
140     }
141 }
142
143 static void
144 mach_msg_destroy_memory(addr, size)
145     vm_offset_t addr;
146     vm_size_t size;
147 {
148     if (size > 0)
149         (void) __vm_deallocate(__mach_task_self(), addr, size);
150 }