Я случайно выполнил rm -rf /*, но хотел ввести rm -rf ./* (заметьте звезду после косой черты).

alias rm='rm -i' и --preserve-root по умолчанию не спасли меня, так что существуют ли какие-либо автоматические меры предосторожности для этого?

Я не был root и сразу отменил команду, но где-то были какие-то послабления в разрешениях или что-то подобное, потому что я заметил, что мой Bash приглашение уже сломалось. Я не хочу полагаться на разрешения и на то, что я не root (я мог бы совершить ту же ошибку с sudo), и я не хочу искать загадочные ошибки из-за одного отсутствующего файла где-то в системе, так что резервное копирование и sudo хороши, но я хотел бы что-то лучшее для этого конкретного случая.

О том, чтобы дважды подумать и использовать мозг. Я на самом деле его использую! Но я использую его для решения некоторой сложной программной задачи, которая включает 10 различных вещей. Я погружен в эту задачу достаточно глубоко, у меня не осталось умственных ресурсов для проверки флагов и путей, я даже не думаю в терминах команд и аргументов, я думаю в терминах действий, таких как ‘очистить текущий каталог’, другая часть моего мозга переводит их в команды, и иногда он ошибается. Я хочу, чтобы компьютер их исправлял, по крайней мере опасные.

Одним из трюков, которые я использую, является добавление # в начало при использовании команды rm.

root@localhost:~# #rm -rf /

Это предотвращает случайное выполнение rm на неправильном файле/каталоге. После проверки уберите # в начале. Этот трюк работает, потому что в Bash слово, начинающееся с #, игнорируется вместе с оставшимися символами в этой строке. Поэтому команда просто игнорируется.

ИЛИ

Если вы хотите предотвратить удаление любого важного каталога, есть еще один трюк.

Создайте файл с именем -i в этом каталоге. Как можно создать такой странный файл? Используя touch -- -i или touch ./-i

Теперь попробуйте 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: удалить обычный пустой файл `1`? n
rm: удалить регулярный пустой файл `2`? 

Здесь * развернется в -i в командной строке, так что ваша команда в конечном итоге станет rm -rf -i. Таким образом, команда запросит подтверждение перед удалением. Вы можете поместить этот файл в свой /, /home/, /etc/ и т. д.

ИЛИ

Используйте --preserve-root как опцию для rm. В rm, входящем в более новые пакеты coreutils, эта опция является значением по умолчанию.

--preserve-root
              не удалять `/' (по умолчанию)

ИЛИ

Используйте safe-rm

Цитата с веб-сайта:

Safe-rm — это инструмент безопасности, предназначенный для предотвращения случайного удаления
важных файлов, заменяя /bin/rm на обертку, которая проверяет
указанные аргументы на предмет соответствия настраиваемому черному списку файлов и
каталогов, которые никогда не должны быть удалены.

Пользователи, пытающиеся удалить один из этих защищенных файлов или
каталогов, не смогут этого сделать и вместо этого получат предупреждающее
сообщение:

$ rm -rf /usr
Пропуск /usr

Ваша проблема:

Я случайно выполнил rm -rf /*, но я хотел выполнить rm -rf ./* (заметьте звезду после косой черты).

Решение: Не делайте этого! В качестве практики, не используйте ./ в начале пути. Коси черты не добавляют никакой ценности команде и только создают путаницу.

./* означает то же самое, что *, поэтому приведенную выше команду лучше записать как:

rm -rf *

Вот связанная проблема. Я часто вижу следующее выражение, где кто-то предполагал, что FOO установлено на что-то вроде /home/puppies. На самом деле я только сегодня увидел это в документации от крупного поставщика программного обеспечения.

rm -rf $FOO/

Но если FOO не установлено, это будет оцениваться как rm -rf /, что попытается удалить все файлы в вашей системе. Заключительная косая черта не нужна, так что в качестве правила не используйте ее.

Следующее сделает то же самое и с меньшей вероятностью повредит вашу систему:

rm -rf $FOO

Я узнал эти советы на собственном горьком опыте. Когда у меня была первая учетная запись суперпользователя 14 лет назад, я случайно выполнил rm -rf $FOO/ из скрипта оболочки и уничтожил систему. Остальные 4 системных администратора посмотрели на это и сказали: ‘Да. Все делают это один раз. Вот ваши средства установки (36 дискеты). Идите и исправьте это.’

Другие здесь рекомендуют решения, такие как --preserve-root и safe-rm. Однако эти решения не присутствуют для всех дистрибутивов Unix и могут не работать на Solaris, FreeBSD и MacOSX. Кроме того, safe-rm требует установки дополнительных пакетов на каждой системе Linux, которую вы используете. Если вы полагаетесь на safe-rm, что произойдет, когда вы начнете новую работу, и у них не установлен safe-rm? Эти инструменты являются костылем, и гораздо лучше полагаться на известные значения по умолчанию и улучшать свои привычки работы.

Поскольку это на “Serverfault”, мне хотелось бы сказать следующее:

Если у вас есть десятки или более серверов, с большой командой администраторов/пользователей, кто-то собирается выполнить rm -rf или chown на неправильном каталоге.

У вас должен быть план по восстановлению затронутого сервиса с минимальным временем восстановления.

Лучшие решения связаны с изменением ваших привычек, чтобы не использовать rm напрямую.

Один подход — сначала выполнить echo rm -rf /stuff/with/wildcards*. Проверьте, что вывод с шаблонами выглядит разумно, затем используйте историю оболочки для выполнения предыдущей команды без echo.

Другой подход — ограничить команду echo случаями, когда очевидно, что вы собираетесь удалить. Вместо удаления всех файлов в каталоге, удалите сам каталог и создайте новый. Хорошим методом является переименование существующего каталога в DELETE-foo, затем создание нового каталога foo с соответствующими разрешениями, и, наконец, удаление DELETE-foo. Побочным эффектом этого метода является то, что команда, введенная в вашу историю, — это rm -rf DELETE-foo.

cd ..
mv somedir DELETE-somedir
mkdir somedir                 # или rsync -dgop DELETE-somedir somedir для сохранения разрешений
ls DELETE-somedir             # просто чтобы убедиться, что мы удаляем нужное
rm -rf DELETE-somedir

Если вы действительно настаиваете на том, чтобы удалить множество файлов, потому что хотите, чтобы каталог остался (потому что он всегда должен существовать или потому, что у вас не было бы разрешения на его воссоздание), переместите файлы в другой каталог и удалите этот каталог.

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

(Нажмите комбинацию Alt+..)

Удаление каталога изнутри будет привлекательно, потому что rm -rf . коротко, следовательно, имеет низкий риск ошибок. Типичные системы не позволяют вам это сделать, к сожалению. Вы можете выполнить rm -rf -- "$PWD" вместо этого, с более высоким риском ошибок, но большинство из них приведет к удалению ничего. Будьте осторожны, это оставляет опасную команду в вашей истории оболочки.

Когда можете, используйте систему контроля версий. Вы не rm, вы cvs rm или что-то еще, и это можно отменить.

Zsh имеет опции для запроса у вас перед выполнением rm с аргументом, который перечисляет все файлы в каталоге: rm_star_silent (включено по умолчанию) запрашивает перед выполнением rm whatever/*, а rm_star_wait (выключено по умолчанию) добавляет 10-секундную задержку, в течение которой вы не можете подтвердить. Это имеет ограниченное применение, если вы собираетесь удалить все файлы в каком-то каталоге, потому что вы уже ожидаете запроса. Это может помочь предотвратить ошибки, такие как rm foo * для rm foo*.

Существуют еще множество других решений, связанных с изменением команды rm. Ограничение этого подхода в том, что однажды вы будете на машине с настоящим rm и автоматически вызовете rm, находясь в уверенности в получении подтверждения… и в следующую минуту вам придется восстанавливать резервные копии.

Вы всегда можете создать псевдоним, как вы упомянули:

what_the_hell_am_i_thinking() {
   echo "Стоп." >&2
   echo "Серьезно." >&2
   echo "Ты почти взорвал свой компьютер." >&2
   echo 'ЧТО ТЫ ДУМАЛ?!?!!' >&2
   echo "Пожалуйста, предоставьте оправдание ниже: " 
   read 
   echo "Извините, это жалкое оправдание. Вы уволены."
   sleep 2
   telnet nyancat.dakko.us
}

alias rm -fr /*="what_the_hell_am_i_thinking"

Вы также можете интегрировать это с клиентом командной строки Twitter, чтобы оповестить своих друзей о том, как вы чуть не унизили себя, очистив диск с помощью rm -fr /* в качестве root.

Самый простой способ предотвратить случайное rm -rf /* — это полностью избегать использования команды rm! На самом деле, у меня всегда была искушение выполнить rm /bin/rm, чтобы полностью избавиться от команды! Нет, я не шучу.

Вместо этого используйте -delete опцию команды find, но прежде чем удалять файлы, я рекомендую предварительно просмотреть, какие файлы вы собираетесь удалить:

find | less

Обратите внимание, что в современных версиях find, если вы не указываете имя каталога, он неявно использует текущий каталог, так что вышеуказанное эквивалентно:

find . | less

Когда вы уверены, что это те файлы, которые вы хотите удалить, вы можете добавить опцию -delete:

find path/to/files -delete

Таким образом, find более безопасен в использовании и также более выразителен, так что если вы хотите удалить только определенные файлы в иерархии каталогов, которые соответствуют определенному шаблону, вы можете использовать такое выражение для предварительного просмотра, а затем удалить файлы:

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

Есть много хороших причин изучить и использовать find, помимо просто более безопасного rm, так что вы поблагодарите себя позже, если потратите время на изучение работы с find.

В этой теме есть действительно плохие советы, к счастью, большинство из них было проголосовано против.

Прежде всего, когда вам нужно быть root, становитесь root – sudo и различные псевдонимы сделают вас слабыми. И еще хуже, они сделают вас неосторожными. Учитесь делать все правильно, прекратите полагаться на псевдонимы, чтобы защищать вас. Однажды вы получите root на машине, которая не имеет ваших обучающих колес и сломаете что-то.

Во-вторых, когда у вас есть root, представляйте себя водителем автобуса, полным школьников. Иногда вы можете наслаждаться песней на радио, но в другие времена вам нужно смотреть по сторонам, замедлить движение и перепроверить все зеркала.

В-третьих, вы редко действительно должны rm -rf – скорее вы хотите mv что-то что-то.bak или mkdir _trash && mv что-то _trash/

В-четвертых, всегда ls свою подстановку перед rm – Ничего странного в том, чтобы посмотреть на что-то перед тем, как навсегда уничтожить это.

Да: Не работайте как root и всегда дважды думайте перед действием.

Также взгляните на что-то вроде https://launchpad.net/safe-rm.

Это моя стандартная мера предосторожности, касающаяся регулярных выражений в контексте rm, но она бы вас спасла в этом случае.

Я всегда сначала выполняю echo foo*/[0-9]*{bar,baz}*, чтобы увидеть, на что регулярное выражение будет совпадать. Как только я получаю вывод, я возвращаюсь к редактированию командной строки и изменяю echo на rm -rf. Я никогда, никогда не использую rm -rf на непроверенном регулярном выражении.

