libvtv/vtv_malloc.cc

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