Ho corso per rm -rf /*caso, ma intendevo rm -rf ./*(notate la stella dopo la barra).

alias rm='rm -i'e --preserve-rootper impostazione predefinita non mi ha salvato, quindi ci sono garanzie automatiche per questo?

Non ero root e ho annullato immediatamente il comando, ma c'erano alcune autorizzazioni rilassate da qualche parte o qualcosa perché ho notato che il mio prompt di Bash si era già rotto. Non voglio fare affidamento sulle autorizzazioni e non essere root (potrei fare lo stesso errore con sudo), e non voglio cercare bug misteriosi a causa di un file mancante da qualche parte nel sistema, quindi i backup e sudosono buoni , ma vorrei qualcosa di meglio per questo caso specifico.

Pensare due volte e usare il cervello. Lo sto usando davvero! Ma lo sto usando per risolvere alcune complesse attività di programmazione che coinvolgono 10 cose diverse. Sono immerso in questo compito abbastanza profondamente, non è rimasto alcun potere del cervello per controllare bandiere e percorsi, non penso nemmeno in termini di comandi e argomenti, penso in termini di azioni come "dir corrente vuota", parte diversa del mio cervello li traduce in comandi e talvolta commette errori. Voglio che il computer li corregga, almeno quelli pericolosi.

Uno dei trucchi che seguo è quello di mettere #all'inizio usando il rmcomando.

root@localhost:~# #rm -rf /

Questo impedisce l'esecuzione accidentale di rmfile / directory errati. Una volta verificato, rimuoverlo #dall'inizio. Questo trucco funziona, perché in Bash una parola che inizia con #fa sì che quella parola e tutti i caratteri rimanenti su quella riga vengano ignorati. Quindi il comando viene semplicemente ignorato.

O

Se vuoi impedire qualsiasi directory importante, c'è un altro trucco.

Crea un file chiamato -iin quella directory. Come si può creare un file così strano? Utilizzando touch -- -iotouch ./-i

Ora prova 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'? 

Qui *si espanderà -ialla riga di comando, quindi alla fine il tuo comando diventerà rm -rf -i. Pertanto il comando verrà richiesto prima della rimozione. È possibile inserire questo file nel vostro /, /home/, /etc/, etc.

O

Utilizzare --preserve-rootcome opzione per rm. Nel rmincluso nei nuovi coreutilspacchetti, questa opzione è l'impostazione predefinita.

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

O

Usa safe-rm

Estratto dal sito web:

Safe-rm è uno strumento di sicurezza inteso a prevenire la cancellazione accidentale di file importanti sostituendo / bin / rm con un wrapper, che verifica gli argomenti forniti rispetto a una lista nera configurabile di file e directory che non devono mai essere rimossi.

Gli utenti che tentano di eliminare uno di questi file o directory protetti non saranno in grado di farlo e verrà invece visualizzato un messaggio di avviso:

$ rm -rf /usr
Skipping /usr

Il tuo problema:

Ho appena eseguito rm -rf / * per errore, ma intendevo rm -rf ./* (nota la stella dopo la barra).

La soluzione: non farlo! In pratica, non usare ./all'inizio di un percorso. Le barre non aggiungono alcun valore al comando e causeranno solo confusione.

./*significa la stessa cosa di *, quindi il comando sopra è meglio scritto come:

rm -rf *

Ecco un problema correlato. Vedo spesso la seguente espressione, in cui qualcuno ha assunto che FOOfosse impostato su qualcosa di simile /home/puppies. L'ho visto proprio oggi, nella documentazione di un importante fornitore di software.

rm -rf $FOO/

Ma se FOOnon è impostato, verrà valutato a rm -rf /, che tenterà di rimuovere tutti i file sul sistema. La barra finale non è necessaria, quindi per pratica non usarla.

Quanto segue farà la stessa cosa ed è meno probabile che danneggi il sistema:

rm -rf $FOO

Ho imparato questi suggerimenti nel modo più duro. Quando ho avuto il mio primo account superutente 14 anni fa, ho eseguito accidentalmente rm -rf $FOO/all'interno di uno script di shell e distrutto un sistema. Gli altri 4 amministratori di sistema lo guardarono e dissero: "Sì. Lo fanno tutti una volta. Ora ecco il tuo media di installazione (36 floppy disk). Vai a sistemarlo. '

Altre persone qui raccomandano soluzioni come --preserve-roote safe-rm. Tuttavia, queste soluzioni non sono presenti per tutte le varietà Un * xe e potrebbero non funzionare su Solaris, FreeBSD e MacOSX. Inoltre, safe-rmrichiede l'installazione di pacchetti aggiuntivi su ogni singolo sistema Linux utilizzato. Se si fa affidamento safe-rm, cosa succede quando si avvia un nuovo lavoro e non sono stati safe-rminstallati? Questi strumenti sono una stampella ed è molto meglio fare affidamento su valori predefiniti noti e migliorare le abitudini di lavoro.

Poiché questo è su "Serverfault", vorrei dire questo:

Se si dispone di decine o più server, con una squadra abbastanza grande di amministratori / utenti, qualcuno sta per rm -rfo chownla directory sbagliata.

È necessario disporre di un piano per il backup del servizio interessato con il minor MTTR possibile.

Le migliori soluzioni prevedono il cambiamento delle abitudini da non utilizzare rmdirettamente.

Un approccio è quello di eseguire echo rm -rf /stuff/with/wildcards*prima. Verificare che l'output dei caratteri jolly appaia ragionevole, quindi utilizzare la cronologia della shell per eseguire il comando precedente senza il echo.

Un altro approccio è limitare il echocomando ai casi in cui è palesemente ovvio ciò che si eliminerà. Invece di rimuovere tutti i file in una directory, rimuovere la directory e crearne una nuova. Un buon metodo è rinominare la directory esistente in DELETE-foo, quindi creare una nuova directory foocon le autorizzazioni appropriate e infine rimuoverla DELETE-foo. Un vantaggio collaterale di questo metodo è che il comando inserito nella cronologia è 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

Se insisti davvero sull'eliminazione di un mucchio di file perché hai bisogno che la directory rimanga (perché deve sempre esistere o perché non avresti il ​​permesso di ricrearla), sposta i file in un'altra directory ed elimina quella directory .

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

(Premi quel tasto Alt+ ..)

L'eliminazione di una directory dall'interno sarebbe interessante, perché rm -rf .è breve, quindi ha un basso rischio di errori di battitura. I sistemi tipici non ti consentono di farlo purtroppo. È possibile rm -rf -- "$PWD"invece, con un rischio maggiore di errori di battitura, ma la maggior parte di essi porta alla rimozione di nulla. Attenzione che questo lascia un comando pericoloso nella cronologia della shell.

Ogni volta che puoi, usa il controllo versione. Tu rm, tu cvs rmo qualunque altra cosa, e questo è inevitabile.

Zsh ha delle opzioni per chiederti prima di eseguire rmcon un argomento che elenca tutti i file in una directory: rm_star_silent( attivo per impostazione predefinita) richiede prima dell'esecuzione rm whatever/*e rm_star_wait(spento per impostazione predefinita) aggiunge un ritardo di 10 secondi durante il quale non puoi confermare. Questo è di utilità limitata se intendevi rimuovere tutti i file in alcune directory, perché ti aspetterai già il prompt. Può aiutare a prevenire errori di battitura come rm foo *per rm foo*.

Esistono molte altre soluzioni che implicano la modifica del rmcomando. Una limitazione di questo approccio è che un giorno sarai su una macchina con il reale rme chiamerai automaticamente rm, sicuro nelle tue aspettative di conferma ... e la prossima cosa ripristinerai i backup.

Potresti sempre fare un alias, come hai detto:

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"

Potresti anche integrarlo con un client Twitter a riga di comando per avvisare i tuoi amici di come ti sei quasi umiliato cancellando il tuo disco rigido rm -fr /*come root.

Sì: non lavorare come root e pensaci sempre due volte prima di agire.

Inoltre, dai un'occhiata a qualcosa come https://launchpad.net/safe-rm .

Il modo più semplice per prevenire accidentale rm -rf /*è evitare qualsiasi uso del rmcomando! In effetti, sono sempre stato tentato di correre rm /bin/rmper sbarazzarmi completamente del comando! No, non sono faceto.

Utilizza invece l' -deleteopzione del findcomando , ma prima di eliminare i file ti consiglio di visualizzare in anteprima i file che eliminerai:

find | less

Nota, nelle versioni moderne di findse lasci il nome di una directory, utilizzerà implicitamente la directory corrente, quindi quanto sopra è l'equivalente di:

find . | less

Una volta che sei sicuro che questi sono i file che desideri eliminare, puoi aggiungere l' -deleteopzione:

find path/to/files -delete

Quindi, non solo è find più sicuro da usare, ma è anche più espressivo , quindi se si desidera eliminare solo determinati file in una gerarchia di directory che corrispondono a un modello particolare, è possibile utilizzare un'espressione come questa per visualizzare l'anteprima, quindi eliminare i file:

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

Ci sono molte buone ragioni per imparare e usare findoltre a una più sicura rm, quindi ti ringrazierai più tardi se ti prendi il tempo per imparare ad usare find.

Ci sono davvero dei brutti consigli in questa discussione, per fortuna la maggior parte è stata votata in negativo.

Prima di tutto, quando devi essere root, diventa root - sudo e i vari trucchi alias ti renderanno debole. E peggio, ti renderanno incurante. Impara a fare le cose nel modo giusto, smetti di dipendere dagli alias per proteggerti. Un giorno metterai radici su una scatola che non ha le ruote di allenamento e farà esplodere qualcosa.

Secondo: quando hai le radici, pensa a te stesso come guidare un autobus pieno di scolari. A volte puoi ascoltare la canzone alla radio, ma altre volte devi guardare in entrambi i modi, rallentare le cose e ricontrollare tutti i tuoi specchi.

Terzo - Quasi mai è davvero necessario rm -rf- più probabilmente lo vorrai mv something something.bakomkdir _trash && mv something _trash/

Quarto - sempre il lstuo jolly prima rm- Non c'è niente di pazzo nel guardare qualcosa prima di distruggerlo per sempre.

Questo è il mio standard specifico per regexps nel contesto di rm, ma in questo caso ti avrebbe salvato.

Lo faccio sempre per echo foo*/[0-9]*{bar,baz}*primo, per vedere che cosa corrisponderà il regexp. Una volta che ho l'output, torno indietro con la modifica della riga di comando e cambio echoa rm -rf. Non uso mai e poi mai rm -rfsu una regexp non testata .