Решение этой проблемы — регулярно создавать резервные копии. Каждый раз, когда вы создаете что-то, что не хотите рисковать потерять, создавайте резервную копию. Если вы обнаружите, что регулярно делать резервные копии слишком болезненно, упростите процесс, чтобы он не был слишком болезненным.

Например, если вы работаете с исходным кодом, используйте инструмент, такой как git, чтобы создать зеркальное отражение кода и сохранить историю на другой машине. Если вы работаете с документами, создайте скрипт, который будет rsync ваших документов на другую машину.

Похоже, что лучший способ снизить этот риск — это реализовать двухступенчатое удаление, как в большинстве графических интерфейсов. То есть, заменить rm чем-то, что перемещает вещи в каталог ‘мусор’ (на том же томе). Затем очищать этот мусор после того, как прошло достаточно времени, чтобы заметить любую ошибку.

Одним из таких инструментов, trash-cli, обсуждается на Unix StackExchange.

Одним из важных факторов, чтобы избежать таких ошибок, является не входить в систему, используя учетную запись root. Когда вы входите как обычный пользователь без привилегий, вам нужно использовать sudo для каждой команды. Так что вы должны быть более осторожными.

Когда я удаляю каталог рекурсивно, я ставлю -r, и -f, если это уместно, в конце команды, например, rm /foo/bar -rf. Таким образом, если я случайно нажму Enter слишком рано, не завершив ввод всего пути, команда будет не рекурсивной, так что она, скорее всего, будет безвредной. Если я притяну Enter, пытаясь написать косую черту после /foo, я написал rm /foo, а не rm -rf /foo.

