nanosleep - pause execution for a specified time


     #include <time.h>

     int nanosleep(const struct timespec  *req,  struct  timespec


     nanosleep delays the execution of the program for  at  least
     the time specified in *req.  The function can return earlier
     if a signal has been delivered to the process. In this case,
     it returns -1, sets errno to EINTR, and writes the remaining
     time into the structure pointed to  by  rem  unless  rem  is
     NULL.   The value of *rem can then be used to call nanosleep
     again and complete the specified pause.

     The structure timespec is used to specify intervals of  time
     with  nanosecond  precision. It is specified in <time.h> and
     has the form

          struct timespec
                  time_t  tv_sec;         /* seconds */
                  long    tv_nsec;        /* nanoseconds */

     The value of the nanoseconds field must be in the range 0 to
     999 999 999.

     Compared to sleep(3) and usleep(3), nanosleep has the advan-
     tage  of  not  affecting  any signals, it is standardized by
     POSIX, it provides higher timing resolution, and  it  allows
     to  continue  a  sleep that has been interrupted by a signal
     more easily.


     In case of an error or exception, the nanosleep system  call
     returns -1 instead of 0 and sets errno to one of the follow-
     ing values:

     EINTR   The pause has been interrupted by a non-blocked sig-
             nal that was delivered to the process. The remaining
             sleep time has been written into *rem  so  that  the
             process can easily call nanosleep again and continue
             with the pause.

     EINVAL  The value in the tv_nsec field was not in the  range
             0 to 999 999 999 or tv_sec was negative.


     The current implementation of nanosleep is based on the nor-
     mal kernel timer mechanism, which has a resolution of 1/HZ s
     (i.e, 10 ms on Linux/i386 and 1 ms on Linux/Alpha).   There-
     fore,  nanosleep  pauses  always  for at least the specified
     time, however it can take up to 10 ms longer than  specified
     until  the process becomes runnable again. For the same rea-
     son, the value returned in case of  a  delivered  signal  in
     *rem  is  usually  rounded  to  the  next larger multiple of
     1/HZ s.

     As some applications require much more precise pauses (e.g.,
     in  order to control some time-critical hardware), nanosleep
     is also capable of short high-precision pauses. If the  pro-
     cess  is  scheduled under a real-time policy like SCHED_FIFO
     or SCHED_RR, then pauses of up to 2 ms will be performed  as
     busy waits with microsecond precision.


     POSIX.1b (formerly POSIX.4).


     sleep(3),     usleep(3),     sched_setscheduler(2),      and