La soluzione a questo problema è eseguire backup regolari. Ogni volta che produci qualcosa che non vuoi rischiare di perdere, esegui il backup. Se ritieni che il backup regolarmente sia troppo doloroso, semplifica il processo in modo che non sia doloroso.

Ad esempio, se lavori sul codice sorgente, utilizza uno strumento come il gitmirroring del codice e conserva la cronologia su un altro computer. Se lavori sui documenti, utilizza uno script che invii rsynci tuoi documenti a un altro computer.

Sembra che il modo migliore per ridurre questo rischio sia avere una cancellazione in due fasi come la maggior parte delle GUI. Cioè, sostituisci rm con qualcosa che sposta le cose in una cartella cestino (sullo stesso volume). Quindi ripulisci la spazzatura dopo che è trascorso abbastanza tempo per notare eventuali errori.

Una di queste utilità, trash-cli, è discussa su Unix StackExchange, qui .

Un fattore chiave importante per evitare questo tipo di errori è non accedere utilizzando l'account di root. Quando si accede utilizzando un normale utente non privilegiato, è necessario utilizzare sudoper ciascun comando. Quindi, dovresti stare più attento.

Quando elimino ricorsivamente una directory, inserisco -r, e -fse applicabile, alla fine del comando, ad es rm /foo/bar -rf. In questo modo, se premo accidentalmente Invio troppo presto, senza aver ancora digitato l'intero percorso, il comando non è ricorsivo, quindi è probabilmente innocuo. Se bump Invio mentre provo a digitare la barra dopo /foo, ho scritto rm /foopiuttosto che rm -rf /foo.

