Simplemente corrí rm -rf /*accidentalmente, pero quise decir rm -rf ./*(note la estrella después de la barra).

alias rm='rm -i'y --preserve-rootpor defecto no me salvó, entonces, ¿hay alguna protección automática para esto?

No era root y cancelé el comando de inmediato, pero había algunos permisos relajados en algún lugar o algo así porque noté que mi mensaje Bash ya no funcionaba. No quiero confiar en los permisos y no ser root (podría cometer el mismo error sudo), y no quiero buscar errores misteriosos debido a que falta un archivo en alguna parte del sistema, por lo tanto, las copias de seguridad sudoson buenas , pero me gustaría algo mejor para este caso específico.

Sobre pensar dos veces y usar el cerebro. ¡Lo estoy usando en realidad! Pero lo estoy usando para resolver algunas tareas de programación complejas que involucran 10 cosas diferentes. Estoy inmerso en esta tarea lo suficientemente profundo, no queda ningún poder cerebral para verificar indicadores y rutas, ni siquiera pienso en términos de comandos y argumentos, pienso en términos de acciones como 'directorio actual vacío', diferente parte de mi cerebro los traduce a comandos y a veces comete errores. Quiero que la computadora los corrija, al menos los peligrosos.

Uno de los trucos que sigo es poner #al principio mientras uso el rmcomando.

root@localhost:~# #rm -rf /

Esto evita la ejecución accidental de rmun archivo / directorio incorrecto. Una vez verificado, eliminar #desde el principio. Este truco funciona, porque en Bash una palabra que comienza con #hace que esa palabra y todos los caracteres restantes en esa línea sean ignorados. Entonces el comando simplemente se ignora.

O

Si desea evitar cualquier directorio importante, hay un truco más.

Cree un archivo nombrado -ien ese directorio. ¿Cómo se puede crear un archivo tan extraño? Usando touch -- -iotouch ./-i

Ahora intenta rm -rf *:

sachin@sachin-ThinkPad-T420:~$ touch {1..4}
sachin@sachin-ThinkPad-T420:~$ touch -- -i
sachin@sachin-ThinkPad-T420:~$ ls
1  2  3  4  -i
sachin@sachin-ThinkPad-T420:~$ rm -rf *
rm: remove regular empty file `1'? n
rm: remove regular empty file `2'? 

Aquí *se expandirá -ia la línea de comando, por lo que su comando finalmente se convierte rm -rf -i. Por lo tanto, el comando se solicitará antes de la eliminación. Usted puede poner este archivo en su /, /home/, /etc/, etc.

O

Úselo --preserve-rootcomo una opción para rm. En los paquetes rmincluidos en los más nuevos coreutils, esta opción es la predeterminada.

--preserve-root
              do not remove `/' (default)

O

Use safe-rm

Extracto del sitio web:

Safe-rm es una herramienta de seguridad destinada a evitar la eliminación accidental de archivos importantes al reemplazar / bin / rm con un contenedor, que verifica los argumentos dados contra una lista negra configurable de archivos y directorios que nunca deberían eliminarse.

Los usuarios que intenten eliminar uno de estos archivos o directorios protegidos no podrán hacerlo y en su lugar se les mostrará un mensaje de advertencia:

$ rm -rf /usr
Skipping /usr

Tu problema:

Acabo de ejecutar rm -rf / * accidentalmente, pero me refería a rm -rf ./* (observe la estrella después de la barra).

La solución: ¡no hagas eso! Como práctica, no lo use ./al comienzo de un camino. Las barras no agregan ningún valor al comando y solo causarán confusión.

./*significa lo mismo que *, por lo que el comando anterior se escribe mejor como:

rm -rf *

Aquí hay un problema relacionado. Veo la siguiente expresión a menudo, donde alguien asumió que FOOestá configurado para algo así /home/puppies. Hoy vi esto en realidad, en la documentación de un importante proveedor de software.

rm -rf $FOO/

Pero si FOOno está configurado, esto evaluará a rm -rf /, que intentará eliminar todos los archivos en su sistema. La barra diagonal final es innecesaria, por lo que, como práctica, no la use.

Lo siguiente hará lo mismo y es menos probable que dañe su sistema:

rm -rf $FOO

Aprendí estos consejos por las malas. Cuando tuve mi primera cuenta de superusuario hace 14 años, corrí accidentalmente rm -rf $FOO/desde un script de shell y destruí un sistema. Los otros 4 administradores de sistemas miraron esto y dijeron: 'Sí. Todos lo hacen una vez. Ahora aquí está su medio de instalación (36 disquetes). Ve a arreglarlo.

Otras personas aquí recomiendan soluciones como --preserve-rooty safe-rm. Sin embargo, estas soluciones no están presentes para todas las variantes de Un * xe y pueden no funcionar en Solaris, FreeBSD y MacOSX. Además, safe-rmrequiere que instale paquetes adicionales en cada sistema Linux que use. Si confía safe-rm, ¿qué sucede cuando comienza un nuevo trabajo y no se han safe-rminstalado? Estas herramientas son una muleta, y es mucho mejor confiar en los valores predeterminados conocidos y mejorar sus hábitos de trabajo.

Como esto está en "Serverfault", me gustaría decir esto:

Si tiene docenas o más servidores, con un equipo bastante grande de los administradores / usuarios, alguien va a rm -rfo chownel directorio equivocado.

Debe tener un plan para recuperar el servicio afectado con el menor MTTR posible.

Las mejores soluciones implican cambiar sus hábitos para no usarlos rmdirectamente.

Un enfoque es correr echo rm -rf /stuff/with/wildcards*primero. Verifique que el resultado de los comodines se vea razonable, luego use el historial del shell para ejecutar el comando anterior sin el echo.

Otro enfoque es limitar el echocomando a casos en los que es muy obvio lo que va a eliminar. En lugar de eliminar todos los archivos en un directorio, elimine el directorio y cree uno nuevo. Un buen método es cambiar el nombre del directorio existente DELETE-foo, luego crear un nuevo directorio foocon los permisos apropiados y finalmente eliminarlo DELETE-foo. Un beneficio adicional de este método es que el comando que se ingresó en su historial es rm -rf DELETE-foo.

cd ..
mv somedir DELETE-somedir
mkdir somedir                 # or rsync -dgop DELETE-somedir somedir to preserve permissions
ls DELETE-somedir             # just to make sure we're deleting the right thing
rm -rf DELETE-somedir

Si realmente insiste en eliminar un montón de archivos porque necesita que el directorio permanezca (porque siempre debe existir o porque no tendría el permiso para volver a crearlo), mueva los archivos a un directorio diferente y elimine ese directorio .

mkdir ../DELETE_ME
mv * ../DELETE_ME
ls ../DELETE_ME
rm -rf ../DELETE_ME

(Presione esa tecla Alt+ .).

Eliminar un directorio desde adentro sería atractivo, porque rm -rf .es corto , por lo tanto, tiene un bajo riesgo de errores tipográficos. Los sistemas típicos no te permiten hacer eso, desafortunadamente. En rm -rf -- "$PWD"cambio, puede hacerlo, con un mayor riesgo de errores tipográficos, pero la mayoría de ellos conducen a eliminar nada. Tenga en cuenta que esto deja un comando peligroso en su historial de shell.

Siempre que puedas, usa el control de versiones. Tú no rm, tú cvs rmo lo que sea, y eso es imposible de hacer.

Zsh tiene opciones para avisarle antes de ejecutarlo rmcon un argumento que enumera todos los archivos en un directorio: (activado de forma rm_star_silentpredeterminada) solicita antes de ejecutarlo rm whatever/*y rm_star_wait(desactivado de manera predeterminada) agrega un retraso de 10 segundos durante el cual no puede confirmar. Esto es de uso limitado si tiene la intención de eliminar todos los archivos en algún directorio, porque ya estará esperando el mensaje. Puede ayudar a prevenir errores tipográficos como rm foo *para rm foo*.

Hay muchas más soluciones flotando que implican cambiar el rmcomando. Una limitación de este enfoque es que un día estarás en una máquina con lo real rmy llamarás automáticamente rm, seguro a la espera de una confirmación ... y lo siguiente será restaurar las copias de seguridad.

Siempre puedes hacer un alias, como mencionaste:

what_the_hell_am_i_thinking() {
   echo "Stop." >&2
   echo "Seriously." >&2
   echo "You almost blew up your computer." >&2
   echo 'WHAT WERE YOU THINKING!?!?!' >&2
   echo "Please provide an excuse for yourself below: " 
   read 
   echo "I'm sorry, that's a pathetic excuse. You're fired."
   sleep 2
   telnet nyancat.dakko.us
}

alias rm -fr /*="what_the_hell_am_i_thinking"

También puede integrarlo con un cliente de Twitter de línea de comandos para alertar a sus amigos acerca de cómo casi se humilló al limpiar su disco duro rm -fr /*como root.

Sí: no trabaje como root y siempre piense dos veces antes de actuar.

Además, eche un vistazo a algo como https://launchpad.net/safe-rm .

¡La forma más sencilla de evitar accidentes rm -rf /*es evitar el uso del rmcomando! De hecho, siempre he tenido la tentación de correr rm /bin/rmpara deshacerme del comando por completo. No, no estoy siendo gracioso.

En su lugar, use la -deleteopción del findcomando , pero antes de eliminar los archivos, le recomiendo obtener una vista previa de los archivos que eliminará:

find | less

Tenga en cuenta que en las versiones modernas de findsi omite el nombre de un directorio, utilizará implícitamente el directorio actual, por lo que lo anterior es el equivalente de:

find . | less

Una vez que esté seguro de que estos son los archivos que desea eliminar, puede agregar la -deleteopción:

find path/to/files -delete

Por lo tanto, no solo es find más seguro de usar, también es más expresivo , por lo que si desea eliminar solo ciertos archivos en una jerarquía de directorios que coinciden con un patrón en particular, puede usar una expresión como esta para obtener una vista previa y luego eliminar los archivos:

find path/to/files -name '*~' | less
find path/to/files -name '*~' -delete

Hay muchas buenas razones para aprender y usar, findademás de solo una más segura rm, por lo que te agradecerás más tarde si te tomas el tiempo de aprender a usar find.

Hay algunos consejos realmente malos en este hilo, afortunadamente la mayoría ha sido rechazada.

En primer lugar, cuando necesite ser root, conviértase en root - sudo y los diversos trucos de alias lo debilitarán. Y lo que es peor, te harán descuidado. Aprende a hacer las cosas de la manera correcta, deja de depender de los alias para protegerte. Un día obtendrás la raíz en una caja que no tiene tus ruedas de entrenamiento y explotarás algo.

Segundo: cuando tienes root, piensa en ti mismo como conducir un autobús lleno de niños en edad escolar. A veces puedes escuchar la canción en la radio, pero otras veces debes mirar a ambos lados, ralentizar las cosas y revisar todos tus espejos.

En tercer lugar - Casi nunca realmente tiene que rm -rf- más probable es que desee mv something something.bakomkdir _trash && mv something _trash/

Cuarto, siempre lstu comodín antes rm: no hay nada loco en mirar algo antes de destruirlo para siempre.

Este es el estándar mío específicamente para expresiones regulares en el contexto de rm, pero en este caso te habría salvado.

Siempre hago echo foo*/[0-9]*{bar,baz}*primero, para ver qué coincide con la expresión regular. Una vez que tengo la salida, vuelvo con la edición de línea de comandos y cambio echoa rm -rf. Yo nunca, nunca utilizar rm -rfen una expresión regular no probado .