Это хорошо работает на системах, использующих GNU coreutils, но утилиты на некоторых других Unix-системах не позволяют помещать опции таким образом в конце. К счастью, я не очень часто использую такие системы.

Мне нравится подход Windows с корзиной.

Обычно я создаю каталог с именем “/tmp/recyclebin” для всего, что мне нужно удалить:

mkdir /tmp/recyclebin

И никогда не использую rm -rf, я всегда использую:

mv целевой_каталог /tmp/recyclebin

Затем позже я очищаю корзину с помощью скрипта или вручную.

Это может быть сложно, но вы можете настроить роли в рамках SELinux так, чтобы даже если пользователь становится root через sudo su – (или просто su), возможность удаления файлов может быть ограничена (вам нужно войти в систему как root, чтобы удалить файлы). Если вы используете AppArmor, вы можете сделать что-то похожее.

Конечно, другое решение — это убедиться, что у вас есть резервные копии. 🙂

Мой процесс удаления на Unix-ориентированных системах таков.

• Введите ls /path/to/intented/file_or_directory в терминальном окне, затем нажмите return (или Tab, как пожелаете), чтобы увидеть список файлов.

Если все выглядит хорошо,

• Нажмите клавишу вверх, чтобы снова получить ls /path/to/intented/file_or_directory из истории терминала.

