1NANOSLEEP(2)               Linux Programmer's Manual              NANOSLEEP(2)
2
3
4

NAME

6       nanosleep - high-resolution sleep
7

SYNOPSIS

9       #include <time.h>
10
11       int nanosleep(const struct timespec *req, struct timespec *rem);
12
13   Feature Test Macro Requirements for glibc (see feature_test_macros(7)):
14
15       nanosleep():
16           _POSIX_C_SOURCE >= 199309L
17

DESCRIPTION

19       nanosleep()  suspends  the execution of the calling thread until either
20       at least the time specified in *req has elapsed, or the delivery  of  a
21       signal  that triggers the invocation of a handler in the calling thread
22       or that terminates the process.
23
24       If the call is interrupted by a signal handler, nanosleep() returns -1,
25       sets  errno  to EINTR, and writes the remaining time into the structure
26       pointed to by rem unless rem is NULL.  The value of *rem  can  then  be
27       used  to  call  nanosleep() again and complete the specified pause (but
28       see NOTES).
29
30       The structure timespec is  used  to  specify  intervals  of  time  with
31       nanosecond precision.  It is defined as follows:
32
33           struct timespec {
34               time_t tv_sec;        /* seconds */
35               long   tv_nsec;       /* nanoseconds */
36           };
37
38       The value of the nanoseconds field must be in the range 0 to 999999999.
39
40       Compared  to  sleep(3) and usleep(3), nanosleep() has the following ad‐
41       vantages: it provides a higher resolution for specifying the sleep  in‐
42       terval;  POSIX.1  explicitly  specifies  that it does not interact with
43       signals; and it makes the task of resuming a sleep that has been inter‐
44       rupted by a signal handler easier.
45

RETURN VALUE

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

ERRORS

52       EFAULT Problem with copying information from user space.
53
54       EINTR  The pause has been interrupted by a signal that was delivered to
55              the thread (see signal(7)).  The remaining sleep time  has  been
56              written into *rem so that the thread can easily call nanosleep()
57              again and continue with the pause.
58
59       EINVAL The value in the tv_nsec  field  was  not  in  the  range  0  to
60              999999999 or tv_sec was negative.
61

CONFORMING TO

63       POSIX.1-2001, POSIX.1-2008.
64

NOTES

66       If the interval specified in req is not an exact multiple of the granu‐
67       larity underlying clock  (see  time(7)),  then  the  interval  will  be
68       rounded  up  to  the  next multiple.  Furthermore, after the sleep com‐
69       pletes, there may still be a delay before the CPU becomes free to  once
70       again execute the calling thread.
71
72       The  fact  that nanosleep() sleeps for a relative interval can be prob‐
73       lematic if the call is repeatedly restarted after being interrupted  by
74       signals,  since  the time between the interruptions and restarts of the
75       call will lead to drift in the time when the sleep  finally  completes.
76       This  problem  can be avoided by using clock_nanosleep(2) with an abso‐
77       lute time value.
78
79       POSIX.1 specifies that nanosleep()  should  measure  time  against  the
80       CLOCK_REALTIME  clock.   However,  Linux  measures  the  time using the
81       CLOCK_MONOTONIC clock.   This  probably  does  not  matter,  since  the
82       POSIX.1  specification  for  clock_settime(2)  says  that discontinuous
83       changes in CLOCK_REALTIME should not affect nanosleep():
84
85              Setting the value of the  CLOCK_REALTIME  clock  via  clock_set‐
86              time(2) shall have no effect on threads that are blocked waiting
87              for a relative time service based upon this clock, including the
88              nanosleep()  function;  ...   Consequently,  these time services
89              shall expire when the requested relative interval elapses, inde‐
90              pendently of the new or old value of the clock.
91
92   Old behavior
93       In  order  to  support  applications requiring much more precise pauses
94       (e.g., in order to control some  time-critical  hardware),  nanosleep()
95       would  handle  pauses  of up to 2 milliseconds by busy waiting with mi‐
96       crosecond precision when called from a thread scheduled under  a  real-
97       time  policy  like  SCHED_FIFO or SCHED_RR.  This special extension was
98       removed in kernel 2.5.39, and is thus not available in Linux 2.6.0  and
99       later kernels.
100

BUGS

102       If a program that catches signals and uses nanosleep() receives signals
103       at a very high rate, then scheduling delays and rounding errors in  the
104       kernel's  calculation  of  the  sleep  interval and the returned remain
105       value mean that the remain value may steadily  increase  on  successive
106       restarts  of  the  nanosleep()  call.   To  avoid  such  problems,  use
107       clock_nanosleep(2) with the TIMER_ABSTIME flag to sleep to an  absolute
108       deadline.
109
110       In  Linux  2.4,  if nanosleep() is stopped by a signal (e.g., SIGTSTP),
111       then the call fails with the error EINTR after the thread is resumed by
112       a  SIGCONT  signal.  If the system call is subsequently restarted, then
113       the time that the thread spent in the  stopped  state  is  not  counted
114       against  the  sleep interval.  This problem is fixed in Linux 2.6.0 and
115       later kernels.
116

SEE ALSO

118       clock_nanosleep(2),     restart_syscall(2),      sched_setscheduler(2),
119       timer_create(2), sleep(3), usleep(3), time(7)
120

COLOPHON

122       This  page  is  part of release 5.13 of the Linux man-pages project.  A
123       description of the project, information about reporting bugs,  and  the
124       latest     version     of     this    page,    can    be    found    at
125       https://www.kernel.org/doc/man-pages/.
126
127
128
129Linux                             2021-03-22                      NANOSLEEP(2)
Impressum