summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorwolfbeast <mcwerewolf@gmail.com>2018-07-02 09:46:06 +0200
committerwolfbeast <mcwerewolf@gmail.com>2018-07-02 09:46:06 +0200
commit9ee07e9b8894de3aec81689dba5dbc0fc025bb83 (patch)
tree62595e56b49c727f517581fc318cd08da96c20ae
parenta659def00b38cded555d4005d2ceb7b55d27040b (diff)
downloadUXP-9ee07e9b8894de3aec81689dba5dbc0fc025bb83.tar
UXP-9ee07e9b8894de3aec81689dba5dbc0fc025bb83.tar.gz
UXP-9ee07e9b8894de3aec81689dba5dbc0fc025bb83.tar.lz
UXP-9ee07e9b8894de3aec81689dba5dbc0fc025bb83.tar.xz
UXP-9ee07e9b8894de3aec81689dba5dbc0fc025bb83.zip
Issue #578: Applications cannot start without /proc (chroot).
UXP uses the current stack frame address and the stack size as a sort of heuristic for various things in the JavaScript engine. The js::GetNativeStackBaseImpl() function is used to get the base stack address (i.e. the address from which the stack grows, so this can be either the first or last memory address of the stack memory space depending on the CPU architecture). On Linux, this function is implemented using the pthreads APIs. For non-main threads, the queried thread info is stored in memory. The main thread does not have this information on hand, so it gets the stack memory range via the /proc/self/maps file (see glibc's pthread_get_attr_np.c). Fortunately (per discussions with the firefox devs in #jsapi) the base address only needs to be approximate. In reality, environment variables, args, and other things are stored in stack space between the end/beginning of the mapped stack memory and the 'top' of the stack space used by stack frames. When using glibc, we can get the top of this usable stack from __libc_stack_end, which is a void* set by glibc during program initialization, avoiding the need to access /proc. Non-main threads still get their stack-base through the usual pthreads APIs. Other libc implementations like musl will fall back to the standard UNIX-like implementation which calls pthread's pthread_attr_getstack() also from the main thread, which may imply /proc access and not work in restricted environments.
-rw-r--r--js/src/jsnativestack.cpp68
1 files changed, 65 insertions, 3 deletions
diff --git a/js/src/jsnativestack.cpp b/js/src/jsnativestack.cpp
index 05928ea3d..166a5a4f7 100644
--- a/js/src/jsnativestack.cpp
+++ b/js/src/jsnativestack.cpp
@@ -21,6 +21,18 @@
# include <unistd.h>
# endif
+# if defined(XP_LINUX) && !defined(ANDROID) && defined(__GLIBC__)
+# include <dlfcn.h>
+# include <sys/syscall.h>
+# include <sys/types.h>
+# include <unistd.h>
+static pid_t
+gettid()
+{
+ return syscall(__NR_gettid);
+}
+# endif
+
#else
# error "Unsupported platform"
@@ -88,6 +100,52 @@ js::GetNativeStackBaseImpl()
context.uc_stack.ss_size;
}
+#elif defined(XP_LINUX) && !defined(ANDROID) && defined(__GLIBC__)
+void*
+js::GetNativeStackBaseImpl()
+{
+ // On the main thread, get stack base from glibc's __libc_stack_end rather than pthread APIs
+ // to avoid filesystem calls /proc/self/maps. Non-main threads spawned with pthreads can read
+ // this information directly from their pthread struct, but when using the pthreads API, the
+ // main thread must go parse /proc/self/maps to figure the mapped stack address space ranges.
+ // We want to avoid reading from /proc/ so that the application can run in restricted
+ // environments where /proc may not be mounted (e.g. chroot).
+ if (gettid() == getpid()) {
+ void** pLibcStackEnd = (void**)dlsym(RTLD_DEFAULT, "__libc_stack_end");
+
+ // If __libc_stack_end is not found, architecture specific frame pointer hopping will need
+ // to be implemented.
+ MOZ_RELEASE_ASSERT(pLibcStackEnd, "__libc_stack_end unavailable, unable to setup stack range for JS.");
+ void* stackBase = *pLibcStackEnd;
+ MOZ_RELEASE_ASSERT(stackBase, "Invalid stack base, unable to setup stack range for JS.");
+
+ // We don't need to fix stackBase, as it already roughly points to beginning of the stack.
+ return stackBase;
+ }
+
+ // Non-main threads have the required info stored in memory, so no filesystem calls are made.
+ pthread_t thread = pthread_self();
+ pthread_attr_t sattr;
+ pthread_attr_init(&sattr);
+ pthread_getattr_np(thread, &sattr);
+
+ // stackBase will be the *lowest* address on all architectures.
+ void* stackBase = nullptr;
+ size_t stackSize = 0;
+ int rc = pthread_attr_getstack(&sattr, &stackBase, &stackSize);
+ if (rc) {
+ MOZ_CRASH("Call to pthread_attr_getstack failed, unable to setup stack range for JS.");
+ }
+ MOZ_RELEASE_ASSERT(stackBase, "Invalid stack base, unable to setup stack range for JS.");
+ pthread_attr_destroy(&sattr);
+
+# if JS_STACK_GROWTH_DIRECTION > 0
+ return stackBase;
+# else
+ return static_cast<char*>(stackBase) + stackSize;
+# endif
+}
+
#else /* XP_UNIX */
void*
@@ -156,11 +214,15 @@ js::GetNativeStackBaseImpl()
// the truth.
rc = pthread_attr_getstack(&sattr, &stackBase, &stackSize);
# else
+ // Use the default pthread_attr_getstack() call. Note that this function
+ // differs between libc implementations and could imply /proc access etc.
+ // which may not work in restricted environments.
rc = pthread_attr_getstack(&sattr, &stackBase, &stackSize);
# endif
- if (rc)
- MOZ_CRASH();
- MOZ_ASSERT(stackBase);
+ if (rc) {
+ MOZ_CRASH("Call to pthread_attr_getstack failed, unable to setup stack range for JS.");
+ }
+ MOZ_RELEASE_ASSERT(stackBase, "Invalid stack base, unable to setup stack range for JS.");
pthread_attr_destroy(&sattr);
# if JS_STACK_GROWTH_DIRECTION > 0