Bash infinite sleep infinite blocking

Question

I use startx to start X which will evaluate my  xinitrc  In my  xinitrc I start my window manager using  usr bin mywm  Now  if I kill my WM  in order to f e  test some other WM   X will terminate too because the  xinitrc script reached EOF  So I added this at the end of my  xinitrc  while true  do sleep 10000  done  This way X won t terminate if I kill my WM  Now my question  how can I do an infinite sleep instead of looping sleep  Is there a command which will kinda like freeze the script

User · Answer

sleep infinity looks most elegant  but sometimes it doesn t work for some reason  In that case  you can try other blocking commands such as cat  read  tail -f  dev null  grep a etc

User · Answer

tail does not block  As always   For everything there is an answer which is short  easy to understand  easy to follow and completely wrong   Here tail -f  dev null falls into this category     If you look at it with strace tail -f  dev null you will notice  that this solution is far from blocking   It s probably even worse than the sleep solution in the question  as it uses  under Linux  precious resources like the inotify system   Also other processes which write to  dev null make tail loop    On my Ubuntu64 16 10 this adds several 10 syscalls per second on an already busy system    The question was for a blocking command  Unfortunately  there is no such thing     Read  I do not know any way to archive this with the shell directly   Everything  even sleep infinity  can be interrupted by some signal   So if you want to be really sure it does not exceptionally return  it must run in a loop  like you already did for your sleep   Please note  that  on Linux   bin sleep apparently is capped at 24 days  have a look at strace sleep infinity   hence the best you can do probably is   while    do sleep 2073600  done    Note that I believe sleep loops internally for higher values than 24 days  but this means   It is not blocking  it is very slowly looping   So why not move this loop to the outside       but you can come quite near with an unnamed fifo  You can create something which really blocks as long as there are no signals send to the process   Following uses bash 4  2 PIDs and 1 fifo   bash -c  coproc   exec  gt  amp -  read     eval exec    COPROC 0   lt  amp -   wait    You can check that this really blocks with strace if you like   strace -ff bash -c    see above      How this was constructed  read blocks if there is no input data  see some other answers    However  the tty  aka  stdin  usually is not a good source  as it is closed when the user logs out   Also it might steal some input from the tty   Not nice   To make read block  we need to wait for something like a fifo which will never return anything   In bash 4 there is a command which can exactly provide us with such a fifo  coproc   If we also wait the blocking read  which is our coproc   we are done   Sadly this needs to keep open two PIDs and a fifo   Variant with a named fifo  If you do not bother using a named fifo  you can do this as follows   mkfifo   HOME  pause fifo  2 gt  dev null  read  lt   HOME  pause fifo    Not using a loop on the read is a bit sloppy  but you can reuse this fifo as often as you like and make the reads terminat using touch   HOME  pause fifo   if there are more than a single read waiting  all are terminated at once    Or use the Linux pause   syscall  For the infinite blocking there is a Linux kernel call  called pause    which does what we want   Wait forever  until a signal arrives    However there is no userspace program for this  yet    C  Create such a program is easy   Here is a snippet to create a very small Linux program called pause which pauses indefinitely  needs diet  gcc etc     printf   include  lt unistd h gt  nint main   for    pause       gt  pause c  diet -Os cc pause c -o pause  strip -s pause  ls -al pause   python  If you do not want to compile something yourself  but you have python installed  you can use this under Linux   python -c  while 1  import ctypes  ctypes CDLL None  pause       Note  Use exec python -c     to replace the current shell  this frees one PID   The solution can be improved with some IO redirection as well  freeing unused FDs   This is up to you    How this works  I think   ctypes CDLL None  loads the standard C library and runs the pause   function in it within some additional loop   Less efficient than the C version  but works   My recommendation for you   Stay at the looping sleep   It s easy to understand  very portable  and blocks most of the time

User · Answer

Instead of killing the window manager  try running the new one with --replace or -replace if available

User · Answer

sleep infinity does exactly what it suggests and works without cat abuse

User · Answer

What about sending a SIGSTOP to itself   This should pause the process until SIGCONT is received  Which is in your case  never   kill -STOP         grace time for signal delivery sleep 60

User · Answer

This approach will not consume any resources for keeping process alive   while    do sleep 1  done  amp  kill -STOP     amp  amp  wait     Breakdown   while    do sleep 1  done  amp  Creates a dummy process in background kill -STOP    Stops the background process  wait    Wait for the background process  this will be blocking forever  cause background process was stopped before

