1// Copyright (c) 2012 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#ifndef SANDBOX_LINUX_SECCOMP_BPF_SYSCALL_H__
6#define SANDBOX_LINUX_SECCOMP_BPF_SYSCALL_H__
7
8#include <signal.h>
9#include <stdint.h>
10
11#include "base/macros.h"
12#include "sandbox/sandbox_export.h"
13
14// Android's signal.h doesn't define ucontext etc.
15#if defined(OS_ANDROID)
16#include "sandbox/linux/services/android_ucontext.h"
17#endif
18
19namespace sandbox {
20
21// This purely static class can be used to perform system calls with some
22// low-level control.
23class SANDBOX_EXPORT Syscall {
24 public:
25  // InvalidCall() invokes Call() with a platform-appropriate syscall
26  // number that is guaranteed to not be implemented (i.e., normally
27  // returns -ENOSYS).
28  // This is primarily meant to be useful for writing sandbox policy
29  // unit tests.
30  static intptr_t InvalidCall();
31
32  // System calls can take up to six parameters (up to eight on some
33  // architectures). Traditionally, glibc
34  // implements this property by using variadic argument lists. This works, but
35  // confuses modern tools such as valgrind, because we are nominally passing
36  // uninitialized data whenever we call through this function and pass less
37  // than the full six arguments.
38  // So, instead, we use C++'s template system to achieve a very similar
39  // effect. C++ automatically sets the unused parameters to zero for us, and
40  // it also does the correct type expansion (e.g. from 32bit to 64bit) where
41  // necessary.
42  // We have to use C-style cast operators as we want to be able to accept both
43  // integer and pointer types.
44  template <class T0,
45            class T1,
46            class T2,
47            class T3,
48            class T4,
49            class T5,
50            class T6,
51            class T7>
52  static inline intptr_t
53  Call(int nr, T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6, T7 p7) {
54    return Call(nr,
55                (intptr_t)p0,
56                (intptr_t)p1,
57                (intptr_t)p2,
58                (intptr_t)p3,
59                (intptr_t)p4,
60                (intptr_t)p5,
61                (intptr_t)p6,
62                (intptr_t)p7);
63  }
64
65  template <class T0,
66            class T1,
67            class T2,
68            class T3,
69            class T4,
70            class T5,
71            class T6>
72  static inline intptr_t
73  Call(int nr, T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6) {
74    return Call(nr,
75                (intptr_t)p0,
76                (intptr_t)p1,
77                (intptr_t)p2,
78                (intptr_t)p3,
79                (intptr_t)p4,
80                (intptr_t)p5,
81                (intptr_t)p6,
82                0);
83  }
84
85  template <class T0, class T1, class T2, class T3, class T4, class T5>
86  static inline intptr_t
87  Call(int nr, T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5) {
88    return Call(nr,
89                (intptr_t)p0,
90                (intptr_t)p1,
91                (intptr_t)p2,
92                (intptr_t)p3,
93                (intptr_t)p4,
94                (intptr_t)p5,
95                0,
96                0);
97  }
98
99  template <class T0, class T1, class T2, class T3, class T4>
100  static inline intptr_t Call(int nr, T0 p0, T1 p1, T2 p2, T3 p3, T4 p4) {
101    return Call(nr, p0, p1, p2, p3, p4, 0, 0, 0);
102  }
103
104  template <class T0, class T1, class T2, class T3>
105  static inline intptr_t Call(int nr, T0 p0, T1 p1, T2 p2, T3 p3) {
106    return Call(nr, p0, p1, p2, p3, 0, 0, 0, 0);
107  }
108
109  template <class T0, class T1, class T2>
110  static inline intptr_t Call(int nr, T0 p0, T1 p1, T2 p2) {
111    return Call(nr, p0, p1, p2, 0, 0, 0, 0, 0);
112  }
113
114  template <class T0, class T1>
115  static inline intptr_t Call(int nr, T0 p0, T1 p1) {
116    return Call(nr, p0, p1, 0, 0, 0, 0, 0, 0);
117  }
118
119  template <class T0>
120  static inline intptr_t Call(int nr, T0 p0) {
121    return Call(nr, p0, 0, 0, 0, 0, 0, 0, 0);
122  }
123
124  static inline intptr_t Call(int nr) {
125    return Call(nr, 0, 0, 0, 0, 0, 0, 0, 0);
126  }
127
128  // Set the registers in |ctx| to match what they would be after a system call
129  // returning |ret_val|. |ret_val| must follow the Syscall::Call() convention
130  // of being -errno on errors.
131  static void PutValueInUcontext(intptr_t ret_val, ucontext_t* ctx);
132
133 private:
134  // This performs system call |nr| with the arguments p0 to p7 from a constant
135  // userland address, which is for instance observable by seccomp-bpf filters.
136  // The constant userland address from which these system calls are made will
137  // be returned if |nr| is passed as -1.
138  // On error, this function will return a value between -1 and -4095 which
139  // should be interpreted as -errno.
140  static intptr_t Call(int nr,
141                       intptr_t p0,
142                       intptr_t p1,
143                       intptr_t p2,
144                       intptr_t p3,
145                       intptr_t p4,
146                       intptr_t p5,
147                       intptr_t p6,
148                       intptr_t p7);
149
150#if defined(__mips__)
151  // This function basically does on MIPS what SandboxSyscall() is doing on
152  // other architectures. However, because of specificity of MIPS regarding
153  // handling syscall errors, SandboxSyscall() is made as a wrapper for this
154  // function in order for SandboxSyscall() to behave more like on other
155  // architectures on places where return value from SandboxSyscall() is used
156  // directly (like in most tests).
157  // The syscall "nr" is called with arguments that are set in an array on which
158  // pointer "args" points to and an information weather there is an error or no
159  // is returned to SandboxSyscall() by err_stat.
160  static intptr_t SandboxSyscallRaw(int nr,
161                                    const intptr_t* args,
162                                    intptr_t* err_stat);
163#endif  // defined(__mips__)
164
165  DISALLOW_IMPLICIT_CONSTRUCTORS(Syscall);
166};
167
168}  // namespace sandbox
169
170#endif  // SANDBOX_LINUX_SECCOMP_BPF_SYSCALL_H__
171