native_client_sdk/src/libraries/error_handling/error_handling.c

   1 /* Copyright (c) 2013 The Chromium Authors. All rights reserved.
   2  * Use of this source code is governed by a BSD-style license that can be
   3  * found in the LICENSE file. */
   4
   5 #include <assert.h>
   6 #include <inttypes.h>
   7 #include <pthread.h>
   8 #include <stdio.h>
   9 #include <stdlib.h>
  10 #include <string.h>
  11 #include <sys/mman.h>
  12 #include <unistd.h>
  13
  14 #ifdef __GLIBC__
  15 #include <elf.h>
  16 #include <link.h>
  17 #endif  /* __GLIBC__ */
  18
  19 #include "irt.h"
  20 #include "nacl/nacl_exception.h"
  21
  22 #include "error_handling/error_handling.h"
  23 #include "error_handling/string_stream.h"
  24
  25
  26 #define PAGE_CHUNK_SIZE (64 * 1024)
  27 #define PAGE_CHUNK_MASK (PAGE_CHUNK_SIZE - 1)
  28 #define STACK_SIZE_MIN (PAGE_CHUNK_SIZE * 4)
  29
  30 #define MAX_FRAME_SIZE (10 * 1024)
  31 #define MAX_FRAME_CAP 128
  32
  33 static pthread_key_t s_eh_stack_info_key;
  34 static EHJsonHandler s_eh_json_callback = NULL;
  35 static int s_eh_exception_enabled = 0;
  36 static struct nacl_irt_exception_handling s_exception_handling;
  37
  38
  39 typedef struct {
  40   void* stack;
  41   size_t size;
  42 } EHStackInfo;
  43
  44 static uintptr_t EHReadPointer(uintptr_t offset) {
  45   return *((uintptr_t*) offset);
  46 }
  47
  48 static void EHPrintArch(sstream_t* ss, struct NaClExceptionContext* context) {
  49 #if defined(__x86_64__)
  50   ssprintf(ss, "\"arch\": \"x86_64\",\n");
  51 #elif defined(__i386__)
  52   ssprintf(ss, "\"arch\": \"x86_32\",\n");
  53 #elif defined(__arm__)
  54   ssprintf(ss, "\"arch\": \"arm\",\n");
  55 #elif defined(__mips__)
  56   ssprintf(ss, "\"arch\": \"mips\",\n");
  57 #else
  58 #error Unknown ARCH
  59 #endif
  60 }
  61
  62 static void EHPrintSegments(sstream_t* ss,
  63                             struct NaClExceptionContext* context) {
  64   ssprintf(ss, "\"segments\": [");
  65   ssprintf(ss, "],\n");
  66 }
  67
  68 static void EHPrintFrame(sstream_t* ss, EHFrame* frame) {
  69   uintptr_t start;
  70   uintptr_t i;
  71
  72   ssprintf(ss, "{\n");
  73   ssprintf(ss, "\"frame_ptr\": %u,\n", frame->frame_ptr);
  74   ssprintf(ss, "\"prog_ctr\": %u,\n", frame->prog_ctr);
  75   ssprintf(ss, "\"data\": [\n");
  76
  77 #if defined(__x86_64__)
  78   start = frame->frame_ptr + 8;
  79 #else
  80   start = frame->frame_ptr + 16;
  81 #endif
  82   /* Capture the stack, no mare than 128 bytes to keep the size sane. */
  83   for (i = start; i < frame->next_ptr && i - start < MAX_FRAME_CAP; i += 4) {
  84     if (i != start) {
  85       ssprintf(ss, ",");
  86     }
  87     ssprintf(ss, "%u\n", EHReadPointer(i));
  88   }
  89   ssprintf(ss, "]\n}\n");
  90 }
  91
  92
  93 static void EHPrintMainContext(sstream_t* ss,
  94                                struct NaClExceptionContext* context) {
  95   struct NaClExceptionPortableContext* portable_context =
  96       nacl_exception_context_get_portable(context);
  97   ssprintf(ss, "\"handler\": {\n");
  98   ssprintf(ss, "\"prog_ctr\": %u,\n", portable_context->prog_ctr);
  99   ssprintf(ss, "\"stack_ptr\": %u,\n", portable_context->stack_ptr);
 100   ssprintf(ss, "\"frame_ptr\": %u\n", portable_context->frame_ptr);
 101   ssprintf(ss, "},\n");
 102 }
 103
 104
 105 int EHGetTopFrame(sstream_t* ss, struct NaClExceptionContext* context,
 106                   EHFrame* frame) {
 107   struct NaClExceptionPortableContext* portable_context =
 108       nacl_exception_context_get_portable(context);
 109
 110   frame->prog_ctr = portable_context->prog_ctr;
 111   frame->frame_ptr = portable_context->frame_ptr;
 112   frame->next_ptr = EHReadPointer(portable_context->frame_ptr);
 113   return 1;
 114 }
 115
 116
 117 int EHUnwindFrame(EHFrame* frame) {
 118   uintptr_t frame_ptr;
 119   uintptr_t next;
 120
 121   // Verify the current frame
 122   if (NULL == frame) return 0;
 123
 124   frame_ptr = frame->frame_ptr;
 125   next = frame->next_ptr;
 126
 127   // Abort if done or unwind moves us in the wrong direction
 128   if (next <= frame_ptr || next == 0) return 0;
 129
 130   // Abort if frame is > 10K
 131   if (next - frame_ptr > MAX_FRAME_SIZE) return 0;
 132
 133   // Unwind the frame
 134   frame->frame_ptr = next;
 135   frame->next_ptr = EHReadPointer(frame->frame_ptr);
 136 #if defined(__x86_64__)
 137   frame->prog_ctr = EHReadPointer(frame_ptr + 8);
 138 #else
 139   frame->prog_ctr = EHReadPointer(frame_ptr + 4);
 140 #endif
 141   return 1;
 142 }
 143
 144
 145 static void EHStackInfoDestructor(void *arg) {
 146   EHStackInfo* info = (EHStackInfo*) arg;
 147
 148   if (info) {
 149     munmap(info->stack, info->size);
 150   }
 151   free(info);
 152 }
 153
 154
 155 void EHDefaultJsonHandler(struct NaClExceptionContext* context) {
 156   if (s_eh_json_callback) {
 157     EHFrame frame;
 158     sstream_t ss;
 159     ssinit(&ss);
 160
 161     ssprintf(&ss, "{\n");
 162     EHPrintArch(&ss, context);
 163     EHPrintSegments(&ss, context);
 164     EHPrintMainContext(&ss, context);
 165
 166     EHGetTopFrame(&ss, context, &frame);
 167     int first = 1;
 168
 169     ssprintf(&ss, "\"frames\": [\n");
 170     do {
 171       if (!first) ssprintf(&ss, ",");
 172       EHPrintFrame(&ss, &frame);
 173       first = 0;
 174     } while (EHUnwindFrame(&frame));
 175
 176     /* End frame LIST and context DICT */
 177     ssprintf(&ss, "]\n}\n");
 178     s_eh_json_callback(ss.data);
 179
 180     ssfree(&ss);
 181     while(1) sleep(9999);
 182   }
 183 }
 184
 185
 186 void EHRequestExceptionsRaw(EHRawHandler callback) {
 187   size_t interface_size = sizeof(s_exception_handling);
 188   if (s_eh_exception_enabled) {
 189     fprintf(stderr, "ERROR: EHInit already initialized.\n");
 190     return;
 191   }
 192   if (NULL == callback) {
 193     fprintf(stderr, "ERROR: EHInit called with NULL callback.\n");
 194     return;
 195   }
 196
 197   /* Expect an exact match on the interface structure size. */
 198   if (nacl_interface_query(NACL_IRT_EXCEPTION_HANDLING_v0_1,
 199                            &s_exception_handling,
 200                            interface_size) != interface_size) {
 201     fprintf(stderr, "ERROR: EHInit failed nacl_interface_query\n");
 202     return;
 203   }
 204
 205   if (s_exception_handling.exception_handler(callback, NULL) != 0) {
 206     fprintf(stderr, "ERROR: EHInit failed to install exception_handler\n");
 207     return;
 208   }
 209
 210   s_eh_exception_enabled = 1;
 211
 212   // Create a TLS key for storing per thread stack info
 213   pthread_key_create(&s_eh_stack_info_key, EHStackInfoDestructor);
 214 }
 215
 216
 217 void *EHRequestExceptionStackOnThread(size_t stack_size) {
 218   void* stack;
 219   void* guard;
 220   EHStackInfo* stack_info;
 221
 222   // Set the stack size
 223   stack_size = (stack_size + PAGE_CHUNK_MASK) & PAGE_CHUNK_MASK;
 224   if (stack_size < STACK_SIZE_MIN) stack_size = STACK_SIZE_MIN;
 225
 226   // Allocate stack + guard page
 227   stack = mmap(NULL, stack_size + PAGE_CHUNK_SIZE,
 228       PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
 229   if (MAP_FAILED == stack) return MAP_FAILED;
 230
 231   // Remap to mprotect which may not be available
 232   guard = mmap(stack, PAGE_CHUNK_SIZE,
 233       PROT_NONE, MAP_FIXED | MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
 234   if (guard != stack) {
 235     fprintf(stderr, "WARNING: Failed to add guard page for alt stack.\n");
 236   }
 237
 238   if (!s_exception_handling.exception_stack(stack, stack_size)) {
 239     fprintf(stderr, "ERROR: Failed to assign stack.\n");
 240     munmap(stack, stack_size);
 241     return MAP_FAILED;
 242   }
 243
 244   // Allocate stack tracking information for this thread
 245   stack_info = (EHStackInfo*) malloc(sizeof(EHStackInfo));
 246   stack_info->stack = stack;
 247   stack_info->size = stack_size + PAGE_CHUNK_SIZE;
 248   pthread_setspecific(s_eh_stack_info_key, stack_info);
 249   return stack;
 250 }
 251
 252
 253 void EHRequestExceptionsJson(EHJsonHandler callback) {
 254   if (NULL == callback) return;
 255
 256   EHRequestExceptionsRaw(EHDefaultJsonHandler);
 257   if (s_eh_exception_enabled) s_eh_json_callback = callback;
 258 }
 259
 260
 261 int EHHanderInstalled() {
 262   return s_eh_exception_enabled;
 263 }