Port linux_syscall_support and linux_dumper to support Linux ARM. Unit tests...

src/client/linux/handler/exception_handler.cc

 // Copyright (c) 2009, Google Inc.
 // All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
@@ skipping 69 matching lines @@
 #include <unistd.h>
 
 #include "common/linux/linux_libc_support.h"
 #include "common/linux/linux_syscall_support.h"
 #include "common/linux/memory.h"
 #include "client/linux/minidump_writer//minidump_writer.h"
 #include "common/linux/guid_creator.h"
 
 // A wrapper for the tgkill syscall: send a signal to a specific thread.
 static int tgkill(pid_t tgid, pid_t tid, int sig) {
-  syscall(__NR_tgkill, tgid, tid, sig);
+  return syscall(__NR_tgkill, tgid, tid, sig);
 }
 
 namespace google_breakpad {
 
 // The list of signals which we consider to be crashes. The default action for
 // all these signals must be Core (see man 7 signal) because we rethrow the
 // signal after handling it and expect that it'll be fatal.
 static const int kExceptionSignals[] = {
   SIGSEGV, SIGABRT, SIGFPE, SIGILL, SIGBUS, -1
 };
@@ skipping 63 matching lines @@
 
   sa.sa_sigaction = SignalHandler;
   sa.sa_flags = SA_ONSTACK | SA_SIGINFO;
 
   for (unsigned i = 0; kExceptionSignals[i] != -1; ++i) {
     struct sigaction* old = new struct sigaction;
     if (sigaction(kExceptionSignals[i], &sa, old) == -1)
       return false;
     old_handlers_.push_back(std::make_pair(kExceptionSignals[i], old));
   }
+  return true;
 }
 
 // Runs before crashing: normal context.
 void ExceptionHandler::UninstallHandlers() {
   for (unsigned i = 0; i < old_handlers_.size(); ++i) {
     struct sigaction *action =
         reinterpret_cast<struct sigaction*>(old_handlers_[i].second);
     sigaction(old_handlers_[i].first, action, NULL);
     delete action;
   }
@@ skipping 73 matching lines @@
 bool ExceptionHandler::HandleSignal(int sig, siginfo_t* info, void* uc) {
   if (filter_ && !filter_(callback_context_))
     return false;
 
   // Allow ourselves to be dumped.
   sys_prctl(PR_SET_DUMPABLE, 1);
 
   CrashContext context;
   memcpy(&context.siginfo, info, sizeof(siginfo_t));
   memcpy(&context.context, uc, sizeof(struct ucontext));
+#if !defined(__ARM_ARCH_7A__)
+  // FP state is not part of user ABI on ARM Linux.
   memcpy(&context.float_state, ((struct ucontext *)uc)->uc_mcontext.fpregs,
          sizeof(context.float_state));
+#endif
   context.tid = sys_gettid();
 
   if (crash_handler_ && crash_handler_(&context, sizeof(context),
                                        callback_context_))
     return true;
 
   static const unsigned kChildStackSize = 8000;
   PageAllocator allocator;
   uint8_t* stack = (uint8_t*) allocator.Alloc(kChildStackSize);
   if (!stack)
@@ skipping 34 matching lines @@
 
 // This function runs in a compromised context: see the top of the file.
 // Runs on the cloned process.
 bool ExceptionHandler::DoDump(pid_t crashing_process, const void* context,
                               size_t context_size) {
   return google_breakpad::WriteMinidump(
       next_minidump_path_c_, crashing_process, context, context_size);
 }
 
 }  // namespace google_breakpad