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