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.1 2005/02/01 12:38:27 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/cdefs.h>
  68 #include <sys/types.h>
  69 #include <sys/mman.h>
  70 #include <sys/param.h>
  71 #include <sys/select.h>
  72 #include <sys/signalvar.h>
  73 #include <sys/socket.h>
  74 #include <sys/stat.h>
  75 #include <sys/time.h>
  76 #include <sys/uio.h>
  77 #include <sys/wait.h>
  78 #include <aio.h>
  79 #include <dirent.h>
  80 #include <errno.h>
  81 #include <fcntl.h>
  82 #include <poll.h>
  83 #include <signal.h>
  84 #include <stdarg.h>
  85 #include <stdio.h>
  86 #include <stdlib.h>
  87 #include <string.h>
  88 #include <termios.h>
  89 #include <unistd.h>
  90 #include <pthread.h>
  91
  92 #include "thr_private.h"
  93
  94 extern int __creat(const char *, mode_t);
  95 extern int __pause(void);
  96 extern int __pselect(int count, fd_set *rfds, fd_set *wfds, fd_set *efds,
  97                 const struct timespec *timo, const sigset_t *mask);
  98 extern unsigned int __sleep(unsigned int);
  99 extern int __system(const char *);
 100 extern int __tcdrain(int);
 101 extern pid_t __wait(int *);
 102 extern pid_t __sys_wait4(pid_t, int *, int, struct rusage *);
 103 extern pid_t __waitpid(pid_t, int *, int);
 104
 105 __weak_reference(__accept, accept);
 106 int
 107 __accept(int s, struct sockaddr *addr, socklen_t *addrlen)
 108 {
 109         struct pthread *curthread;
 110         int oldcancel;
 111         int ret;
 112
 113         curthread = _get_curthread();
 114         oldcancel = _thr_cancel_enter(curthread);
 115         ret = __sys_accept(s, addr, addrlen);
 116         _thr_cancel_leave(curthread, oldcancel);
 117
 118         return (ret);
 119 }
 120
 121 __weak_reference(_aio_suspend, aio_suspend);
 122
 123 int
 124 _aio_suspend(const struct aiocb * const iocbs[], int niocb, const struct
 125     timespec *timeout)
 126 {
 127         struct pthread *curthread = _get_curthread();
 128         int oldcancel;
 129         int ret;
 130
 131         oldcancel = _thr_cancel_enter(curthread);
 132         ret = __sys_aio_suspend(iocbs, niocb, timeout);
 133         _thr_cancel_leave(curthread, oldcancel);
 134
 135         return (ret);
 136 }
 137
 138 __weak_reference(__close, close);
 139
 140 int
 141 __close(int fd)
 142 {
 143         struct pthread  *curthread = _get_curthread();
 144         int     oldcancel;
 145         int     ret;
 146
 147         oldcancel = _thr_cancel_enter(curthread);
 148         ret = __sys_close(fd);
 149         _thr_cancel_leave(curthread, oldcancel);
 150
 151         return (ret);
 152 }
 153
 154 __weak_reference(__connect, connect);
 155
 156 int
 157 __connect(int fd, const struct sockaddr *name, socklen_t namelen)
 158 {
 159         struct pthread *curthread = _get_curthread();
 160         int oldcancel;
 161         int ret;
 162
 163         curthread = _get_curthread();
 164         oldcancel = _thr_cancel_enter(curthread);
 165         ret = __sys_connect(fd, name, namelen);
 166         _thr_cancel_leave(curthread, oldcancel);
 167
 168         return (ret);
 169 }
 170
 171 __weak_reference(___creat, creat);
 172
 173 int
 174 ___creat(const char *path, mode_t mode)
 175 {
 176         struct pthread *curthread = _get_curthread();
 177         int oldcancel;
 178         int ret;
 179
 180         oldcancel = _thr_cancel_enter(curthread);
 181         ret = __creat(path, mode);
 182         _thr_cancel_leave(curthread, oldcancel);
 183
 184         return ret;
 185 }
 186
 187 __weak_reference(__fcntl, fcntl);
 188
 189 int
 190 __fcntl(int fd, int cmd,...)
 191 {
 192         struct pthread *curthread = _get_curthread();
 193         int     oldcancel;
 194         int     ret;
 195         va_list ap;
 196
 197         oldcancel = _thr_cancel_enter(curthread);
 198
 199         va_start(ap, cmd);
 200         switch (cmd) {
 201         case F_DUPFD:
 202                 ret = __sys_fcntl(fd, cmd, va_arg(ap, int));
 203                 break;
 204         case F_SETFD:
 205         case F_SETFL:
 206                 ret = __sys_fcntl(fd, cmd, va_arg(ap, int));
 207                 break;
 208         case F_GETFD:
 209         case F_GETFL:
 210                 ret = __sys_fcntl(fd, cmd);
 211                 break;
 212         default:
 213                 ret = __sys_fcntl(fd, cmd, va_arg(ap, void *));
 214         }
 215         va_end(ap);
 216
 217         _thr_cancel_leave(curthread, oldcancel);
 218
 219         return (ret);
 220 }
 221
 222 __weak_reference(__fsync, fsync);
 223
 224 int
 225 __fsync(int fd)
 226 {
 227         struct pthread *curthread = _get_curthread();
 228         int     oldcancel;
 229         int     ret;
 230
 231         oldcancel = _thr_cancel_enter(curthread);
 232         ret = __sys_fsync(fd);
 233         _thr_cancel_leave(curthread, oldcancel);
 234
 235         return (ret);
 236 }
 237
 238 __weak_reference(__msync, msync);
 239
 240 int
 241 __msync(void *addr, size_t len, int flags)
 242 {
 243         struct pthread *curthread = _get_curthread();
 244         int     oldcancel;
 245         int     ret;
 246
 247         oldcancel = _thr_cancel_enter(curthread);
 248         ret = __sys_msync(addr, len, flags);
 249         _thr_cancel_leave(curthread, oldcancel);
 250
 251         return ret;
 252 }
 253
 254 __weak_reference(__nanosleep, nanosleep);
 255
 256 int
 257 __nanosleep(const struct timespec *time_to_sleep,
 258     struct timespec *time_remaining)
 259 {
 260         struct pthread *curthread = _get_curthread();
 261         int             oldcancel;
 262         int             ret;
 263
 264         oldcancel = _thr_cancel_enter(curthread);
 265         ret = __sys_nanosleep(time_to_sleep, time_remaining);
 266         _thr_cancel_leave(curthread, oldcancel);
 267
 268         return (ret);
 269 }
 270
 271 __weak_reference(___open, open);
 272
 273 int
 274 ___open(const char *path, int flags,...)
 275 {
 276         struct pthread *curthread = _get_curthread();
 277         int     oldcancel;
 278         int     ret;
 279         int     mode = 0;
 280         va_list ap;
 281
 282         _thread_printf(1, "%s %s\n", __func__, path);
 283         oldcancel = _thr_cancel_enter(curthread);
 284
 285         /* Check if the file is being created: */
 286         if (flags & O_CREAT) {
 287                 /* Get the creation mode: */
 288                 va_start(ap, flags);
 289                 mode = va_arg(ap, int);
 290                 va_end(ap);
 291         }
 292
 293         ret = __sys_open(path, flags, mode);
 294
 295         _thr_cancel_leave(curthread, oldcancel);
 296
 297         return ret;
 298 }
 299
 300 __weak_reference(_pause, pause);
 301
 302 int
 303 _pause(void)
 304 {
 305         struct pthread *curthread = _get_curthread();
 306         int     oldcancel;
 307         int     ret;
 308
 309         oldcancel = _thr_cancel_enter(curthread);
 310         ret = __pause();
 311         _thr_cancel_leave(curthread, oldcancel);
 312
 313         return ret;
 314 }
 315
 316 __weak_reference(__poll, poll);
 317
 318 int
 319 __poll(struct pollfd *fds, unsigned int nfds, int timeout)
 320 {
 321         struct pthread *curthread = _get_curthread();
 322         int oldcancel;
 323         int ret;
 324
 325         oldcancel = _thr_cancel_enter(curthread);
 326         ret = __sys_poll(fds, nfds, timeout);
 327         _thr_cancel_leave(curthread, oldcancel);
 328
 329         return ret;
 330 }
 331
 332 #if 0
 333 __weak_reference(_pselect, pselect);
 334
 335 int
 336 _pselect(int count, fd_set *rfds, fd_set *wfds, fd_set *efds,
 337         const struct timespec *timo, const sigset_t *mask)
 338 {
 339         struct pthread *curthread = _get_curthread();
 340         int oldcancel;
 341         int ret;
 342
 343         oldcancel = _thr_cancel_enter(curthread);
 344         ret = __pselect(count, rfds, wfds, efds, timo, mask);
 345         _thr_cancel_leave(curthread, oldcancel);
 346
 347         return (ret);
 348 }
 349 #endif
 350
 351 __weak_reference(_raise, raise);
 352
 353 int
 354 _raise(int sig)
 355 {
 356         int ret;
 357
 358         if (!_thr_isthreaded())
 359                 ret = kill(getpid(), sig);
 360         else {
 361                 ret = pthread_kill(pthread_self(), sig);
 362                 if (ret != 0) {
 363                         errno = ret;
 364                         ret = -1;
 365                 }
 366         }
 367         return (ret);
 368 }
 369
 370 __weak_reference(__read, read);
 371
 372 ssize_t
 373 __read(int fd, void *buf, size_t nbytes)
 374 {
 375         struct pthread *curthread = _get_curthread();
 376         int oldcancel;
 377         ssize_t ret;
 378
 379         oldcancel = _thr_cancel_enter(curthread);
 380         ret = __sys_read(fd, buf, nbytes);
 381         _thr_cancel_leave(curthread, oldcancel);
 382
 383         return ret;
 384 }
 385
 386 __weak_reference(__readv, readv);
 387
 388 ssize_t
 389 __readv(int fd, const struct iovec *iov, int iovcnt)
 390 {
 391         struct pthread *curthread = _get_curthread();
 392         int oldcancel;
 393         ssize_t ret;
 394
 395         oldcancel = _thr_cancel_enter(curthread);
 396         ret = __sys_readv(fd, iov, iovcnt);
 397         _thr_cancel_leave(curthread, oldcancel);
 398
 399         return ret;
 400 }
 401
 402 __weak_reference(__recvfrom, recvfrom);
 403
 404 ssize_t
 405 __recvfrom(int s, void *b, size_t l, int f, struct sockaddr *from,
 406     socklen_t *fl)
 407 {
 408         struct pthread *curthread = _get_curthread();
 409         int oldcancel;
 410         ssize_t ret;
 411
 412         oldcancel = _thr_cancel_enter(curthread);
 413         ret = __sys_recvfrom(s, b, l, f, from, fl);
 414         _thr_cancel_leave(curthread, oldcancel);
 415         return (ret);
 416 }
 417
 418 __weak_reference(__recvmsg, recvmsg);
 419
 420 ssize_t
 421 __recvmsg(int s, struct msghdr *m, int f)
 422 {
 423         struct pthread *curthread = _get_curthread();
 424         ssize_t ret;
 425         int oldcancel;
 426
 427         oldcancel = _thr_cancel_enter(curthread);
 428         ret = __sys_recvmsg(s, m, f);
 429         _thr_cancel_leave(curthread, oldcancel);
 430         return (ret);
 431 }
 432
 433 __weak_reference(__select, select);
 434
 435 int
 436 __select(int numfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds,
 437         struct timeval *timeout)
 438 {
 439         struct pthread *curthread = _get_curthread();
 440         int oldcancel;
 441         int ret;
 442
 443         oldcancel = _thr_cancel_enter(curthread);
 444         ret = __sys_select(numfds, readfds, writefds, exceptfds, timeout);
 445         _thr_cancel_leave(curthread, oldcancel);
 446         return ret;
 447 }
 448
 449 __weak_reference(__sendmsg, sendmsg);
 450
 451 ssize_t
 452 __sendmsg(int s, const struct msghdr *m, int f)
 453 {
 454         struct pthread *curthread = _get_curthread();
 455         ssize_t ret;
 456         int oldcancel;
 457
 458         oldcancel = _thr_cancel_enter(curthread);
 459         ret = __sys_sendmsg(s, m, f);
 460         _thr_cancel_leave(curthread, oldcancel);
 461         return (ret);
 462 }
 463
 464 __weak_reference(__sendto, sendto);
 465
 466 ssize_t
 467 __sendto(int s, const void *m, size_t l, int f, const struct sockaddr *t,
 468     socklen_t tl)
 469 {
 470         struct pthread *curthread = _get_curthread();
 471         ssize_t ret;
 472         int oldcancel;
 473
 474         oldcancel = _thr_cancel_enter(curthread);
 475         ret = __sys_sendto(s, m, l, f, t, tl);
 476         _thr_cancel_leave(curthread, oldcancel);
 477         return (ret);
 478 }
 479
 480 unsigned int
 481 _sleep(unsigned int seconds)
 482 {
 483         struct pthread *curthread = _get_curthread();
 484         int             oldcancel;
 485         unsigned int    ret;
 486
 487         oldcancel = _thr_cancel_enter(curthread);
 488         ret = __sleep(seconds);
 489         _thr_cancel_leave(curthread, oldcancel);
 490
 491         return (ret);
 492 }
 493
 494 __weak_reference(_system, system);
 495
 496 int
 497 _system(const char *string)
 498 {
 499         struct pthread *curthread = _get_curthread();
 500         int     oldcancel;
 501         int     ret;
 502
 503         oldcancel = _thr_cancel_enter(curthread);
 504         ret = __system(string);
 505         _thr_cancel_leave(curthread, oldcancel);
 506
 507         return ret;
 508 }
 509
 510 __weak_reference(_tcdrain, tcdrain);
 511
 512 int
 513 _tcdrain(int fd)
 514 {
 515         struct pthread *curthread = _get_curthread();
 516         int     oldcancel;
 517         int     ret;
 518
 519         oldcancel = _thr_cancel_enter(curthread);
 520         ret = __tcdrain(fd);
 521         _thr_cancel_leave(curthread, oldcancel);
 522
 523         return (ret);
 524 }
 525
 526 __weak_reference(_vfork, vfork);
 527
 528 int
 529 _vfork(void)
 530 {
 531         return (fork());
 532 }
 533
 534 __weak_reference(_wait, wait);
 535
 536 pid_t
 537 _wait(int *istat)
 538 {
 539         struct pthread *curthread = _get_curthread();
 540         int     oldcancel;
 541         pid_t   ret;
 542
 543         oldcancel = _thr_cancel_enter(curthread);
 544         ret = __wait(istat);
 545         _thr_cancel_leave(curthread, oldcancel);
 546
 547         return ret;
 548 }
 549
 550 __weak_reference(__wait4, wait4);
 551
 552 pid_t
 553 __wait4(pid_t pid, int *istat, int options, struct rusage *rusage)
 554 {
 555         struct pthread *curthread = _get_curthread();
 556         int oldcancel;
 557         pid_t ret;
 558
 559         oldcancel = _thr_cancel_enter(curthread);
 560         ret = __sys_wait4(pid, istat, options, rusage);
 561         _thr_cancel_leave(curthread, oldcancel);
 562
 563         return ret;
 564 }
 565
 566 __weak_reference(_waitpid, waitpid);
 567
 568 pid_t
 569 _waitpid(pid_t wpid, int *status, int options)
 570 {
 571         struct pthread *curthread = _get_curthread();
 572         int     oldcancel;
 573         pid_t   ret;
 574
 575         oldcancel = _thr_cancel_enter(curthread);
 576         ret = __waitpid(wpid, status, options);
 577         _thr_cancel_leave(curthread, oldcancel);
 578
 579         return ret;
 580 }
 581
 582 __weak_reference(__write, write);
 583
 584 ssize_t
 585 __write(int fd, const void *buf, size_t nbytes)
 586 {
 587         struct pthread *curthread = _get_curthread();
 588         int     oldcancel;
 589         ssize_t ret;
 590
 591         oldcancel = _thr_cancel_enter(curthread);
 592         ret = __sys_write(fd, buf, nbytes);
 593         _thr_cancel_leave(curthread, oldcancel);
 594
 595         return ret;
 596 }
 597
 598 __weak_reference(__writev, writev);
 599
 600 ssize_t
 601 __writev(int fd, const struct iovec *iov, int iovcnt)
 602 {
 603         struct pthread *curthread = _get_curthread();
 604         int     oldcancel;
 605         ssize_t ret;
 606
 607         oldcancel = _thr_cancel_enter(curthread);
 608         ret = __sys_writev(fd, iov, iovcnt);
 609         _thr_cancel_leave(curthread, oldcancel);
 610
 611         return ret;
 612 }