
/*--------------------------------------------------------------------*/
/*--- Intercepts for various libc functions we want to capture     ---*/
/*--- (mostly for threading purposes).              vg_intercept.c ---*/
/*--------------------------------------------------------------------*/

/*
   This file is part of Valgrind, an extensible x86 protected-mode
   emulator for monitoring program execution on x86-Unixes.

   Copyright (C) 2000-2003 Julian Seward 
      jseward@acm.org

   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
   published by the Free Software Foundation; either version 2 of the
   License, or (at your option) any later version.

   This program is distributed in the hope that it will be useful, but
   WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
   02111-1307, USA.

   The GNU General Public License is contained in the file COPYING.
*/


/* ---------------------------------------------------------------------
   ALL THE CODE IN THIS FILE RUNS ON THE SIMULATED CPU.  It is
   intended for various reasons as drop-in replacements for libc
   functions.  These functions have global visibility (obviously) and
   have no prototypes in vg_include.h, since they are not intended to
   be called from within Valgrind.
   ------------------------------------------------------------------ */

/* General idea (2003-Apr-26) is that master implementations of
   selected functions are done as VGR_(fnname).  Then we route
   all calls to the master, both here and in vg_libpthread.c.
   This means we no longer have to rely on the semantics of weak
   symbols, which seems to have changed in glibc >= 2.3.2 in such
   a way as to make the previous interception scheme stop working.
*/

/* Sidestep the normal check which disallows using valgrind.h
   directly. */
#define __VALGRIND_SOMESKIN_H
#include "valgrind.h"

#include "vg_include.h"
#include "vg_kerneliface.h"

/* This has some nasty duplication of stuff from vg_libpthread.c */

#include <errno.h>
#include <sys/types.h>
#include <stdio.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <asm/ipc.h>		/* for ipc_kludge */
#include <sys/poll.h>
#include <sys/socket.h>
#include <sys/uio.h>
#ifdef GLIBC_2_1
#include <sys/time.h>
#endif

/* --------------------------------------------------------------- */