La solución a este problema es realizar copias de seguridad periódicas. Cada vez que produzca algo que no quiera arriesgarse a perder, haga una copia de seguridad. Si encuentra que retroceder regularmente es demasiado doloroso, entonces simplifique el proceso para que no sea doloroso.

Por ejemplo, si trabaja en código fuente, use una herramienta como gitpara reflejar el código y mantener el historial en otra máquina. Si trabaja en documentos, tenga un script que rsyncenvíe sus documentos a otra máquina.

Parece que la mejor manera de reducir este riesgo es tener una eliminación en dos etapas como la mayoría de las GUI. Es decir, reemplace rm con algo que mueva las cosas a un directorio de basura (en el mismo volumen). Luego, limpie esa basura después de que haya pasado suficiente tiempo para notar cualquier error.

Una de estas utilidades, trash-cli, se discute en Unix StackExchange, aquí .

Un factor clave importante para evitar este tipo de errores es no iniciar sesión con una cuenta raíz. Cuando inicia sesión con un usuario normal sin privilegios, debe usarlo sudopara cada comando. Entonces, deberías tener más cuidado.

Cuando elimino un directorio de forma recursiva, pongo el -r, y -fsi corresponde, al final del comando, por ejemplo rm /foo/bar -rf. De esa manera, si accidentalmente presiono Enter demasiado pronto, sin haber escrito toda la ruta, el comando no es recursivo, por lo que es probable que sea inofensivo. Si topo Enter mientras intento escribir la barra después /foo, he escrito en rm /foolugar de rm -rf /foo.