Funziona bene su sistemi che usano i coreutils GNU, ma le utility su alcuni altri Unix non consentono di posizionare le opzioni alla fine in questo modo. Fortunatamente, non uso tali sistemi molto spesso.

Può essere complicato, ma è possibile impostare i ruoli all'interno di SELinux in modo che anche se l'utente diventa root tramite sudo su - (o plain su), la possibilità di eliminare i file può essere limitata (è necessario accedere direttamente come root per rimuovere File). Se stai usando AppArmor, potresti fare qualcosa di simile .

Naturalmente, l'altra soluzione sarebbe quella di assicurarsi di disporre di backup. :)

Evita di usare i globbing . In Bash, puoi impostare noglob. Ma ancora una volta, quando si passa a un sistema in cui noglobnon è impostato, è possibile dimenticarlo e procedere come se lo fosse.

Imposta noclobberper impedire mve cpdistruggere anche i file.

Utilizzare un browser di file per l'eliminazione. Alcuni browser di file offrono un cestino (ad esempio Konqueror ).

Un altro modo per evitare il globbing è il seguente. Alla riga di comando, io echo filenamepattern >> xxx. Quindi modifico il file con Vim o vi per verificare quali file devono essere eliminati (controlla i caratteri del modello di nome file nei compagni di file.) E quindi utilizzo %s/^/rm -f/per trasformare ogni riga in un comando di eliminazione. Fonte xxx In questo modo vedi tutti i file che verranno eliminati prima di farlo.

