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