Add test for patching a system call instruction

library.cc

 // Copyright (c) 2010 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #define XOPEN_SOURCE 500
 
 #include "library.h"
 
 #include <algorithm>
 #include <elf.h>
@@ skipping 41 matching lines @@
 typedef Elf32_Sxword  Elf_Sxword;
 typedef Elf32_Off     Elf_Off;
 typedef Elf32_Section Elf_Section;
 typedef Elf32_Versym  Elf_Versym;
 #else
 #error Unsupported target platform
 #endif
 
 namespace playground {
 
-Maps* Library::maps_;
 char* Library::__kernel_vsyscall;
 char* Library::__kernel_sigreturn;
 char* Library::__kernel_rt_sigreturn;
 
 Library::Library() :
       valid_(false),
       isVDSO_(false),
       asr_offset_(0),
       vsys_offset_(0),
       image_(0),
-      image_size_(0) {
+      image_size_(0),
+      maps_(NULL) {
 }
 
 Library::~Library() {
   if (image_size_) {
     // We no longer need access to a full mapping of the underlying library
     // file. Move the temporarily extended mapping back to where we originally
     // found. Make sure to preserve any changes that we might have made since.
     Sandbox::SysCalls sys;
     sys.mprotect(image_, 4096, PROT_READ | PROT_WRITE | PROT_EXEC);
     if (memcmp(image_, memory_ranges_.rbegin()->second.start, 4096)) {
@@ skipping 923 matching lines @@
     return;
     #endif
   }
   SectionTable::const_iterator iter;
   if ((iter = section_table_.find(".text")) == section_table_.end()) {
     return;
   }
   const Elf_Shdr& shdr = iter->second.second;
   char* start = reinterpret_cast<char *>(shdr.sh_addr + asr_offset_);
   char* stop = start + shdr.sh_size;
+  patchSystemCallsInRange(start, stop, &extraSpace, &extraLength);
+
+  // Mark our scratch space as write-protected and executable.
+  if (extraSpace) {
+    Sandbox::SysCalls sys;
+    sys.mprotect(extraSpace, 4096, PROT_READ|PROT_EXEC);
+  }
+}
+
+void Library::patchSystemCallsInRange(char* start, char* stop,
+                                      char** extraSpace, int* extraLength) {
   char* func = start;
   int nopcount = 0;
   bool has_syscall = false;
   for (char *ptr = start; ptr < stop; ptr++) {
     #if defined(__x86_64__)
     if ((*ptr == '\x0F' && ptr[1] == '\x05' /* SYSCALL */) ||
         (isVDSO_ && *ptr == '\xFF')) {
     #elif defined(__i386__)
     if ((*ptr   == '\xCD' && ptr[1] == '\x80' /* INT $0x80 */) ||
         (*ptr   == '\x65' && ptr[1] == '\xFF' &&
@@ skipping 13 matching lines @@
         // padded out with NOPs.
         //
         // For performance reasons, we quickly scan the entire text segment
         // for potential SYSCALLs, and then patch the code in increments of
         // individual functions.
         if (has_syscall) {
           has_syscall = false;
           // Our quick scan of the function found a potential system call.
           // Do a more thorough scan, now.
           patchSystemCallsInFunction(maps_, isVDSO_ ? vsys_offset_ : 0, func,
-                                     ptr, &extraSpace, &extraLength);
+                                     ptr, extraSpace, extraLength);
         }
         func = ptr;
       }
       nopcount = 0;
     } else {
       nopcount = 0;
     }
   }
   if (has_syscall) {
     // Patch any remaining system calls that were in the last function before
     // the loop terminated.
     patchSystemCallsInFunction(maps_, isVDSO_ ? vsys_offset_ : 0, func, stop,
-                               &extraSpace, &extraLength);
-  }
-
-  // Mark our scratch space as write-protected and executable.
-  if (extraSpace) {
-    Sandbox::SysCalls sys;
-    sys.mprotect(extraSpace, 4096, PROT_READ|PROT_EXEC);
+                               extraSpace, extraLength);
   }
 }
 
 bool Library::parseElf() {
   valid_ = true;
 
   // Verify ELF header
   Elf_Shdr str_shdr;
   if (!getOriginal(0, &ehdr_) ||
       ehdr_.e_ehsize < sizeof(Elf_Ehdr) ||
@@ skipping 102 matching lines @@
   }
   iter = symbols_.find("__kernel_rt_sigreturn");
   if (iter != symbols_.end() && iter->second.st_value) {
     __kernel_rt_sigreturn = asr_offset_ + iter->second.st_value;
   }
 
   return true;
 }
 
 } // namespace