Sposta i file in una directory 'attico' o tarball. Oppure usa il controllo versione (come detto prima di me).

Lo ZSH mi chiede (di default) prima di eseguire un rm -rf *.

Al di fuori di questo chattr, non ci sono molte garanzie da parte del root per eseguire tale comando. Ecco perché i gruppi corretti e i comandi accurati sono importanti quando si esegue il privilegio.

La prossima volta; individuare i file che si prevede di eliminare: omettere 'f' rm -rfo utilizzare finde passare axargs rm

Alcuni alias di sicurezza per altri comandi, per prevenire disastri simili, sono disponibili qui :

# 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'

Notare la maiuscola -I, è diversa da -i:

richiesta una volta prima di rimuovere più di tre file o quando si rimuove in modo ricorsivo. Meno invadente di -i, pur offrendo protezione contro la maggior parte degli errori

Di solito uso la -vbandiera per vedere cosa viene eliminato e ho la possibilità di farlo ^Crapidamente se ho il minimo dubbio. Non è davvero un modo per prevenire il male rm, ma questo può essere utile per limitare il danno nel caso qualcosa vada storto.

Il mio processo di eliminazione su macchine basate su Unix è il seguente.

• Digitare ls /path/to/intented/file_or_directorynella finestra del terminale e quindi premere return(o Tab, come desiderato), per visualizzare l'elenco dei file.

Se tutto sembra a posto,

• fare clic sulla up arrowchiave per richiamare ls /path/to/intented/file_or_directorynuovamente dalla cronologia del terminale.

• sostituire lscon rmo rm -ro rm -rf, come richiesto. Personalmente non mi piace usare la -fbandiera.

Questo processo di validazione impedisce anche l'esecuzione prematura del rmcomando, cosa che mi è successa, prima che iniziassi a seguire questo processo.

Se non sei in vena di acquisire nuove abitudini in questo momento, .bashrc/.profileè un buon posto per aggiungere alcuni test per verificare se stai per fare qualcosa di stupido. Ho pensato in una funzione di Bash che potevo chiedere uno schema che potesse rovinarmi la giornata e mi sono inventato questo:

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
}

La cosa positiva è che è solo Bash.