# define strong_alias(name, aliasname) \
  extern __typeof (name) aliasname __attribute__ ((alias (#name)));

#define WEAK	__attribute__((weak))

/* --------------------------------------------------------------- */

static __inline__
int my_do_syscall1 ( int syscallno, int arg1 )
{ 
   int __res;
   __asm__ volatile ("pushl %%ebx; movl %%edx,%%ebx ; int $0x80 ; popl %%ebx"
                     : "=a" (__res)
                     : "0" (syscallno),
                       "d" (arg1) );
   return __res;
}

static __inline__
int my_do_syscall2 ( int syscallno, 
                     int arg1, int arg2 )
{ 
   int __res;
   __asm__ volatile ("pushl %%ebx; movl %%edx,%%ebx ; int $0x80 ; popl %%ebx"
                     : "=a" (__res)
                     : "0" (syscallno),
                       "d" (arg1),
                       "c" (arg2) );
   return __res;
}

static __inline__
int my_do_syscall3 ( int syscallno, 
                     int arg1, int arg2, int arg3 )
{ 
   int __res;
   __asm__ volatile ("pushl %%ebx; movl %%esi,%%ebx ; int $0x80 ; popl %%ebx"
                     : "=a" (__res)
                     : "0" (syscallno),
                       "S" (arg1),
                       "c" (arg2),
                       "d" (arg3) );
   return __res;
}

static __inline__
int my_do_syscall5 ( int syscallno, 
                     int arg1, int arg2, int arg3, int arg4, int arg5 )
{ 
   int __res;
   __asm__ volatile ("int $0x80"
                     : "=a" (__res)
                     : "0" (syscallno),
                       "b" (arg1),
                       "c" (arg2),
                       "d" (arg3),
                       "S" (arg4),
                       "D" (arg5));
   return __res;
}

static __inline__
int do_syscall_select( int n, 
                       vki_fd_set* readfds, 
                       vki_fd_set* writefds, 
                       vki_fd_set* exceptfds, 
                       struct vki_timeval * timeout )
{
   int res;
   int args[5];
   args[0] = n;
   args[1] = (int)readfds;
   args[2] = (int)writefds;
   args[3] = (int)exceptfds;
   args[4] = (int)timeout;
   res = my_do_syscall1(__NR_select, (int)(&(args[0])) );
   return res;
}


static __inline__
int do_syscall_ipc( unsigned call, 
                    int first, int second, int third, 
                    void *ptr)
{
   return my_do_syscall5(__NR_ipc, call, first, second, third, (int)ptr);
}


/* --------------------------------------------------------------- */

/* Just start up Valgrind if it's not already going.  VG_(startup)()
   detects and ignores second and subsequent calls. */

/* We need this guy -- it's in valgrind.so. */
extern void VG_(startup) ( void );

static __inline__
void ensure_valgrind ( char* caller )
{
   VG_(startup)();
}

static __inline__
int is_kerror ( int res )
{
   if (res >= -4095 && res <= -1)
      return 1;
   else
      return 0;
}

/* --------------------------------------------------------------- */

/* Extract from Valgrind the value of VG_(clo_trace_pthread_level).
   Returns 0 (none) if not running on Valgrind. */
static
int get_pt_trace_level ( void )
{
   int res;
   VALGRIND_MAGIC_SEQUENCE(res, 0 /* default */,
                           VG_USERREQ__GET_PTHREAD_TRACE_LEVEL,
                           0, 0, 0, 0);
   return res;
}

static 
void cat_n_send ( char* pre, char* msg )
{
   char  buf[1000];
   if (get_pt_trace_level() >= 0) {
      snprintf(buf, sizeof(buf), "%s%s", pre, msg );
      buf[sizeof(buf)-1] = '\0';
      VALGRIND_NON_SIMD_CALL2(VG_(message), Vg_UserMsg, buf);
   }
}

static
void my_exit ( int arg )
{
   my_do_syscall1(__NR_exit, arg);
   /*NOTREACHED*/
}

static
void my_assert_fail ( const Char* expr, const Char* file, Int line, const Char* fn )
{
   char buf[1000];
   static Bool entered = False;
   if (entered) 
      my_exit(2);
   entered = True;
   sprintf(buf, "\n%s: %s:%d (%s): Assertion `%s' failed.\n",
                "valgrind", file, line, fn, expr );
   cat_n_send ( "", buf );
   sprintf(buf, "Please report this bug to me at: %s\n\n", 
                 VG_EMAIL_ADDR);
   cat_n_send ( "", buf );
   my_exit(1);
}

#define MY__STRING(__str)  #__str

#define my_assert(expr)                                               \
  ((void) ((expr) ? 0 :						      \
	   (my_assert_fail  (MY__STRING(expr),			      \
			      __FILE__, __LINE__,                     \
                              __PRETTY_FUNCTION__), 0)))

/* --------------------------------------------------------------- */

static __inline__
void __my_pthread_testcancel(void)
{
   int res;
   ensure_valgrind("__my_pthread_testcancel");
   VALGRIND_MAGIC_SEQUENCE(res, (-1) /* default */,
                           VG_USERREQ__TESTCANCEL,
                           0, 0, 0, 0);
   my_assert(res == 0);
}

/* ================================ poll ================================ */

/* This is the master implementation of poll().  It blocks only the
   calling thread.  All roads lead here.
*/

#ifndef HAVE_NFDS_T
typedef unsigned long int nfds_t;
#endif


int VGR_(poll) (struct pollfd *__fds, nfds_t __nfds, int __timeout)
{
   unsigned int        ms_now, ms_end, i;
   int                 res;
   struct vki_timespec nanosleep_interval;

   __my_pthread_testcancel();
   ensure_valgrind("poll");

   /* Detect the current time and simultaneously find out if we are
      running on Valgrind. */
   VALGRIND_MAGIC_SEQUENCE(ms_now, 0xFFFFFFFF /* default */,
                           VG_USERREQ__READ_MILLISECOND_TIMER,
                           0, 0, 0, 0);


   /* CHECK SIZES FOR struct pollfd */
   my_assert(sizeof(struct timeval) == sizeof(struct vki_timeval));

   /* dummy initialisation to keep gcc -Wall happy */
   ms_end = 0;

   /* If a zero timeout specified, this call is harmless.  Also do
      this if not running on Valgrind. */
   if (__timeout == 0 || ms_now == 0xFFFFFFFF) {
      res = my_do_syscall3(__NR_poll, (int)__fds, __nfds, __timeout);
      if (is_kerror(res)) {
         * (__errno_location()) = -res;
         return -1;
      } else {
         return res;
      }
   }

   /* If a timeout was specified, set ms_end to be the end wallclock
      time.  Easy considering that __timeout is in milliseconds. */
   if (__timeout > 0) {
      ms_end = ms_now + (unsigned int)__timeout;
   }

   /* fprintf(stderr, "MY_POLL: before loop\n"); */

   /* Either timeout < 0, meaning wait indefinitely, or timeout > 0,
      in which case t_end holds the end time. */

   my_assert(__timeout != 0);

   while (1) {

      /* Do a return-immediately poll. */

      res = my_do_syscall3(__NR_poll, (int)__fds, __nfds, 0 );
      if (is_kerror(res)) {
         /* Some kind of error.  Set errno and return.  */
         * (__errno_location()) = -res;
         return -1;
      }
      if (res > 0) {
         /* One or more fds is ready.  Return now. */
         return res;
      }

      /* Nothing interesting happened, so we go to sleep for a
         while. */

      /* fprintf(stderr, "MY_POLL: nanosleep\n"); */
      /* nanosleep and go round again */
      nanosleep_interval.tv_sec  = 0;
      nanosleep_interval.tv_nsec = 13 * 1000 * 1000; /* 13 milliseconds */
      /* It's critical here that valgrind's nanosleep implementation
         is nonblocking. */
      res = my_do_syscall2(__NR_nanosleep, 
                           (int)(&nanosleep_interval), (int)NULL);
      if (res == -VKI_EINTR) {
         /* The nanosleep was interrupted by a signal.  So we do the
            same. */
         * (__errno_location()) = EINTR;
         return -1;
      }

      /* Sleeping finished.  If a finite timeout, check to see if it
         has expired yet. */
      if (__timeout > 0) {
         VALGRIND_MAGIC_SEQUENCE(ms_now, 0xFFFFFFFF /* default */,
                                 VG_USERREQ__READ_MILLISECOND_TIMER,
                                 0, 0, 0, 0);
         my_assert(ms_now != 0xFFFFFFFF);
         if (ms_now >= ms_end) {
            /* timeout; nothing interesting happened. */
            for (i = 0; i < __nfds; i++) 
               __fds[i].revents = 0;
            return 0;
         }
      }
   }
}

int poll(struct pollfd *__fds, nfds_t __nfds, int __timeout)
{
   return VGR_(poll)(__fds, __nfds, __timeout);
}

strong_alias(poll, __poll)

/* ================================ msgsnd ================================ */

/* Turn a blocking msgsnd() into a polling non-blocking one, so that
   other threads make progress */
int VGR_(msgsnd)(int msgid, 
                 const void *msgp, 
                 /*size_t*/ unsigned int msgsz, 
                 int msgflg)
{
   struct vki_timespec nanosleep_interval;
   int err;

   ensure_valgrind("msgsnd");

   nanosleep_interval.tv_sec  = 0;
   nanosleep_interval.tv_nsec = 13 * 1000 * 1000; /* 13 milliseconds */

   if (msgflg & IPC_NOWAIT) {
      /* If we aren't blocking anyway, just do it */
      err = do_syscall_ipc(11, msgid, msgsz, msgflg, (void *)msgp);
   } else {
      /* Otherwise poll on the queue to let other things run */
      for(;;) {
	 err = do_syscall_ipc(11, msgid, msgsz, msgflg | IPC_NOWAIT, 
                                  (void *)msgp);

	 if (err != -EAGAIN)
	    break;

	 (void)my_do_syscall2(__NR_nanosleep, 
			      (int)(&nanosleep_interval), (int)NULL);
      }  
   }

   if (is_kerror(err)) {
      *(__errno_location()) = -err;
      return -1;
   }
   return 0;
}

#ifdef GLIBC_2_1
int msgsnd(int msgid,       void *msgp, size_t msgsz, int msgflg)
#else
int msgsnd(int msgid, const void *msgp, size_t msgsz, int msgflg)
#endif
{
   return VGR_(msgsnd)(msgid, msgp, msgsz, msgflg);
}

/* ================================ msgrcv ================================ */

/* Turn a blocking msgrcv() into a polling non-blocking one, so that
   other threads make progress */
int VGR_(msgrcv)( int msqid, 
                  void* msgp,  
                  /*size_t*/ unsigned int msgsz, 
                  long msgtyp, 
                  int msgflg )
{
   struct vki_timespec nanosleep_interval;
   int err;
   struct ipc_kludge tmp;

   ensure_valgrind("msgrcv");

   nanosleep_interval.tv_sec  = 0;
   nanosleep_interval.tv_nsec = 13 * 1000 * 1000; /* 13 milliseconds */

   tmp.msgp = msgp;
   tmp.msgtyp = msgtyp;

   if (msgflg & IPC_NOWAIT) {
      /* If we aren't blocking anyway, just do it */
      err = do_syscall_ipc(12, msqid, msgsz, msgflg, &tmp );
   } else {
      /* Otherwise poll on the queue to let other things run */
      for(;;) {
	 err = do_syscall_ipc(12, msqid, msgsz, msgflg | IPC_NOWAIT, &tmp );

	 if (err != -ENOMSG)
	    break;

	 (void)my_do_syscall2(__NR_nanosleep, 
			      (int)(&nanosleep_interval), (int)NULL);
      }  
   }
   
   if (is_kerror(err)) {
      *(__errno_location()) = -err;
      return -1;
   }

   return err;
}

int msgrcv( int msqid, void  *msgp,  size_t msgsz, long msgtyp, int msgflg )
{
   return VGR_(msgrcv)( msqid, msgp,  msgsz, msgtyp, msgflg );
}

/* ================================ accept ================================ */

extern
int __libc_accept(int s, struct sockaddr *addr, socklen_t *addrlen);

int VGR_(accept)(int s, /*struct sockaddr*/ void *addr, 
                        /*socklen_t*/ void *addrlen)
{
   __my_pthread_testcancel();
   VGR_(wait_for_fd_to_be_readable_or_erring)(s);
   __my_pthread_testcancel();
   return __libc_accept(s, addr, addrlen);
}

int accept(int s, struct sockaddr *addr, socklen_t *addrlen)
{
   return VGR_(accept)(s, addr, addrlen);
}

/* ================================ recv ================================ */

extern
int __libc_recv(int s, void *buf, size_t len, int flags);

int VGR_(recv)(int s, void *buf, size_t len, int flags)
{
   __my_pthread_testcancel();
   VGR_(wait_for_fd_to_be_readable_or_erring)(s);
   __my_pthread_testcancel();
   return __libc_recv(s, buf, len, flags);
}

int recv(int s, void *buf, size_t len, int flags)
{
   return VGR_(recv)(s, buf, len, flags);
}

strong_alias(recv, __recv)

/* ================================ select ================================ */

/* This is a wrapper round select(), which makes it thread-safe,
   meaning that only this thread will block, rather than the entire
   process.  This wrapper in turn depends on nanosleep() not to block
   the entire process, but I think (hope? suspect?) that POSIX
   pthreads guarantees that to be the case.

   Basic idea is: modify the timeout parameter to select so that it
   returns immediately.  Poll like this until select returns non-zero,
   indicating something interesting happened, or until our time is up.
   Space out the polls with nanosleeps of say 11 milliseconds, which
   is required to be nonblocking; this allows other threads to run.  

   Assumes:
   * (checked via my_assert) types fd_set and vki_fd_set are identical.
   * (checked via my_assert) types timeval and vki_timeval are identical.
   * (unchecked) libc error numbers (EINTR etc) are the negation of the
     kernel's error numbers (VKI_EINTR etc).
*/

int VGR_(select) ( int n, 
                   /*fd_set*/ void *rfdsV, 
                   /*fd_set*/ void *wfdsV, 
                   /*fd_set*/ void *xfdsV, 
                   /*struct timeval*/ void *timeoutV )
{
   unsigned int ms_now, ms_end;
   int    res;
   fd_set rfds_copy;
   fd_set wfds_copy;
   fd_set xfds_copy;
   struct vki_timeval  t_now;
   struct vki_timeval  zero_timeout;
   struct vki_timespec nanosleep_interval;

   struct timeval* timeout = (struct timeval*)timeoutV;
   fd_set* rfds = (fd_set*)rfdsV;
   fd_set* wfds = (fd_set*)wfdsV;
   fd_set* xfds = (fd_set*)xfdsV;

   __my_pthread_testcancel();

   /* gcc's complains about ms_end being used uninitialised -- classic
      case it can't understand, where ms_end is both defined and used
      only if timeout != NULL.  Hence ... */
   ms_end = 0;

   /* We assume that the kernel and libc data layouts are identical
      for the following types.  These asserts provide a crude
      check. */
   my_assert(sizeof(struct timeval) == sizeof(struct vki_timeval));

   /* Detect the current time and simultaneously find out if we are
      running on Valgrind. */
   VALGRIND_MAGIC_SEQUENCE(ms_now, 0xFFFFFFFF /* default */,
                           VG_USERREQ__READ_MILLISECOND_TIMER,
                           0, 0, 0, 0);

   /* If a zero timeout specified, this call is harmless.  Also go
      this route if we're not running on Valgrind, for whatever
      reason. */
   if ( (timeout && timeout->tv_sec == 0 && timeout->tv_usec == 0)
        || (ms_now == 0xFFFFFFFF) ) {
      res = do_syscall_select( n, (vki_fd_set*)rfds, 
                                   (vki_fd_set*)wfds, 
                                   (vki_fd_set*)xfds, 
                                   (struct vki_timeval*)timeout);
      if (is_kerror(res)) {
         * (__errno_location()) = -res;
         return -1;
      } else {
         return res;
      }
   }

   /* If a timeout was specified, set ms_end to be the end millisecond
      counter [wallclock] time. */
   if (timeout) {
      res = my_do_syscall2(__NR_gettimeofday, (int)&t_now, (int)NULL);
      my_assert(res == 0);
      ms_end = ms_now;
      ms_end += (timeout->tv_usec / 1000);
      ms_end += (timeout->tv_sec * 1000);
      /* Stay sane ... */
      if (ms_end < ms_now)
         ms_end = ms_now;
   }

   /* fprintf(stderr, "MY_SELECT: before loop\n"); */

   /* Either timeout == NULL, meaning wait indefinitely, or timeout !=
      NULL, in which case ms_end holds the end time. */

   while (1) {

      /* First, do a return-immediately select(). */

      /* These could be trashed each time round the loop, so restore
         them each time. */
      if (rfds) rfds_copy = *rfds;
      if (wfds) wfds_copy = *wfds;
      if (xfds) xfds_copy = *xfds;

      zero_timeout.tv_sec = zero_timeout.tv_usec = 0;

      res = do_syscall_select( n, 
                               rfds ? (vki_fd_set*)(&rfds_copy) : NULL,
                               wfds ? (vki_fd_set*)(&wfds_copy) : NULL,
                               xfds ? (vki_fd_set*)(&xfds_copy) : NULL,
                               & zero_timeout );
      if (is_kerror(res)) {
         /* Some kind of error (including EINTR).  Set errno and
            return.  The sets are unspecified in this case. */
         * (__errno_location()) = -res;
         return -1;
      }
      if (res > 0) {
         /* one or more fds is ready.  Copy out resulting sets and
            return. */
         if (rfds) *rfds = rfds_copy;
         if (wfds) *wfds = wfds_copy;
         if (xfds) *xfds = xfds_copy;
         return res;
      }

      /* Nothing interesting happened, so we go to sleep for a
         while. */

      /* fprintf(stderr, "MY_SELECT: nanosleep\n"); */
      /* nanosleep and go round again */
      nanosleep_interval.tv_sec  = 0;
      nanosleep_interval.tv_nsec = 11 * 1000 * 1000; /* 11 milliseconds */
      /* It's critical here that valgrind's nanosleep implementation
         is nonblocking. */
      res = my_do_syscall2(__NR_nanosleep, 
                           (int)(&nanosleep_interval), (int)NULL);
      if (res == -VKI_EINTR) {
         /* The nanosleep was interrupted by a signal.  So we do the
            same. */
         * (__errno_location()) = EINTR;
         return -1;
      }

      /* Sleeping finished.  If a finite timeout, check to see if it
         has expired yet. */
      if (timeout) {
         VALGRIND_MAGIC_SEQUENCE(ms_now, 0xFFFFFFFF /* default */,
                                 VG_USERREQ__READ_MILLISECOND_TIMER,
                                 0, 0, 0, 0);
         my_assert(ms_now != 0xFFFFFFFF);
         if (ms_now >= ms_end) {
            /* timeout; nothing interesting happened. */
            if (rfds) FD_ZERO(rfds);
            if (wfds) FD_ZERO(wfds);
            if (xfds) FD_ZERO(xfds);
            return 0;
         }
      }

   }
}

int select ( int n, 
             fd_set *rfds, 
             fd_set *wfds, 
             fd_set *xfds, 
             struct timeval *timeout )
{
   return VGR_(select)(n, rfds, wfds, xfds, timeout);
}

strong_alias(select, __select)

/* ================================ readv ================================ */

int VGR_(readv)(int fd, const /*struct iovec*/ void *iovV, int count)
{
   int res;
   const struct iovec* iov = (const struct iovec*)iovV;

   __my_pthread_testcancel();
   VGR_(wait_for_fd_to_be_readable_or_erring)(fd);
   __my_pthread_testcancel();
   res = my_do_syscall3(__NR_readv, fd, (unsigned)iov, count);

   if (is_kerror(res)) {
      *(__errno_location()) = -res;
      return -1;
   }
   return res;
}

int readv (int fd, const struct iovec *iov, int count)
{
   return VGR_(readv)(fd, iov, count);
}

strong_alias(readv, __readv)

/* ================================ writev ================================ */

int VGR_(writev)(int fd, const /*struct iovec*/ void *iovV, int count)
{
   int res;
   struct iovec* iov = (struct iovec*)iovV;

   __my_pthread_testcancel();
   VGR_(wait_for_fd_to_be_writable_or_erring)(fd);
   __my_pthread_testcancel();
   res = my_do_syscall3(__NR_writev, fd, (unsigned)iov, count);

   if (is_kerror(res)) {
      *(__errno_location()) = -res;
      return -1;
   }
   return res;
}

int writev (int fd, const struct iovec *iov, int count)
{
   return VGR_(writev)(fd, iov, count);
}

strong_alias(writev, __writev)

/* ================================ sigsuspend ============================ */

/* ---------------------------------------------------------------------
   Horrible hack to make sigsuspend() sort-of work OK.  Same trick as
   for pause() in vg_libpthread.so.
   ------------------------------------------------------------------ */

/* Horrible because

   -- uses VG_(ksigprocmask), VG_(nanosleep) and vg_assert, which are 
      valgrind-native (not intended for client use).

   -- This is here so single-threaded progs (not linking libpthread.so)
      can see it.  But pause() should also be here.  ???
*/

/* Either libc supplies this (weak) or our libpthread.so supplies it
   (strong) in a threaded setting. 
*/
extern int* __errno_location ( void );


int sigsuspend ( /* const sigset_t * */ void* mask)
{
   unsigned int n_orig, n_now;
   struct vki_timespec nanosleep_interval;

   VALGRIND_MAGIC_SEQUENCE(n_orig, 0xFFFFFFFF /* default */,
                           VG_USERREQ__GET_N_SIGS_RETURNED, 
                           0, 0, 0, 0);
   vg_assert(n_orig != 0xFFFFFFFF);

   VG_(ksigprocmask)(VKI_SIG_SETMASK, mask, NULL);

   while (1) {
      VALGRIND_MAGIC_SEQUENCE(n_now, 0xFFFFFFFF /* default */,
                              VG_USERREQ__GET_N_SIGS_RETURNED, 
                              0, 0, 0, 0);
      vg_assert(n_now != 0xFFFFFFFF);
      vg_assert(n_now >= n_orig);
      if (n_now != n_orig) break;

      nanosleep_interval.tv_sec  = 0;
      nanosleep_interval.tv_nsec = 53 * 1000 * 1000; /* 53 milliseconds */
      /* It's critical here that valgrind's nanosleep implementation
         is nonblocking. */
      VG_(nanosleep)( &nanosleep_interval, NULL);
   }

   /* Maybe this is OK both in single and multithreaded setting. */
   * (__errno_location()) = -VKI_EINTR; /* == EINTR; */ 
   return -1;
}


/* ================================ waitpid ============================ */

#undef WNOHANG
#define WNOHANG         0x00000001

extern pid_t __libc_waitpid(pid_t pid, int *status, int options);

pid_t waitpid(pid_t pid, int *status, int options)
{
   pid_t res;
   struct vki_timespec nanosleep_interval;

   if (options & WNOHANG)
      return __libc_waitpid(pid,status,options);

   options |= WNOHANG;
   while (1) {
      res = __libc_waitpid(pid,status,options);
      if (res != 0)
         return res;

      nanosleep_interval.tv_sec  = 0;
      nanosleep_interval.tv_nsec = 54 * 1000 * 1000; /* 54 milliseconds */
      /* It's critical here that valgrind's nanosleep implementation
         is nonblocking. */
      VG_(nanosleep)( &nanosleep_interval, NULL);
   }
}

#undef WNOHANG

/* ---------------------------------------------------------------------
   Hook for running __libc_freeres once the program exits.
   ------------------------------------------------------------------ */

void VG_(__libc_freeres_wrapper)( void )
{
   int res;
   extern void __libc_freeres(void);
   __libc_freeres();
   VALGRIND_MAGIC_SEQUENCE(res, 0 /* default */,
                           VG_USERREQ__LIBC_FREERES_DONE, 0, 0, 0, 0);
   /*NOTREACHED*/
   vg_assert(12345+54321 == 999999);
}

/* ---------------------------------------------------------------------
   Useful for skins that want to replace certain functions
   ------------------------------------------------------------------ */

Bool VG_(is_running_on_simd_CPU)(void)
{
   return VG_(running_on_simd_CPU);
}


/* ---------------------------------------------------------------------
   Helpers for safely (nonblockingly) detecting when a file descriptor
   is safe to use.
   ------------------------------------------------------------------ */

/* Helper function used to make accept() non-blocking.  Idea is to use
   the above nonblocking poll() to make this thread ONLY wait for the
   specified fd to become ready, and then return. */

/* Sigh -- a hack.  We're not supposed to include this file directly;
   should do it via /usr/include/fcntl.h, but that introduces a
   varargs prototype for fcntl itself, which we can't mimic. */
#define _FCNTL_H
#include <bits/fcntl.h>

extern int __libc_fcntl(int fd, int cmd, long arg);

void VGR_(wait_for_fd_to_be_readable_or_erring) ( int fd )
{
   struct pollfd pfd;
   int           res;

   /* fprintf(stderr, "wait_for_fd_to_be_readable_or_erring %d\n", fd); */

   /* First check to see if the fd is nonblocking, and/or invalid.  In
      either case return immediately. */
   res = __libc_fcntl(fd, F_GETFL, 0);
   if (res == -1) return; /* fd is invalid somehow */
   if (res & O_NONBLOCK) return; /* fd is nonblocking */

   /* Ok, we'd better wait with poll. */
   pfd.fd = fd;
   pfd.events = POLLIN | POLLPRI | POLLERR | POLLHUP | POLLNVAL;
   /* ... but not POLLOUT, you may notice. */
   pfd.revents = 0;
   (void)poll(&pfd, 1, -1 /* forever */);
}

void VGR_(wait_for_fd_to_be_writable_or_erring) ( int fd )
{
   struct pollfd pfd;
   int           res;

   /* fprintf(stderr, "wait_for_fd_to_be_readable_or_erring %d\n", fd); */

   /* First check to see if the fd is nonblocking, and/or invalid.  In
      either case return immediately. */
   res = __libc_fcntl(fd, F_GETFL, 0);
   if (res == -1) return; /* fd is invalid somehow */
   if (res & O_NONBLOCK) return; /* fd is nonblocking */

   /* Ok, we'd better wait with poll. */
   pfd.fd = fd;
   pfd.events = POLLOUT | POLLERR | POLLHUP | POLLNVAL;
   pfd.revents = 0;
   (void)poll(&pfd, 1, -1 /* forever */);
}

/*--------------------------------------------------------------------*/
/*--- end                                           vg_intercept.c ---*/
/*--------------------------------------------------------------------*/