Yo uso startxpara iniciar X que evaluará mi .xinitrc. En mi .xinitrcinicio mi administrador de ventanas usando /usr/bin/mywm. Ahora, si elimino mi WM (para probar alguna otra WM), X terminará también porque el .xinitrcscript alcanzó EOF. Así que agregué esto al final de mi .xinitrc:

while true; do sleep 10000; done

De esta manera, X no terminará si elimino mi WM. Ahora mi pregunta: ¿cómo puedo hacer un sueño infinito en lugar de un sueño en bucle? ¿Hay algún comando que parezca congelar el script?

Atentamente

sleep infinity hace exactamente lo que sugiere y funciona sin abuso de gatos.

tail no bloquea

Como siempre: para todo hay una respuesta que es corta, fácil de entender, fácil de seguir y completamente errónea. Aquí tail -f /dev/nullentra en esta categoría;)

Si lo mira con strace tail -f /dev/nullatención, notará que esta solución está lejos de bloquearse. Probablemente sea incluso peor que la sleepsolución en la pregunta, ya que utiliza (bajo Linux) recursos preciosos como el inotifysistema. También otros procesos que escriben para /dev/nullhacer un tailbucle. (En mi Ubuntu64 16.10 esto agrega varias 10 llamadas al sistema por segundo en un sistema que ya está ocupado).

La pregunta era para un comando de bloqueo

Lamentablemente, no existe tal cosa ...

Leer: No conozco ninguna forma de archivar esto con el shell directamente.

Todo (incluso sleep infinity) puede ser interrumpido por alguna señal. Entonces, si desea estar realmente seguro de que no regresa excepcionalmente, debe ejecutarse en un bucle, como ya lo hizo para su sleep. Tenga en cuenta que (en Linux) /bin/sleepaparentemente tiene un límite de 24 días (eche un vistazo strace sleep infinity), por lo tanto, lo mejor que puede hacer es:

while :; do sleep 2073600; done

(Tenga en cuenta que creo que los sleepbucles internos para valores superiores a 24 días, pero esto significa: no está bloqueando, está haciendo un bucle muy lento. Entonces, ¿por qué no mover este bucle al exterior?)

.. pero puedes acercarte bastante con un nombre sin nombre fifo

Puede crear algo que realmente bloquee siempre que no se envíen señales al proceso. Siguientes usos bash 4, 2 PID y 1 fifo:

bash -c 'coproc { exec >&-; read; }; eval exec "${COPROC[0]}<&-"; wait'

Puedes comprobar que esto realmente bloquea stracesi quieres:

strace -ff bash -c '..see above..'

Cómo se construyó esto

readbloquea si no hay datos de entrada (ver algunas otras respuestas). Sin embargo, el tty(alias stdin) generalmente no es una buena fuente, ya que se cierra cuando el usuario cierra sesión. También podría robar alguna información del tty. No está bien.

Para hacer un readbloqueo, debemos esperar algo como algo fifoque nunca devolverá nada. En bash 4existe un comando que exactamente nos puede dar un ejemplo fifo: coproc. Si también esperamos el bloqueo read(que es nuestro coproc), hemos terminado. Lamentablemente, esto debe mantener abiertos dos PID y a fifo.

Variante con un nombre fifo

Si no te molestas en usar un nombre fifo, puedes hacerlo de la siguiente manera:

mkfifo "$HOME/.pause.fifo" 2>/dev/null; read <"$HOME/.pause.fifo"

No usar un bucle en la lectura es un poco descuidado, pero puede reutilizarlo tantas fifoveces como lo desee y hacer que el reads termine usando touch "$HOME/.pause.fifo"(si hay más de una sola lectura en espera, todas se terminan a la vez).

O use el pause()syscall de Linux

Para el bloqueo infinito hay una llamada al kernel de Linux, llamada pause(), que hace lo que queremos: esperar para siempre (hasta que llegue una señal). Sin embargo, no hay un programa de espacio de usuario para esto (todavía).