Chiaramente non è abbastanza generico in quella forma, ma penso che abbia un potenziale, quindi per favore pubblica alcune idee o commenti.

Purtroppo, non posso lasciare un commento sopra a causa dell'insufficiente karma, ma volevo avvertire gli altri che la sicurezza non è una panacea per incubi accidentali di cancellazione di massa.

Quanto segue è stato testato in una macchina virtuale Linux Mint 17.1 (avvertimento per coloro che non hanno familiarità con questi comandi: NON FARE QUESTO! In realtà, anche quelli che hanno familiarità con questi comandi non dovrebbero / probabilmente mai fare questo per evitare la catastrofica perdita di dati):

Versione testo (condensata):

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

Versione immagine (completa):

Mi piace l'approccio windows del cestino.

Di solito creo una directory chiamata "/ tmp / recyclebin" per tutto ciò che devo eliminare:

mkdir /tmp/recyclebin

E mai usare rm -rf, io uso sempre:

mv target_folder /tmp/recyclebin

Successivamente, svuoto il cestino usando uno script o manualmente.

Hehe (non testato e un po 'facetiously!):

$ 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

E poi:

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

Realisticamente, dovresti fare una pausa mentale prima di eseguire quel tipo di operazione con un glob, sia che tu stia eseguendo come root, anteponendo "sudo" ad esso, ecc. Puoi eseguire un "ls" sullo stesso glob, ecc., ma, mentalmente, dovresti fermarti per un secondo, assicurarti di aver digitato ciò che volevi, assicurarti che ciò che vuoi sia in realtà ciò che vuoi, ecc. Suppongo che questo sia qualcosa che si impara principalmente distruggendo qualcosa nel primo anno come una Unix SA, allo stesso modo in cui il bruciatore a caldo è un buon insegnante nel dirti che qualcosa sulla stufa può essere caldo.

E assicurati di avere buoni backup!

Inoltre, non come una protezione, ma come un modo per scoprire quali file sono stati eliminati prima di premere ^ C, puoi usare il locatedatabase (ovviamente solo se è stato installato e sopravvissuto rm)

L'ho imparato da questo post sul blog

Basta usare ZFS per archiviare i file necessari per resistere alla rimozione accidentale e disporre di un demone che:

• crea regolarmente istantanee di questo file system
• rimuove le istantanee più vecchie / non necessarie.

Se i file vengono rimossi, sovrascritti, danneggiati, qualunque cosa, è sufficiente ripristinare il file system su un clone dell'ultima istantanea valida e il gioco è fatto.

non tanto una risposta, ma una punta, faccio sempre rm (dir) -rf, non rm -rf (dir)vale a dire: non andare nucleare fino all'ultimo momento possibile.

Aiuta a mitigare le situazioni in cui si preme il nome della directory in modo tale che sia ancora una cancellazione valida, come scivolare e premere il tasto Invio.

Penso che questo sia un potente suggerimento di prevenzione, con * collegamento di espansione nella shell:

Innanzitutto, digitare rm -rf *o rm -rf your/path/*, NON digitare il Entertasto. (ovviamente, dovresti avere l'abitudine di preoccuparti di non premere Invio velocemente / accidentalmente durante l'utilizzo rm -rf)

Quindi, premi Alt-Shift-8(ie Alt-Shift-*) per espandere il carattere jolly "*" esplicitamente in bash. Ciò evita anche di immettere nuovamente un comando "rm -rf *" durante la navigazione nella cronologia.

Alla fine, dopo aver verificato che l'espansione abbia i file / le directory giusti, premi Invio.

Fatto.

Nel caso in cui ciò aiuti qualcuno là fuori per il proprio caso:

1. Usa rmsafe:

Sposta i file in una cartella "cestino" e hai sempre la possibilità di riportarli con un semplice mv:

$ rmsafe /path/to/important/files

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

2. Usa safe:

Puoi impostare un alias per l' rmutilizzo di safe:

$ alias rm="safe rm"

Ora se corri rm /*ottieni questo in risposta:

$ 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]

e credo che non scriverai y!

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