Eso funciona muy bien en los sistemas que utilizan los coreutils de GNU, pero las utilidades en algunos otros Unix no permiten que las opciones se coloquen al final de esa manera. Afortunadamente, no uso tales sistemas con mucha frecuencia.

Puede ser complicado, pero puede configurar roles dentro de SELinux para que, incluso si el usuario se convierte en root a través de sudo su - (o su simple), la capacidad de eliminar archivos puede ser limitada (debe iniciar sesión directamente como root para eliminar archivos). Si está utilizando AppArmor, puede hacer algo similar .

Por supuesto, la otra solución sería asegurarse de tener copias de seguridad. :)

Evita usar globos . En Bash, puedes configurar noglob. Pero nuevamente, cuando se muda a un sistema donde noglobno está configurado, puede olvidarlo y proceder como si lo fuera.

Configurado noclobberpara evitar mvy cpdestruir archivos también.

Use un buscador de archivos para borrar. Algunos navegadores de archivos ofrecen una papelera (por ejemplo, Konqueror ).

Otra forma de evitar el engorde es un seguimiento. En la línea de comando, yo echo filenamepattern >> xxx. Luego edito el archivo con Vim o vi para verificar qué archivos se van a eliminar (observe los caracteres del patrón de nombre de archivo en filenmates) y luego lo uso %s/^/rm -f/para convertir cada línea en un comando de eliminación. Fuente xxx. De esta manera, verá todos los archivos que se eliminarán antes de hacerlo.