User · Answer

while    do read  done   no waiting for child sleeping process

User · Answer

I recently had a need to do this  I came up with the following function that will allow bash to sleep forever without calling any external program   snore         local IFS        -n     snore fd -           exec   snore fd  lt  gt   lt        2 gt  dev null                    workaround for MacOS and similar systems         local fifo         fifo   mktemp -u          mkfifo -m 700   fifo          exec   snore fd  lt  gt   fifo          rm   fifo            read   1  -t   1   -u   snore fd          NOTE  I previously posted a version of this that would open and close the file descriptor each time  but I found that on some systems doing this hundreds of times a second would eventually lock up  Thus the new solution keeps the file descriptor between calls to the function  Bash will clean it up on exit anyway   This can be called just like  bin sleep  and it will sleep for the requested time  Called without parameters  it will hang forever   snore 0 1    sleeps for 0 1 seconds snore 10     sleeps for 10 seconds snore        sleeps forever   There s a writeup with excessive details on my blog here

User · Answer

TL DR  sleep infinity actually sleeps the maximum time allowed  which is finite  Wondering why this is not documented anywhere  I bothered to read the sources from GNU coreutils and I found it executes roughly what follows   Use strtod from C stdlib on the first argument to convert  infinity  to a double precision value  So  assuming IEEE 754 double precision the 64-bit positive infinity value is stored in the seconds variable  Invoke xnanosleep seconds   found in gnulib   this in turn invokes dtotimespec seconds   also in gnulib   to convert from double to struct timespec  struct timespec is just a pair of numbers  integer part  in seconds  and fractional part  in nanoseconds   Na  vely converting positive infinity to integer would result in undefined behaviour  see   6 3 1 4 from C standard   so instead it truncates to TYPE MAXIMUM time t   The actual value of TYPE MAXIMUM time t  is not set in the standard  even sizeof time t  isn t   so  for the sake of example let s pick x86-64 from a recent Linux kernel   This is TIME T MAX in the Linux kernel  which is defined  time h  as   time t   1UL  lt  lt    sizeof time t   lt  lt  3  - 1   - 1   Note that time t is   kernel time t and time t is long  the LP64 data model is used  so sizeof long  is 8  64 bits   Which results in  TIME T MAX   9223372036854775807  That is  sleep infinite results in an actual sleep time of 9223372036854775807 seconds  10 11 years   And for 32-bit linux systems  sizeof long  is 4  32 bits    2147483647 seconds  68 years  see also year 2038 problem    Edit  apparently the nanoseconds function called is not directly the syscall  but an OS-dependent wrapper  also defined in gnulib   There s an extra step as a result  for some systems where HAVE BUG BIG NANOSLEEP is true the sleep is truncated to 24 days and then called in a loop  This is the case for some  or all   Linux distros  Note that this wrapper may be not used if a configure-time test succeeds  source   In particular  that would be 24   24   60   60   2073600 seconds  plus 999999999 nanoseconds   but this is called in a loop in order to respect the specified total sleep time  Therefore the previous conclusions remain valid   In conclusion  the resulting sleep time is not infinite but high enough for all practical purposes  even if the resulting actual time lapse is not portable  that depends on the OS and architecture  To answer the original question  this is obviously good enough but if for some reason  a very resource-constrained system  you really want to avoid an useless extra countdown timer  I guess the most correct alternative is to use the cat method described in other answers  Edit  recent GNU coreutils versions will try to use the pause syscall  if available  instead of looping  The previous argument is no longer valid when targeting these newer versions in Linux  and possibly BSD    Portability This is an important valid concern   sleep infinity is a GNU coreutils extension not contemplated in POSIX  GNU s implementation also supports a  quot fancy quot  syntax for time durations  like sleep 1h 5 2s while POSIX only allows a positive integer  e g  sleep 0 5 is not allowed   Some compatible implementations  GNU coreutils  FreeBSD  at least from version 8 2    Busybox  requires to be compiled with options FANCY SLEEP and FLOAT DURATION   The strtod behaviour is C and POSIX compatible  i e  strtod  quot infinity quot   0  is always valid in C99-conformant implementations  see   7 20 1 3

User · Answer

