lib/libthread_xu/thread/thr_syscalls.c

   1 /*
   2  * Copyright (C) 2005 David Xu <davidxu@freebsd.org>.
   3  * Copyright (c) 2003 Daniel Eischen <deischen@freebsd.org>.
   4  * Copyright (C) 2000 Jason Evans <jasone@freebsd.org>.
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice(s), this list of conditions and the following disclaimer as
  12  *    the first lines of this file unmodified other than the possible
  13  *    addition of one or more copyright notices.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice(s), this list of conditions and the following disclaimer in
  16  *    the documentation and/or other materials provided with the
  17  *    distribution.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) ``AS IS'' AND ANY
  20  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  22  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) BE
  23  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
  26  * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  27  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
  28  * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
  29  * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  30  *
  31  * $DragonFly: src/lib/libthread_xu/thread/thr_syscalls.c,v 1.7 2006/04/06 13:03:09 davidxu Exp $
  32  */
  33
  34 /*
  35  * Copyright (c) 1995-1998 John Birrell <jb@cimlogic.com.au>
  36  * All rights reserved.
  37  *
  38  * Redistribution and use in source and binary forms, with or without
  39  * modification, are permitted provided that the following conditions
  40  * are met:
  41  * 1. Redistributions of source code must retain the above copyright
  42  *    notice, this list of conditions and the following disclaimer.
  43  * 2. Redistributions in binary form must reproduce the above copyright
  44  *    notice, this list of conditions and the following disclaimer in the
  45  *    documentation and/or other materials provided with the distribution.
  46  * 3. All advertising materials mentioning features or use of this software
  47  *    must display the following acknowledgement:
  48  *      This product includes software developed by John Birrell.
  49  * 4. Neither the name of the author nor the names of any co-contributors
  50  *    may be used to endorse or promote products derived from this software
  51  *    without specific prior written permission.
  52  *
  53  * THIS SOFTWARE IS PROVIDED BY JOHN BIRRELL AND CONTRIBUTORS ``AS IS'' AND
  54  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  55  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  56  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  57  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  58  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  59  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  60  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  61  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  62  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  63  * SUCH DAMAGE.
  64  *
  65  */
  66
  67 #include <sys/types.h>
  68 #include <sys/mman.h>
  69 #include <sys/param.h>
  70 #include <sys/select.h>
  71 #include <sys/signalvar.h>
  72 #include <sys/socket.h>
  73 #include <sys/stat.h>
  74 #include <sys/time.h>
  75 #include <sys/uio.h>
  76 #include <sys/wait.h>
  77
  78 #include <machine/tls.h>
  79
  80 #include <aio.h>
  81 #include <dirent.h>
  82 #include <errno.h>
  83 #include <fcntl.h>
  84 #include <poll.h>
  85 #include <signal.h>
  86 #include <stdarg.h>
  87 #include <stdio.h>
  88 #include <stdlib.h>
  89 #include <string.h>
  90 #include <termios.h>
  91 #include <unistd.h>
  92 #include <pthread.h>
  93
  94 #include "thr_private.h"
  95
  96 extern int      __creat(const char *, mode_t);
  97 extern int      __pause(void);
  98 extern int      __pselect(int, fd_set *, fd_set *, fd_set *,
  99                         const struct timespec *, const sigset_t *);
 100 extern unsigned __sleep(unsigned int);
 101 extern int      __system(const char *);
 102 extern int      __tcdrain(int);
 103 extern int      __usleep(unsigned);
 104 extern pid_t    __wait(int *);
 105 extern pid_t    __waitpid(pid_t, int *, int);
 106 extern int      __sys_aio_suspend(const struct aiocb * const[], int,
 107                         const struct timespec *);
 108 extern int      __sys_accept(int, struct sockaddr *, socklen_t *);
 109 extern int      __sys_connect(int, const struct sockaddr *, socklen_t);
 110 extern int      __sys_fsync(int);
 111 extern int      __sys_msync(void *, size_t, int);
 112 extern int      __sys_poll(struct pollfd *, unsigned, int);
 113 extern ssize_t  __sys_recv(int, void *, size_t, int);
 114 extern ssize_t  __sys_recvfrom(int, void *, size_t, int, struct sockaddr *, socklen_t *);
 115 extern ssize_t  __sys_recvmsg(int, struct msghdr *, int);
 116 extern int      __sys_select(int, fd_set *, fd_set *, fd_set *, struct timeval *);
 117 extern int      __sys_sendfile(int, int, off_t, size_t, struct sf_hdtr *,
 118                         off_t *, int);
 119 extern ssize_t  __sys_sendmsg(int, const struct msghdr *, int);
 120 extern ssize_t  __sys_sendto(int, const void *,size_t, int, const struct sockaddr *, socklen_t);
 121 extern ssize_t  __sys_readv(int, const struct iovec *, int);
 122 extern pid_t    __sys_wait4(pid_t, int *, int, struct rusage *);
 123 extern ssize_t  __sys_writev(int, const struct iovec *, int);
 124
 125 int     ___creat(const char *, mode_t);
 126 int     ___usleep(unsigned);
 127 int     __accept(int, struct sockaddr *, socklen_t *);
 128 int     __close(int);
 129 int     __connect(int, const struct sockaddr *, socklen_t);
 130 int     __fcntl(int, int,...);
 131 int     __fsync(int);
 132 int     __msync(void *, size_t, int);
 133 int     __nanosleep(const struct timespec *, struct timespec *);
 134 int     __open(const char *, int,...);
 135 int     __poll(struct pollfd *, unsigned int, int);
 136 ssize_t __read(int, void *buf, size_t);
 137 ssize_t __readv(int, const struct iovec *, int);
 138 ssize_t __recvfrom(int, void *, size_t, int f, struct sockaddr *, socklen_t *);
 139 ssize_t __recvmsg(int, struct msghdr *, int);
 140 int     __select(int, fd_set *, fd_set *, fd_set *, struct timeval *);
 141 ssize_t __sendmsg(int, const struct msghdr *, int);
 142 ssize_t __sendto(int, const void *, size_t, int,
 143                 const struct sockaddr *, socklen_t);
 144 pid_t   __wait4(pid_t, int *, int, struct rusage *);
 145 ssize_t __write(int, const void *, size_t);
 146 ssize_t __writev(int, const struct iovec *, int);
 147 int     _aio_suspend(const struct aiocb * const iocbs[], int,
 148                 const struct timespec *);
 149 int     _pause(void);
 150 int     _pselect(int, fd_set *, fd_set *, fd_set *,
 151                 const struct timespec *, const sigset_t *);
 152 int     _raise(int);
 153 unsigned        _sleep(unsigned);
 154 int     _system(const char *);
 155 int     _tcdrain(int);
 156 int     _vfork(void);
 157 pid_t   _wait(int *);
 158 pid_t   _waitpid(pid_t wpid, int *status, int options);
 159
 160 int
 161 __accept(int s, struct sockaddr *addr, socklen_t *addrlen)
 162 {
 163         struct pthread *curthread;
 164         int oldcancel;
 165         int ret;
 166
 167         curthread = tls_get_curthread();
 168         oldcancel = _thr_cancel_enter(curthread);
 169         ret = __sys_accept(s, addr, addrlen);
 170         _thr_cancel_leave(curthread, oldcancel);
 171
 172         return (ret);
 173 }
 174
 175 __strong_reference(__accept, accept);
 176
 177 int
 178 _aio_suspend(const struct aiocb * const iocbs[], int niocb, const struct
 179     timespec *timeout)
 180 {
 181         struct pthread *curthread = tls_get_curthread();
 182         int oldcancel;
 183         int ret;
 184
 185         oldcancel = _thr_cancel_enter(curthread);
 186         ret = __sys_aio_suspend(iocbs, niocb, timeout);
 187         _thr_cancel_leave(curthread, oldcancel);
 188
 189         return (ret);
 190 }
 191
 192 __strong_reference(_aio_suspend, aio_suspend);
 193
 194 int
 195 __close(int fd)
 196 {
 197         struct pthread  *curthread = tls_get_curthread();
 198         int     oldcancel;
 199         int     ret;
 200
 201         oldcancel = _thr_cancel_enter(curthread);
 202         ret = __sys_close(fd);
 203         _thr_cancel_leave(curthread, oldcancel);
 204
 205         return (ret);
 206 }
 207
 208 __strong_reference(__close, close);
 209
 210 int
 211 __connect(int fd, const struct sockaddr *name, socklen_t namelen)
 212 {
 213         struct pthread *curthread = tls_get_curthread();
 214         int oldcancel;
 215         int ret;
 216
 217         oldcancel = _thr_cancel_enter(curthread);
 218         ret = __sys_connect(fd, name, namelen);
 219         _thr_cancel_leave(curthread, oldcancel);
 220
 221         return (ret);
 222 }
 223
 224 __strong_reference(__connect, connect);
 225
 226 int
 227 ___creat(const char *path, mode_t mode)
 228 {
 229         struct pthread *curthread = tls_get_curthread();
 230         int oldcancel;
 231         int ret;
 232
 233         oldcancel = _thr_cancel_enter(curthread);
 234         ret = __creat(path, mode);
 235         _thr_cancel_leave(curthread, oldcancel);
 236
 237         return ret;
 238 }
 239
 240 __strong_reference(___creat, creat);
 241
 242 int
 243 __fcntl(int fd, int cmd,...)
 244 {
 245         struct pthread *curthread = tls_get_curthread();
 246         int     oldcancel;
 247         int     ret;
 248         va_list ap;
 249
 250         oldcancel = _thr_cancel_enter(curthread);
 251
 252         va_start(ap, cmd);
 253         switch (cmd) {
 254         case F_DUPFD:
 255                 ret = __sys_fcntl(fd, cmd, va_arg(ap, int));
 256                 break;
 257         case F_SETFD:
 258         case F_SETFL:
 259                 ret = __sys_fcntl(fd, cmd, va_arg(ap, int));
 260                 break;
 261         case F_GETFD:
 262         case F_GETFL:
 263                 ret = __sys_fcntl(fd, cmd);
 264                 break;
 265         default:
 266                 ret = __sys_fcntl(fd, cmd, va_arg(ap, void *));
 267         }
 268         va_end(ap);
 269
 270         _thr_cancel_leave(curthread, oldcancel);
 271
 272         return (ret);
 273 }
 274
 275 __strong_reference(__fcntl, fcntl);
 276
 277 int
 278 __fsync(int fd)
 279 {
 280         struct pthread *curthread = tls_get_curthread();
 281         int     oldcancel;
 282         int     ret;
 283
 284         oldcancel = _thr_cancel_enter(curthread);
 285         ret = __sys_fsync(fd);
 286         _thr_cancel_leave(curthread, oldcancel);
 287
 288         return (ret);
 289 }
 290
 291 __strong_reference(__fsync, fsync);
 292
 293 int
 294 __msync(void *addr, size_t len, int flags)
 295 {
 296         struct pthread *curthread = tls_get_curthread();
 297         int     oldcancel;
 298         int     ret;
 299
 300         oldcancel = _thr_cancel_enter(curthread);
 301         ret = __sys_msync(addr, len, flags);
 302         _thr_cancel_leave(curthread, oldcancel);
 303
 304         return ret;
 305 }
 306
 307 __strong_reference(__msync, msync);
 308
 309 int
 310 __nanosleep(const struct timespec *time_to_sleep,
 311     struct timespec *time_remaining)
 312 {
 313         struct pthread *curthread = tls_get_curthread();
 314         int             oldcancel;
 315         int             ret;
 316
 317         oldcancel = _thr_cancel_enter(curthread);
 318         ret = __sys_nanosleep(time_to_sleep, time_remaining);
 319         _thr_cancel_leave(curthread, oldcancel);
 320
 321         return (ret);
 322 }
 323
 324 __strong_reference(__nanosleep, nanosleep);
 325
 326 int
 327 __open(const char *path, int flags,...)
 328 {
 329         struct pthread *curthread = tls_get_curthread();
 330         int     oldcancel;
 331         int     ret;
 332         int     mode = 0;
 333         va_list ap;
 334
 335         oldcancel = _thr_cancel_enter(curthread);
 336
 337         /* Check if the file is being created: */
 338         if (flags & O_CREAT) {
 339                 /* Get the creation mode: */
 340                 va_start(ap, flags);
 341                 mode = va_arg(ap, int);
 342                 va_end(ap);
 343         }
 344
 345         ret = __sys_open(path, flags, mode);
 346
 347         _thr_cancel_leave(curthread, oldcancel);
 348
 349         return ret;
 350 }
 351
 352 __strong_reference(__open, open);
 353
 354 int
 355 _pause(void)
 356 {
 357         struct pthread *curthread = tls_get_curthread();
 358         int     oldcancel;
 359         int     ret;
 360
 361         oldcancel = _thr_cancel_enter(curthread);
 362         ret = __pause();
 363         _thr_cancel_leave(curthread, oldcancel);
 364
 365         return ret;
 366 }
 367
 368 __strong_reference(_pause, pause);
 369
 370 int
 371 __poll(struct pollfd *fds, unsigned int nfds, int timeout)
 372 {
 373         struct pthread *curthread = tls_get_curthread();
 374         int oldcancel;
 375         int ret;
 376
 377         oldcancel = _thr_cancel_enter(curthread);
 378         ret = __sys_poll(fds, nfds, timeout);
 379         _thr_cancel_leave(curthread, oldcancel);
 380
 381         return ret;
 382 }
 383
 384 __strong_reference(__poll, poll);
 385 #if 0
 386
 387 int
 388 _pselect(int count, fd_set *rfds, fd_set *wfds, fd_set *efds,
 389         const struct timespec *timo, const sigset_t *mask)
 390 {
 391         struct pthread *curthread = tls_get_curthread();
 392         int oldcancel;
 393         int ret;
 394
 395         oldcancel = _thr_cancel_enter(curthread);
 396         ret = __pselect(count, rfds, wfds, efds, timo, mask);
 397         _thr_cancel_leave(curthread, oldcancel);
 398
 399         return (ret);
 400 }
 401 __strong_reference(_pselect, pselect);
 402 #endif
 403
 404
 405 int
 406 _raise(int sig)
 407 {
 408         int ret;
 409
 410         if (!_thr_isthreaded())
 411                 ret = kill(getpid(), sig);
 412         else
 413                 ret = _thr_send_sig(tls_get_curthread(), sig);
 414         return (ret);
 415 }
 416
 417 __strong_reference(_raise, raise);
 418
 419 ssize_t
 420 __read(int fd, void *buf, size_t nbytes)
 421 {
 422         struct pthread *curthread = tls_get_curthread();
 423         int oldcancel;
 424         ssize_t ret;
 425
 426         oldcancel = _thr_cancel_enter(curthread);
 427         ret = __sys_read(fd, buf, nbytes);
 428         _thr_cancel_leave(curthread, oldcancel);
 429
 430         return ret;
 431 }
 432
 433 __strong_reference(__read, read);
 434
 435 ssize_t
 436 __readv(int fd, const struct iovec *iov, int iovcnt)
 437 {
 438         struct pthread *curthread = tls_get_curthread();
 439         int oldcancel;
 440         ssize_t ret;
 441
 442         oldcancel = _thr_cancel_enter(curthread);
 443         ret = __sys_readv(fd, iov, iovcnt);
 444         _thr_cancel_leave(curthread, oldcancel);
 445
 446         return ret;
 447 }
 448
 449 __strong_reference(__readv, readv);
 450
 451 ssize_t
 452 __recvfrom(int s, void *b, size_t l, int f, struct sockaddr *from,
 453     socklen_t *fl)
 454 {
 455         struct pthread *curthread = tls_get_curthread();
 456         int oldcancel;
 457         ssize_t ret;
 458
 459         oldcancel = _thr_cancel_enter(curthread);
 460         ret = __sys_recvfrom(s, b, l, f, from, fl);
 461         _thr_cancel_leave(curthread, oldcancel);
 462         return (ret);
 463 }
 464
 465 __strong_reference(__recvfrom, recvfrom);
 466
 467 ssize_t
 468 __recvmsg(int s, struct msghdr *m, int f)
 469 {
 470         struct pthread *curthread = tls_get_curthread();
 471         ssize_t ret;
 472         int oldcancel;
 473
 474         oldcancel = _thr_cancel_enter(curthread);
 475         ret = __sys_recvmsg(s, m, f);
 476         _thr_cancel_leave(curthread, oldcancel);
 477         return (ret);
 478 }
 479
 480 __strong_reference(__recvmsg, recvmsg);
 481
 482 int
 483 __select(int numfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds,
 484         struct timeval *timeout)
 485 {
 486         struct pthread *curthread = tls_get_curthread();
 487         int oldcancel;
 488         int ret;
 489
 490         oldcancel = _thr_cancel_enter(curthread);
 491         ret = __sys_select(numfds, readfds, writefds, exceptfds, timeout);
 492         _thr_cancel_leave(curthread, oldcancel);
 493         return ret;
 494 }
 495
 496 __strong_reference(__select, select);
 497
 498 ssize_t
 499 __sendmsg(int s, const struct msghdr *m, int f)
 500 {
 501         struct pthread *curthread = tls_get_curthread();
 502         ssize_t ret;
 503         int oldcancel;
 504
 505         oldcancel = _thr_cancel_enter(curthread);
 506         ret = __sys_sendmsg(s, m, f);
 507         _thr_cancel_leave(curthread, oldcancel);
 508         return (ret);
 509 }
 510
 511 __strong_reference(__sendmsg, sendmsg);
 512
 513 ssize_t
 514 __sendto(int s, const void *m, size_t l, int f, const struct sockaddr *t,
 515     socklen_t tl)
 516 {
 517         struct pthread *curthread = tls_get_curthread();
 518         ssize_t ret;
 519         int oldcancel;
 520
 521         oldcancel = _thr_cancel_enter(curthread);
 522         ret = __sys_sendto(s, m, l, f, t, tl);
 523         _thr_cancel_leave(curthread, oldcancel);
 524         return (ret);
 525 }
 526
 527 __strong_reference(__sendto, sendto);
 528
 529 unsigned int
 530 _sleep(unsigned int seconds)
 531 {
 532         struct pthread *curthread = tls_get_curthread();
 533         int             oldcancel;
 534         unsigned int    ret;
 535
 536         oldcancel = _thr_cancel_enter(curthread);
 537         ret = __sleep(seconds);
 538         _thr_cancel_leave(curthread, oldcancel);
 539
 540         return (ret);
 541 }
 542
 543 int
 544 _system(const char *string)
 545 {
 546         struct pthread *curthread = tls_get_curthread();
 547         int     oldcancel;
 548         int     ret;
 549
 550         oldcancel = _thr_cancel_enter(curthread);
 551         ret = __system(string);
 552         _thr_cancel_leave(curthread, oldcancel);
 553
 554         return ret;
 555 }
 556
 557 __strong_reference(_system, system);
 558
 559 int
 560 _tcdrain(int fd)
 561 {
 562         struct pthread *curthread = tls_get_curthread();
 563         int     oldcancel;
 564         int     ret;
 565
 566         oldcancel = _thr_cancel_enter(curthread);
 567         ret = __tcdrain(fd);
 568         _thr_cancel_leave(curthread, oldcancel);
 569
 570         return (ret);
 571 }
 572
 573 __strong_reference(_tcdrain, tcdrain);
 574
 575 int
 576 ___usleep(unsigned int useconds)
 577 {
 578         struct pthread *curthread = tls_get_curthread();
 579         int             oldcancel;
 580         int             ret;
 581
 582         oldcancel = _thr_cancel_enter(curthread);
 583         ret = __usleep(useconds);
 584         _thr_cancel_leave(curthread, oldcancel);
 585
 586         return (ret);
 587 }
 588
 589 __strong_reference(___usleep, usleep);
 590
 591 int
 592 _vfork(void)
 593 {
 594         return (fork());
 595 }
 596
 597 __strong_reference(_vfork, vfork);
 598
 599 pid_t
 600 _wait(int *istat)
 601 {
 602         struct pthread *curthread = tls_get_curthread();
 603         int     oldcancel;
 604         pid_t   ret;
 605
 606         oldcancel = _thr_cancel_enter(curthread);
 607         ret = __wait(istat);
 608         _thr_cancel_leave(curthread, oldcancel);
 609
 610         return ret;
 611 }
 612
 613 __strong_reference(_wait, wait);
 614
 615 pid_t
 616 __wait4(pid_t pid, int *istat, int options, struct rusage *rusage)
 617 {
 618         struct pthread *curthread = tls_get_curthread();
 619         int oldcancel;
 620         pid_t ret;
 621
 622         oldcancel = _thr_cancel_enter(curthread);
 623         ret = __sys_wait4(pid, istat, options, rusage);
 624         _thr_cancel_leave(curthread, oldcancel);
 625
 626         return ret;
 627 }
 628
 629 __strong_reference(__wait4, wait4);
 630
 631 pid_t
 632 _waitpid(pid_t wpid, int *status, int options)
 633 {
 634         struct pthread *curthread = tls_get_curthread();
 635         int     oldcancel;
 636         pid_t   ret;
 637
 638         oldcancel = _thr_cancel_enter(curthread);
 639         ret = __waitpid(wpid, status, options);
 640         _thr_cancel_leave(curthread, oldcancel);
 641
 642         return ret;
 643 }
 644
 645 __strong_reference(_waitpid, waitpid);
 646
 647 ssize_t
 648 __write(int fd, const void *buf, size_t nbytes)
 649 {
 650         struct pthread *curthread = tls_get_curthread();
 651         int     oldcancel;
 652         ssize_t ret;
 653
 654         oldcancel = _thr_cancel_enter(curthread);
 655         ret = __sys_write(fd, buf, nbytes);
 656         _thr_cancel_leave(curthread, oldcancel);
 657
 658         return ret;
 659 }
 660
 661 __strong_reference(__write, write);
 662
 663 ssize_t
 664 __writev(int fd, const struct iovec *iov, int iovcnt)
 665 {
 666         struct pthread *curthread = tls_get_curthread();
 667         int     oldcancel;
 668         ssize_t ret;
 669
 670         oldcancel = _thr_cancel_enter(curthread);
 671         ret = __sys_writev(fd, iov, iovcnt);
 672         _thr_cancel_leave(curthread, oldcancel);
 673
 674         return ret;
 675 }
 676
 677 __strong_reference(__writev, writev);
 678