Mover archivos a un directorio 'ático' o tarball. O use el control de versiones (como dije antes que yo).

El ZSH me pregunta (por defecto) antes de realizar una rm -rf *.

Fuera de chattr, no hay muchas salvaguardas para permitir que root ejecute dicho comando. Es por eso que los grupos adecuados y los comandos cuidadosos son importantes cuando se ejecutan privilegios.

La próxima vez; busque los archivos que planea eliminar: omita 'f' de rm -rf, o use findy páselo axargs rm

Algunos alias de seguridad para otros comandos, para prevenir desastres similares, se encuentran aquí :

# safety features
alias cp='cp -i'
alias mv='mv -i'
alias rm='rm -I'                    # 'rm -i' prompts for every file
alias ln='ln -i'
alias chown='chown --preserve-root'
alias chmod='chmod --preserve-root'
alias chgrp='chgrp --preserve-root'

Observe las mayúsculas -I, es diferente de -i:

preguntar una vez antes de eliminar más de tres archivos, o al eliminar de forma recursiva. Menos intrusivo que -i, a la vez que brinda protección contra la mayoría de los errores

Usualmente uso la -vbandera para ver qué se está borrando y tengo la oportunidad de hacerlo ^Crápidamente si tengo la menor duda. Realmente no es una forma de prevenir las malas rm, pero puede ser útil para limitar el daño en caso de que algo salga mal.

Mi proceso de eliminación en máquinas basadas en Unix es el siguiente.

• Escriba ls /path/to/intented/file_or_directoryen la ventana del terminal y luego presione return(o Tab, según lo desee), para ver la lista de archivos.

Si todo se ve bien,

• haga clic en la up arrowtecla para volver a traer ls /path/to/intented/file_or_directorydel historial del terminal.

• reemplace lscon rmo rm -ro rm -rf, según sea necesario. Personalmente no me gusta usar la -fbandera.

Este proceso de validación también evita la ejecución prematura del rmcomando, algo que me ha sucedido, antes de comenzar a seguir este proceso.

Si no está de humor para adquirir nuevos hábitos en este momento, .bashrc/.profilees un buen lugar para agregar algunas pruebas para verificar si está a punto de hacer algo estúpido. Pensé en una función Bash que podría buscar un patrón que pudiera arruinar mi día y se me ocurrió esto:

alias rm='set -f; myrm' #set -f turns off wildcard expansion need to do it outside of           
                        #the function so that we get the "raw" string.
myrm() {
    ARGV="$*"
    set +f #opposite of set -f
    if echo "$ARGV" | grep -e '-rf /*' \
                           -e 'another scary pattern'
    then
        echo "Do Not Operate Heavy Machinery while under the influence of this medication"
        return 1
    else
        /bin/rm $@
    fi
}

Lo bueno de esto es que solo es Bash.

Claramente no es lo suficientemente genérico en esa forma, pero creo que tiene potencial, así que publique algunas ideas o comentarios.