• Замените ls на rm или rm -r или rm -rf, в зависимости от необходимости. Лично я не люблю использовать флаг -f.

Этот процесс проверки также предотвращает преждевременное выполнение команды rm, что раньше случалось со мной, прежде чем я начал следовать этому процессу.

Избегайте использования глоббинга. В Bash вы можете установить noglob. Но опять же, когда вы переходите на систему, где noglob не установлен, вы можете забыть об этом и действовать так, как будто он установлен.

Установите noclobber, чтобы предотвратить уничтожение файлов при использовании mv и cp.

Используйте файловый браузер для удаления. Некоторые файловые браузеры предлагают корзину (например, Konqueror).

Другой способ избежать глоббинга таков. В командной строке я echo filenamepattern >> xxx. Затем я редактирую файл с помощью Vim или vi, чтобы проверить, какие файлы будут удалены (следите за символами шаблона имени файла), а затем использую %s/^/rm -f/, чтобы превратить каждую строку в команду удаления. Исходный xxx. Таким образом, вы увидите каждый файл, который будет удален, перед его удалением.

Переместите файлы в каталог ‘чердак’ или архив. Или используйте систему контроля версий (как уже говорилось раньше).

ZSH спрашивает меня (по умолчанию) перед выполнением rm -rf *.

Кроме того, ZSH также предоставляет плагин (zsh-safe-rm), чтобы добавить функциональность safe-rm, так что rm будет помещать файлы в корзину вашей ОС вместо того, чтобы навсегда их удалять.