Let me explain why sleep infinity works though it is not documented  jp48 s answer is also useful   The most important thing  By specifying inf or infinity  both case-insensitive   you can sleep for the longest time your implementation permits  i e  the smaller value of HUGE VAL and TYPE MAXIMUM time t     Now let s dig into the details  The source code of sleep command can be read from coreutils src sleep c  Essentially  the function does this   double s    seconds xstrtod  argv i    amp p   amp s  cl strtod      p  is not essential  just used for error check   xnanosleep  s     Understanding xstrtod  argv i    amp p   amp s  cl strtod   xstrtod    According to gnulib lib xstrtod c  the call of xstrtod   converts string argv i  to a floating point value and stores it to  s  using a converting function cl strtod     cl strtod    As can be seen from coreutils lib cl-strtod c  cl strtod   converts a string to a floating point value  using strtod     strtod    According to man 3 strtod  strtod   converts a string to a value of type double  The manpage says     The  expected  form  of the  initial portion of the  string is     or  iii  an infinity  or       and an infinity is defined as      An infinity is either  INF  or  INFINITY   disregarding case    Although the document tells     If the correct value would cause overflow  plus or minus HUGE VAL  HUGE VALF  HUGE VALL  is returned     it is not clear how an infinity is treated  So let s see the source code gnulib lib strtod c  What we want to read is  else if  c tolower   s      i            amp  amp  c tolower  s 1       n            amp  amp  c tolower  s 2       f           s    3      if  c tolower   s      i           amp  amp  c tolower  s 1       n           amp  amp  c tolower  s 2       i           amp  amp  c tolower  s 3       t           amp  amp  c tolower  s 4       y         s    5      num   HUGE VAL      errno   saved errno        Thus  INF and INFINITY  both case-insensitive  are regarded as HUGE VAL   HUGE VAL family  Let s use N1570 as the C standard  HUGE VAL  HUGE VALF and HUGE VALL macros are defined in   7 12-3     The macro    nbsp  nbsp  nbsp  nbsp HUGE VAL   expands to a positive double constant expression  not necessarily representable as a float  The macros    nbsp  nbsp  nbsp  nbsp HUGE VALF    nbsp  nbsp  nbsp  nbsp HUGE VALL   are respectively float and long double analogs of HUGE VAL       HUGE VAL  HUGE VALF  and HUGE VALL can be positive infinities in an implementation that supports infinities    and in   7 12 1-5     If a floating result overflows and default rounding is in effect  then the function returns the value of the macro HUGE VAL  HUGE VALF  or HUGE VALL according to the return type   Understanding xnanosleep  s   Now we understand all essence of xstrtod    From the explanations above  it is crystal-clear that xnanosleep s  we ve seen first actually means xnanosleep HUGE VALL    xnanosleep    According to the source code gnulib lib xnanosleep c  xnanosleep s  essentially does this   struct timespec ts sleep   dtotimespec  s   nanosleep   amp ts sleep  NULL     dtotimespec    This function converts an argument of type double to an object of type struct timespec  Since it is very simple  let me cite the source code gnulib lib dtotimespec c  All of the comments are added by me   struct timespec dtotimespec  double sec      if     TYPE MINIMUM  time t   lt  sec     underflow case     return make timespec  TYPE MINIMUM  time t   0     else if     sec  lt  1 0   TYPE MAXIMUM  time t      overflow case     return make timespec  TYPE MAXIMUM  time t   TIMESPEC HZ - 1     else   normal case  looks complex but does nothing technical              time t s   sec        double frac   TIMESPEC HZ    sec - s         long ns   frac        ns    ns  lt  frac        s    ns   TIMESPEC HZ        ns    TIMESPEC HZ         if  ns  lt  0                      s--            ns    TIMESPEC HZ                   return make timespec  s  ns             Since time t is defined as an integral type  see   7 27 1-3   it is natural we assume the maximum value of type time t is smaller than HUGE VAL  of type double   which means we enter the overflow case   Actually this assumption is not needed since  in all cases  the procedure is essentially the same    make timespec    The last wall we have to climb up is make timespec    Very fortunately  it is so simple that citing the source code gnulib lib timespec h is enough    GL TIMESPEC INLINE struct timespec make timespec  time t s  long int ns      struct timespec r    r tv sec   s    r tv nsec   ns    return r

User · Answer

Maybe this seems ugly  but why not just run cat and let it wait for input forever

[linux] Bash: infinite sleep (infinite blocking)

Examples related to linux

Examples related to bash

Examples related to sleep

Examples related to infinite