OLD | NEW |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 1 // Copyright 2014 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "sandbox/linux/services/syscall_wrappers.h" | 5 #include "sandbox/linux/services/syscall_wrappers.h" |
6 | 6 |
| 7 #include <pthread.h> |
| 8 #include <sched.h> |
| 9 #include <setjmp.h> |
7 #include <sys/resource.h> | 10 #include <sys/resource.h> |
8 #include <sys/syscall.h> | 11 #include <sys/syscall.h> |
9 #include <sys/time.h> | 12 #include <sys/time.h> |
10 #include <sys/types.h> | 13 #include <sys/types.h> |
11 #include <unistd.h> | 14 #include <unistd.h> |
12 | 15 |
| 16 #include "base/compiler_specific.h" |
13 #include "base/logging.h" | 17 #include "base/logging.h" |
| 18 #include "base/third_party/valgrind/valgrind.h" |
14 #include "build/build_config.h" | 19 #include "build/build_config.h" |
15 #include "sandbox/linux/services/linux_syscalls.h" | 20 #include "sandbox/linux/services/linux_syscalls.h" |
16 | 21 |
17 namespace sandbox { | 22 namespace sandbox { |
18 | 23 |
19 pid_t sys_getpid(void) { | 24 pid_t sys_getpid(void) { |
20 return syscall(__NR_getpid); | 25 return syscall(__NR_getpid); |
21 } | 26 } |
22 | 27 |
23 pid_t sys_gettid(void) { | 28 pid_t sys_gettid(void) { |
24 return syscall(__NR_gettid); | 29 return syscall(__NR_gettid); |
25 } | 30 } |
26 | 31 |
27 long sys_clone(unsigned long flags) { | 32 namespace { |
28 return sys_clone(flags, nullptr, nullptr, nullptr, nullptr); | |
29 } | |
30 | 33 |
31 long sys_clone(unsigned long flags, | 34 bool CloneArgumentsValid(unsigned long flags, pid_t* ptid, pid_t* ctid) { |
32 void* child_stack, | |
33 pid_t* ptid, | |
34 pid_t* ctid, | |
35 decltype(nullptr) tls) { | |
36 const bool clone_tls_used = flags & CLONE_SETTLS; | 35 const bool clone_tls_used = flags & CLONE_SETTLS; |
37 const bool invalid_ctid = | 36 const bool invalid_ctid = |
38 (flags & (CLONE_CHILD_SETTID | CLONE_CHILD_CLEARTID)) && !ctid; | 37 (flags & (CLONE_CHILD_SETTID | CLONE_CHILD_CLEARTID)) && !ctid; |
39 const bool invalid_ptid = (flags & CLONE_PARENT_SETTID) && !ptid; | 38 const bool invalid_ptid = (flags & CLONE_PARENT_SETTID) && !ptid; |
40 const bool invalid_stack = (flags & CLONE_VM) && !child_stack; | |
41 | 39 |
42 if (clone_tls_used || invalid_ctid || invalid_ptid || invalid_stack) { | 40 // We do not support CLONE_VM. |
| 41 const bool clone_vm_used = flags & CLONE_VM; |
| 42 |
| 43 return !(clone_tls_used || invalid_ctid || invalid_ptid || clone_vm_used); |
| 44 } |
| 45 |
| 46 bool IsRunningOnValgrind() { |
| 47 return RUNNING_ON_VALGRIND; |
| 48 } |
| 49 |
| 50 // This function runs on the stack specified on the clone call. It uses longjmp |
| 51 // to switch back to the original stack so the child can return from sys_clone. |
| 52 int CloneHelper(void* arg) { |
| 53 jmp_buf* env_ptr = reinterpret_cast<jmp_buf*>(arg); |
| 54 longjmp(*env_ptr, 1); |
| 55 |
| 56 // Should not be reached. |
| 57 RAW_CHECK(false); |
| 58 return 1; |
| 59 } |
| 60 |
| 61 // This function is noinline to ensure that stack_buf is below the stack pointer |
| 62 // that is saved when setjmp is called below. This is needed because when |
| 63 // compiled with FORTIFY_SOURCE, glibc's longjmp checks that the stack is moved |
| 64 // upwards. See crbug.com/442912 for more details. |
| 65 NOINLINE pid_t CloneAndLongjmpInChild(unsigned long flags, |
| 66 pid_t* ptid, |
| 67 pid_t* ctid, |
| 68 jmp_buf* env) { |
| 69 // We use the libc clone wrapper instead of making the syscall |
| 70 // directly because making the syscall may fail to update the libc's |
| 71 // internal pid cache. The libc interface unfortunately requires |
| 72 // specifying a new stack, so we use setjmp/longjmp to emulate |
| 73 // fork-like behavior. |
| 74 char stack_buf[PTHREAD_STACK_MIN]; |
| 75 #if defined(ARCH_CPU_X86_FAMILY) || defined(ARCH_CPU_ARM_FAMILY) || \ |
| 76 defined(ARCH_CPU_MIPS64_FAMILY) || defined(ARCH_CPU_MIPS_FAMILY) |
| 77 // The stack grows downward. |
| 78 void* stack = stack_buf + sizeof(stack_buf); |
| 79 #else |
| 80 #error "Unsupported architecture" |
| 81 #endif |
| 82 return clone(&CloneHelper, stack, flags, env, ptid, nullptr, ctid); |
| 83 } |
| 84 |
| 85 } // namespace |
| 86 |
| 87 long sys_clone(unsigned long flags, |
| 88 decltype(nullptr) child_stack, |
| 89 pid_t* ptid, |
| 90 pid_t* ctid, |
| 91 decltype(nullptr) tls) { |
| 92 |
| 93 if (!CloneArgumentsValid(flags, ptid, ctid)) { |
43 RAW_LOG(FATAL, "Invalid usage of sys_clone"); | 94 RAW_LOG(FATAL, "Invalid usage of sys_clone"); |
44 } | 95 } |
45 | 96 |
46 // See kernel/fork.c in Linux. There is different ordering of sys_clone | 97 // See kernel/fork.c in Linux. There is different ordering of sys_clone |
47 // parameters depending on CONFIG_CLONE_BACKWARDS* configuration options. | 98 // parameters depending on CONFIG_CLONE_BACKWARDS* configuration options. |
48 #if defined(ARCH_CPU_X86_64) | 99 #if defined(ARCH_CPU_X86_64) |
49 return syscall(__NR_clone, flags, child_stack, ptid, ctid, tls); | 100 return syscall(__NR_clone, flags, child_stack, ptid, ctid, tls); |
50 #elif defined(ARCH_CPU_X86) || defined(ARCH_CPU_ARM_FAMILY) || \ | 101 #elif defined(ARCH_CPU_X86) || defined(ARCH_CPU_ARM_FAMILY) || \ |
51 defined(ARCH_CPU_MIPS_FAMILY) || defined(ARCH_CPU_MIPS64_FAMILY) | 102 defined(ARCH_CPU_MIPS_FAMILY) || defined(ARCH_CPU_MIPS64_FAMILY) |
52 // CONFIG_CLONE_BACKWARDS defined. | 103 // CONFIG_CLONE_BACKWARDS defined. |
53 return syscall(__NR_clone, flags, child_stack, ptid, tls, ctid); | 104 return syscall(__NR_clone, flags, child_stack, ptid, tls, ctid); |
54 #endif | 105 #endif |
55 } | 106 } |
56 | 107 |
| 108 long sys_clone(unsigned long flags) { |
| 109 return sys_clone(flags, nullptr, nullptr, nullptr, nullptr); |
| 110 } |
| 111 |
| 112 pid_t ForkWithFlags(unsigned long flags, pid_t* ptid, pid_t* ctid) { |
| 113 if (!CloneArgumentsValid(flags, ptid, ctid)) { |
| 114 RAW_LOG(FATAL, "Invalid usage of ForkWithFlags"); |
| 115 } |
| 116 |
| 117 // Valgrind's clone implementation does not support specifiying a child_stack |
| 118 // without CLONE_VM, so we cannot use libc's clone wrapper when running under |
| 119 // Valgrind. As a result, the libc pid cache may be incorrect under Valgrind. |
| 120 // See crbug.com/442817 for more details. |
| 121 if (IsRunningOnValgrind()) { |
| 122 return sys_clone(flags, nullptr, ptid, ctid, nullptr); |
| 123 } |
| 124 |
| 125 jmp_buf env; |
| 126 if (setjmp(env) == 0) { |
| 127 return CloneAndLongjmpInChild(flags, ptid, ctid, &env); |
| 128 } |
| 129 |
| 130 return 0; |
| 131 } |
| 132 |
57 void sys_exit_group(int status) { | 133 void sys_exit_group(int status) { |
58 syscall(__NR_exit_group, status); | 134 syscall(__NR_exit_group, status); |
59 } | 135 } |
60 | 136 |
61 int sys_seccomp(unsigned int operation, | 137 int sys_seccomp(unsigned int operation, |
62 unsigned int flags, | 138 unsigned int flags, |
63 const struct sock_fprog* args) { | 139 const struct sock_fprog* args) { |
64 return syscall(__NR_seccomp, operation, flags, args); | 140 return syscall(__NR_seccomp, operation, flags, args); |
65 } | 141 } |
66 | 142 |
67 int sys_prlimit64(pid_t pid, | 143 int sys_prlimit64(pid_t pid, |
68 int resource, | 144 int resource, |
69 const struct rlimit64* new_limit, | 145 const struct rlimit64* new_limit, |
70 struct rlimit64* old_limit) { | 146 struct rlimit64* old_limit) { |
71 return syscall(__NR_prlimit64, pid, resource, new_limit, old_limit); | 147 return syscall(__NR_prlimit64, pid, resource, new_limit, old_limit); |
72 } | 148 } |
73 | 149 |
74 } // namespace sandbox | 150 } // namespace sandbox |
OLD | NEW |