gcc/config/host-linux.c

   1 /* Linux host-specific hook definitions.
   2    Copyright (C) 2004 Free Software Foundation, Inc.
   3
   4    This file is part of GCC.
   5
   6    GCC is free software; you can redistribute it and/or modify it
   7    under the terms of the GNU General Public License as published
   8    by the Free Software Foundation; either version 2, or (at your
   9    option) any later version.
  10
  11    GCC is distributed in the hope that it will be useful, but WITHOUT
  12    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  13    or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
  14    License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with GCC; see the file COPYING.  If not, write to the
  18    Free Software Foundation, 59 Temple Place - Suite 330, Boston,
  19    MA 02111-1307, USA.  */
  20
  21 #include "config.h"
  22 #include "system.h"
  23 #include "coretypes.h"
  24 #include <sys/mman.h>
  25 #include "hosthooks.h"
  26 #include "hosthooks-def.h"
  27
  28
  29 /* Linux has a feature called exec-shield-randomize that perturbs the
  30    address of non-fixed mapped segments by a (relatively) small amount.
  31    The feature is intended to make it harder to attack the system with
  32    buffer overflow attacks, since every invocation of a program will
  33    have its libraries and data segments at slightly different addresses.
  34
  35    This feature causes us problems with PCH because it makes it that
  36    much harder to acquire a stable location at which to map our PCH
  37    data file.
  38
  39    [ The feature causes other points of non-determinism within the
  40      compiler as well, so we'd *really* like to be able to have the
  41      driver disable exec-shield-randomize for the process group, but
  42      that isn't possible at present.  ]
  43
  44    We're going to try several things:
  45
  46       * Select an architecture specific address as "likely" and see
  47         if that's free.  For our 64-bit hosts, we can easily choose
  48         an address in Never Never Land.
  49
  50       * If exec-shield-randomize is disabled, then just use the
  51         address chosen by mmap in step one.
  52
  53       * If exec-shield-randomize is enabled, then temporarily allocate
  54         32M of memory as a buffer, then allocate PCH memory, then
  55         free the buffer.  The theory here is that the perturbation is
  56         no more than 16M, and so by allocating our buffer larger than
  57         that we make it considerably more likely that the address will
  58         be free when we want to load the data back.
  59 */
  60
  61 #undef HOST_HOOKS_GT_PCH_GET_ADDRESS
  62 #define HOST_HOOKS_GT_PCH_GET_ADDRESS linux_gt_pch_get_address
  63
  64 /* For various ports, try to guess a fixed spot in the vm space
  65    that's probably free.  */
  66 #if defined(__alpha)
  67 # define TRY_EMPTY_VM_SPACE     0x10000000000
  68 #elif defined(__ia64)
  69 # define TRY_EMPTY_VM_SPACE     0x2000000100000000
  70 #elif defined(__x86_64)
  71 # define TRY_EMPTY_VM_SPACE     0x1000000000
  72 #elif defined(__i386)
  73 # define TRY_EMPTY_VM_SPACE     0x60000000
  74 #elif defined(__powerpc__)
  75 # define TRY_EMPTY_VM_SPACE     0x60000000
  76 #elif defined(__s390x__)
  77 # define TRY_EMPTY_VM_SPACE     0x8000000000
  78 #elif defined(__s390__)
  79 # define TRY_EMPTY_VM_SPACE     0x60000000
  80 #elif defined(__sparc__) && defined(__LP64__)
  81 # define TRY_EMPTY_VM_SPACE     0x8000000000
  82 #elif defined(__sparc__)
  83 # define TRY_EMPTY_VM_SPACE     0x60000000
  84 #else
  85 # define TRY_EMPTY_VM_SPACE     0
  86 #endif
  87
  88 /* Determine a location where we might be able to reliably allocate SIZE
  89    bytes.  FD is the PCH file, though we should return with the file
  90    unmapped.  */
  91
  92 static void *
  93 linux_gt_pch_get_address (size_t size, int fd)
  94 {
  95   size_t buffer_size = 32 * 1024 * 1024;
  96   void *addr, *buffer;
  97   FILE *f;
  98   bool randomize_on;
  99
 100   addr = mmap ((void *)TRY_EMPTY_VM_SPACE, size, PROT_READ | PROT_WRITE,
 101                MAP_PRIVATE, fd, 0);
 102
 103   /* If we failed the map, that means there's *no* free space.  */
 104   if (addr == (void *) MAP_FAILED)
 105     return NULL;
 106   /* Unmap the area before returning.  */
 107   munmap (addr, size);
 108
 109   /* If we got the exact area we requested, then that's great.  */
 110   if (TRY_EMPTY_VM_SPACE && addr == (void *) TRY_EMPTY_VM_SPACE)
 111     return addr;
 112
 113   /* If we didn't, then we need to look to see if randomization is on.  */
 114   f = fopen ("/proc/sys/kernel/exec-shield-randomize", "r");
 115   randomize_on = false;
 116   if (f != NULL)
 117     {
 118       char buf[100];
 119       size_t c;
 120
 121       c = fread (buf, 1, sizeof buf - 1, f);
 122       if (c > 0)
 123         {
 124           buf[c] = '\0';
 125           randomize_on = (atoi (buf) > 0);
 126         }
 127       fclose (f);
 128     }
 129
 130   /* If it isn't, then accept the address that mmap selected as fine.  */
 131   if (!randomize_on)
 132     return addr;
 133
 134   /* Otherwise, we need to try again with buffer space.  */
 135   buffer = mmap (0, buffer_size, PROT_NONE, MAP_PRIVATE | MAP_ANON, -1, 0);
 136   addr = mmap (0, size, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);
 137   if (buffer != (void *) MAP_FAILED)
 138     munmap (buffer, buffer_size);
 139   if (addr == (void *) MAP_FAILED)
 140     return NULL;
 141   munmap (addr, size);
 142
 143   return addr;
 144 }
 145
 146 \f
 147 const struct host_hooks host_hooks = HOST_HOOKS_INITIALIZER;