OLD | NEW |
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 Loading... |
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 |
OLD | NEW |