Thread suspension: Implement for Linux

src/trusted/service_runtime/nacl_app_thread.h

 /*
  * Copyright (c) 2012 The Native Client Authors. All rights reserved.
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 /*
  * NaCl Server Runtime user thread state.
  */
 
 #ifndef NATIVE_CLIENT_SERVICE_RUNTIME_NACL_APP_THREAD_H__
 #define NATIVE_CLIENT_SERVICE_RUNTIME_NACL_APP_THREAD_H__ 1
 
+#include "native_client/src/include/atomic_ops.h"
 #include "native_client/src/shared/platform/nacl_sync.h"
 #include "native_client/src/shared/platform/nacl_threads.h"
 #include "native_client/src/trusted/service_runtime/nacl_signal.h"
 #include "native_client/src/trusted/service_runtime/sel_rt.h"
 
 
 EXTERN_C_BEGIN
 
 struct NaClApp;
 
 /*
  * The thread hosting the NaClAppThread may change suspend_state
  * between NACL_APP_THREAD_TRUSTED and NACL_APP_THREAD_UNTRUSTED using
  * NaClAppThreadSetSuspendState().
  *
- * Another thread may change this from:
+ * A controlling thread may change this from:
  *   NACL_APP_THREAD_UNTRUSTED
  *   -> NACL_APP_THREAD_UNTRUSTED | NACL_APP_THREAD_SUSPENDING
  * or
  *   NACL_APP_THREAD_TRUSTED
  *   -> NACL_APP_THREAD_TRUSTED | NACL_APP_THREAD_SUSPENDING
  * and back again.
+ *
+ * Additionally, on Linux, the signal handler in the thread being
+ * suspended will change suspend_state from:
+ *   NACL_APP_THREAD_UNTRUSTED | NACL_APP_THREAD_SUSPENDING
+ *   -> (NACL_APP_THREAD_UNTRUSTED | NACL_APP_THREAD_SUSPENDING
+ *       | NACL_APP_THREAD_SUSPENDED)
+ * The controlling thread will later change suspend_thread back to:
+ *   NACL_APP_THREAD_UNTRUSTED
+ * This tells the signal handler to resume execution.
  */
 enum NaClSuspendState {
   NACL_APP_THREAD_UNTRUSTED = 1,
   NACL_APP_THREAD_TRUSTED = 2,
   NACL_APP_THREAD_SUSPENDING = 4
+#if NACL_LINUX
+  , NACL_APP_THREAD_SUSPENDED = 8
+#endif
 };
 
 /*
  * Generally, only the thread itself will need to manipulate this
  * structure, but occasionally we may need to blow away a thread for
  * some reason, and look inside.  While a thread is in the NaCl
  * application running untrusted code, the lock must *not* be held.
  */
 struct NaClAppThread {
   struct NaClMutex          mu;
@@ skipping 14 matching lines @@
    * accessed via the %gs segment register on x86-32 so must point
    * into untrusted address space; we store it as a system pointer.
    * The second TLS may be an arbitrary value.
    */
   uintptr_t                 sys_tls;  /* first saved TLS ptr */
   uint32_t                  *usr_tlsp;
   uint32_t                  tls2;     /* second saved TLS value */
 
   struct NaClThread         thread;  /* low level thread representation */
 
-  /*
-   * Thread suspension is currently only needed and implemented for
-   * Windows, for preventing race conditions when opening up holes in
-   * untrusted address space during mmap/munmap.
-   */
-#if NACL_WINDOWS
-  enum NaClSuspendState     suspend_state;
-#endif
+  Atomic32                  suspend_state; /* enum NaClSuspendState */
 
   struct NaClThreadContext  user;
   struct NaClThreadContext  sys;
   /*
    * NaClThread abstraction allows us to specify the stack size
    * (NACL_KERN_STACK_SIZE), but not its location.  The underlying
    * implementation takes care of finding memory for the thread stack,
    * and when the thread exits (they're not joinable), the stack
    * should be automatically released.
    */
@@ skipping 52 matching lines @@
  * NaClAppThread.  It can be used to switch between the states
  * NACL_APP_THREAD_TRUSTED and NACL_APP_THREAD_UNTRUSTED.
  */
 void NaClAppThreadSetSuspendState(struct NaClAppThread *natp,
                                   enum NaClSuspendState old_state,
                                   enum NaClSuspendState new_state);
 
 EXTERN_C_END
 
 #endif  /* NATIVE_CLIENT_SERVICE_RUNTIME_NACL_APP_THREAD_H__ */