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 <sys/types.h> // Include something that will define __GLIBC__. 6 7// The entire file is wrapped in this #if. We do this so this .cc file can be 8// compiled, even on a non-newlib build. 9#if defined(__native_client__) && !defined(__GLIBC__) && !defined(__BIONIC__) 10 11#include "nacl_io/kernel_wrap.h" 12 13#include <dirent.h> 14#include <errno.h> 15#include <irt.h> 16#include <irt_dev.h> 17#include <sys/mman.h> 18#include <sys/stat.h> 19#include <sys/time.h> 20 21#include "nacl_io/kernel_intercept.h" 22#include "nacl_io/kernel_wrap_real.h" 23#include "nacl_io/log.h" 24 25EXTERN_C_BEGIN 26 27// Macro to get the REAL function pointer 28#define REAL(name) __nacl_irt_##name##_real 29 30// Macro to get the WRAP function 31#define WRAP(name) __nacl_irt_##name##_wrap 32 33// Declare REAL function pointer. 34#define DECLARE_REAL_PTR(group, name) \ 35 typeof(__libnacl_irt_##group.name) REAL(name); 36 37// Assign the REAL function pointer. 38#define ASSIGN_REAL_PTR(group, name) REAL(name) = __libnacl_irt_##group.name; 39 40// Switch IRT's pointer to the REAL pointer 41#define USE_REAL(group, name) \ 42 __libnacl_irt_##group.name = (typeof(REAL(name)))REAL(name); 43 44// Switch the IRT's pointer to the WRAP function 45#define USE_WRAP(group, name) \ 46 __libnacl_irt_##group.name = (typeof(REAL(name)))WRAP(name); 47 48extern void __libnacl_irt_dev_filename_init(void); 49 50extern struct nacl_irt_basic __libnacl_irt_basic; 51extern struct nacl_irt_fdio __libnacl_irt_fdio; 52extern struct nacl_irt_dev_fdio __libnacl_irt_dev_fdio; 53extern struct nacl_irt_dev_filename __libnacl_irt_dev_filename; 54extern struct nacl_irt_memory __libnacl_irt_memory; 55 56// Create function pointers to the REAL implementation 57#define EXPAND_SYMBOL_LIST_OPERATION(OP) \ 58 OP(basic, exit); \ 59 OP(fdio, close); \ 60 OP(fdio, dup); \ 61 OP(fdio, dup2); \ 62 OP(fdio, read); \ 63 OP(fdio, write); \ 64 OP(fdio, seek); \ 65 OP(fdio, fstat); \ 66 OP(fdio, getdents); \ 67 OP(dev_fdio, fchdir); \ 68 OP(dev_fdio, fchmod); \ 69 OP(dev_fdio, fsync); \ 70 OP(dev_fdio, fdatasync); \ 71 OP(dev_fdio, ftruncate); \ 72 OP(dev_fdio, isatty); \ 73 OP(dev_filename, open); \ 74 OP(dev_filename, stat); \ 75 OP(dev_filename, mkdir); \ 76 OP(dev_filename, rmdir); \ 77 OP(dev_filename, chdir); \ 78 OP(dev_filename, getcwd); \ 79 OP(dev_filename, unlink); \ 80 OP(dev_filename, truncate); \ 81 OP(dev_filename, lstat); \ 82 OP(dev_filename, link); \ 83 OP(dev_filename, rename); \ 84 OP(dev_filename, symlink); \ 85 OP(dev_filename, chmod); \ 86 OP(dev_filename, access); \ 87 OP(dev_filename, readlink); \ 88 OP(dev_filename, utimes); \ 89 OP(memory, mmap); \ 90 OP(memory, munmap); 91 92EXPAND_SYMBOL_LIST_OPERATION(DECLARE_REAL_PTR); 93 94int WRAP(close)(int fd) { 95 ERRNO_RTN(ki_close(fd)); 96} 97 98int WRAP(dup)(int fd, int* newfd) { 99 *newfd = ki_dup(fd); 100 ERRNO_RTN(*newfd); 101} 102 103int WRAP(dup2)(int fd, int newfd) { 104 newfd = ki_dup2(fd, newfd); 105 ERRNO_RTN(newfd); 106} 107 108void WRAP(exit)(int status) { 109 ki_exit(status); 110} 111 112int WRAP(read)(int fd, void* buf, size_t count, size_t* nread) { 113 ssize_t signed_nread = ki_read(fd, buf, count); 114 *nread = static_cast<size_t>(signed_nread); 115 ERRNO_RTN(signed_nread); 116} 117 118int WRAP(write)(int fd, const void* buf, size_t count, size_t* nwrote) { 119 ssize_t signed_nwrote = ki_write(fd, buf, count); 120 *nwrote = static_cast<size_t>(signed_nwrote); 121 ERRNO_RTN(signed_nwrote); 122} 123 124int WRAP(seek)(int fd, off_t offset, int whence, off_t* new_offset) { 125 *new_offset = ki_lseek(fd, offset, whence); 126 ERRNO_RTN(*new_offset); 127} 128 129int WRAP(fstat)(int fd, struct stat* buf) { 130 ERRNO_RTN(ki_fstat(fd, buf)); 131} 132 133int WRAP(getdents)(int fd, dirent* buf, size_t count, size_t* nread) { 134 int rtn = ki_getdents(fd, buf, count); 135 RTN_ERRNO_IF(rtn < 0); 136 *nread = rtn; 137 return 0; 138} 139 140int WRAP(fchdir)(int fd) { 141 ERRNO_RTN(ki_fchdir(fd)); 142} 143 144int WRAP(fchmod)(int fd, mode_t mode) { 145 ERRNO_RTN(ki_fchmod(fd, mode)); 146} 147 148int WRAP(fsync)(int fd) { 149 ERRNO_RTN(ki_fsync(fd)); 150} 151 152int WRAP(fdatasync)(int fd) { 153 ERRNO_RTN(ki_fdatasync(fd)); 154} 155 156int WRAP(ftruncate)(int fd, off_t length) { 157 ERRNO_RTN(ki_ftruncate(fd, length)); 158} 159 160int WRAP(isatty)(int fd, int* result) { 161 *result = ki_isatty(fd); 162 RTN_ERRNO_IF(*result == 0); 163 return 0; 164} 165 166int WRAP(mmap)(void** addr, 167 size_t length, 168 int prot, 169 int flags, 170 int fd, 171 off_t offset) { 172 if (flags & MAP_ANONYMOUS) 173 return REAL(mmap)(addr, length, prot, flags, fd, offset); 174 175 *addr = ki_mmap(*addr, length, prot, flags, fd, offset); 176 RTN_ERRNO_IF(*addr == (void*)-1); 177 return 0; 178} 179 180int WRAP(munmap)(void* addr, size_t length) { 181 // Always let the real munmap run on the address range. It is not an error if 182 // there are no mapped pages in that range. 183 ki_munmap(addr, length); 184 return REAL(munmap)(addr, length); 185} 186 187int WRAP(open)(const char* pathname, int oflag, mode_t cmode, int* newfd) { 188 *newfd = ki_open(pathname, oflag); 189 ERRNO_RTN(*newfd); 190} 191 192int WRAP(stat)(const char* pathname, struct stat* buf) { 193 ERRNO_RTN(ki_stat(pathname, buf)); 194} 195 196int WRAP(mkdir)(const char* pathname, mode_t mode) { 197 ERRNO_RTN(ki_mkdir(pathname, mode)); 198} 199 200int WRAP(rmdir)(const char* pathname) { 201 ERRNO_RTN(ki_rmdir(pathname)); 202} 203 204int WRAP(chdir)(const char* pathname) { 205 ERRNO_RTN(ki_chdir(pathname)); 206} 207 208int WRAP(getcwd)(char* pathname, size_t len) { 209 char* rtn = ki_getcwd(pathname, len); 210 RTN_ERRNO_IF(NULL == rtn); 211 return 0; 212} 213 214int WRAP(unlink)(const char* pathname) { 215 ERRNO_RTN(ki_unlink(pathname)); 216} 217 218int WRAP(truncate)(const char* pathname, off_t length) { 219 ERRNO_RTN(ki_truncate(pathname, length)); 220} 221 222int WRAP(lstat)(const char* pathname, struct stat* buf) { 223 ERRNO_RTN(ki_lstat(pathname, buf)); 224} 225 226int WRAP(link)(const char* pathname, const char* newpath) { 227 ERRNO_RTN(ki_link(pathname, newpath)); 228} 229 230int WRAP(rename)(const char* pathname, const char* newpath) { 231 ERRNO_RTN(ki_rename(pathname, newpath)); 232} 233 234int WRAP(symlink)(const char* pathname, const char* newpath) { 235 ERRNO_RTN(ki_symlink(pathname, newpath)); 236} 237 238int WRAP(chmod)(const char* pathname, mode_t mode) { 239 ERRNO_RTN(ki_chmod(pathname, mode)); 240} 241 242int WRAP(access)(const char* pathname, int amode) { 243 ERRNO_RTN(ki_access(pathname, amode)); 244} 245 246int WRAP(readlink)(const char* pathname, 247 char* buf, 248 size_t count, 249 size_t* nread) { 250 int rtn = ki_readlink(pathname, buf, count); 251 RTN_ERRNO_IF(rtn < 0); 252 *nread = rtn; 253 return 0; 254} 255 256int WRAP(utimes)(const char* pathname, const struct timeval times[2]) { 257 ERRNO_RTN(ki_utimes(pathname, times)); 258} 259 260static void assign_real_pointers() { 261 static bool assigned = false; 262 if (!assigned) { 263 __libnacl_irt_dev_filename_init(); 264 EXPAND_SYMBOL_LIST_OPERATION(ASSIGN_REAL_PTR) 265 assigned = true; 266 } 267} 268 269#define CHECK_REAL(func) \ 270 if (!REAL(func)) \ 271 assign_real_pointers(); 272 273// "real" functions, i.e. the unwrapped original functions. 274 275int _real_close(int fd) { 276 CHECK_REAL(close); 277 return REAL(close)(fd); 278} 279 280void _real_exit(int status) { 281 CHECK_REAL(exit); 282 REAL(exit)(status); 283} 284 285int _real_fstat(int fd, struct stat* buf) { 286 CHECK_REAL(fstat); 287 return REAL(fstat)(fd, buf); 288} 289 290int _real_isatty(int fd, int* result) { 291 CHECK_REAL(isatty); 292 return REAL(isatty)(fd, result); 293} 294 295int _real_getdents(int fd, void* nacl_buf, size_t nacl_count, size_t* nread) { 296 CHECK_REAL(getdents); 297 return REAL(getdents)(fd, static_cast<dirent*>(nacl_buf), nacl_count, nread); 298} 299 300int _real_lseek(int fd, off_t offset, int whence, off_t* new_offset) { 301 CHECK_REAL(seek); 302 return REAL(seek)(fd, offset, whence, new_offset); 303} 304 305int _real_mkdir(const char* pathname, mode_t mode) { 306 return ENOSYS; 307} 308 309int _real_mmap(void** addr, 310 size_t length, 311 int prot, 312 int flags, 313 int fd, 314 off_t offset) { 315 CHECK_REAL(mmap); 316 return REAL(mmap)(addr, length, prot, flags, fd, offset); 317} 318 319int _real_munmap(void* addr, size_t length) { 320 CHECK_REAL(munmap); 321 return REAL(munmap)(addr, length); 322} 323 324int _real_open(const char* pathname, int oflag, mode_t cmode, int* newfd) { 325 CHECK_REAL(open); 326 return REAL(open)(pathname, oflag, cmode, newfd); 327} 328 329int _real_open_resource(const char* file, int* fd) { 330 return ENOSYS; 331} 332 333int _real_read(int fd, void* buf, size_t count, size_t* nread) { 334 CHECK_REAL(read); 335 return REAL(read)(fd, buf, count, nread); 336} 337 338int _real_rmdir(const char* pathname) { 339 return ENOSYS; 340} 341 342int _real_write(int fd, const void* buf, size_t count, size_t* nwrote) { 343 CHECK_REAL(write); 344 return REAL(write)(fd, buf, count, nwrote); 345} 346 347static bool s_wrapped = false; 348 349void kernel_wrap_init() { 350 if (!s_wrapped) { 351 LOG_TRACE("kernel_wrap_init"); 352 assign_real_pointers(); 353 EXPAND_SYMBOL_LIST_OPERATION(USE_WRAP) 354 s_wrapped = true; 355 } 356} 357 358void kernel_wrap_uninit() { 359 if (s_wrapped) { 360 LOG_TRACE("kernel_wrap_uninit"); 361 EXPAND_SYMBOL_LIST_OPERATION(USE_REAL) 362 s_wrapped = false; 363 } 364} 365 366EXTERN_C_END 367 368#endif // defined(__native_client__) && !defined(__GLIBC__) ... 369