Lamentablemente, no puedo dejar un comentario arriba debido al karma insuficiente, pero quería advertir a otros que safe-rm no es una panacea para las pesadillas accidentales de eliminación masiva.

Lo siguiente se probó en una máquina virtual Linux Mint 17.1 (advertencia para aquellos que no están familiarizados con estos comandos: ¡NO HAGA ESTO! En realidad, incluso aquellos familiarizados con estos comandos deberían / ​​probablemente nunca harían esto para evitar la pérdida catastrófica de datos):

Versión de texto (condensada):

$ cd /
$ sudo safe-rm -rf *
$ ls
bash: /bin/ls: No such file or directory

Versión de imagen (completa):

Me gusta el enfoque de Windows de la papelera de reciclaje.

Por lo general, creo un directorio llamado "/ tmp / recyclebin" para todo lo que necesito eliminar:

mkdir /tmp/recyclebin

Y nunca use rm -rf, siempre uso:

mv target_folder /tmp/recyclebin

Luego, más tarde, vacío la papelera de reciclaje usando un script o manualmente.

Jeje (¡no probado y algo gracioso!):

$ cat /usr/local/bin/saferm

#! /bin/bash

/bin/ls -- "$@"

echo "Those be the files you're about to delete."
echo "Do you want to proceed (y/N)?"

read userresponse

if [ "$userresponse" -eq "y" ]; then

  echo "Executing...."
  /bin/rm -- "$@"

fi

Y entonces:

alias rm="/usr/local/bin/saferm"

Siendo realistas, debe tener una pausa mental antes de ejecutar ese tipo de operación con un glob, ya sea que esté ejecutando como root, pretendiendo "sudo", etc. Puede ejecutar un "ls" en el mismo glob, etc. pero, mentalmente, debes detenerte por un segundo, asegurarte de haber escrito lo que querías, asegurarte de que lo que quieres es realmente lo que quieres, etc. Supongo que esto es algo que se aprende principalmente destruyendo algo en el primer año como Unix SA, de la misma manera que el quemador caliente es un buen maestro para decirle que algo en la estufa puede estar caliente.

¡Y asegúrese de tener buenas copias de seguridad!

Además, no como salvaguarda, sino como una forma de averiguar qué archivos se eliminaron antes de presionar ^ C, puede usar la locatebase de datos (por supuesto, solo si se instaló y sobrevivió rm)

Lo aprendí de esta publicación de blog

Simplemente use ZFS para almacenar los archivos que necesita para resistir la eliminación accidental y tener un demonio que:

• regularmente toma instantáneas de este sistema de archivos
• elimina instantáneas antiguas / innecesarias.

Si se eliminan los archivos, se sobrescriben, se corrompen, lo que sea, simplemente revierta su sistema de archivos a un clon de la última instantánea correcta y listo.

no tanto una respuesta sino un consejo, siempre rm (dir) -rfno, rm -rf (dir)es decir: no se nuclear hasta el último momento posible.

Ayuda a mitigar situaciones en las que el dedo gordo toca el nombre del directorio de tal manera que sigue siendo una eliminación válida, como deslizarse y presionar la tecla Intro.

Creo que este es un poderoso consejo de prevención, con * acceso directo de expansión en shell:

Primero, escriba rm -rf *o rm -rf your/path/*, NO escriba la Enterclave. (por supuesto, debe tener el hábito de cuidar de no presionar Enter rápido / accidentalmente cuando lo use rm -rf)

Luego, presione Alt-Shift-8(es decir Alt-Shift-*) para expandir el comodín "*" explícitamente en bash. Esto también evita volver a ingresar un comando "rm -rf *" al navegar por el historial.

Finalmente, después de comprobar que la expansión tiene los archivos / directorios correctos, presione Entrar.

Hecho.

En caso de que esto ayude a alguien para su propio caso:

1. Uso rmsafe:

Mueve los archivos a una carpeta "basura" y siempre tiene la oportunidad de traerlos de vuelta con un simple mv:

$ rmsafe /path/to/important/files

Fuente: https://github.com/pendashteh/rmsafe

2. Uso safe:

Puede establecer un alias para rmusar safe:

$ alias rm="safe rm"

Ahora si corres rm /*obtienes esto en respuesta:

$ rm /*
Are you sure you want to 'rm /bin /boot /data /dev /etc /home /initrd.img /lib /lib64 /mnt /opt /proc /root /run /sbin /srv /sys /tmp /usr /var'? [y/n]

y yo creo que no va a escribir y!

Fuente: https://github.com/pendashteh/safe