Кроме chattr, не так много мер предосторожности, чтобы не позволить root выполнять такую команду. Вот почему важны правильные группы и осторожные команды при выполнении привилегированных действий.

В следующий раз оцените файлы, которые вы собираетесь удалить — опустите ‘f’ из rm -rf, или используйте find и передайте это в xargs rm

Некоторые безопасные псевдонимы для других команд, чтобы предотвратить аналогичные несчастья, найдены здесь:

# функции безопасности
alias cp='cp -i'
alias mv='mv -i'
alias rm='rm -I'                    # 'rm -i' запрашивает подтверждение для каждого файла
alias ln='ln -i'
alias chown='chown --preserve-root'
alias chmod='chmod --preserve-root'
alias chgrp='chgrp --preserve-root'

Обратите внимание на заглавную букву -I, она отличается от -i:

запрашивает подтверждение перед удалением более чем трех файлов или при рекурсивном удалении. Менее навязчиво, чем -i, одновременно обеспечивая защиту от большинства ошибок

Просто используйте ZFS для хранения файлов, которые вам нужно защитить от случайного удаления, и имейте демон, который:

• регулярно создает снимки этой файловой системы
• удаляет более старые/ненужные снимки.

Если файлы удаляются, перезаписываются, повреждаются и так далее, просто откатите свою файловую систему на клонированный последний хороший снимок, и все.

Если у вас нет настроения приобретать новые привычки прямо сейчас, .bashrc/.profile — это хорошее место, чтобы добавить некоторые проверки, чтобы узнать, собираетесь ли вы сделать что-то глупое.
Я придумал в функции Bash, как я мог бы grep на шаблон, который может испортить мой день, и вот что вышло:

alias rm='set -f; myrm' #set -f отключает расширение подстановок, это нужно сделать вне 
                        #функции, чтобы получить "сырое" значение.
myrm() {
    ARGV="$*"
    set +f #противоположно set -f
    if echo "$ARGV" | grep -e '-rf /*' \
                           -e 'другой страшный шаблон'
    then
        echo "Не управляйте тяжелой техникой под воздействием этого лекарства"
        return 1
    else
        /bin/rm $@
    fi
}

Хорошо то, что это работает только в Bash.

Это явно не настолько универсально в такой форме, но я думаю, что с ним есть потенциал, так что, пожалуйста, публикуйте идеи или комментарии.

К сожалению, я не могу оставить комментарий выше из-за недостатка кармы, но хотел бы предостеречь других, что safe-rm не является панацеей от кошмаров случайного массового удаления.

Следующее было протестировано на виртуальной машине Linux Mint 17.1 (предупреждение для тех, кто незнаком с этими командами: НЕ ДЕЛАЙТЕ ЭТО! На самом деле, даже те, кто знаком с этими командами, вероятно, никогда не сделают этого, чтобы избежать катастрофической потери данных):

Текстовая версия (сжато):

$ cd /
$ sudo safe-rm -rf *
$ ls
bash: /bin/ls: Нет такого файла или каталога

Изображение (полная версия):

Я думаю, что это мощный совет по предотвращению, связанный с расширением подстановки в оболочке:

