kernel_intercept.cc revision cedac228d2dd51db4b79ea1e72c7f249408ee061
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#include "nacl_io/kernel_intercept.h" 6 7#include <assert.h> 8#include <errno.h> 9#include <string.h> 10 11#include "nacl_io/kernel_proxy.h" 12#include "nacl_io/kernel_wrap.h" 13#include "nacl_io/kernel_wrap_real.h" 14#include "nacl_io/log.h" 15#include "nacl_io/osmman.h" 16#include "nacl_io/ossocket.h" 17#include "nacl_io/pepper_interface.h" 18#include "nacl_io/real_pepper_interface.h" 19 20using namespace nacl_io; 21 22#define ON_NOSYS_RETURN(x) \ 23 if (!ki_is_initialized()) { \ 24 errno = ENOSYS; \ 25 return x; \ 26 } 27 28struct KernelInterceptState { 29 KernelProxy* kp; 30 PepperInterface* ppapi; 31 bool kp_owned; 32}; 33 34static KernelInterceptState s_state; 35 36// The the test code we want to be able to save the previous kernel 37// proxy when intialising and restore it on uninit. 38static KernelInterceptState s_saved_state; 39 40int ki_push_state_for_testing() { 41 assert(s_saved_state.kp == NULL); 42 if (s_saved_state.kp != NULL) 43 return 1; 44 s_saved_state = s_state; 45 s_state.kp = NULL; 46 s_state.ppapi = NULL; 47 s_state.kp_owned = false; 48 return 0; 49} 50 51int ki_init(void* kp) { 52 LOG_TRACE("ki_init: %p", kp); 53 return ki_init_ppapi(kp, 0, NULL); 54} 55 56int ki_init_ppapi(void* kp, 57 PP_Instance instance, 58 PPB_GetInterface get_browser_interface) { 59 assert(!s_state.kp); 60 if (s_state.kp != NULL) 61 return 1; 62 PepperInterface* ppapi = NULL; 63 if (instance && get_browser_interface) { 64 ppapi = new RealPepperInterface(instance, get_browser_interface); 65 s_state.ppapi = ppapi; 66 } 67 int rtn = ki_init_interface(kp, ppapi); 68 return rtn; 69} 70 71int ki_init_interface(void* kp, void* pepper_interface) { 72 LOG_TRACE("ki_init_interface: %p %p", kp, pepper_interface); 73 assert(!s_state.kp); 74 if (s_state.kp != NULL) 75 return 1; 76 PepperInterface* ppapi = static_cast<PepperInterface*>(pepper_interface); 77 kernel_wrap_init(); 78 79 if (kp == NULL) { 80 s_state.kp = new KernelProxy(); 81 s_state.kp_owned = true; 82 } else { 83 s_state.kp = static_cast<KernelProxy*>(kp); 84 s_state.kp_owned = false; 85 } 86 87 if (s_state.kp->Init(ppapi) != 0) 88 return 1; 89 90 return 0; 91} 92 93int ki_is_initialized() { 94 return s_state.kp != NULL; 95} 96 97void ki_uninit() { 98 LOG_TRACE("ki_uninit"); 99 if (s_saved_state.kp == NULL) 100 kernel_wrap_uninit(); 101 102 // If we are going to delete the KernelProxy don't do it 103 // until we've swapped it out. 104 KernelInterceptState state_to_delete = s_state; 105 106 // Swap out the KernelProxy. This will normally reset the 107 // proxy to NULL, aside from in test code that has called 108 // ki_push_state_for_testing(). 109 s_state = s_saved_state; 110 s_saved_state.kp = NULL; 111 s_saved_state.ppapi = NULL; 112 s_saved_state.kp_owned = false; 113 114 if (state_to_delete.kp_owned) 115 delete state_to_delete.kp; 116 117 delete state_to_delete.ppapi; 118} 119 120nacl_io::KernelProxy* ki_get_proxy() { 121 return s_state.kp; 122} 123 124int ki_chdir(const char* path) { 125 ON_NOSYS_RETURN(-1); 126 return s_state.kp->chdir(path); 127} 128 129void ki_exit(int status) { 130 if (ki_is_initialized()) 131 s_state.kp->exit(status); 132 133 _real_exit(status); 134} 135 136char* ki_getcwd(char* buf, size_t size) { 137 // gtest uses getcwd in a static initializer. If we haven't initialized the 138 // kernel-intercept yet, just return ".". 139 if (!ki_is_initialized()) { 140 if (size < 2) { 141 errno = ERANGE; 142 return NULL; 143 } 144 buf[0] = '.'; 145 buf[1] = 0; 146 return buf; 147 } 148 return s_state.kp->getcwd(buf, size); 149} 150 151char* ki_getwd(char* buf) { 152 ON_NOSYS_RETURN(NULL); 153 return s_state.kp->getwd(buf); 154} 155 156int ki_dup(int oldfd) { 157 ON_NOSYS_RETURN(-1); 158 return s_state.kp->dup(oldfd); 159} 160 161int ki_dup2(int oldfd, int newfd) { 162 ON_NOSYS_RETURN(-1); 163 return s_state.kp->dup2(oldfd, newfd); 164} 165 166int ki_chmod(const char *path, mode_t mode) { 167 ON_NOSYS_RETURN(-1); 168 return s_state.kp->chmod(path, mode); 169} 170 171int ki_fchdir(int fd) { 172 ON_NOSYS_RETURN(-1); 173 return s_state.kp->fchdir(fd); 174} 175 176int ki_fchmod(int fd, mode_t mode) { 177 ON_NOSYS_RETURN(-1); 178 return s_state.kp->fchmod(fd, mode); 179} 180 181int ki_stat(const char *path, struct stat *buf) { 182 ON_NOSYS_RETURN(-1); 183 return s_state.kp->stat(path, buf); 184} 185 186int ki_mkdir(const char *path, mode_t mode) { 187 ON_NOSYS_RETURN(-1); 188 return s_state.kp->mkdir(path, mode); 189} 190 191int ki_rmdir(const char *path) { 192 ON_NOSYS_RETURN(-1); 193 return s_state.kp->rmdir(path); 194} 195 196int ki_mount(const char *source, const char *target, const char *filesystemtype, 197 unsigned long mountflags, const void *data) { 198 ON_NOSYS_RETURN(-1); 199 return s_state.kp->mount(source, target, filesystemtype, mountflags, data); 200} 201 202int ki_umount(const char *path) { 203 ON_NOSYS_RETURN(-1); 204 return s_state.kp->umount(path); 205} 206 207int ki_open(const char *path, int oflag) { 208 ON_NOSYS_RETURN(-1); 209 return s_state.kp->open(path, oflag); 210} 211 212int ki_pipe(int pipefds[2]) { 213 ON_NOSYS_RETURN(-1); 214 return s_state.kp->pipe(pipefds); 215} 216 217ssize_t ki_read(int fd, void *buf, size_t nbyte) { 218 ON_NOSYS_RETURN(-1); 219 return s_state.kp->read(fd, buf, nbyte); 220} 221 222ssize_t ki_write(int fd, const void *buf, size_t nbyte) { 223 ON_NOSYS_RETURN(-1); 224 return s_state.kp->write(fd, buf, nbyte); 225} 226 227int ki_fstat(int fd, struct stat *buf){ 228 ON_NOSYS_RETURN(-1); 229 return s_state.kp->fstat(fd, buf); 230} 231 232int ki_getdents(int fd, void *buf, unsigned int count) { 233 ON_NOSYS_RETURN(-1); 234 return s_state.kp->getdents(fd, buf, count); 235} 236 237int ki_ftruncate(int fd, off_t length) { 238 ON_NOSYS_RETURN(-1); 239 return s_state.kp->ftruncate(fd, length); 240} 241 242int ki_fsync(int fd) { 243 ON_NOSYS_RETURN(-1); 244 return s_state.kp->fsync(fd); 245} 246 247int ki_fdatasync(int fd) { 248 ON_NOSYS_RETURN(-1); 249 return s_state.kp->fdatasync(fd); 250} 251 252int ki_isatty(int fd) { 253 ON_NOSYS_RETURN(0); 254 return s_state.kp->isatty(fd); 255} 256 257int ki_close(int fd) { 258 ON_NOSYS_RETURN(-1); 259 return s_state.kp->close(fd); 260} 261 262off_t ki_lseek(int fd, off_t offset, int whence) { 263 ON_NOSYS_RETURN(-1); 264 return s_state.kp->lseek(fd, offset, whence); 265} 266 267int ki_remove(const char* path) { 268 ON_NOSYS_RETURN(-1); 269 return s_state.kp->remove(path); 270} 271 272int ki_unlink(const char* path) { 273 ON_NOSYS_RETURN(-1); 274 return s_state.kp->unlink(path); 275} 276 277int ki_truncate(const char* path, off_t length) { 278 ON_NOSYS_RETURN(-1); 279 return s_state.kp->truncate(path, length); 280} 281 282int ki_lstat(const char* path, struct stat* buf) { 283 ON_NOSYS_RETURN(-1); 284 return s_state.kp->lstat(path, buf); 285} 286 287int ki_link(const char* oldpath, const char* newpath) { 288 ON_NOSYS_RETURN(-1); 289 return s_state.kp->link(oldpath, newpath); 290} 291 292int ki_rename(const char* path, const char* newpath) { 293 ON_NOSYS_RETURN(-1); 294 return s_state.kp->rename(path, newpath); 295} 296 297int ki_symlink(const char* oldpath, const char* newpath) { 298 ON_NOSYS_RETURN(-1); 299 return s_state.kp->symlink(oldpath, newpath); 300} 301 302int ki_access(const char* path, int amode) { 303 ON_NOSYS_RETURN(-1); 304 return s_state.kp->access(path, amode); 305} 306 307int ki_readlink(const char *path, char *buf, size_t count) { 308 ON_NOSYS_RETURN(-1); 309 return s_state.kp->readlink(path, buf, count); 310} 311 312int ki_utimes(const char *path, const struct timeval times[2]) { 313 ON_NOSYS_RETURN(-1); 314 return s_state.kp->utimes(path, times); 315} 316 317void* ki_mmap(void* addr, size_t length, int prot, int flags, int fd, 318 off_t offset) { 319 ON_NOSYS_RETURN(MAP_FAILED); 320 return s_state.kp->mmap(addr, length, prot, flags, fd, offset); 321} 322 323int ki_munmap(void* addr, size_t length) { 324 ON_NOSYS_RETURN(-1); 325 return s_state.kp->munmap(addr, length); 326} 327 328int ki_open_resource(const char* file) { 329 ON_NOSYS_RETURN(-1); return s_state.kp->open_resource(file); 330} 331 332int ki_fcntl(int d, int request, va_list args) { 333 ON_NOSYS_RETURN(-1); 334 return s_state.kp->fcntl(d, request, args); 335} 336 337int ki_ioctl(int d, int request, va_list args) { 338 ON_NOSYS_RETURN(-1); 339 return s_state.kp->ioctl(d, request, args); 340} 341 342int ki_chown(const char* path, uid_t owner, gid_t group) { 343 ON_NOSYS_RETURN(-1); 344 return s_state.kp->chown(path, owner, group); 345} 346 347int ki_fchown(int fd, uid_t owner, gid_t group) { 348 ON_NOSYS_RETURN(-1); 349 return s_state.kp->fchown(fd, owner, group); 350} 351 352int ki_lchown(const char* path, uid_t owner, gid_t group) { 353 ON_NOSYS_RETURN(-1); 354 return s_state.kp->lchown(path, owner, group); 355} 356 357int ki_utime(const char* filename, const struct utimbuf* times) { 358 ON_NOSYS_RETURN(-1); 359 return s_state.kp->utime(filename, times); 360} 361 362int ki_poll(struct pollfd *fds, nfds_t nfds, int timeout) { 363 return s_state.kp->poll(fds, nfds, timeout); 364} 365 366int ki_select(int nfds, fd_set* readfds, fd_set* writefds, 367 fd_set* exceptfds, struct timeval* timeout) { 368 return s_state.kp->select(nfds, readfds, writefds, exceptfds, timeout); 369} 370 371int ki_tcflush(int fd, int queue_selector) { 372 ON_NOSYS_RETURN(-1); 373 return s_state.kp->tcflush(fd, queue_selector); 374} 375 376int ki_tcgetattr(int fd, struct termios* termios_p) { 377 ON_NOSYS_RETURN(-1); 378 return s_state.kp->tcgetattr(fd, termios_p); 379} 380 381int ki_tcsetattr(int fd, int optional_actions, 382 const struct termios *termios_p) { 383 ON_NOSYS_RETURN(-1); 384 return s_state.kp->tcsetattr(fd, optional_actions, termios_p); 385} 386 387int ki_kill(pid_t pid, int sig) { 388 ON_NOSYS_RETURN(-1); 389 return s_state.kp->kill(pid, sig); 390} 391 392int ki_killpg(pid_t pid, int sig) { 393 errno = ENOSYS; 394 return -1; 395} 396 397int ki_sigaction(int signum, const struct sigaction* action, 398 struct sigaction* oaction) { 399 ON_NOSYS_RETURN(-1); 400 return s_state.kp->sigaction(signum, action, oaction); 401} 402 403int ki_sigpause(int sigmask) { 404 errno = ENOSYS; 405 return -1; 406} 407 408int ki_sigpending(sigset_t* set) { 409 errno = ENOSYS; 410 return -1; 411} 412 413int ki_sigsuspend(const sigset_t* set) { 414 errno = ENOSYS; 415 return -1; 416} 417 418sighandler_t ki_signal(int signum, sighandler_t handler) { 419 return ki_sigset(signum, handler); 420} 421 422sighandler_t ki_sigset(int signum, sighandler_t handler) { 423 ON_NOSYS_RETURN(SIG_ERR); 424 // Implement sigset(2) in terms of sigaction(2). 425 struct sigaction action; 426 struct sigaction oaction; 427 memset(&action, 0, sizeof(action)); 428 memset(&oaction, 0, sizeof(oaction)); 429 action.sa_handler = handler; 430 int rtn = s_state.kp->sigaction(signum, &action, &oaction); 431 if (rtn) 432 return SIG_ERR; 433 return oaction.sa_handler; 434} 435 436#ifdef PROVIDES_SOCKET_API 437// Socket Functions 438int ki_accept(int fd, struct sockaddr* addr, socklen_t* len) { 439 ON_NOSYS_RETURN(-1); 440 return s_state.kp->accept(fd, addr, len); 441} 442 443int ki_bind(int fd, const struct sockaddr* addr, socklen_t len) { 444 ON_NOSYS_RETURN(-1); 445 return s_state.kp->bind(fd, addr, len); 446} 447 448int ki_connect(int fd, const struct sockaddr* addr, socklen_t len) { 449 ON_NOSYS_RETURN(-1); 450 return s_state.kp->connect(fd, addr, len); 451} 452 453struct hostent* ki_gethostbyname(const char* name) { 454 ON_NOSYS_RETURN(NULL); 455 return s_state.kp->gethostbyname(name); 456} 457 458int ki_getaddrinfo(const char *node, const char *service, 459 const struct addrinfo *hints, 460 struct addrinfo **res) { 461 ON_NOSYS_RETURN(EAI_SYSTEM); 462 return s_state.kp->getaddrinfo(node, service, hints, res); 463} 464 465void ki_freeaddrinfo(struct addrinfo *res) { 466 s_state.kp->freeaddrinfo(res); 467} 468 469int ki_getpeername(int fd, struct sockaddr* addr, socklen_t* len) { 470 ON_NOSYS_RETURN(-1); 471 return s_state.kp->getpeername(fd, addr, len); 472} 473 474int ki_getsockname(int fd, struct sockaddr* addr, socklen_t* len) { 475 ON_NOSYS_RETURN(-1); 476 return s_state.kp->getsockname(fd, addr, len); 477} 478 479int ki_getsockopt(int fd, int lvl, int optname, void* optval, socklen_t* len) { 480 ON_NOSYS_RETURN(-1); 481 return s_state.kp->getsockopt(fd, lvl, optname, optval, len); 482} 483 484int ki_listen(int fd, int backlog) { 485 ON_NOSYS_RETURN(-1); 486 return s_state.kp->listen(fd, backlog); 487} 488 489ssize_t ki_recv(int fd, void* buf, size_t len, int flags) { 490 ON_NOSYS_RETURN(-1); 491 return s_state.kp->recv(fd, buf, len, flags); 492} 493 494ssize_t ki_recvfrom(int fd, void* buf, size_t len, int flags, 495 struct sockaddr* addr, socklen_t* addrlen) { 496 ON_NOSYS_RETURN(-1); 497 return s_state.kp->recvfrom(fd, buf, len, flags, addr, addrlen); 498} 499 500ssize_t ki_recvmsg(int fd, struct msghdr* msg, int flags) { 501 ON_NOSYS_RETURN(-1); 502 return s_state.kp->recvmsg(fd, msg, flags); 503} 504 505ssize_t ki_send(int fd, const void* buf, size_t len, int flags) { 506 ON_NOSYS_RETURN(-1); 507 return s_state.kp->send(fd, buf, len, flags); 508} 509 510ssize_t ki_sendto(int fd, const void* buf, size_t len, int flags, 511 const struct sockaddr* addr, socklen_t addrlen) { 512 ON_NOSYS_RETURN(-1); 513 return s_state.kp->sendto(fd, buf, len, flags, addr, addrlen); 514} 515 516ssize_t ki_sendmsg(int fd, const struct msghdr* msg, int flags) { 517 ON_NOSYS_RETURN(-1); 518 return s_state.kp->sendmsg(fd, msg, flags); 519} 520 521int ki_setsockopt(int fd, int lvl, int optname, const void* optval, 522 socklen_t len) { 523 ON_NOSYS_RETURN(-1); 524 return s_state.kp->setsockopt(fd, lvl, optname, optval, len); 525} 526 527int ki_shutdown(int fd, int how) { 528 ON_NOSYS_RETURN(-1); 529 return s_state.kp->shutdown(fd, how); 530} 531 532int ki_socket(int domain, int type, int protocol) { 533 ON_NOSYS_RETURN(-1); 534 return s_state.kp->socket(domain, type, protocol); 535} 536 537int ki_socketpair(int domain, int type, int protocol, int* sv) { 538 ON_NOSYS_RETURN(-1); 539 return s_state.kp->socketpair(domain, type, protocol, sv); 540} 541#endif // PROVIDES_SOCKET_API 542