libvtv/vtv_malloc.cc

   1 /* Copyright (C) 2012-2018 Free Software Foundation, Inc.
   2
   3    This file is part of GCC.
   4
   5    GCC is free software; you can redistribute it and/or modify
   6    it under the terms of the GNU General Public License as published by
   7    the Free Software Foundation; either version 3, or (at your option)
   8    any later version.
   9
  10    GCC is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13    GNU General Public License for more details.
  14
  15    Under Section 7 of GPL version 3, you are granted additional
  16    permissions described in the GCC Runtime Library Exception, version
  17    3.1, as published by the Free Software Foundation.
  18
  19    You should have received a copy of the GNU General Public License and
  20    a copy of the GCC Runtime Library Exception along with this program;
  21    see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  22    <http://www.gnu.org/licenses/>.  */
  23
  24 /* This file is part of the vtable verification runtime library.  It
  25    contains our memory allocation and deallocation routines, which we
  26    use in order to keep track of the pages in memory in which our sets
  27    of valid vtable pointes are stored.  (We need to know the pages so
  28    we can set the protections on them appropriately).  For more
  29    information about the vtable verification feature, see the comments
  30    in vtv_rts.cc.  We use the existing obstack implementation in our
  31    memory allocation scheme.  */
  32
  33 #include <stdlib.h>
  34 #include <unistd.h>
  35 #if defined (__CYGWIN__) || defined (__MINGW32__)
  36 #include <windows.h>
  37 #else
  38 #include <sys/mman.h>
  39 #endif
  40 #include <sys/types.h>
  41 #include <sys/stat.h>
  42 #include <fcntl.h>
  43 #include <stdio.h>
  44
  45 #include "vtv_utils.h"
  46 #include "vtv_malloc.h"
  47 #include "obstack.h"
  48
  49 /* The following variables are used only for debugging and performance tuning
  50    purposes. Therefore they do not need to be "protected".  They cannot be used
  51    to attack the vtable verification system and if they become corrupted it will
  52    not affect the correctness or security of any of the rest of the vtable
  53    verification feature.  */
  54
  55 unsigned int num_calls_to_mprotect = 0;
  56 unsigned int num_pages_protected = 0;
  57 unsigned int long long mprotect_cycles = 0;
  58
  59 /* Put the following variables in our ".vtable_map_vars" section so
  60    that they are protected.  They are explicitly unprotected and
  61    protected again by calls to __vtv_unprotect and __vtv_protect */
  62
  63 static struct obstack vtv_obstack VTV_PROTECTED_VAR;
  64 static void *current_chunk VTV_PROTECTED_VAR = 0;
  65 static size_t current_chunk_size VTV_PROTECTED_VAR = 0;
  66 static int malloc_initialized VTV_PROTECTED_VAR = 0;
  67
  68 #if defined (__CYGWIN__) || defined (__MINGW32__)
  69 //sysconf(_SC_PAGE_SIZE) port
  70 long sysconf_SC_PAGE_SIZE()
  71 {
  72   SYSTEM_INFO si;
  73   GetSystemInfo(&si);
  74   long pageSize = (long)si.dwPageSize;
  75   return pageSize;
  76   //return 4096; // standard usermode 32bit pagesize in bytes // FIXME
  77 }
  78 #endif
  79
  80 /* The function goes through and counts all the pages we have allocated
  81    so far.  It returns the page count.  */
  82
  83 int
  84 __vtv_count_mmapped_pages (void)
  85 {
  86   int count = 0;
  87   struct _obstack_chunk * ci = (struct _obstack_chunk *) current_chunk;
  88   while (ci)
  89     {
  90       count++;
  91       ci = ci->prev;
  92     }
  93
  94   return count;
  95 }
  96
  97 /* This function goes through all of the pages we have allocated so
  98    far and calls mprotect to change the protections on the pages,
  99    according to the value of PROTECTION_FLAG.  */
 100
 101 static void
 102 change_protections_on_data_chunks (int protection_flag)
 103 {
 104   struct _obstack_chunk *ci;
 105   ci = (struct _obstack_chunk *) current_chunk;
 106
 107   while (ci)
 108     {
 109       /* Initial set up for mprotect call.*/
 110       struct _obstack_chunk *protect_start = ci;
 111       size_t chunk_size;
 112       size_t total_size;
 113       unsigned int num_pages_in_chunk;
 114       char *next_page;
 115       unsigned long long start, end;
 116       int result;
 117
 118
 119       /* As long as the next 'chunk' is adjacent to the current one,
 120          keep going down the list.  */
 121       do
 122         {
 123           chunk_size = (ci->limit - (char *) ci);
 124           total_size = (ci->limit - (char *) protect_start);
 125           num_pages_in_chunk = chunk_size / VTV_PAGE_SIZE;
 126           if (chunk_size % VTV_PAGE_SIZE > 0)
 127             num_pages_in_chunk++;
 128           next_page = (char *) ci + (num_pages_in_chunk * VTV_PAGE_SIZE);
 129           ci = ci->prev;
 130         } while (ci && (char *) ci == next_page);
 131
 132       VTV_DEBUG_ASSERT (((unsigned long) protect_start & (VTV_PAGE_SIZE - 1))
 133                                                                        == 0);
 134
 135       /* Protect the contiguous chunks so far.  */
 136       start = rdtsc ();
 137       result = mprotect (protect_start, total_size, protection_flag);
 138       end = rdtsc ();
 139       mprotect_cycles += end - start;
 140       if (result == -1)
 141         VTV_error ();
 142       num_calls_to_mprotect++;
 143       num_pages_protected += (total_size + VTV_PAGE_SIZE - 1)/ VTV_PAGE_SIZE;
 144     }
 145
 146 #ifdef VTV_DEBUG
 147     __vtv_malloc_dump_stats ();
 148 #endif
 149 }
 150
 151 /* This function makes all of our allocated pages read-only.  */
 152
 153 void
 154 __vtv_malloc_protect (void)
 155 {
 156   change_protections_on_data_chunks (PROT_READ);
 157 }
 158
 159 /* This function makes all of our allocated pages read-write.  */
 160
 161 void
 162 __vtv_malloc_unprotect (void)
 163 {
 164   change_protections_on_data_chunks (PROT_READ | PROT_WRITE);
 165 }
 166
 167 /* Allocates a SIZE-sized chunk of memory that is aligned to a page
 168    boundary.  The amount of memory requested (SIZE) must be a multiple
 169    of the page size.  Note: We must use mmap to allocate the memory;
 170    using malloc here will cause problems.  */
 171
 172 static void *
 173 obstack_chunk_alloc (size_t size)
 174 {
 175   /* Increase size to the next multiple of VTV_PAGE_SIZE.   */
 176   size = (size + (VTV_PAGE_SIZE - 1)) & (~(VTV_PAGE_SIZE - 1));
 177   VTV_DEBUG_ASSERT ((size & (VTV_PAGE_SIZE - 1)) == 0);
 178   void *allocated;
 179
 180 #if defined (__CYGWIN__) || defined (__MINGW32__)
 181   if ((allocated = VirtualAlloc(NULL, size,  MEM_RESERVE|MEM_COMMIT,
 182                          PAGE_READWRITE)) == 0)
 183 #else
 184   if ((allocated = mmap (NULL, size, PROT_READ | PROT_WRITE,
 185                          MAP_PRIVATE | MAP_ANONYMOUS,  -1, 0)) == 0)
 186 #endif
 187     VTV_error ();
 188
 189   VTV_DEBUG_ASSERT (((unsigned long) allocated & (VTV_PAGE_SIZE - 1)) == 0);
 190
 191   current_chunk = allocated;
 192   current_chunk_size = size;
 193   return allocated;
 194 }
 195
 196 static void
 197 obstack_chunk_free (void *)
 198 {
 199   /* Do nothing. For our purposes there should be very little
 200      de-allocation. */
 201 }
 202
 203 /* This function sets up and initializes the obstack pieces for our
 204    memory allocation scheme.  */
 205
 206 void
 207 __vtv_malloc_init (void)
 208 {
 209   /* Make sure we only execute the main body of this function ONCE.  */
 210   if (malloc_initialized)
 211     return;
 212
 213 #if defined (__CYGWIN__) || defined (__MINGW32__)
 214   if (VTV_PAGE_SIZE != sysconf_SC_PAGE_SIZE())
 215 #else
 216   if (VTV_PAGE_SIZE != sysconf (_SC_PAGE_SIZE))
 217 #endif
 218     VTV_error ();
 219
 220   /* We guarantee that the obstack alloc failed handler will never be
 221      called because in case the allocation of the chunk fails, it will
 222      never return */
 223   obstack_alloc_failed_handler = NULL;
 224
 225   obstack_specify_allocation (&vtv_obstack, VTV_PAGE_SIZE, sizeof (long),
 226                               obstack_chunk_alloc, obstack_chunk_free);
 227   malloc_initialized = 1;
 228 }
 229
 230 /* This is our external interface for the memory allocation.  SIZE is
 231    the requested number of bytes to be allocated/  */
 232
 233 void *
 234 __vtv_malloc (size_t size)
 235 {
 236   return obstack_alloc (&vtv_obstack, size);
 237 }
 238
 239
 240 /* This is our external interface for memory deallocation.  */
 241
 242 void
 243 __vtv_free (void *)
 244 {
 245   /* Do nothing. We dont care about recovering unneded memory at this
 246      time.  */
 247 }
 248
 249
 250 /* This is a debugging function tat collects statistics about our
 251    memory allocation.  */
 252 void
 253 __vtv_malloc_stats (void)
 254 {
 255   int count = 0;
 256   struct _obstack_chunk * ci = (struct _obstack_chunk *) current_chunk;
 257   while (ci)
 258     {
 259       count++;
 260       ci = ci->prev;
 261     }
 262   fprintf (stderr,
 263            "__vtv_malloc_stats:\n  Page Size = %lu bytes\n  "
 264            "Number of pages = %d\n", static_cast<unsigned long>(VTV_PAGE_SIZE),
 265            count);
 266 }
 267
 268 /* This is a debugging function.  It writes out our memory allocation
 269    statistics to a log file.  */
 270
 271 void
 272 __vtv_malloc_dump_stats (void)
 273 {
 274   static int fd = -1;
 275
 276   if (fd == -1)
 277     fd = __vtv_open_log ("vtv_mem_protection.log");
 278   if (fd == -1)
 279     return;
 280
 281   int count = 0;
 282   struct _obstack_chunk * ci = (struct _obstack_chunk *) current_chunk;
 283   while (ci)
 284     {
 285       count++;
 286       ci = ci->prev;
 287     }
 288
 289   __vtv_add_to_log (fd, "__vtv_malloc_protect protected=%d pages\n", count);
 290 }