291 lines
8.4 KiB
C++
291 lines
8.4 KiB
C++
|
/* Copyright (C) 2012-2022 Free Software Foundation, Inc.
|
||
|
|
||
|
This file is part of GCC.
|
||
|
|
||
|
GCC is free software; you can redistribute it and/or modify
|
||
|
it under the terms of the GNU General Public License as published by
|
||
|
the Free Software Foundation; either version 3, or (at your option)
|
||
|
any later version.
|
||
|
|
||
|
GCC is distributed in the hope that it will be useful,
|
||
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
|
GNU General Public License for more details.
|
||
|
|
||
|
Under Section 7 of GPL version 3, you are granted additional
|
||
|
permissions described in the GCC Runtime Library Exception, version
|
||
|
3.1, as published by the Free Software Foundation.
|
||
|
|
||
|
You should have received a copy of the GNU General Public License and
|
||
|
a copy of the GCC Runtime Library Exception along with this program;
|
||
|
see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
|
||
|
<http://www.gnu.org/licenses/>. */
|
||
|
|
||
|
/* This file is part of the vtable verification runtime library. It
|
||
|
contains our memory allocation and deallocation routines, which we
|
||
|
use in order to keep track of the pages in memory in which our sets
|
||
|
of valid vtable pointes are stored. (We need to know the pages so
|
||
|
we can set the protections on them appropriately). For more
|
||
|
information about the vtable verification feature, see the comments
|
||
|
in vtv_rts.cc. We use the existing obstack implementation in our
|
||
|
memory allocation scheme. */
|
||
|
|
||
|
#include <stdlib.h>
|
||
|
#include <unistd.h>
|
||
|
#if defined (__CYGWIN__) || defined (__MINGW32__)
|
||
|
#include <windows.h>
|
||
|
#else
|
||
|
#include <sys/mman.h>
|
||
|
#endif
|
||
|
#include <sys/types.h>
|
||
|
#include <sys/stat.h>
|
||
|
#include <fcntl.h>
|
||
|
#include <stdio.h>
|
||
|
|
||
|
#include "vtv_utils.h"
|
||
|
#include "vtv_malloc.h"
|
||
|
#include "obstack.h"
|
||
|
|
||
|
/* The following variables are used only for debugging and performance tuning
|
||
|
purposes. Therefore they do not need to be "protected". They cannot be used
|
||
|
to attack the vtable verification system and if they become corrupted it will
|
||
|
not affect the correctness or security of any of the rest of the vtable
|
||
|
verification feature. */
|
||
|
|
||
|
unsigned int num_calls_to_mprotect = 0;
|
||
|
unsigned int num_pages_protected = 0;
|
||
|
unsigned int long long mprotect_cycles = 0;
|
||
|
|
||
|
/* Put the following variables in our ".vtable_map_vars" section so
|
||
|
that they are protected. They are explicitly unprotected and
|
||
|
protected again by calls to __vtv_unprotect and __vtv_protect */
|
||
|
|
||
|
static struct obstack vtv_obstack VTV_PROTECTED_VAR;
|
||
|
static void *current_chunk VTV_PROTECTED_VAR = 0;
|
||
|
static size_t current_chunk_size VTV_PROTECTED_VAR = 0;
|
||
|
static int malloc_initialized VTV_PROTECTED_VAR = 0;
|
||
|
|
||
|
#if defined (__CYGWIN__) || defined (__MINGW32__)
|
||
|
//sysconf(_SC_PAGE_SIZE) port
|
||
|
long sysconf_SC_PAGE_SIZE()
|
||
|
{
|
||
|
SYSTEM_INFO si;
|
||
|
GetSystemInfo(&si);
|
||
|
long pageSize = (long)si.dwPageSize;
|
||
|
return pageSize;
|
||
|
//return 4096; // standard usermode 32bit pagesize in bytes // FIXME
|
||
|
}
|
||
|
#endif
|
||
|
|
||
|
/* The function goes through and counts all the pages we have allocated
|
||
|
so far. It returns the page count. */
|
||
|
|
||
|
int
|
||
|
__vtv_count_mmapped_pages (void)
|
||
|
{
|
||
|
int count = 0;
|
||
|
struct _obstack_chunk * ci = (struct _obstack_chunk *) current_chunk;
|
||
|
while (ci)
|
||
|
{
|
||
|
count++;
|
||
|
ci = ci->prev;
|
||
|
}
|
||
|
|
||
|
return count;
|
||
|
}
|
||
|
|
||
|
/* This function goes through all of the pages we have allocated so
|
||
|
far and calls mprotect to change the protections on the pages,
|
||
|
according to the value of PROTECTION_FLAG. */
|
||
|
|
||
|
static void
|
||
|
change_protections_on_data_chunks (int protection_flag)
|
||
|
{
|
||
|
struct _obstack_chunk *ci;
|
||
|
ci = (struct _obstack_chunk *) current_chunk;
|
||
|
|
||
|
while (ci)
|
||
|
{
|
||
|
/* Initial set up for mprotect call.*/
|
||
|
struct _obstack_chunk *protect_start = ci;
|
||
|
size_t chunk_size;
|
||
|
size_t total_size;
|
||
|
unsigned int num_pages_in_chunk;
|
||
|
char *next_page;
|
||
|
unsigned long long start, end;
|
||
|
int result;
|
||
|
|
||
|
|
||
|
/* As long as the next 'chunk' is adjacent to the current one,
|
||
|
keep going down the list. */
|
||
|
do
|
||
|
{
|
||
|
chunk_size = (ci->limit - (char *) ci);
|
||
|
total_size = (ci->limit - (char *) protect_start);
|
||
|
num_pages_in_chunk = chunk_size / VTV_PAGE_SIZE;
|
||
|
if (chunk_size % VTV_PAGE_SIZE > 0)
|
||
|
num_pages_in_chunk++;
|
||
|
next_page = (char *) ci + (num_pages_in_chunk * VTV_PAGE_SIZE);
|
||
|
ci = ci->prev;
|
||
|
} while (ci && (char *) ci == next_page);
|
||
|
|
||
|
VTV_DEBUG_ASSERT (((unsigned long) protect_start & (VTV_PAGE_SIZE - 1))
|
||
|
== 0);
|
||
|
|
||
|
/* Protect the contiguous chunks so far. */
|
||
|
start = rdtsc ();
|
||
|
result = mprotect (protect_start, total_size, protection_flag);
|
||
|
end = rdtsc ();
|
||
|
mprotect_cycles += end - start;
|
||
|
if (result == -1)
|
||
|
VTV_error ();
|
||
|
num_calls_to_mprotect++;
|
||
|
num_pages_protected += (total_size + VTV_PAGE_SIZE - 1)/ VTV_PAGE_SIZE;
|
||
|
}
|
||
|
|
||
|
#ifdef VTV_DEBUG
|
||
|
__vtv_malloc_dump_stats ();
|
||
|
#endif
|
||
|
}
|
||
|
|
||
|
/* This function makes all of our allocated pages read-only. */
|
||
|
|
||
|
void
|
||
|
__vtv_malloc_protect (void)
|
||
|
{
|
||
|
change_protections_on_data_chunks (PROT_READ);
|
||
|
}
|
||
|
|
||
|
/* This function makes all of our allocated pages read-write. */
|
||
|
|
||
|
void
|
||
|
__vtv_malloc_unprotect (void)
|
||
|
{
|
||
|
change_protections_on_data_chunks (PROT_READ | PROT_WRITE);
|
||
|
}
|
||
|
|
||
|
/* Allocates a SIZE-sized chunk of memory that is aligned to a page
|
||
|
boundary. The amount of memory requested (SIZE) must be a multiple
|
||
|
of the page size. Note: We must use mmap to allocate the memory;
|
||
|
using malloc here will cause problems. */
|
||
|
|
||
|
static void *
|
||
|
obstack_chunk_alloc (size_t size)
|
||
|
{
|
||
|
/* Increase size to the next multiple of VTV_PAGE_SIZE. */
|
||
|
size = (size + (VTV_PAGE_SIZE - 1)) & (~(VTV_PAGE_SIZE - 1));
|
||
|
VTV_DEBUG_ASSERT ((size & (VTV_PAGE_SIZE - 1)) == 0);
|
||
|
void *allocated;
|
||
|
|
||
|
#if defined (__CYGWIN__) || defined (__MINGW32__)
|
||
|
if ((allocated = VirtualAlloc(NULL, size, MEM_RESERVE|MEM_COMMIT,
|
||
|
PAGE_READWRITE)) == 0)
|
||
|
#else
|
||
|
if ((allocated = mmap (NULL, size, PROT_READ | PROT_WRITE,
|
||
|
MAP_PRIVATE | MAP_ANONYMOUS, -1, 0)) == 0)
|
||
|
#endif
|
||
|
VTV_error ();
|
||
|
|
||
|
VTV_DEBUG_ASSERT (((unsigned long) allocated & (VTV_PAGE_SIZE - 1)) == 0);
|
||
|
|
||
|
current_chunk = allocated;
|
||
|
current_chunk_size = size;
|
||
|
return allocated;
|
||
|
}
|
||
|
|
||
|
static void
|
||
|
obstack_chunk_free (void *)
|
||
|
{
|
||
|
/* Do nothing. For our purposes there should be very little
|
||
|
de-allocation. */
|
||
|
}
|
||
|
|
||
|
/* This function sets up and initializes the obstack pieces for our
|
||
|
memory allocation scheme. */
|
||
|
|
||
|
void
|
||
|
__vtv_malloc_init (void)
|
||
|
{
|
||
|
/* Make sure we only execute the main body of this function ONCE. */
|
||
|
if (malloc_initialized)
|
||
|
return;
|
||
|
|
||
|
#if defined (__CYGWIN__) || defined (__MINGW32__)
|
||
|
if (VTV_PAGE_SIZE != sysconf_SC_PAGE_SIZE())
|
||
|
#else
|
||
|
if (VTV_PAGE_SIZE != sysconf (_SC_PAGE_SIZE))
|
||
|
#endif
|
||
|
VTV_error ();
|
||
|
|
||
|
/* We guarantee that the obstack alloc failed handler will never be
|
||
|
called because in case the allocation of the chunk fails, it will
|
||
|
never return */
|
||
|
obstack_alloc_failed_handler = NULL;
|
||
|
|
||
|
obstack_specify_allocation (&vtv_obstack, VTV_PAGE_SIZE, sizeof (long),
|
||
|
obstack_chunk_alloc, obstack_chunk_free);
|
||
|
malloc_initialized = 1;
|
||
|
}
|
||
|
|
||
|
/* This is our external interface for the memory allocation. SIZE is
|
||
|
the requested number of bytes to be allocated/ */
|
||
|
|
||
|
void *
|
||
|
__vtv_malloc (size_t size)
|
||
|
{
|
||
|
return obstack_alloc (&vtv_obstack, size);
|
||
|
}
|
||
|
|
||
|
|
||
|
/* This is our external interface for memory deallocation. */
|
||
|
|
||
|
void
|
||
|
__vtv_free (void *)
|
||
|
{
|
||
|
/* Do nothing. We dont care about recovering unneded memory at this
|
||
|
time. */
|
||
|
}
|
||
|
|
||
|
|
||
|
/* This is a debugging function tat collects statistics about our
|
||
|
memory allocation. */
|
||
|
void
|
||
|
__vtv_malloc_stats (void)
|
||
|
{
|
||
|
int count = 0;
|
||
|
struct _obstack_chunk * ci = (struct _obstack_chunk *) current_chunk;
|
||
|
while (ci)
|
||
|
{
|
||
|
count++;
|
||
|
ci = ci->prev;
|
||
|
}
|
||
|
fprintf (stderr,
|
||
|
"__vtv_malloc_stats:\n Page Size = %lu bytes\n "
|
||
|
"Number of pages = %d\n", static_cast<unsigned long>(VTV_PAGE_SIZE),
|
||
|
count);
|
||
|
}
|
||
|
|
||
|
/* This is a debugging function. It writes out our memory allocation
|
||
|
statistics to a log file. */
|
||
|
|
||
|
void
|
||
|
__vtv_malloc_dump_stats (void)
|
||
|
{
|
||
|
static int fd = -1;
|
||
|
|
||
|
if (fd == -1)
|
||
|
fd = __vtv_open_log ("vtv_mem_protection.log");
|
||
|
if (fd == -1)
|
||
|
return;
|
||
|
|
||
|
int count = 0;
|
||
|
struct _obstack_chunk * ci = (struct _obstack_chunk *) current_chunk;
|
||
|
while (ci)
|
||
|
{
|
||
|
count++;
|
||
|
ci = ci->prev;
|
||
|
}
|
||
|
|
||
|
__vtv_add_to_log (fd, "__vtv_malloc_protect protected=%d pages\n", count);
|
||
|
}
|