Сначала введите rm -rf * или rm -rf your/path/*, НИ В КОЕМ СЛУЧАЕ не нажимайте клавишу Enter. (Конечно, вы должны иметь привычку не нажимать Enter слишком быстро/случайно при использовании rm -rf)

Затем нажмите Alt-Shift-8 (т.е. Alt-Shift-*), чтобы явно развернуть подстановочный символ “*” в bash. Это также предотвратит повторный ввод команды “rm -rf *” при навигации по истории.

Наконец, после проверки, что развертывание содержит правильные файлы/каталоги, нажмите Enter.

Готово.

На случай, если это поможет кому-то в их ситуации:

1. Используйте rmsafe:

Он перемещает файлы в папку “корзина”, и у вас всегда есть возможность вернуть их с помощью простого mv:

$ rmsafe /path/to/important/files

Источник: https://github.com/pendashteh/rmsafe

2. Используйте safe:

Вы можете установить псевдоним для rm с использованием safe:

$ alias rm="safe rm"

Теперь, если вы запустите rm /*, вы получите такой ответ:

$ rm /*
Вы уверены, что хотите '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!

Источник: https://github.com/pendashteh/safe

В дополнение ко всем другим решениям здесь, при выполнении большого rm обычно используйте флаг -v, чтобы видеть, что удаляется, и иметь возможность быстро нажать ^C, если у меня возникнет хоть малейшее сомнение. Это не совсем способ предотвратить плохие rm, но это может быть полезно, чтобы ограничить ущерб в случае, если что-то пойдет не так.

Хе-хе (не протестировано и несколько шутливо!):

$ cat /usr/local/bin/saferm

#! /bin/bash

/bin/ls -- "$@"

echo "Это файлы, которые вы собираетесь удалить."
echo "Вы хотите продолжить (y/N)?"

read userresponse

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

  echo "Выполняю...."
  /bin/rm -- "$@"

fi

А затем:

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

На самом деле вы должны сделать паузу в мыслях перед выполнением подобной операции с использованием глобальных символов, независимо от того, запускаете ли вы от имени root, добавляете “sudo” и т.д. Вы можете выполнить “ls” на такой же подстановке и т.д., но, мысленно, вы должны остановиться на секунду, убедиться, что вы ввели то, что хотели, и убедиться, что то, что вы хотите, действительно то, что вы хотите, и так далее. Я полагаю, что это вещь, которую в основном учат, разрушив что-то в первый год как системный администратор Unix, таким образом, что горячая плита — хороший учитель в том, что может быть горячо.

И убедитесь, что у вас есть хорошие резервные копии!

Кроме того, не как мера предосторожности, а как способ узнать, какие файлы были удалены до того, как вы нажали ^C, вы можете использовать базу данных locate (конечно, только если она была установлена и выжила после rm)

Я узнал об этом из этого блог-поста

не столько ответ, сколько совет: я всегда ввожу rm (dir) -rf, а не rm -rf (dir), т.е.: не идите на уничтожение до последнего возможного момента.

Это помогает смягчить ситуации, в которых вы случайно вводите имя каталога таким образом, что оно все еще является допустимым для удаления, например, случайно нажав клавишу enter.

Я просто создал свой собственный скрипт, который может просто предупреждать и запрашивать подтверждение для каждой ситуации, как хотите.

#!/bin/sh
# просто переместите /usr/bin/rm в /usr/bin/rm-original

path=${!#}

color_yel="\x1b[1;33m"
color_rst="\x1b[0m"

function get_yn() {
    read i
    if [ "$i" != "y" ]; then echo "отменено."; exit 1; fi
}

if [ -d ${path} ]; then
    echo -e "${color_yel}Вы удаляете папку, это потенциально опасно. Вы уверены (y/n)?${color_rst}"
    get_yn
    /usr/bin/rm-original $@
fi

Дальнейшая идея по улучшению:

• проверить определенные флаги и пути
• переместить в папку для мусора и затем удалить
• периодически очищать старые вещи в мусоре после некоторого времени

Таким образом, простой настраиваемый скрипт позволяет иметь любое особое поведение и избежать установки дополнительных пакетов.

С некоторыми знаниями Bash вы можете уничтожить только определенные виды вещей.