C

Crear un programa así es fácil. Aquí hay un fragmento para crear un programa Linux muy pequeño llamado pauseque se detiene indefinidamente (necesidades diet, gccetc.):

printf '#include <unistd.h>\nint main(){for(;;)pause();}' > pause.c;
diet -Os cc pause.c -o pause;
strip -s pause;
ls -al pause

python

Si no desea compilar algo usted mismo, pero lo ha pythoninstalado, puede usar esto en Linux:

python -c 'while 1: import ctypes; ctypes.CDLL(None).pause()'

(Nota: se usa exec python -c ...para reemplazar el shell actual, esto libera un PID. La solución se puede mejorar también con alguna redirección de E / S, liberando FD no utilizados. Esto depende de usted).

Cómo funciona esto (creo): ctypes.CDLL(None)carga la biblioteca C estándar y ejecuta la pause()función dentro de un bucle adicional. Menos eficiente que la versión C, pero funciona.

Mi recomendación para ti:

Quédate en el sueño en bucle. Es fácil de entender, muy portátil y bloquea la mayor parte del tiempo.

Tal vez esto parezca feo, pero ¿por qué no simplemente correr caty dejar que espere la entrada para siempre?

TL; DR: en sleep infinityrealidad duerme el tiempo máximo permitido, que es finito.

Preguntándome por qué esto no está documentado en ninguna parte, me molesté en leer las fuentes de los núcleos de GNU y descubrí que ejecuta aproximadamente lo siguiente:

1. Use strtodC stdlib en el primer argumento para convertir 'infinito' a la precisión doble. Por lo tanto, suponiendo que IEEE 754 doble precisión, el valor de infinito positivo de 64 bits se almacena en la secondsvariable.
2. Invocar xnanosleep(seconds)(que se encuentra en gnulib ), esto a su vez invoca dtotimespec(seconds)( también en gnulib ) para convertir de doublea struct timespec.
3. struct timespeces solo un par de números: parte entera (en segundos) y parte fraccionaria (en nanosegundos). La conversión ingenua de infinito positivo a entero daría como resultado un comportamiento indefinido (consulte §6.3.1.4 del estándar C), por lo que en su lugar se trunca TYPE_MAXIMUM (time_t).
4. El valor real de TYPE_MAXIMUM (time_t)no está establecido en el estándar (incluso sizeof(time_t)no lo está); entonces, por ejemplo, escojamos x86-64 de un kernel de Linux reciente.

Esto está TIME_T_MAXen el kernel de Linux, que se define ( time.h) como:

(time_t)((1UL << ((sizeof(time_t) << 3) - 1)) - 1)

Tenga en cuenta que time_tes __kernel_time_ty time_tes long; se utiliza el modelo de datos LP64, también lo sizeof(long)es 8 (64 bits).

Que se traduce en: TIME_T_MAX = 9223372036854775807.

Es decir: sleep infiniteda como resultado un tiempo de sueño real de 9223372036854775807 segundos (10 ^ 11 años). Y para sistemas Linux de 32 bits ( sizeof(long)es 4 (32 bits)): 2147483647 segundos (68 años; ver también el problema del año 2038 ).

Editar : aparentemente la nanosecondsfunción llamada no es directamente la llamada al sistema, sino un contenedor dependiente del sistema operativo (también definido en gnulib ).

Hay un paso adicional como resultado: para algunos sistemas en los que HAVE_BUG_BIG_NANOSLEEPes trueel sueño se trunca a 24 días y luego se llama en un bucle. Este es el caso de algunas (o todas) distribuciones de Linux. Tenga en cuenta que este contenedor no se puede usar si una prueba de configuración de tiempo tiene éxito ( fuente )

En particular, eso sería 24 * 24 * 60 * 60 = 2073600 seconds(más 999999999 nanosegundos); pero esto se llama en un bucle para respetar el tiempo de sueño total especificado. Por lo tanto, las conclusiones anteriores siguen siendo válidas.

