[safestack] Remove pageSize

[vitalybuka]

Summary

3rd party sysconf interceptor may crash if it's called before unsafe_stack_setup

However pageSize is not useful here. mmap should round up on it's own, SFS_CHECK can be removed.

[vlad.tsyrklevich]

Alternatively, we could have a static buffer we use as a 'temporary' safe stack while initialization runs. I'm not really set on that idea, but it seems cleaner and like it may be more future proof in case another syscall we use (like getrlimit() right now) is intercepted. What do you think?

[vitalybuka]

In D57924#1389664, @vlad.tsyrklevich wrote:

Alternatively, we could have a static buffer we use as a 'temporary' safe stack while initialization runs. I'm not really set on that idea, but it seems cleaner and like it may be more future proof in case another syscall we use (like getrlimit() right now) is intercepted. What do you think?

Hm, but buffer needs to be large, we don't know RLIMIT_STACK

[vitalybuka]

remove pageSize

[vlad.tsyrklevich]

LGTM as long as https://reviews.llvm.org/D57863 doesn't land (to ensure that struct tinfo *tinfo = reinterpret_cast<struct tinfo *>(addr); is a valid pointer to writable memory as the guard is no longer rounded up to page size.)

compiler-rt/lib/safestack/safestack.cc

 
 /// Minimum stack alignment for the unsafe stack.
 const unsigned kStackAlign = 16;
 
 /// Default size of the unsafe stack. This value is only used if the stack
 /// size rlimit is set to infinity.
 const unsigned kDefaultUnsafeStackSize = 0x2800000;
 
-/// Runtime page size obtained through sysconf
-unsigned pageSize;
-
 // Per-thread unsafe stack information. It's not frequently accessed, so there
 // it can be kept out of the tcb in normal thread-local variables.
 __thread void *unsafe_stack_start = nullptr;
 __thread size_t unsafe_stack_size = 0;
 __thread size_t unsafe_stack_guard = 0;
 
 inline void *unsafe_stack_alloc(size_t size, size_t guard) {
   SFS_CHECK(size + guard >= size);
-  void *addr = Mmap(nullptr, RoundUpTo(size + guard, pageSize),
-                    PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0);
+  void *addr = Mmap(nullptr, size + guard, PROT_READ | PROT_WRITE,
+                    MAP_PRIVATE | MAP_ANON, -1, 0);
   SFS_CHECK(MAP_FAILED != addr);
   Mprotect(addr, guard, PROT_NONE);
   return (char *)addr + guard;
 }
 
 inline void unsafe_stack_setup(void *start, size_t size, size_t guard) {
   SFS_CHECK((char *)start + size >= (char *)start);
   SFS_CHECK((char *)start + guard >= (char *)start);
if (attr) {
     pthread_attr_init(&tmpattr);
     pthread_attr_getstacksize(&tmpattr, &size);
     pthread_attr_getguardsize(&tmpattr, &guard);
     pthread_attr_destroy(&tmpattr);
   }
 
   SFS_CHECK(size);
   size = RoundUpTo(size, kStackAlign);
-  SFS_CHECK((guard & (pageSize - 1)) == 0);
 
   void *addr = unsafe_stack_alloc(size, guard);
   struct tinfo *tinfo = reinterpret_cast<struct tinfo *>(addr);
   tinfo->start_routine = start_routine;
   tinfo->start_routine_arg = arg;
   tinfo->unsafe_stack_start = addr;
   tinfo->unsafe_stack_size = size;
   tinfo->unsafe_stack_guard = guard;

 }  // namespace
 
 extern "C" __attribute__((visibility("default")))
 #if !SANITIZER_CAN_USE_PREINIT_ARRAY
 // On ELF platforms, the constructor is invoked using .preinit_array (see below)
 __attribute__((constructor(0)))
 #endif
 void __safestack_init() {
-  pageSize = sysconf(_SC_PAGESIZE);
-
   // Determine the stack size for the main thread.
   size_t size = kDefaultUnsafeStackSize;
   size_t guard = 4096;
 
   struct rlimit limit;
   if (getrlimit(RLIMIT_STACK, &limit) == 0 && limit.rlim_cur != RLIM_INFINITY)
     size = limit.rlim_cur;
 
   // Allocate unsafe stack for main thread
   void *addr = unsafe_stack_alloc(size, guard);
-
   unsafe_stack_setup(addr, size, guard);
 
   // Setup the cleanup handler
   pthread_key_create(&thread_cleanup_key, thread_cleanup_handler);
 }
 
 #if SANITIZER_CAN_USE_PREINIT_ARRAY
 // On ELF platforms, run safestack initialization before any other constructors.