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

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 5 years, 11 months 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 KP_TRACE nacl_io_log
33 #else
34 #define KP_TRACE(...)
35 #endif
36
37 #define KP_CALL(METHOD, ARGS) \
38 ON_NOSYS_RETURN(-1); \
39 int rtn = s_state.kp-> METHOD ARGS; \
40 KP_TRACE("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) {
154 KP_TRACE("ki_exit\n");
145 if (ki_is_initialized()) 155 if (ki_is_initialized())
146 s_state.kp->exit(status); 156 s_state.kp->exit(status);
147 157
148 _real_exit(status); 158 _real_exit(status);
149 } 159 }
150 160
151 char* ki_getcwd(char* buf, size_t size) { 161 char* ki_getcwd(char* buf, size_t size) {
152 ON_NOSYS_RETURN(NULL); 162 ON_NOSYS_RETURN(NULL);
163 KP_TRACE("ki_getcwd\n");
153 return s_state.kp->getcwd(buf, size); 164 return s_state.kp->getcwd(buf, size);
154 } 165 }
155 166
156 char* ki_getwd(char* buf) { 167 char* ki_getwd(char* buf) {
157 ON_NOSYS_RETURN(NULL); 168 ON_NOSYS_RETURN(NULL);
169 KP_TRACE("ki_getwd\n");
158 return s_state.kp->getwd(buf); 170 return s_state.kp->getwd(buf);
159 } 171 }
160 172
173 int ki_chdir(const char* path) {
174 KP_CALL(chdir, (path));
175 }
176
161 int ki_dup(int oldfd) { 177 int ki_dup(int oldfd) {
162 ON_NOSYS_RETURN(-1); 178 KP_CALL(dup, (oldfd));
163 return s_state.kp->dup(oldfd);
164 } 179 }
165 180
166 int ki_dup2(int oldfd, int newfd) { 181 int ki_dup2(int oldfd, int newfd) {
167 ON_NOSYS_RETURN(-1); 182 KP_CALL(dup2, (oldfd, newfd));
168 return s_state.kp->dup2(oldfd, newfd);
169 } 183 }
170 184
171 int ki_chmod(const char* path, mode_t mode) { 185 int ki_chmod(const char* path, mode_t mode) {
172 ON_NOSYS_RETURN(-1); 186 KP_CALL(chmod, (path, mode));
173 return s_state.kp->chmod(path, mode);
174 } 187 }
175 188
176 int ki_fchdir(int fd) { 189 int ki_fchdir(int fd) {
177 ON_NOSYS_RETURN(-1); 190 KP_CALL(fchdir, (fd));
178 return s_state.kp->fchdir(fd);
179 } 191 }
180 192
181 int ki_fchmod(int fd, mode_t mode) { 193 int ki_fchmod(int fd, mode_t mode) {
182 ON_NOSYS_RETURN(-1); 194 KP_CALL(fchmod, (fd, mode));
183 return s_state.kp->fchmod(fd, mode);
184 } 195 }
185 196
186 int ki_stat(const char* path, struct stat* buf) { 197 int ki_stat(const char* path, struct stat* buf) {
187 ON_NOSYS_RETURN(-1); 198 KP_CALL(stat, (path, buf));
188 return s_state.kp->stat(path, buf);
189 } 199 }
190 200
191 int ki_mkdir(const char* path, mode_t mode) { 201 int ki_mkdir(const char* path, mode_t mode) {
192 ON_NOSYS_RETURN(-1); 202 KP_CALL(mkdir, (path, mode));
193 return s_state.kp->mkdir(path, mode);
194 } 203 }
195 204
196 int ki_rmdir(const char* path) { 205 int ki_rmdir(const char* path) {
197 ON_NOSYS_RETURN(-1); 206 KP_CALL(rmdir, (path));
198 return s_state.kp->rmdir(path);
199 } 207 }
200 208
201 int ki_mount(const char* source, 209 int ki_mount(const char* source,
202 const char* target, 210 const char* target,
203 const char* filesystemtype, 211 const char* filesystemtype,
204 unsigned long mountflags, 212 unsigned long mountflags,
205 const void* data) { 213 const void* data) {
206 ON_NOSYS_RETURN(-1); 214 KP_CALL(mount, (source, target, filesystemtype, mountflags, data));
207 return s_state.kp->mount(source, target, filesystemtype, mountflags, data);
208 } 215 }
209 216
210 int ki_umount(const char* path) { 217 int ki_umount(const char* path) {
211 ON_NOSYS_RETURN(-1); 218 KP_CALL(umount, (path));
212 return s_state.kp->umount(path);
213 } 219 }
214 220
215 int ki_open(const char* path, int oflag, mode_t mode) { 221 int ki_open(const char* path, int oflag, mode_t mode) {
216 ON_NOSYS_RETURN(-1); 222 KP_CALL(open, (path, oflag, mode));
217 return s_state.kp->open(path, oflag, mode);
218 } 223 }
219 224
220 int ki_pipe(int pipefds[2]) { 225 int ki_pipe(int pipefds[2]) {
221 ON_NOSYS_RETURN(-1); 226 KP_CALL(pipe, (pipefds));
222 return s_state.kp->pipe(pipefds);
223 } 227 }
224 228
225 ssize_t ki_read(int fd, void* buf, size_t nbyte) { 229 ssize_t ki_read(int fd, void* buf, size_t nbyte) {
226 ON_NOSYS_RETURN(-1); 230 ON_NOSYS_RETURN(-1);
231 KP_TRACE("ki_read\n");
227 return s_state.kp->read(fd, buf, nbyte); 232 return s_state.kp->read(fd, buf, nbyte);
228 } 233 }
229 234
230 ssize_t ki_write(int fd, const void* buf, size_t nbyte) { 235 ssize_t ki_write(int fd, const void* buf, size_t nbyte) {
231 ON_NOSYS_RETURN(-1); 236 ON_NOSYS_RETURN(-1);
237 KP_TRACE("ki_write\n");
232 return s_state.kp->write(fd, buf, nbyte); 238 return s_state.kp->write(fd, buf, nbyte);
233 } 239 }
234 240
235 int ki_fstat(int fd, struct stat* buf) { 241 int ki_fstat(int fd, struct stat* buf) {
236 ON_NOSYS_RETURN(-1); 242 KP_CALL(fstat, (fd, buf));
237 return s_state.kp->fstat(fd, buf);
238 } 243 }
239 244
240 int ki_getdents(int fd, void* buf, unsigned int count) { 245 int ki_getdents(int fd, void* buf, unsigned int count) {
241 ON_NOSYS_RETURN(-1); 246 KP_CALL(getdents, (fd, buf, count));
242 return s_state.kp->getdents(fd, buf, count);
243 } 247 }
244 248
245 int ki_ftruncate(int fd, off_t length) { 249 int ki_ftruncate(int fd, off_t length) {
246 ON_NOSYS_RETURN(-1); 250 KP_CALL(ftruncate, (fd, length));
247 return s_state.kp->ftruncate(fd, length);
248 } 251 }
249 252
250 int ki_fsync(int fd) { 253 int ki_fsync(int fd) {
251 ON_NOSYS_RETURN(-1); 254 KP_CALL(fsync, (fd));
252 return s_state.kp->fsync(fd);
253 } 255 }
254 256
255 int ki_fdatasync(int fd) { 257 int ki_fdatasync(int fd) {
256 ON_NOSYS_RETURN(-1); 258 KP_CALL(fdatasync, (fd));
257 return s_state.kp->fdatasync(fd);
258 } 259 }
259 260
260 int ki_isatty(int fd) { 261 int ki_isatty(int fd) {
261 ON_NOSYS_RETURN(0); 262 ON_NOSYS_RETURN(0);
263 KP_TRACE("ki_isatty\n");
262 return s_state.kp->isatty(fd); 264 return s_state.kp->isatty(fd);
263 } 265 }
264 266
265 int ki_close(int fd) { 267 int ki_close(int fd) {
266 ON_NOSYS_RETURN(-1); 268 KP_CALL(close, (fd));
267 return s_state.kp->close(fd);
268 } 269 }
269 270
270 off_t ki_lseek(int fd, off_t offset, int whence) { 271 off_t ki_lseek(int fd, off_t offset, int whence) {
271 ON_NOSYS_RETURN(-1); 272 ON_NOSYS_RETURN(-1);
273 KP_TRACE("ki_lseek\n");
272 return s_state.kp->lseek(fd, offset, whence); 274 return s_state.kp->lseek(fd, offset, whence);
273 } 275 }
274 276
275 int ki_remove(const char* path) { 277 int ki_remove(const char* path) {
276 ON_NOSYS_RETURN(-1); 278 KP_CALL(remove, (path));
277 return s_state.kp->remove(path);
278 } 279 }
279 280
280 int ki_unlink(const char* path) { 281 int ki_unlink(const char* path) {
281 ON_NOSYS_RETURN(-1); 282 KP_CALL(unlink, (path));
282 return s_state.kp->unlink(path);
283 } 283 }
284 284
285 int ki_truncate(const char* path, off_t length) { 285 int ki_truncate(const char* path, off_t length) {
286 ON_NOSYS_RETURN(-1); 286 KP_CALL(truncate, (path, length));
287 return s_state.kp->truncate(path, length);
288 } 287 }
289 288
290 int ki_lstat(const char* path, struct stat* buf) { 289 int ki_lstat(const char* path, struct stat* buf) {
291 ON_NOSYS_RETURN(-1); 290 KP_CALL(lstat, (path, buf));
292 return s_state.kp->lstat(path, buf);
293 } 291 }
294 292
295 int ki_link(const char* oldpath, const char* newpath) { 293 int ki_link(const char* oldpath, const char* newpath) {
296 ON_NOSYS_RETURN(-1); 294 KP_CALL(link, (oldpath, newpath));
297 return s_state.kp->link(oldpath, newpath);
298 } 295 }
299 296
300 int ki_rename(const char* path, const char* newpath) { 297 int ki_rename(const char* path, const char* newpath) {
301 ON_NOSYS_RETURN(-1); 298 KP_CALL(rename, (path, newpath));
302 return s_state.kp->rename(path, newpath);
303 } 299 }
304 300
305 int ki_symlink(const char* oldpath, const char* newpath) { 301 int ki_symlink(const char* oldpath, const char* newpath) {
306 ON_NOSYS_RETURN(-1); 302 KP_CALL(symlink, (oldpath, newpath));
307 return s_state.kp->symlink(oldpath, newpath);
308 } 303 }
309 304
310 int ki_access(const char* path, int amode) { 305 int ki_access(const char* path, int amode) {
311 ON_NOSYS_RETURN(-1); 306 KP_CALL(access, (path, amode));
312 return s_state.kp->access(path, amode);
313 } 307 }
314 308
315 int ki_readlink(const char* path, char* buf, size_t count) { 309 int ki_readlink(const char* path, char* buf, size_t count) {
316 ON_NOSYS_RETURN(-1); 310 KP_CALL(readlink, (path, buf, count));
317 return s_state.kp->readlink(path, buf, count);
318 } 311 }
319 312
320 int ki_utimes(const char* path, const struct timeval times[2]) { 313 int ki_utimes(const char* path, const struct timeval times[2]) {
321 ON_NOSYS_RETURN(-1); 314 ON_NOSYS_RETURN(-1);
315 KP_TRACE("ki_utimes");
322 // Implement in terms of utimens. 316 // Implement in terms of utimens.
323 if (!times) { 317 if (!times) {
324 return s_state.kp->utimens(path, NULL); 318 return s_state.kp->utimens(path, NULL);
325 } 319 }
326 320
327 struct timespec ts[2]; 321 struct timespec ts[2];
328 ts[0].tv_sec = times[0].tv_sec; 322 ts[0].tv_sec = times[0].tv_sec;
329 ts[0].tv_nsec = times[0].tv_usec * 1000; 323 ts[0].tv_nsec = times[0].tv_usec * 1000;
330 ts[1].tv_sec = times[1].tv_sec; 324 ts[1].tv_sec = times[1].tv_sec;
331 ts[1].tv_nsec = times[1].tv_usec * 1000; 325 ts[1].tv_nsec = times[1].tv_usec * 1000;
332 return s_state.kp->utimens(path, ts); 326 return s_state.kp->utimens(path, ts);
333 } 327 }
334 328
335 int ki_futimes(int fd, const struct timeval times[2]) { 329 int ki_futimes(int fd, const struct timeval times[2]) {
336 ON_NOSYS_RETURN(-1); 330 ON_NOSYS_RETURN(-1);
331 KP_TRACE("ki_futimes");
337 // Implement in terms of futimens. 332 // Implement in terms of futimens.
338 if (!times) { 333 if (!times) {
339 return s_state.kp->futimens(fd, NULL); 334 return s_state.kp->futimens(fd, NULL);
340 } 335 }
341 336
342 struct timespec ts[2]; 337 struct timespec ts[2];
343 ts[0].tv_sec = times[0].tv_sec; 338 ts[0].tv_sec = times[0].tv_sec;
344 ts[0].tv_nsec = times[0].tv_usec * 1000; 339 ts[0].tv_nsec = times[0].tv_usec * 1000;
345 ts[1].tv_sec = times[1].tv_sec; 340 ts[1].tv_sec = times[1].tv_sec;
346 ts[1].tv_nsec = times[1].tv_usec * 1000; 341 ts[1].tv_nsec = times[1].tv_usec * 1000;
347 return s_state.kp->futimens(fd, ts); 342 return s_state.kp->futimens(fd, ts);
348 } 343 }
349 344
350 void* ki_mmap(void* addr, 345 void* ki_mmap(void* addr,
351 size_t length, 346 size_t length,
352 int prot, 347 int prot,
353 int flags, 348 int flags,
354 int fd, 349 int fd,
355 off_t offset) { 350 off_t offset) {
356 ON_NOSYS_RETURN(MAP_FAILED); 351 ON_NOSYS_RETURN(MAP_FAILED);
352 KP_TRACE("ki_mmap\n");
357 return s_state.kp->mmap(addr, length, prot, flags, fd, offset); 353 return s_state.kp->mmap(addr, length, prot, flags, fd, offset);
358 } 354 }
359 355
360 int ki_munmap(void* addr, size_t length) { 356 int ki_munmap(void* addr, size_t length) {
361 ON_NOSYS_RETURN(-1); 357 ON_NOSYS_RETURN(-1);
358 KP_TRACE("ki_munmap\n");
362 return s_state.kp->munmap(addr, length); 359 return s_state.kp->munmap(addr, length);
363 } 360 }
364 361
365 int ki_open_resource(const char* file) { 362 int ki_open_resource(const char* file) {
366 ON_NOSYS_RETURN(-1); 363 ON_NOSYS_RETURN(-1);
364 KP_TRACE("ki_open_resource\n");
367 return s_state.kp->open_resource(file); 365 return s_state.kp->open_resource(file);
368 } 366 }
369 367
370 int ki_fcntl(int d, int request, va_list args) { 368 int ki_fcntl(int d, int request, va_list args) {
371 ON_NOSYS_RETURN(-1); 369 KP_CALL(fcntl, (d, request, args));
372 return s_state.kp->fcntl(d, request, args);
373 } 370 }
374 371
375 int ki_ioctl(int d, int request, va_list args) { 372 int ki_ioctl(int d, int request, va_list args) {
376 ON_NOSYS_RETURN(-1); 373 KP_CALL(ioctl, (d, request, args));
377 return s_state.kp->ioctl(d, request, args);
378 } 374 }
379 375
380 int ki_chown(const char* path, uid_t owner, gid_t group) { 376 int ki_chown(const char* path, uid_t owner, gid_t group) {
381 ON_NOSYS_RETURN(-1); 377 KP_CALL(chown, (path, owner, group));
382 return s_state.kp->chown(path, owner, group);
383 } 378 }
384 379
385 int ki_fchown(int fd, uid_t owner, gid_t group) { 380 int ki_fchown(int fd, uid_t owner, gid_t group) {
386 ON_NOSYS_RETURN(-1); 381 KP_CALL(fchown, (fd, owner, group));
387 return s_state.kp->fchown(fd, owner, group);
388 } 382 }
389 383
390 int ki_lchown(const char* path, uid_t owner, gid_t group) { 384 int ki_lchown(const char* path, uid_t owner, gid_t group) {
391 ON_NOSYS_RETURN(-1); 385 KP_CALL(lchown, (path, owner, group));
392 return s_state.kp->lchown(path, owner, group);
393 } 386 }
394 387
395 int ki_utime(const char* filename, const struct utimbuf* times) { 388 int ki_utime(const char* filename, const struct utimbuf* times) {
396 ON_NOSYS_RETURN(-1); 389 ON_NOSYS_RETURN(-1);
390 KP_TRACE("ki_utime\n");
397 // Implement in terms of utimens. 391 // Implement in terms of utimens.
398 if (!times) { 392 if (!times) {
399 return s_state.kp->utimens(filename, NULL); 393 return s_state.kp->utimens(filename, NULL);
400 } 394 }
401 395
402 struct timespec ts[2]; 396 struct timespec ts[2];
403 ts[0].tv_sec = times->actime; 397 ts[0].tv_sec = times->actime;
404 ts[0].tv_nsec = 0; 398 ts[0].tv_nsec = 0;
405 ts[1].tv_sec = times->modtime; 399 ts[1].tv_sec = times->modtime;
406 ts[1].tv_nsec = 0; 400 ts[1].tv_nsec = 0;
407 return s_state.kp->utimens(filename, ts); 401 return s_state.kp->utimens(filename, ts);
408 } 402 }
409 403
410 int ki_futimens(int fd, const struct timespec times[2]) { 404 int ki_futimens(int fd, const struct timespec times[2]) {
411 ON_NOSYS_RETURN(-1); 405 KP_CALL(futimens, (fd, times));
412 return s_state.kp->futimens(fd, times);
413 } 406 }
414 407
415 mode_t ki_umask(mode_t mask) { 408 mode_t ki_umask(mode_t mask) {
416 ON_NOSYS_RETURN(0); 409 ON_NOSYS_RETURN(0);
410 KP_TRACE("ki_umask\n");
417 return s_state.kp->umask(mask); 411 return s_state.kp->umask(mask);
418 } 412 }
419 413
420 int ki_poll(struct pollfd* fds, nfds_t nfds, int timeout) { 414 int ki_poll(struct pollfd* fds, nfds_t nfds, int timeout) {
421 return s_state.kp->poll(fds, nfds, timeout); 415 KP_CALL(poll, (fds, nfds, timeout));
422 } 416 }
423 417
424 int ki_select(int nfds, 418 int ki_select(int nfds,
425 fd_set* readfds, 419 fd_set* readfds,
426 fd_set* writefds, 420 fd_set* writefds,
427 fd_set* exceptfds, 421 fd_set* exceptfds,
428 struct timeval* timeout) { 422 struct timeval* timeout) {
429 return s_state.kp->select(nfds, readfds, writefds, exceptfds, timeout); 423 KP_CALL(select, (nfds, readfds, writefds, exceptfds, timeout));
430 } 424 }
431 425
432 int ki_tcflush(int fd, int queue_selector) { 426 int ki_tcflush(int fd, int queue_selector) {
433 ON_NOSYS_RETURN(-1); 427 KP_CALL(tcflush, (fd, queue_selector));
434 return s_state.kp->tcflush(fd, queue_selector);
435 } 428 }
436 429
437 int ki_tcgetattr(int fd, struct termios* termios_p) { 430 int ki_tcgetattr(int fd, struct termios* termios_p) {
438 ON_NOSYS_RETURN(-1); 431 KP_CALL(tcgetattr, (fd, termios_p));
439 return s_state.kp->tcgetattr(fd, termios_p);
440 } 432 }
441 433
442 int ki_tcsetattr(int fd, 434 int ki_tcsetattr(int fd,
443 int optional_actions, 435 int optional_actions,
444 const struct termios* termios_p) { 436 const struct termios* termios_p) {
445 ON_NOSYS_RETURN(-1); 437 KP_CALL(tcsetattr, (fd, optional_actions, termios_p));
446 return s_state.kp->tcsetattr(fd, optional_actions, termios_p);
447 } 438 }
448 439
449 int ki_kill(pid_t pid, int sig) { 440 int ki_kill(pid_t pid, int sig) {
450 ON_NOSYS_RETURN(-1); 441 KP_CALL(kill, (pid, sig));
451 return s_state.kp->kill(pid, sig);
452 } 442 }
453 443
454 int ki_killpg(pid_t pid, int sig) { 444 int ki_killpg(pid_t pid, int sig) {
455 errno = ENOSYS; 445 errno = ENOSYS;
456 return -1; 446 return -1;
457 } 447 }
458 448
459 int ki_sigaction(int signum, 449 int ki_sigaction(int signum,
460 const struct sigaction* action, 450 const struct sigaction* action,
461 struct sigaction* oaction) { 451 struct sigaction* oaction) {
462 ON_NOSYS_RETURN(-1); 452 KP_CALL(sigaction, (signum, action, oaction));
463 return s_state.kp->sigaction(signum, action, oaction);
464 } 453 }
465 454
466 int ki_sigpause(int sigmask) { 455 int ki_sigpause(int sigmask) {
467 errno = ENOSYS; 456 errno = ENOSYS;
468 return -1; 457 return -1;
469 } 458 }
470 459
471 int ki_sigpending(sigset_t* set) { 460 int ki_sigpending(sigset_t* set) {
472 errno = ENOSYS; 461 errno = ENOSYS;
473 return -1; 462 return -1;
474 } 463 }
475 464
476 int ki_sigsuspend(const sigset_t* set) { 465 int ki_sigsuspend(const sigset_t* set) {
477 errno = ENOSYS; 466 errno = ENOSYS;
478 return -1; 467 return -1;
479 } 468 }
480 469
481 sighandler_t ki_signal(int signum, sighandler_t handler) { 470 sighandler_t ki_signal(int signum, sighandler_t handler) {
482 return ki_sigset(signum, handler); 471 return ki_sigset(signum, handler);
483 } 472 }
484 473
485 sighandler_t ki_sigset(int signum, sighandler_t handler) { 474 sighandler_t ki_sigset(int signum, sighandler_t handler) {
486 ON_NOSYS_RETURN(SIG_ERR); 475 ON_NOSYS_RETURN(SIG_ERR);
476 KP_TRACE("ki_sigset\n");
487 // Implement sigset(2) in terms of sigaction(2). 477 // Implement sigset(2) in terms of sigaction(2).
488 struct sigaction action; 478 struct sigaction action;
489 struct sigaction oaction; 479 struct sigaction oaction;
490 memset(&action, 0, sizeof(action)); 480 memset(&action, 0, sizeof(action));
491 memset(&oaction, 0, sizeof(oaction)); 481 memset(&oaction, 0, sizeof(oaction));
492 action.sa_handler = handler; 482 action.sa_handler = handler;
493 int rtn = s_state.kp->sigaction(signum, &action, &oaction); 483 int rtn = s_state.kp->sigaction(signum, &action, &oaction);
494 if (rtn) 484 if (rtn)
495 return SIG_ERR; 485 return SIG_ERR;
496 return oaction.sa_handler; 486 return oaction.sa_handler;
497 } 487 }
498 488
499 #ifdef PROVIDES_SOCKET_API 489 #ifdef PROVIDES_SOCKET_API
500 // Socket Functions 490 // Socket Functions
501 int ki_accept(int fd, struct sockaddr* addr, socklen_t* len) { 491 int ki_accept(int fd, struct sockaddr* addr, socklen_t* len) {
502 ON_NOSYS_RETURN(-1); 492 KP_CALL(accept, (fd, addr, len));
503 return s_state.kp->accept(fd, addr, len);
504 } 493 }
505 494
506 int ki_bind(int fd, const struct sockaddr* addr, socklen_t len) { 495 int ki_bind(int fd, const struct sockaddr* addr, socklen_t len) {
507 ON_NOSYS_RETURN(-1); 496 KP_CALL(bind, (fd, addr, len));
508 return s_state.kp->bind(fd, addr, len);
509 } 497 }
510 498
511 int ki_connect(int fd, const struct sockaddr* addr, socklen_t len) { 499 int ki_connect(int fd, const struct sockaddr* addr, socklen_t len) {
512 ON_NOSYS_RETURN(-1); 500 KP_CALL(connect, (fd, addr, len));
513 return s_state.kp->connect(fd, addr, len);
514 } 501 }
515 502
516 struct hostent* ki_gethostbyname(const char* name) { 503 struct hostent* ki_gethostbyname(const char* name) {
517 ON_NOSYS_RETURN(NULL); 504 ON_NOSYS_RETURN(NULL);
518 return s_state.kp->gethostbyname(name); 505 return s_state.kp->gethostbyname(name);
519 } 506 }
520 507
521 int ki_getnameinfo(const struct sockaddr *sa, 508 int ki_getnameinfo(const struct sockaddr *sa,
522 socklen_t salen, 509 socklen_t salen,
523 char *host, 510 char *host,
524 size_t hostlen, 511 size_t hostlen,
525 char *serv, 512 char *serv,
526 size_t servlen, 513 size_t servlen,
527 unsigned int flags) { 514 unsigned int flags) {
528 ON_NOSYS_RETURN(EAI_SYSTEM); 515 ON_NOSYS_RETURN(EAI_SYSTEM);
516 KP_TRACE("ki_getnameinfo\n");
529 return s_state.kp->getnameinfo(sa, salen, host, hostlen, serv, servlen, 517 return s_state.kp->getnameinfo(sa, salen, host, hostlen, serv, servlen,
530 flags); 518 flags);
531 } 519 }
532 520
533 int ki_getaddrinfo(const char* node, 521 int ki_getaddrinfo(const char* node,
534 const char* service, 522 const char* service,
535 const struct addrinfo* hints, 523 const struct addrinfo* hints,
536 struct addrinfo** res) { 524 struct addrinfo** res) {
537 ON_NOSYS_RETURN(EAI_SYSTEM); 525 ON_NOSYS_RETURN(EAI_SYSTEM);
526 KP_TRACE("ki_getaddrinfo\n");
538 return s_state.kp->getaddrinfo(node, service, hints, res); 527 return s_state.kp->getaddrinfo(node, service, hints, res);
539 } 528 }
540 529
541 void ki_freeaddrinfo(struct addrinfo* res) { 530 void ki_freeaddrinfo(struct addrinfo* res) {
531 KP_TRACE("ki_freeaddrinfo\n");
542 s_state.kp->freeaddrinfo(res); 532 s_state.kp->freeaddrinfo(res);
543 } 533 }
544 534
545 int ki_getpeername(int fd, struct sockaddr* addr, socklen_t* len) { 535 int ki_getpeername(int fd, struct sockaddr* addr, socklen_t* len) {
546 ON_NOSYS_RETURN(-1); 536 KP_CALL(getpeername, (fd, addr, len));
547 return s_state.kp->getpeername(fd, addr, len);
548 } 537 }
549 538
550 int ki_getsockname(int fd, struct sockaddr* addr, socklen_t* len) { 539 int ki_getsockname(int fd, struct sockaddr* addr, socklen_t* len) {
551 ON_NOSYS_RETURN(-1); 540 KP_CALL(getsockname, (fd, addr, len));
552 return s_state.kp->getsockname(fd, addr, len);
553 } 541 }
554 542
555 int ki_getsockopt(int fd, int lvl, int optname, void* optval, socklen_t* len) { 543 int ki_getsockopt(int fd, int lvl, int optname, void* optval, socklen_t* len) {
556 ON_NOSYS_RETURN(-1); 544 KP_CALL(getsockopt, (fd, lvl, optname, optval, len));
557 return s_state.kp->getsockopt(fd, lvl, optname, optval, len);
558 } 545 }
559 546
560 int ki_listen(int fd, int backlog) { 547 int ki_listen(int fd, int backlog) {
561 ON_NOSYS_RETURN(-1); 548 KP_CALL(listen, (fd, backlog));
562 return s_state.kp->listen(fd, backlog);
563 } 549 }
564 550
565 ssize_t ki_recv(int fd, void* buf, size_t len, int flags) { 551 ssize_t ki_recv(int fd, void* buf, size_t len, int flags) {
566 ON_NOSYS_RETURN(-1); 552 ON_NOSYS_RETURN(-1);
553 KP_TRACE("ki_recv\n");
567 return s_state.kp->recv(fd, buf, len, flags); 554 return s_state.kp->recv(fd, buf, len, flags);
568 } 555 }
569 556
570 ssize_t ki_recvfrom(int fd, 557 ssize_t ki_recvfrom(int fd,
571 void* buf, 558 void* buf,
572 size_t len, 559 size_t len,
573 int flags, 560 int flags,
574 struct sockaddr* addr, 561 struct sockaddr* addr,
575 socklen_t* addrlen) { 562 socklen_t* addrlen) {
576 ON_NOSYS_RETURN(-1); 563 ON_NOSYS_RETURN(-1);
564 KP_TRACE("ki_recvfrom\n");
577 return s_state.kp->recvfrom(fd, buf, len, flags, addr, addrlen); 565 return s_state.kp->recvfrom(fd, buf, len, flags, addr, addrlen);
578 } 566 }
579 567
580 ssize_t ki_recvmsg(int fd, struct msghdr* msg, int flags) { 568 ssize_t ki_recvmsg(int fd, struct msghdr* msg, int flags) {
581 ON_NOSYS_RETURN(-1); 569 ON_NOSYS_RETURN(-1);
570 KP_TRACE("ki_recvmsg\n");
582 return s_state.kp->recvmsg(fd, msg, flags); 571 return s_state.kp->recvmsg(fd, msg, flags);
583 } 572 }
584 573
585 ssize_t ki_send(int fd, const void* buf, size_t len, int flags) { 574 ssize_t ki_send(int fd, const void* buf, size_t len, int flags) {
586 ON_NOSYS_RETURN(-1); 575 ON_NOSYS_RETURN(-1);
576 KP_TRACE("ki_send\n");
587 return s_state.kp->send(fd, buf, len, flags); 577 return s_state.kp->send(fd, buf, len, flags);
588 } 578 }
589 579
590 ssize_t ki_sendto(int fd, 580 ssize_t ki_sendto(int fd,
591 const void* buf, 581 const void* buf,
592 size_t len, 582 size_t len,
593 int flags, 583 int flags,
594 const struct sockaddr* addr, 584 const struct sockaddr* addr,
595 socklen_t addrlen) { 585 socklen_t addrlen) {
596 ON_NOSYS_RETURN(-1); 586 ON_NOSYS_RETURN(-1);
587 KP_TRACE("ki_sendto\n");
597 return s_state.kp->sendto(fd, buf, len, flags, addr, addrlen); 588 return s_state.kp->sendto(fd, buf, len, flags, addr, addrlen);
598 } 589 }
599 590
600 ssize_t ki_sendmsg(int fd, const struct msghdr* msg, int flags) { 591 ssize_t ki_sendmsg(int fd, const struct msghdr* msg, int flags) {
601 ON_NOSYS_RETURN(-1); 592 ON_NOSYS_RETURN(-1);
593 KP_TRACE("ki_sendmsg\n");
602 return s_state.kp->sendmsg(fd, msg, flags); 594 return s_state.kp->sendmsg(fd, msg, flags);
603 } 595 }
604 596
605 int ki_setsockopt(int fd, 597 int ki_setsockopt(int fd,
606 int lvl, 598 int lvl,
607 int optname, 599 int optname,
608 const void* optval, 600 const void* optval,
609 socklen_t len) { 601 socklen_t len) {
610 ON_NOSYS_RETURN(-1); 602 KP_CALL(setsockopt, (fd, lvl, optname, optval, len));
611 return s_state.kp->setsockopt(fd, lvl, optname, optval, len);
612 } 603 }
613 604
614 int ki_shutdown(int fd, int how) { 605 int ki_shutdown(int fd, int how) {
615 ON_NOSYS_RETURN(-1); 606 KP_CALL(shutdown, (fd, how));
616 return s_state.kp->shutdown(fd, how);
617 } 607 }
618 608
619 int ki_socket(int domain, int type, int protocol) { 609 int ki_socket(int domain, int type, int protocol) {
620 ON_NOSYS_RETURN(-1); 610 KP_CALL(socket, (domain, type, protocol));
621 return s_state.kp->socket(domain, type, protocol);
622 } 611 }
623 612
624 int ki_socketpair(int domain, int type, int protocol, int* sv) { 613 int ki_socketpair(int domain, int type, int protocol, int* sv) {
625 ON_NOSYS_RETURN(-1); 614 KP_CALL(socketpair, (domain, type, protocol, sv));
626 return s_state.kp->socketpair(domain, type, protocol, sv);
627 } 615 }
628 #endif // PROVIDES_SOCKET_API 616 #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