En conclusión, el tiempo de sueño resultante no es infinito, sino lo suficientemente alto para todos los fines prácticos , incluso si el lapso de tiempo real resultante no es portátil; eso depende del sistema operativo y la arquitectura.

Para responder a la pregunta original, esto es obviamente lo suficientemente bueno, pero si por alguna razón (un sistema muy limitado en recursos) realmente desea evitar un temporizador de cuenta regresiva adicional inútil, supongo que la alternativa más correcta es usar el catmétodo descrito en otras respuestas .

sleep infinityse ve muy elegante, pero a veces no funciona por alguna razón. En ese caso, puede probar otros órdenes de bloqueo tales como cat, read, tail -f /dev/null, grep aetc.

¿Qué pasa con el envío de un SIGSTOP para sí mismo?

Esto debería pausar el proceso hasta que se reciba SIGCONT. Lo cual es en tu caso: nunca.

kill -STOP "$$";
# grace time for signal delivery
sleep 60;

Permítanme explicar por qué sleep infinityfunciona, aunque no está documentado. La respuesta de jp48 también es útil.

Lo más importante: al especificar info infinity(sin distinción entre mayúsculas y minúsculas), puede dormir durante el tiempo más largo que su implementación lo permita (es decir, el valor menor de HUGE_VALy TYPE_MAXIMUM(time_t)).

Ahora profundicemos en los detalles. El código fuente del sleepcomando se puede leer desde coreutils / src / sleep.c . Esencialmente, la función hace esto:

double s; //seconds
xstrtod (argv[i], &p, &s, cl_strtod); //`p` is not essential (just used for error check).
xnanosleep (s);

Comprensión xstrtod (argv[i], &p, &s, cl_strtod)

xstrtod()

De acuerdo con gnulib / lib / xstrtod.c , la llamada de xstrtod()convierte la cadena argv[i]a un valor de punto flotante y la almacena *s, utilizando una función de conversión cl_strtod().

cl_strtod()

Como se puede ver en coreutils / lib / cl-strtod.c , cl_strtod()convierte una cadena a un valor de coma flotante, utilizando strtod().

strtod()

Según man 3 strtod, strtod()convierte una cadena en un valor de tipo double. La página del manual dice

La forma esperada de la (porción inicial de la cadena) es ... o (iii) un infinito, o ...

y un infinito se define como

Un infinito es "INF" o "INFINITY", sin tener en cuenta el caso.

Aunque el documento dice

Si el valor correcto causaría un desbordamiento, se devuelve más o menos HUGE_VAL( HUGE_VALF, HUGE_VALL)

, no está claro cómo se trata un infinito. Así que veamos el código fuente gnulib / lib / strtod.c . Lo que queremos leer es

else if (c_tolower (*s) == 'i'
         && c_tolower (s[1]) == 'n'
         && c_tolower (s[2]) == 'f')
  {
    s += 3;
    if (c_tolower (*s) == 'i'
        && c_tolower (s[1]) == 'n'
        && c_tolower (s[2]) == 'i'
        && c_tolower (s[3]) == 't'
        && c_tolower (s[4]) == 'y')
      s += 5;
    num = HUGE_VAL;
    errno = saved_errno;
  }

Por lo tanto, INFy INFINITY(ambos no distinguen entre mayúsculas y minúsculas) se consideran como HUGE_VAL.

HUGE_VAL familia

Vamos a usar N1570 como el estándar C. HUGE_VAL, HUGE_VALFy las HUGE_VALLmacros se definen en §7.12-3

La macro se
    HUGE_VAL
expande a una expresión constante doble positiva, no necesariamente representable como flotante. Las macros
    HUGE_VALF
    HUGE_VALL
son, respectivamente, flotantes y análogos dobles largos de HUGE_VAL.

HUGE_VAL, HUGE_VALFy HUGE_VALLpueden ser infinitos positivos en una implementación que admita infinitos.

