Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(376)

Side by Side Diff: native_client_sdk/src/libraries/nacl_io/kernel_intercept.cc

Issue 757293005: [NaCl SDK] nacl_io: wrap kernel intercept calls in a macro (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Created 6 years ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « no previous file | no next file » | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 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 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 "nacl_io/kernel_intercept.h" 5 #include "nacl_io/kernel_intercept.h"
6 6
7 #include <assert.h> 7 #include <assert.h>
8 #include <errno.h> 8 #include <errno.h>
9 #include <string.h> 9 #include <string.h>
10 10
11 #include "nacl_io/kernel_proxy.h" 11 #include "nacl_io/kernel_proxy.h"
12 #include "nacl_io/kernel_wrap.h" 12 #include "nacl_io/kernel_wrap.h"
13 #include "nacl_io/kernel_wrap_real.h" 13 #include "nacl_io/kernel_wrap_real.h"
14 #include "nacl_io/log.h" 14 #include "nacl_io/log.h"
15 #include "nacl_io/osmman.h" 15 #include "nacl_io/osmman.h"
16 #include "nacl_io/ossocket.h" 16 #include "nacl_io/ossocket.h"
17 #include "nacl_io/ostime.h" 17 #include "nacl_io/ostime.h"
18 #include "nacl_io/pepper_interface.h" 18 #include "nacl_io/pepper_interface.h"
19 #include "nacl_io/real_pepper_interface.h" 19 #include "nacl_io/real_pepper_interface.h"
20 20
21 using namespace nacl_io; 21 using namespace nacl_io;
22 22
23 #define ON_NOSYS_RETURN(x) \ 23 #define ON_NOSYS_RETURN(x) \
24 if (!ki_is_initialized()) { \ 24 if (!ki_is_initialized()) { \
25 errno = ENOSYS; \ 25 errno = ENOSYS; \
26 return x; \ 26 return x; \
27 } 27 }
28 28
29 #define TRACE_KP_CALLS 0
30
31 #if TRACE_KP_CALLS
32 #define TRACE_KP nacl_io_log
33 #else
34 #define TRACE_KP(...)
35 #endif
36
37 #define KP_CALL(METHOD, ARGS) \
binji 2014/12/02 18:31:56 I like this in general, but I don't like that you'
Sam Clegg 2015/01/13 18:46:29 Done.
38 ON_NOSYS_RETURN(-1); \
39 int rtn = s_state.kp-> METHOD ARGS; \
40 TRACE_KP("ki_" #METHOD " -> %d\n", rtn); \
41 return rtn;
42
29 struct KernelInterceptState { 43 struct KernelInterceptState {
30 KernelProxy* kp; 44 KernelProxy* kp;
31 PepperInterface* ppapi; 45 PepperInterface* ppapi;
32 bool kp_owned; 46 bool kp_owned;
33 }; 47 };
34 48
35 static KernelInterceptState s_state; 49 static KernelInterceptState s_state;
36 50
37 // The the test code we want to be able to save the previous kernel 51 // The the test code we want to be able to save the previous kernel
38 // proxy when intialising and restore it on uninit. 52 // proxy when intialising and restore it on uninit.
(...skipping 90 matching lines...) Expand 10 before | Expand all | Expand 10 after
129 delete state_to_delete.kp; 143 delete state_to_delete.kp;
130 144
131 delete state_to_delete.ppapi; 145 delete state_to_delete.ppapi;
132 return 0; 146 return 0;
133 } 147 }
134 148
135 nacl_io::KernelProxy* ki_get_proxy() { 149 nacl_io::KernelProxy* ki_get_proxy() {
136 return s_state.kp; 150 return s_state.kp;
137 } 151 }
138 152
139 int ki_chdir(const char* path) {
140 ON_NOSYS_RETURN(-1);
141 return s_state.kp->chdir(path);
142 }
143
144 void ki_exit(int status) { 153 void ki_exit(int status) {
145 if (ki_is_initialized()) 154 if (ki_is_initialized())
146 s_state.kp->exit(status); 155 s_state.kp->exit(status);
147 156
148 _real_exit(status); 157 _real_exit(status);
149 } 158 }
150 159
151 char* ki_getcwd(char* buf, size_t size) { 160 char* ki_getcwd(char* buf, size_t size) {
152 // gtest uses getcwd in a static initializer and expects it to always 161 // gtest uses getcwd in a static initializer and expects it to always
153 // succeed. If we haven't initialized kernel-intercept yet, then try 162 // succeed. If we haven't initialized kernel-intercept yet, then try
(...skipping 12 matching lines...) Expand all
166 return buf; 175 return buf;
167 } 176 }
168 return s_state.kp->getcwd(buf, size); 177 return s_state.kp->getcwd(buf, size);
169 } 178 }
170 179
171 char* ki_getwd(char* buf) { 180 char* ki_getwd(char* buf) {
172 ON_NOSYS_RETURN(NULL); 181 ON_NOSYS_RETURN(NULL);
173 return s_state.kp->getwd(buf); 182 return s_state.kp->getwd(buf);
174 } 183 }
175 184
185 int ki_chdir(const char* path) {
186 KP_CALL(chdir, (path));
187 }
188
176 int ki_dup(int oldfd) { 189 int ki_dup(int oldfd) {
177 ON_NOSYS_RETURN(-1); 190 KP_CALL(dup, (oldfd));
178 return s_state.kp->dup(oldfd);
179 } 191 }
180 192
181 int ki_dup2(int oldfd, int newfd) { 193 int ki_dup2(int oldfd, int newfd) {
182 ON_NOSYS_RETURN(-1); 194 KP_CALL(dup2, (oldfd, newfd));
183 return s_state.kp->dup2(oldfd, newfd);
184 } 195 }
185 196
186 int ki_chmod(const char* path, mode_t mode) { 197 int ki_chmod(const char* path, mode_t mode) {
187 ON_NOSYS_RETURN(-1); 198 KP_CALL(chmod, (path, mode));
188 return s_state.kp->chmod(path, mode);
189 } 199 }
190 200
191 int ki_fchdir(int fd) { 201 int ki_fchdir(int fd) {
192 ON_NOSYS_RETURN(-1); 202 KP_CALL(fchdir, (fd));
193 return s_state.kp->fchdir(fd);
194 } 203 }
195 204
196 int ki_fchmod(int fd, mode_t mode) { 205 int ki_fchmod(int fd, mode_t mode) {
197 ON_NOSYS_RETURN(-1); 206 KP_CALL(fchmod, (fd, mode));
198 return s_state.kp->fchmod(fd, mode);
199 } 207 }
200 208
201 int ki_stat(const char* path, struct stat* buf) { 209 int ki_stat(const char* path, struct stat* buf) {
202 ON_NOSYS_RETURN(-1); 210 KP_CALL(stat, (path, buf));
203 return s_state.kp->stat(path, buf);
204 } 211 }
205 212
206 int ki_mkdir(const char* path, mode_t mode) { 213 int ki_mkdir(const char* path, mode_t mode) {
207 ON_NOSYS_RETURN(-1); 214 KP_CALL(mkdir, (path, mode));
208 return s_state.kp->mkdir(path, mode);
209 } 215 }
210 216
211 int ki_rmdir(const char* path) { 217 int ki_rmdir(const char* path) {
212 ON_NOSYS_RETURN(-1); 218 KP_CALL(rmdir, (path));
213 return s_state.kp->rmdir(path);
214 } 219 }
215 220
216 int ki_mount(const char* source, 221 int ki_mount(const char* source,
217 const char* target, 222 const char* target,
218 const char* filesystemtype, 223 const char* filesystemtype,
219 unsigned long mountflags, 224 unsigned long mountflags,
220 const void* data) { 225 const void* data) {
221 ON_NOSYS_RETURN(-1); 226 KP_CALL(mount, (source, target, filesystemtype, mountflags, data));
222 return s_state.kp->mount(source, target, filesystemtype, mountflags, data);
223 } 227 }
224 228
225 int ki_umount(const char* path) { 229 int ki_umount(const char* path) {
226 ON_NOSYS_RETURN(-1); 230 KP_CALL(umount, (path));
227 return s_state.kp->umount(path);
228 } 231 }
229 232
230 int ki_open(const char* path, int oflag, mode_t mode) { 233 int ki_open(const char* path, int oflag, mode_t mode) {
231 ON_NOSYS_RETURN(-1); 234 KP_CALL(open, (path, oflag, mode));
232 return s_state.kp->open(path, oflag, mode);
233 } 235 }
234 236
235 int ki_pipe(int pipefds[2]) { 237 int ki_pipe(int pipefds[2]) {
236 ON_NOSYS_RETURN(-1); 238 KP_CALL(pipe, (pipefds));
237 return s_state.kp->pipe(pipefds);
238 } 239 }
239 240
240 ssize_t ki_read(int fd, void* buf, size_t nbyte) { 241 ssize_t ki_read(int fd, void* buf, size_t nbyte) {
241 ON_NOSYS_RETURN(-1); 242 ON_NOSYS_RETURN(-1);
242 return s_state.kp->read(fd, buf, nbyte); 243 return s_state.kp->read(fd, buf, nbyte);
243 } 244 }
244 245
245 ssize_t ki_write(int fd, const void* buf, size_t nbyte) { 246 ssize_t ki_write(int fd, const void* buf, size_t nbyte) {
246 ON_NOSYS_RETURN(-1); 247 ON_NOSYS_RETURN(-1);
247 return s_state.kp->write(fd, buf, nbyte); 248 return s_state.kp->write(fd, buf, nbyte);
248 } 249 }
249 250
250 int ki_fstat(int fd, struct stat* buf) { 251 int ki_fstat(int fd, struct stat* buf) {
251 ON_NOSYS_RETURN(-1); 252 KP_CALL(fstat, (fd, buf));
252 return s_state.kp->fstat(fd, buf);
253 } 253 }
254 254
255 int ki_getdents(int fd, void* buf, unsigned int count) { 255 int ki_getdents(int fd, void* buf, unsigned int count) {
256 ON_NOSYS_RETURN(-1); 256 KP_CALL(getdents, (fd, buf, count));
257 return s_state.kp->getdents(fd, buf, count);
258 } 257 }
259 258
260 int ki_ftruncate(int fd, off_t length) { 259 int ki_ftruncate(int fd, off_t length) {
261 ON_NOSYS_RETURN(-1); 260 KP_CALL(ftruncate, (fd, length));
262 return s_state.kp->ftruncate(fd, length);
263 } 261 }
264 262
265 int ki_fsync(int fd) { 263 int ki_fsync(int fd) {
266 ON_NOSYS_RETURN(-1); 264 KP_CALL(fsync, (fd));
267 return s_state.kp->fsync(fd);
268 } 265 }
269 266
270 int ki_fdatasync(int fd) { 267 int ki_fdatasync(int fd) {
271 ON_NOSYS_RETURN(-1); 268 KP_CALL(fdatasync, (fd));
272 return s_state.kp->fdatasync(fd);
273 } 269 }
274 270
275 int ki_isatty(int fd) { 271 int ki_isatty(int fd) {
276 ON_NOSYS_RETURN(0); 272 ON_NOSYS_RETURN(0);
277 return s_state.kp->isatty(fd); 273 return s_state.kp->isatty(fd);
278 } 274 }
279 275
280 int ki_close(int fd) { 276 int ki_close(int fd) {
281 ON_NOSYS_RETURN(-1); 277 KP_CALL(close, (fd));
282 return s_state.kp->close(fd);
283 } 278 }
284 279
285 off_t ki_lseek(int fd, off_t offset, int whence) { 280 off_t ki_lseek(int fd, off_t offset, int whence) {
286 ON_NOSYS_RETURN(-1); 281 ON_NOSYS_RETURN(-1);
287 return s_state.kp->lseek(fd, offset, whence); 282 return s_state.kp->lseek(fd, offset, whence);
288 } 283 }
289 284
290 int ki_remove(const char* path) { 285 int ki_remove(const char* path) {
291 ON_NOSYS_RETURN(-1); 286 KP_CALL(remove, (path));
292 return s_state.kp->remove(path);
293 } 287 }
294 288
295 int ki_unlink(const char* path) { 289 int ki_unlink(const char* path) {
296 ON_NOSYS_RETURN(-1); 290 KP_CALL(unlink, (path));
297 return s_state.kp->unlink(path);
298 } 291 }
299 292
300 int ki_truncate(const char* path, off_t length) { 293 int ki_truncate(const char* path, off_t length) {
301 ON_NOSYS_RETURN(-1); 294 KP_CALL(truncate, (path, length));
302 return s_state.kp->truncate(path, length);
303 } 295 }
304 296
305 int ki_lstat(const char* path, struct stat* buf) { 297 int ki_lstat(const char* path, struct stat* buf) {
306 ON_NOSYS_RETURN(-1); 298 KP_CALL(lstat, (path, buf));
307 return s_state.kp->lstat(path, buf);
308 } 299 }
309 300
310 int ki_link(const char* oldpath, const char* newpath) { 301 int ki_link(const char* oldpath, const char* newpath) {
311 ON_NOSYS_RETURN(-1); 302 KP_CALL(link, (oldpath, newpath));
312 return s_state.kp->link(oldpath, newpath);
313 } 303 }
314 304
315 int ki_rename(const char* path, const char* newpath) { 305 int ki_rename(const char* path, const char* newpath) {
316 ON_NOSYS_RETURN(-1); 306 KP_CALL(rename, (path, newpath));
317 return s_state.kp->rename(path, newpath);
318 } 307 }
319 308
320 int ki_symlink(const char* oldpath, const char* newpath) { 309 int ki_symlink(const char* oldpath, const char* newpath) {
321 ON_NOSYS_RETURN(-1); 310 KP_CALL(symlink, (oldpath, newpath));
322 return s_state.kp->symlink(oldpath, newpath);
323 } 311 }
324 312
325 int ki_access(const char* path, int amode) { 313 int ki_access(const char* path, int amode) {
326 ON_NOSYS_RETURN(-1); 314 KP_CALL(access, (path, amode));
327 return s_state.kp->access(path, amode);
328 } 315 }
329 316
330 int ki_readlink(const char* path, char* buf, size_t count) { 317 int ki_readlink(const char* path, char* buf, size_t count) {
331 ON_NOSYS_RETURN(-1); 318 KP_CALL(readlink, (path, buf, count));
332 return s_state.kp->readlink(path, buf, count);
333 } 319 }
334 320
335 int ki_utimes(const char* path, const struct timeval times[2]) { 321 int ki_utimes(const char* path, const struct timeval times[2]) {
336 ON_NOSYS_RETURN(-1); 322 ON_NOSYS_RETURN(-1);
337 // Implement in terms of utimens. 323 // Implement in terms of utimens.
338 if (!times) { 324 if (!times) {
339 return s_state.kp->utimens(path, NULL); 325 return s_state.kp->utimens(path, NULL);
340 } 326 }
341 327
342 struct timespec ts[2]; 328 struct timespec ts[2];
(...skipping 291 matching lines...) Expand 10 before | Expand all | Expand 10 after
634 int ki_socket(int domain, int type, int protocol) { 620 int ki_socket(int domain, int type, int protocol) {
635 ON_NOSYS_RETURN(-1); 621 ON_NOSYS_RETURN(-1);
636 return s_state.kp->socket(domain, type, protocol); 622 return s_state.kp->socket(domain, type, protocol);
637 } 623 }
638 624
639 int ki_socketpair(int domain, int type, int protocol, int* sv) { 625 int ki_socketpair(int domain, int type, int protocol, int* sv) {
640 ON_NOSYS_RETURN(-1); 626 ON_NOSYS_RETURN(-1);
641 return s_state.kp->socketpair(domain, type, protocol, sv); 627 return s_state.kp->socketpair(domain, type, protocol, sv);
642 } 628 }
643 #endif // PROVIDES_SOCKET_API 629 #endif // PROVIDES_SOCKET_API
OLDNEW
« no previous file with comments | « no previous file | no next file » | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698