1112918Sjeff/* 2144518Sdavidxu * Copyright (C) 2005 David Xu <davidxu@freebsd.org>. 3144518Sdavidxu * Copyright (c) 2003 Daniel Eischen <deischen@freebsd.org>. 4144518Sdavidxu * Copyright (C) 2000 Jason Evans <jasone@freebsd.org>. 5112918Sjeff * All rights reserved. 6112918Sjeff * 7112918Sjeff * Redistribution and use in source and binary forms, with or without 8112918Sjeff * modification, are permitted provided that the following conditions 9112918Sjeff * are met: 10112918Sjeff * 1. Redistributions of source code must retain the above copyright 11112918Sjeff * notice(s), this list of conditions and the following disclaimer as 12112918Sjeff * the first lines of this file unmodified other than the possible 13112918Sjeff * addition of one or more copyright notices. 14112918Sjeff * 2. Redistributions in binary form must reproduce the above copyright 15112918Sjeff * notice(s), this list of conditions and the following disclaimer in 16112918Sjeff * the documentation and/or other materials provided with the 17112918Sjeff * distribution. 18112918Sjeff * 19112918Sjeff * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) ``AS IS'' AND ANY 20112918Sjeff * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 21112918Sjeff * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 22112918Sjeff * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) BE 23112918Sjeff * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 24112918Sjeff * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 25112918Sjeff * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR 26112918Sjeff * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 27112918Sjeff * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE 28112918Sjeff * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, 29112918Sjeff * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 30112918Sjeff * 31112918Sjeff * $FreeBSD$ 32112918Sjeff */ 33112918Sjeff 34112918Sjeff/* 35112918Sjeff * Copyright (c) 1995-1998 John Birrell <jb@cimlogic.com.au> 36112918Sjeff * All rights reserved. 37112918Sjeff * 38112918Sjeff * Redistribution and use in source and binary forms, with or without 39112918Sjeff * modification, are permitted provided that the following conditions 40112918Sjeff * are met: 41112918Sjeff * 1. Redistributions of source code must retain the above copyright 42112918Sjeff * notice, this list of conditions and the following disclaimer. 43112918Sjeff * 2. Redistributions in binary form must reproduce the above copyright 44112918Sjeff * notice, this list of conditions and the following disclaimer in the 45112918Sjeff * documentation and/or other materials provided with the distribution. 46165967Simp * 3. Neither the name of the author nor the names of any co-contributors 47112918Sjeff * may be used to endorse or promote products derived from this software 48112918Sjeff * without specific prior written permission. 49112918Sjeff * 50112918Sjeff * THIS SOFTWARE IS PROVIDED BY JOHN BIRRELL AND CONTRIBUTORS ``AS IS'' AND 51112918Sjeff * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 52112918Sjeff * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 53112918Sjeff * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 54112918Sjeff * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 55112918Sjeff * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 56112918Sjeff * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 57112918Sjeff * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 58112918Sjeff * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 59112918Sjeff * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 60112918Sjeff * SUCH DAMAGE. 61112918Sjeff * 62112918Sjeff */ 63112918Sjeff 64157457Sdavidxu#include "namespace.h" 65144518Sdavidxu#include <sys/types.h> 66112918Sjeff#include <sys/mman.h> 67112918Sjeff#include <sys/param.h> 68112918Sjeff#include <sys/select.h> 69144518Sdavidxu#include <sys/signalvar.h> 70135301Smtm#include <sys/socket.h> 71144518Sdavidxu#include <sys/stat.h> 72112918Sjeff#include <sys/time.h> 73112918Sjeff#include <sys/uio.h> 74112918Sjeff#include <sys/wait.h> 75112918Sjeff#include <aio.h> 76112918Sjeff#include <dirent.h> 77112918Sjeff#include <errno.h> 78112918Sjeff#include <fcntl.h> 79112918Sjeff#include <poll.h> 80112918Sjeff#include <signal.h> 81112918Sjeff#include <stdarg.h> 82112918Sjeff#include <stdio.h> 83112918Sjeff#include <stdlib.h> 84112918Sjeff#include <string.h> 85112918Sjeff#include <termios.h> 86112918Sjeff#include <unistd.h> 87144518Sdavidxu#include <pthread.h> 88157457Sdavidxu#include "un-namespace.h" 89112918Sjeff 90112918Sjeff#include "thr_private.h" 91112918Sjeff 92157457Sdavidxuextern int __creat(const char *, mode_t); 93157457Sdavidxuextern int __pselect(int, fd_set *, fd_set *, fd_set *, 94157457Sdavidxu const struct timespec *, const sigset_t *); 95157457Sdavidxuextern unsigned __sleep(unsigned int); 96157457Sdavidxuextern int __system(const char *); 97157457Sdavidxuextern int __tcdrain(int); 98157457Sdavidxuextern int __usleep(useconds_t); 99157457Sdavidxuextern pid_t __wait(int *); 100157457Sdavidxuextern pid_t __waitpid(pid_t, int *, int); 101157457Sdavidxuextern int __sys_aio_suspend(const struct aiocb * const[], int, 102157457Sdavidxu const struct timespec *); 103157457Sdavidxuextern int __sys_accept(int, struct sockaddr *, socklen_t *); 104157457Sdavidxuextern int __sys_connect(int, const struct sockaddr *, socklen_t); 105157457Sdavidxuextern int __sys_fsync(int); 106157457Sdavidxuextern int __sys_msync(void *, size_t, int); 107198508Skibextern int __sys_pselect(int, fd_set *, fd_set *, fd_set *, 108198508Skib const struct timespec *, const sigset_t *); 109157457Sdavidxuextern int __sys_poll(struct pollfd *, unsigned, int); 110157457Sdavidxuextern ssize_t __sys_recv(int, void *, size_t, int); 111157457Sdavidxuextern ssize_t __sys_recvfrom(int, void *, size_t, int, struct sockaddr *, socklen_t *); 112157457Sdavidxuextern ssize_t __sys_recvmsg(int, struct msghdr *, int); 113157457Sdavidxuextern int __sys_select(int, fd_set *, fd_set *, fd_set *, struct timeval *); 114157457Sdavidxuextern int __sys_sendfile(int, int, off_t, size_t, struct sf_hdtr *, 115157457Sdavidxu off_t *, int); 116157457Sdavidxuextern ssize_t __sys_sendmsg(int, const struct msghdr *, int); 117157457Sdavidxuextern ssize_t __sys_sendto(int, const void *,size_t, int, const struct sockaddr *, socklen_t); 118157457Sdavidxuextern ssize_t __sys_readv(int, const struct iovec *, int); 119157457Sdavidxuextern pid_t __sys_wait4(pid_t, int *, int, struct rusage *); 120157457Sdavidxuextern ssize_t __sys_writev(int, const struct iovec *, int); 121115260Smtm 122157457Sdavidxuint ___creat(const char *, mode_t); 123160662Sdavidxuint ___pselect(int, fd_set *, fd_set *, fd_set *, 124160662Sdavidxu const struct timespec *, const sigset_t *); 125160662Sdavidxuunsigned ___sleep(unsigned); 126160662Sdavidxuint ___system(const char *); 127160662Sdavidxuint ___tcdrain(int); 128160662Sdavidxuint ___usleep(useconds_t useconds); 129160662Sdavidxupid_t ___wait(int *); 130160662Sdavidxupid_t ___waitpid(pid_t, int *, int); 131157457Sdavidxuint __accept(int, struct sockaddr *, socklen_t *); 132160662Sdavidxuint __aio_suspend(const struct aiocb * const iocbs[], int, 133160662Sdavidxu const struct timespec *); 134157457Sdavidxuint __close(int); 135157457Sdavidxuint __connect(int, const struct sockaddr *, socklen_t); 136157457Sdavidxuint __fcntl(int, int,...); 137189549Sdavidxu#ifdef SYSCALL_COMPAT 138179434Sdfrextern int __fcntl_compat(int, int,...); 139189549Sdavidxu#endif 140157457Sdavidxuint __fsync(int); 141157457Sdavidxuint __msync(void *, size_t, int); 142157457Sdavidxuint __nanosleep(const struct timespec *, struct timespec *); 143157457Sdavidxuint __open(const char *, int,...); 144197968Sjillesint __openat(int, const char *, int,...); 145157457Sdavidxuint __poll(struct pollfd *, unsigned int, int); 146157457Sdavidxussize_t __read(int, void *buf, size_t); 147157457Sdavidxussize_t __readv(int, const struct iovec *, int); 148157457Sdavidxussize_t __recvfrom(int, void *, size_t, int f, struct sockaddr *, socklen_t *); 149157457Sdavidxussize_t __recvmsg(int, struct msghdr *, int); 150157457Sdavidxuint __select(int, fd_set *, fd_set *, fd_set *, struct timeval *); 151157457Sdavidxussize_t __sendmsg(int, const struct msghdr *, int); 152157457Sdavidxussize_t __sendto(int, const void *, size_t, int, 153157457Sdavidxu const struct sockaddr *, socklen_t); 154160662Sdavidxupid_t __wait3(int *, int, struct rusage *); 155157457Sdavidxupid_t __wait4(pid_t, int *, int, struct rusage *); 156157457Sdavidxussize_t __write(int, const void *, size_t); 157157457Sdavidxussize_t __writev(int, const struct iovec *, int); 158157457Sdavidxu 159144518Sdavidxu__weak_reference(__accept, accept); 160157457Sdavidxu 161211524Sdavidxu/* 162211524Sdavidxu * Cancellation behavior: 163211524Sdavidxu * If thread is canceled, no socket is created. 164211524Sdavidxu */ 165135301Smtmint 166144518Sdavidxu__accept(int s, struct sockaddr *addr, socklen_t *addrlen) 167135301Smtm{ 168144518Sdavidxu struct pthread *curthread; 169135301Smtm int ret; 170135301Smtm 171144518Sdavidxu curthread = _get_curthread(); 172212076Sdavidxu _thr_cancel_enter(curthread); 173135301Smtm ret = __sys_accept(s, addr, addrlen); 174212076Sdavidxu _thr_cancel_leave(curthread, ret == -1); 175144518Sdavidxu 176144518Sdavidxu return (ret); 177135301Smtm} 178135301Smtm 179160662Sdavidxu__weak_reference(__aio_suspend, aio_suspend); 180112918Sjeff 181112918Sjeffint 182160662Sdavidxu__aio_suspend(const struct aiocb * const iocbs[], int niocb, const struct 183112918Sjeff timespec *timeout) 184112918Sjeff{ 185144518Sdavidxu struct pthread *curthread = _get_curthread(); 186144518Sdavidxu int ret; 187112918Sjeff 188164583Sdavidxu _thr_cancel_enter(curthread); 189112918Sjeff ret = __sys_aio_suspend(iocbs, niocb, timeout); 190212076Sdavidxu _thr_cancel_leave(curthread, 1); 191112918Sjeff 192144518Sdavidxu return (ret); 193112918Sjeff} 194112918Sjeff 195144518Sdavidxu__weak_reference(__close, close); 196112918Sjeff 197211524Sdavidxu/* 198211524Sdavidxu * Cancellation behavior: 199211524Sdavidxu * According to manual of close(), the file descriptor is always deleted. 200211524Sdavidxu * Here, thread is only canceled after the system call, so the file 201211524Sdavidxu * descriptor is always deleted despite whether the thread is canceled 202211524Sdavidxu * or not. 203211524Sdavidxu */ 204112918Sjeffint 205144518Sdavidxu__close(int fd) 206112918Sjeff{ 207144518Sdavidxu struct pthread *curthread = _get_curthread(); 208112918Sjeff int ret; 209112918Sjeff 210212076Sdavidxu _thr_cancel_enter2(curthread, 0); 211112918Sjeff ret = __sys_close(fd); 212212076Sdavidxu _thr_cancel_leave(curthread, 1); 213112918Sjeff 214144518Sdavidxu return (ret); 215112918Sjeff} 216135301Smtm 217144518Sdavidxu__weak_reference(__connect, connect); 218135301Smtm 219211524Sdavidxu/* 220211524Sdavidxu * Cancellation behavior: 221211524Sdavidxu * If the thread is canceled, connection is not made. 222211524Sdavidxu */ 223135301Smtmint 224144518Sdavidxu__connect(int fd, const struct sockaddr *name, socklen_t namelen) 225135301Smtm{ 226144518Sdavidxu struct pthread *curthread = _get_curthread(); 227135301Smtm int ret; 228135301Smtm 229212076Sdavidxu _thr_cancel_enter(curthread); 230144518Sdavidxu ret = __sys_connect(fd, name, namelen); 231212076Sdavidxu _thr_cancel_leave(curthread, ret == -1); 232144518Sdavidxu 233144518Sdavidxu return (ret); 234135301Smtm} 235112918Sjeff 236144518Sdavidxu__weak_reference(___creat, creat); 237144518Sdavidxu 238211524Sdavidxu/* 239211524Sdavidxu * Cancellation behavior: 240211524Sdavidxu * If thread is canceled, file is not created. 241211524Sdavidxu */ 242112918Sjeffint 243144518Sdavidxu___creat(const char *path, mode_t mode) 244112918Sjeff{ 245144518Sdavidxu struct pthread *curthread = _get_curthread(); 246144518Sdavidxu int ret; 247112918Sjeff 248212076Sdavidxu _thr_cancel_enter(curthread); 249112918Sjeff ret = __creat(path, mode); 250212076Sdavidxu _thr_cancel_leave(curthread, ret == -1); 251112918Sjeff 252112918Sjeff return ret; 253112918Sjeff} 254112918Sjeff 255144518Sdavidxu__weak_reference(__fcntl, fcntl); 256112918Sjeff 257211524Sdavidxu/* 258211524Sdavidxu * Cancellation behavior: 259211524Sdavidxu * According to specification, only F_SETLKW is a cancellation point. 260211524Sdavidxu * Thread is only canceled at start, or canceled if the system call 261211524Sdavidxu * is failure, this means the function does not generate side effect 262211524Sdavidxu * if it is canceled. 263211524Sdavidxu */ 264112918Sjeffint 265144518Sdavidxu__fcntl(int fd, int cmd,...) 266112918Sjeff{ 267144518Sdavidxu struct pthread *curthread = _get_curthread(); 268112918Sjeff int ret; 269112918Sjeff va_list ap; 270211524Sdavidxu 271112918Sjeff va_start(ap, cmd); 272212076Sdavidxu if (cmd == F_OSETLKW || cmd == F_SETLKW) { 273212076Sdavidxu _thr_cancel_enter(curthread); 274211522Sdavidxu#ifdef SYSCALL_COMPAT 275211522Sdavidxu ret = __fcntl_compat(fd, cmd, va_arg(ap, void *)); 276211522Sdavidxu#else 277211522Sdavidxu ret = __sys_fcntl(fd, cmd, va_arg(ap, void *)); 278211522Sdavidxu#endif 279212076Sdavidxu _thr_cancel_leave(curthread, ret == -1); 280212076Sdavidxu } else { 281189549Sdavidxu#ifdef SYSCALL_COMPAT 282179434Sdfr ret = __fcntl_compat(fd, cmd, va_arg(ap, void *)); 283189549Sdavidxu#else 284189553Sdavidxu ret = __sys_fcntl(fd, cmd, va_arg(ap, void *)); 285189549Sdavidxu#endif 286112918Sjeff } 287112918Sjeff va_end(ap); 288112918Sjeff 289144518Sdavidxu return (ret); 290112918Sjeff} 291112918Sjeff 292144518Sdavidxu__weak_reference(__fsync, fsync); 293131181Smtm 294211524Sdavidxu/* 295211524Sdavidxu * Cancellation behavior: 296211524Sdavidxu * Thread may be canceled after system call. 297211524Sdavidxu */ 298131181Smtmint 299144518Sdavidxu__fsync(int fd) 300131181Smtm{ 301144518Sdavidxu struct pthread *curthread = _get_curthread(); 302131181Smtm int ret; 303131181Smtm 304212076Sdavidxu _thr_cancel_enter2(curthread, 0); 305112918Sjeff ret = __sys_fsync(fd); 306212076Sdavidxu _thr_cancel_leave(curthread, 1); 307112918Sjeff 308144518Sdavidxu return (ret); 309112918Sjeff} 310112918Sjeff 311144518Sdavidxu__weak_reference(__msync, msync); 312135301Smtm 313211524Sdavidxu/* 314211524Sdavidxu * Cancellation behavior: 315211524Sdavidxu * Thread may be canceled after system call. 316211524Sdavidxu */ 317135301Smtmint 318144518Sdavidxu__msync(void *addr, size_t len, int flags) 319135301Smtm{ 320144518Sdavidxu struct pthread *curthread = _get_curthread(); 321112918Sjeff int ret; 322112918Sjeff 323212076Sdavidxu _thr_cancel_enter2(curthread, 0); 324112918Sjeff ret = __sys_msync(addr, len, flags); 325212076Sdavidxu _thr_cancel_leave(curthread, 1); 326112918Sjeff 327112918Sjeff return ret; 328112918Sjeff} 329112918Sjeff 330144518Sdavidxu__weak_reference(__nanosleep, nanosleep); 331112918Sjeff 332112918Sjeffint 333144518Sdavidxu__nanosleep(const struct timespec *time_to_sleep, 334144518Sdavidxu struct timespec *time_remaining) 335112918Sjeff{ 336144518Sdavidxu struct pthread *curthread = _get_curthread(); 337144518Sdavidxu int ret; 338112918Sjeff 339164583Sdavidxu _thr_cancel_enter(curthread); 340112918Sjeff ret = __sys_nanosleep(time_to_sleep, time_remaining); 341212076Sdavidxu _thr_cancel_leave(curthread, 1); 342112918Sjeff 343144518Sdavidxu return (ret); 344112918Sjeff} 345112918Sjeff 346144518Sdavidxu__weak_reference(__open, open); 347112918Sjeff 348211524Sdavidxu/* 349211524Sdavidxu * Cancellation behavior: 350211524Sdavidxu * If the thread is canceled, file is not opened. 351211524Sdavidxu */ 352112918Sjeffint 353144518Sdavidxu__open(const char *path, int flags,...) 354112918Sjeff{ 355144518Sdavidxu struct pthread *curthread = _get_curthread(); 356112918Sjeff int ret; 357112918Sjeff int mode = 0; 358112918Sjeff va_list ap; 359112918Sjeff 360112918Sjeff /* Check if the file is being created: */ 361112918Sjeff if (flags & O_CREAT) { 362112918Sjeff /* Get the creation mode: */ 363112918Sjeff va_start(ap, flags); 364112918Sjeff mode = va_arg(ap, int); 365112918Sjeff va_end(ap); 366112918Sjeff } 367112918Sjeff 368212076Sdavidxu _thr_cancel_enter(curthread); 369112918Sjeff ret = __sys_open(path, flags, mode); 370212076Sdavidxu _thr_cancel_leave(curthread, ret == -1); 371112918Sjeff 372112918Sjeff return ret; 373112918Sjeff} 374112918Sjeff 375197968Sjilles__weak_reference(__openat, openat); 376197968Sjilles 377211524Sdavidxu/* 378211524Sdavidxu * Cancellation behavior: 379211524Sdavidxu * If the thread is canceled, file is not opened. 380211524Sdavidxu */ 381197968Sjillesint 382197968Sjilles__openat(int fd, const char *path, int flags, ...) 383197968Sjilles{ 384197968Sjilles struct pthread *curthread = _get_curthread(); 385197968Sjilles int ret; 386197968Sjilles int mode = 0; 387197968Sjilles va_list ap; 388197968Sjilles 389197968Sjilles 390197968Sjilles /* Check if the file is being created: */ 391197968Sjilles if (flags & O_CREAT) { 392197968Sjilles /* Get the creation mode: */ 393197968Sjilles va_start(ap, flags); 394197968Sjilles mode = va_arg(ap, int); 395197968Sjilles va_end(ap); 396197968Sjilles } 397197968Sjilles 398212076Sdavidxu _thr_cancel_enter(curthread); 399197968Sjilles ret = __sys_openat(fd, path, flags, mode); 400212076Sdavidxu _thr_cancel_leave(curthread, ret == -1); 401197968Sjilles 402197968Sjilles return ret; 403197968Sjilles} 404197968Sjilles 405144518Sdavidxu__weak_reference(__poll, poll); 406112918Sjeff 407211524Sdavidxu/* 408211524Sdavidxu * Cancellation behavior: 409211524Sdavidxu * Thread may be canceled at start, but if the system call returns something, 410211524Sdavidxu * the thread is not canceled. 411211524Sdavidxu */ 412112918Sjeffint 413144518Sdavidxu__poll(struct pollfd *fds, unsigned int nfds, int timeout) 414112918Sjeff{ 415144518Sdavidxu struct pthread *curthread = _get_curthread(); 416112918Sjeff int ret; 417112918Sjeff 418212076Sdavidxu _thr_cancel_enter(curthread); 419112918Sjeff ret = __sys_poll(fds, nfds, timeout); 420212076Sdavidxu _thr_cancel_leave(curthread, ret == -1); 421112918Sjeff 422112918Sjeff return ret; 423112918Sjeff} 424112918Sjeff 425160662Sdavidxu__weak_reference(___pselect, pselect); 426135301Smtm 427211524Sdavidxu/* 428211524Sdavidxu * Cancellation behavior: 429211524Sdavidxu * Thread may be canceled at start, but if the system call returns something, 430211524Sdavidxu * the thread is not canceled. 431211524Sdavidxu */ 432112918Sjeffint 433160662Sdavidxu___pselect(int count, fd_set *rfds, fd_set *wfds, fd_set *efds, 434112918Sjeff const struct timespec *timo, const sigset_t *mask) 435112918Sjeff{ 436144518Sdavidxu struct pthread *curthread = _get_curthread(); 437112918Sjeff int ret; 438112918Sjeff 439212076Sdavidxu _thr_cancel_enter(curthread); 440198508Skib ret = __sys_pselect(count, rfds, wfds, efds, timo, mask); 441212076Sdavidxu _thr_cancel_leave(curthread, ret == -1); 442112918Sjeff 443112918Sjeff return (ret); 444112918Sjeff} 445112918Sjeff 446144518Sdavidxu__weak_reference(__read, read); 447112918Sjeff 448211524Sdavidxu/* 449211524Sdavidxu * Cancellation behavior: 450211524Sdavidxu * Thread may be canceled at start, but if the system call got some data, 451211524Sdavidxu * the thread is not canceled. 452211524Sdavidxu */ 453112918Sjeffssize_t 454144518Sdavidxu__read(int fd, void *buf, size_t nbytes) 455112918Sjeff{ 456144518Sdavidxu struct pthread *curthread = _get_curthread(); 457112918Sjeff ssize_t ret; 458112918Sjeff 459212076Sdavidxu _thr_cancel_enter(curthread); 460112918Sjeff ret = __sys_read(fd, buf, nbytes); 461212076Sdavidxu _thr_cancel_leave(curthread, ret == -1); 462112918Sjeff 463112918Sjeff return ret; 464112918Sjeff} 465112918Sjeff 466144518Sdavidxu__weak_reference(__readv, readv); 467112918Sjeff 468211524Sdavidxu/* 469211524Sdavidxu * Cancellation behavior: 470211524Sdavidxu * Thread may be canceled at start, but if the system call got some data, 471211524Sdavidxu * the thread is not canceled. 472211524Sdavidxu */ 473112918Sjeffssize_t 474144518Sdavidxu__readv(int fd, const struct iovec *iov, int iovcnt) 475112918Sjeff{ 476144518Sdavidxu struct pthread *curthread = _get_curthread(); 477112918Sjeff ssize_t ret; 478112918Sjeff 479212076Sdavidxu _thr_cancel_enter(curthread); 480112918Sjeff ret = __sys_readv(fd, iov, iovcnt); 481212076Sdavidxu _thr_cancel_leave(curthread, ret == -1); 482112918Sjeff return ret; 483112918Sjeff} 484112918Sjeff 485144518Sdavidxu__weak_reference(__recvfrom, recvfrom); 486135301Smtm 487211524Sdavidxu/* 488211524Sdavidxu * Cancellation behavior: 489211524Sdavidxu * Thread may be canceled at start, but if the system call got some data, 490211524Sdavidxu * the thread is not canceled. 491211524Sdavidxu */ 492135301Smtmssize_t 493144518Sdavidxu__recvfrom(int s, void *b, size_t l, int f, struct sockaddr *from, 494135301Smtm socklen_t *fl) 495135301Smtm{ 496144518Sdavidxu struct pthread *curthread = _get_curthread(); 497135301Smtm ssize_t ret; 498135301Smtm 499212076Sdavidxu _thr_cancel_enter(curthread); 500135301Smtm ret = __sys_recvfrom(s, b, l, f, from, fl); 501212076Sdavidxu _thr_cancel_leave(curthread, ret == -1); 502135301Smtm return (ret); 503135301Smtm} 504135301Smtm 505144518Sdavidxu__weak_reference(__recvmsg, recvmsg); 506135301Smtm 507211524Sdavidxu/* 508211524Sdavidxu * Cancellation behavior: 509211524Sdavidxu * Thread may be canceled at start, but if the system call got some data, 510211524Sdavidxu * the thread is not canceled. 511211524Sdavidxu */ 512135301Smtmssize_t 513144518Sdavidxu__recvmsg(int s, struct msghdr *m, int f) 514135301Smtm{ 515144518Sdavidxu struct pthread *curthread = _get_curthread(); 516135301Smtm ssize_t ret; 517135301Smtm 518212076Sdavidxu _thr_cancel_enter(curthread); 519135301Smtm ret = __sys_recvmsg(s, m, f); 520212076Sdavidxu _thr_cancel_leave(curthread, ret == -1); 521135301Smtm return (ret); 522135301Smtm} 523135301Smtm 524144518Sdavidxu__weak_reference(__select, select); 525112918Sjeff 526211524Sdavidxu/* 527211524Sdavidxu * Cancellation behavior: 528211524Sdavidxu * Thread may be canceled at start, but if the system call returns something, 529211524Sdavidxu * the thread is not canceled. 530211524Sdavidxu */ 531112918Sjeffint 532144518Sdavidxu__select(int numfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, 533112918Sjeff struct timeval *timeout) 534112918Sjeff{ 535144518Sdavidxu struct pthread *curthread = _get_curthread(); 536112918Sjeff int ret; 537112918Sjeff 538212076Sdavidxu _thr_cancel_enter(curthread); 539112918Sjeff ret = __sys_select(numfds, readfds, writefds, exceptfds, timeout); 540212076Sdavidxu _thr_cancel_leave(curthread, ret == -1); 541112918Sjeff return ret; 542112918Sjeff} 543112918Sjeff 544144518Sdavidxu__weak_reference(__sendmsg, sendmsg); 545135301Smtm 546211524Sdavidxu/* 547211524Sdavidxu * Cancellation behavior: 548211524Sdavidxu * Thread may be canceled at start, but if the system call sent 549211524Sdavidxu * data, the thread is not canceled. 550211524Sdavidxu */ 551135301Smtmssize_t 552144518Sdavidxu__sendmsg(int s, const struct msghdr *m, int f) 553135301Smtm{ 554144518Sdavidxu struct pthread *curthread = _get_curthread(); 555135301Smtm ssize_t ret; 556135301Smtm 557212076Sdavidxu _thr_cancel_enter(curthread); 558135301Smtm ret = __sys_sendmsg(s, m, f); 559212076Sdavidxu _thr_cancel_leave(curthread, ret <= 0); 560135301Smtm return (ret); 561135301Smtm} 562135301Smtm 563144518Sdavidxu__weak_reference(__sendto, sendto); 564135301Smtm 565211524Sdavidxu/* 566211524Sdavidxu * Cancellation behavior: 567211524Sdavidxu * Thread may be canceled at start, but if the system call sent some 568211524Sdavidxu * data, the thread is not canceled. 569211524Sdavidxu */ 570135301Smtmssize_t 571144518Sdavidxu__sendto(int s, const void *m, size_t l, int f, const struct sockaddr *t, 572135301Smtm socklen_t tl) 573135301Smtm{ 574144518Sdavidxu struct pthread *curthread = _get_curthread(); 575135301Smtm ssize_t ret; 576135301Smtm 577212076Sdavidxu _thr_cancel_enter(curthread); 578135301Smtm ret = __sys_sendto(s, m, l, f, t, tl); 579212076Sdavidxu _thr_cancel_leave(curthread, ret <= 0); 580135301Smtm return (ret); 581135301Smtm} 582135301Smtm 583160662Sdavidxu__weak_reference(___sleep, sleep); 584148658Sdeischen 585112918Sjeffunsigned int 586160662Sdavidxu___sleep(unsigned int seconds) 587112918Sjeff{ 588144518Sdavidxu struct pthread *curthread = _get_curthread(); 589112918Sjeff unsigned int ret; 590112918Sjeff 591164583Sdavidxu _thr_cancel_enter(curthread); 592112918Sjeff ret = __sleep(seconds); 593212076Sdavidxu _thr_cancel_leave(curthread, 1); 594112918Sjeff 595144518Sdavidxu return (ret); 596112918Sjeff} 597112918Sjeff 598160662Sdavidxu__weak_reference(___system, system); 599112918Sjeff 600112918Sjeffint 601160662Sdavidxu___system(const char *string) 602112918Sjeff{ 603144518Sdavidxu struct pthread *curthread = _get_curthread(); 604112918Sjeff int ret; 605112918Sjeff 606164583Sdavidxu _thr_cancel_enter(curthread); 607112918Sjeff ret = __system(string); 608212076Sdavidxu _thr_cancel_leave(curthread, 1); 609112918Sjeff 610112918Sjeff return ret; 611112918Sjeff} 612112918Sjeff 613160662Sdavidxu__weak_reference(___tcdrain, tcdrain); 614112918Sjeff 615211524Sdavidxu/* 616211524Sdavidxu * Cancellation behavior: 617211524Sdavidxu * If thread is canceled, the system call is not completed, 618211524Sdavidxu * this means not all bytes were drained. 619211524Sdavidxu */ 620112918Sjeffint 621160662Sdavidxu___tcdrain(int fd) 622112918Sjeff{ 623144518Sdavidxu struct pthread *curthread = _get_curthread(); 624112918Sjeff int ret; 625112918Sjeff 626212076Sdavidxu _thr_cancel_enter(curthread); 627112918Sjeff ret = __tcdrain(fd); 628212076Sdavidxu _thr_cancel_leave(curthread, ret == -1); 629144518Sdavidxu return (ret); 630112918Sjeff} 631112918Sjeff 632160662Sdavidxu__weak_reference(___usleep, usleep); 633148658Sdeischen 634148658Sdeischenint 635160662Sdavidxu___usleep(useconds_t useconds) 636148658Sdeischen{ 637148658Sdeischen struct pthread *curthread = _get_curthread(); 638148658Sdeischen int ret; 639148658Sdeischen 640164583Sdavidxu _thr_cancel_enter(curthread); 641148658Sdeischen ret = __usleep(useconds); 642212076Sdavidxu _thr_cancel_leave(curthread, 1); 643148658Sdeischen 644148658Sdeischen return (ret); 645148658Sdeischen} 646148658Sdeischen 647160662Sdavidxu__weak_reference(___wait, wait); 648112918Sjeff 649211524Sdavidxu/* 650211524Sdavidxu * Cancellation behavior: 651211524Sdavidxu * Thread may be canceled at start, but if the system call returns 652211524Sdavidxu * a child pid, the thread is not canceled. 653211524Sdavidxu */ 654112918Sjeffpid_t 655160662Sdavidxu___wait(int *istat) 656112918Sjeff{ 657144518Sdavidxu struct pthread *curthread = _get_curthread(); 658112918Sjeff pid_t ret; 659112918Sjeff 660212076Sdavidxu _thr_cancel_enter(curthread); 661112918Sjeff ret = __wait(istat); 662212076Sdavidxu _thr_cancel_leave(curthread, ret <= 0); 663112918Sjeff 664112918Sjeff return ret; 665112918Sjeff} 666112918Sjeff 667160662Sdavidxu__weak_reference(__wait3, wait3); 668160662Sdavidxu 669211524Sdavidxu/* 670211524Sdavidxu * Cancellation behavior: 671211524Sdavidxu * Thread may be canceled at start, but if the system call returns 672211524Sdavidxu * a child pid, the thread is not canceled. 673211524Sdavidxu */ 674160662Sdavidxupid_t 675160662Sdavidxu__wait3(int *status, int options, struct rusage *rusage) 676160662Sdavidxu{ 677160662Sdavidxu struct pthread *curthread = _get_curthread(); 678160662Sdavidxu pid_t ret; 679160662Sdavidxu 680212076Sdavidxu _thr_cancel_enter(curthread); 681160662Sdavidxu ret = _wait4(WAIT_ANY, status, options, rusage); 682212076Sdavidxu _thr_cancel_leave(curthread, ret <= 0); 683160662Sdavidxu 684160662Sdavidxu return (ret); 685160662Sdavidxu} 686160662Sdavidxu 687144518Sdavidxu__weak_reference(__wait4, wait4); 688112918Sjeff 689211524Sdavidxu/* 690211524Sdavidxu * Cancellation behavior: 691211524Sdavidxu * Thread may be canceled at start, but if the system call returns 692211524Sdavidxu * a child pid, the thread is not canceled. 693211524Sdavidxu */ 694112918Sjeffpid_t 695160662Sdavidxu__wait4(pid_t pid, int *status, int options, struct rusage *rusage) 696112918Sjeff{ 697144518Sdavidxu struct pthread *curthread = _get_curthread(); 698112918Sjeff pid_t ret; 699112918Sjeff 700212076Sdavidxu _thr_cancel_enter(curthread); 701160662Sdavidxu ret = __sys_wait4(pid, status, options, rusage); 702212076Sdavidxu _thr_cancel_leave(curthread, ret <= 0); 703112918Sjeff 704112918Sjeff return ret; 705112918Sjeff} 706112918Sjeff 707160662Sdavidxu__weak_reference(___waitpid, waitpid); 708112918Sjeff 709211524Sdavidxu/* 710211524Sdavidxu * Cancellation behavior: 711211524Sdavidxu * Thread may be canceled at start, but if the system call returns 712211524Sdavidxu * a child pid, the thread is not canceled. 713211524Sdavidxu */ 714112918Sjeffpid_t 715160662Sdavidxu___waitpid(pid_t wpid, int *status, int options) 716112918Sjeff{ 717144518Sdavidxu struct pthread *curthread = _get_curthread(); 718112918Sjeff pid_t ret; 719112918Sjeff 720212076Sdavidxu _thr_cancel_enter(curthread); 721112918Sjeff ret = __waitpid(wpid, status, options); 722212076Sdavidxu _thr_cancel_leave(curthread, ret <= 0); 723112918Sjeff 724112918Sjeff return ret; 725112918Sjeff} 726112918Sjeff 727144518Sdavidxu__weak_reference(__write, write); 728112918Sjeff 729211524Sdavidxu/* 730211524Sdavidxu * Cancellation behavior: 731211524Sdavidxu * Thread may be canceled at start, but if the thread wrote some data, 732211524Sdavidxu * it is not canceled. 733211524Sdavidxu */ 734112918Sjeffssize_t 735144518Sdavidxu__write(int fd, const void *buf, size_t nbytes) 736112918Sjeff{ 737144518Sdavidxu struct pthread *curthread = _get_curthread(); 738112918Sjeff ssize_t ret; 739112918Sjeff 740212076Sdavidxu _thr_cancel_enter(curthread); 741112918Sjeff ret = __sys_write(fd, buf, nbytes); 742212076Sdavidxu _thr_cancel_leave(curthread, (ret <= 0)); 743112918Sjeff return ret; 744112918Sjeff} 745112918Sjeff 746144518Sdavidxu__weak_reference(__writev, writev); 747112918Sjeff 748211524Sdavidxu/* 749211524Sdavidxu * Cancellation behavior: 750211524Sdavidxu * Thread may be canceled at start, but if the thread wrote some data, 751211524Sdavidxu * it is not canceled. 752211524Sdavidxu */ 753112918Sjeffssize_t 754144518Sdavidxu__writev(int fd, const struct iovec *iov, int iovcnt) 755112918Sjeff{ 756144518Sdavidxu struct pthread *curthread = _get_curthread(); 757112918Sjeff ssize_t ret; 758112918Sjeff 759212076Sdavidxu _thr_cancel_enter(curthread); 760112918Sjeff ret = __sys_writev(fd, iov, iovcnt); 761212076Sdavidxu _thr_cancel_leave(curthread, (ret <= 0)); 762112918Sjeff return ret; 763112918Sjeff} 764