Provided by: manpages-dev_2.77-1_all bug


       nanosleep - pause execution for a specified time


       #include <time.h>

       int nanosleep(const struct timespec *req, struct timespec *rem);

   Feature Test Macro Requirements for glibc (see feature_test_macros(7)):

       nanosleep(): _POSIX_C_SOURCE >= 199309L


       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 999999999.

       Compared to sleep(3) and usleep(3), nanosleep() has  the  advantage  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.


       On  successfully  sleeping  for  the  requested  interval,  nanosleep()
       returns 0.   If  the  call  is  interrupted  by  a  signal  handler  or
       encounters an error, then it returns -1, with errno set to indicate the


       EFAULT Problem with copying information from user space.

       EINTR  The pause has been interrupted by a non-blocked signal 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
              999999999 or tv_sec was negative.




       The current implementation of nanosleep() is based on the normal kernel
       timer  mechanism,  which  has  a  resolution  of  1/HZ s (see time(7)).
       Therefore, 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 reason,  the  value  returned  in
       case  of  a  delivered  signal  in  *rem is usually rounded to the next
       larger multiple of 1/HZ s.

   Old behavior
       In order to support applications requiring  much  more  precise  pauses
       (e.g.,  in  order  to control some time-critical hardware), nanosleep()
       would handle pauses of up to 2 ms  by  busy  waiting  with  microsecond
       precision when called from a process scheduled under a real-time policy
       like SCHED_FIFO or SCHED_RR.  This special  extension  was  removed  in
       kernel  2.5.39,  hence is still present in current 2.4 kernels, but not
       in 2.6 kernels.

       In Linux 2.4, if nanosleep() is stopped by a  signal  (e.g.,  SIGTSTP),
       then  the  call fails with the error EINTR after the process is resumed
       by a SIGCONT signal.  If the system  call  is  subsequently  restarted,
       then  the  time  that  the  process  spent  in the stopped state is not
       counted against the sleep interval.


       sched_setscheduler(2), sleep(3), timer_create(3), usleep(3), time(7)


       This page is part of release 2.77 of the Linux  man-pages  project.   A
       description  of  the project, and information about reporting bugs, can
       be found at