y en §7.12.1-5

Si un resultado flotante desborda y redondeo por defecto es en efecto, a continuación, la función devuelve el valor de la macro HUGE_VAL, HUGE_VALFo HUGE_VALLde acuerdo con el tipo de retorno

Comprensión xnanosleep (s)

Ahora entendemos toda la esencia de xstrtod(). De las explicaciones anteriores, es claro como el cristal que xnanosleep(s)hemos visto primero significa realmente xnanosleep(HUGE_VALL).

xnanosleep()

De acuerdo con el código fuente gnulib / lib / xnanosleep.c , xnanosleep(s)esencialmente hace esto:

struct timespec ts_sleep = dtotimespec (s);
nanosleep (&ts_sleep, NULL);

dtotimespec()

Esta función convierte un argumento de tipo doubleen un objeto de tipo struct timespec. Como es muy simple, permítanme citar el código fuente gnulib / lib / dtotimespec.c . Todos los comentarios son agregados por mí.

struct timespec
dtotimespec (double sec)
{
  if (! (TYPE_MINIMUM (time_t) < sec)) //underflow case
    return make_timespec (TYPE_MINIMUM (time_t), 0);
  else if (! (sec < 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 < frac;
      s += ns / TIMESPEC_HZ;
      ns %= TIMESPEC_HZ;

      if (ns < 0)
        {
          s--;
          ns += TIMESPEC_HZ;
        }

      return make_timespec (s, ns);
    }
}

Como time_tse define como un tipo integral (véase §7.27.1-3), es natural que supongamos que el valor máximo de tipo time_tes menor que HUGE_VAL(de tipo double), lo que significa que ingresamos al caso de desbordamiento. (En realidad, esta suposición no es necesaria ya que, en todos los casos, el procedimiento es esencialmente el mismo).

make_timespec()

El último muro que tenemos que trepar es make_timespec(). Afortunadamente, es tan simple que citar el código fuente gnulib / lib / timespec.h es suficiente.

_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;
}

Recientemente tuve la necesidad de hacer esto. Se me ocurrió la siguiente función que permitirá que bash duerma para siempre sin llamar a ningún programa externo:

snore()
{
    local IFS
    [[ -n "${_snore_fd:-}" ]] || { exec {_snore_fd}<> <(:); } 2>/dev/null ||
    {
        # workaround for MacOS and similar systems
        local fifo
        fifo=$(mktemp -u)
        mkfifo -m 700 "$fifo"
        exec {_snore_fd}<>"$fifo"
        rm "$fifo"
    }
    read ${1:+-t "$1"} -u $_snore_fd || :
}

NOTA: Publiqué previamente una versión de esto que abriría y cerraría el descriptor de archivo cada vez, pero descubrí que en algunos sistemas que lo hacen cientos de veces por segundo eventualmente se bloqueará. Así, la nueva solución mantiene el descriptor de archivo entre llamadas a la función. Bash lo limpiará a la salida de todos modos.

Esto se puede llamar como / bin / sleep, y se dormirá durante el tiempo solicitado. Llamado sin parámetros, se colgará para siempre.

snore 0.1  # sleeps for 0.1 seconds
snore 10   # sleeps for 10 seconds
snore      # sleeps forever

Hay una reseña con detalles excesivos en mi blog aquí.

Este enfoque no consumirá ningún recurso para mantener vivo el proceso.

while :; do sleep 1; done & kill -STOP $! && wait $!

Descompostura

• while :; do sleep 1; done & Crea un proceso ficticio en segundo plano.
• kill -STOP $! Detiene el proceso en segundo plano.
• wait $! Espere el proceso en segundo plano, esto se bloqueará para siempre, porque el proceso en segundo plano se detuvo antes

En lugar de eliminar el administrador de ventanas, intente ejecutar el nuevo con --replaceo -replacesi está disponible.

while :; do read; done

sin esperar el proceso de dormir del niño.