View source for Software:Rm (Unix)

{{Short description|Unix command utility}}
{{lowercase title}}
{{Infobox software
| name                   = rm
| logo                   = 
| screenshot             = Rm --help Command - Unix.png
| screenshot size        = 
| caption                = The {{code|rm}} command
| author                 = [[Biography:Ken Thompson|Ken Thompson]], [[Biography:Dennis Ritchie|Dennis Ritchie]]<br />(AT&T Bell Laboratories)
| developer              = Various [[Open-source software|open-source]] and [[Commercial software|commercial]] developers
| released               = {{Start date and age|1971|11|3}}
| latest release version = 
| latest release date    = 
| programming language   = [[C (programming language)|C]]
| operating system       = [[Software:Unix|Unix]], [[Unix-like]], [[Software:V (operating system)|V]], [[Software:Plan 9 from Bell Labs|Plan 9]], [[Software:Inferno (operating system)|Inferno]], [[Software:KolibriOS|KolibriOS]], [[Software:IBM i|IBM i]]
| platform               = Cross-platform
| genre                  = [[Command (computing)|Command]]
| license                = coreutils: GPLv3+<br />Plan 9: [[Software:MIT License|MIT License]]
| website                = 
}}
'''<code>rm</code>''' (short for ''remove'') is a basic [[Command (computing)|command]] on [[Software:Unix|Unix]] and [[Unix-like]] [[Operating system|operating system]]s used to remove objects such as [[Computer file|computer file]]s, [[Directory (computing)|directories]] and [[Symbolic link|symbolic link]]s from [[File system|file system]]s and also [[Device file|special files]] such as device nodes, [[Pipeline (Unix)|pipes]] and [[Unix domain socket|socket]]s, similar to the <code>[[Software:Del (command)|del]]</code> command in [[Software:MS-DOS|MS-DOS]], OS/2, and [[Software:Microsoft Windows|Microsoft Windows]]. The command is also available in the EFI shell.<ref name="EFI-Shells-and-Scripting">{{cite web
 | url = http://software.intel.com/en-us/articles/efi-shells-and-scripting/
 | title = EFI Shells and Scripting
 | publisher = [[Company:Intel|Intel]]
 | access-date = 2013-09-25
}}</ref>

== Overview ==
The <code>rm</code> command removes references to objects from the filesystem using the [[Software:Unlink (Unix)|unlink]] system call, where those objects might have had multiple references (for example, a file with two different names), and the objects themselves are discarded only when all references have been removed and no programs still have open handles to the objects.

This allows for scenarios where a program can open a file, immediately remove it from the filesystem, and then use it for temporary space, knowing that the file's space will be reclaimed after the program exits, even if it exits by crashing.

The command generally does not destroy file data, since its purpose is really merely to [[Software:Unlink (Unix)|unlink]] references, and the filesystem space freed may still contain leftover data from the removed file. This can be a security concern in some cases, and hardened versions sometimes provide for wiping out the data as the last link is being cut, and programs such as [[Software:Shred (Unix)|shred]] and [[Software:Srm (Unix)|srm]] are available which specifically provide data wiping capability.

<code>rm</code> is generally only seen on UNIX-derived operating systems, which typically do not provide for recovery of deleted files through a mechanism like the recycle bin,<ref>{{Cite web|url=http://www.faqs.org/faqs/unix-faq/faq/part3/section-6.html|title=Unix - Frequently Asked Questions (3/7) [Frequent posting]Section - How do I "undelete" a file?|website=www.faqs.org}}</ref> hence the tendency for users to enclose <code>rm</code> in some kind of wrapper to limit accidental file deletion.

There are undelete utilities that will attempt to reconstruct the index and can bring the file back if the parts were not reused.

== History ==
On some old versions of Unix, the <code>rm</code> command would delete directories if they were empty.<ref>{{Cite web|url=http://man.cat-v.org/unix_8th/1/rm|title=rm page from Section 1 of the unix 8th manual|website=man.cat-v.org}}</ref> This behaviour can still be obtained in some versions of <code>rm</code> with the <code>-d</code> flag, e.g., the [[Software:Berkeley Software Distribution|BSDs]] (such as [[Software:FreeBSD|FreeBSD]],<ref>{{citation |url=http://modman.unixdev.net/?manpath=FreeBSD-5.4-RELEASE&page=rm&sektion=1&apropos= |title=RM(1) |work=FreeBSD-5.4-RELEASE |access-date=February 5, 2015 }}</ref> [[Software:NetBSD|NetBSD]],<ref>{{citation |url=http://modman.unixdev.net/?manpath=NetBSD-2.0&page=rm&sektion=1&apropos= |title=RM(1) |work=NetBSD-2.0 |access-date=February 5, 2015 }}</ref> [[Organization:OpenBSD|OpenBSD]]<ref>{{citation |url=http://modman.unixdev.net/?manpath=OpenBSD-3.6&page=rm&sektion=1&apropos= |title=RM(1) |work=OpenBSD-3.6 |access-date=February 5, 2015 }}</ref> and [[Software:MacOS|macOS]]) derived from 4.4BSD-Lite2.

The version of <code>rm</code> bundled in [[Software:GNU|GNU]] coreutils was written by Paul Rubin, David MacKenzie, [[Biography:Richard Stallman|Richard Stallman]], and Jim Meyering.<ref>{{Cite web|url=https://linux.die.net/man/1/rm|title=rm(1): remove files/directories - Linux man page|website=linux.die.net}}</ref> This version also provides <code>-d</code> option, to help with compatibility.<ref>{{cite web |url=http://git.savannah.gnu.org/cgit/coreutils.git/commit/src/rm.c?id=fdc2da7165d93c8065365999341173ad2a818833 |title=rm: new option --dir (-d) to remove empty directories |date=January 22, 2012 |author=Krzysztof Goj |website=coreutils.git }}</ref>  The same functionality is provided by the standard <code>[[Software:Rmdir|rmdir]]</code> command.

The <code>-i</code> option in [[Software:Version 7 Unix|Version 7]] replaced <code>dsw</code>, or "delete from switches", which debuted in Version 1. Doug McIlroy wrote that <code>dsw</code> "was a desperation tool designed to clean up files with unutterable names".<ref name="reader">{{cite tech report |first1=M. D. |last1=McIlroy |year=1987 |url=http://www.cs.dartmouth.edu/~doug/reader.pdf |title=A Research Unix reader: annotated excerpts from the Programmer's Manual, 1971–1986 |series=CSTR |number=139 |institution=Bell Labs}}</ref>

The command is available as a separate package for Microsoft Windows as part of the UnxUtils collection of [[Native (computing)|native]] [[Software:Windows API|Win32]] [[Porting|ports]] of common GNU Unix-like utilities.<ref>{{Cite web|url=http://unxutils.sourceforge.net/|title=Native Win32 ports of some GNU utilities|website=unxutils.sourceforge.net}}</ref> [[Software:KolibriOS|KolibriOS]] includes an implementation of the {{code|rm}} command.<ref>{{Cite web|url=http://wiki.kolibrios.org/wiki/Shell|title=Shell - KolibriOS wiki|website=wiki.kolibrios.org}}</ref> The {{Mono|rm}} command has also been ported to the [[Software:IBM i|IBM i]] operating system.<ref>{{cite web |title=IBM System i Version 7.2 Programming Qshell |language=en |author=IBM |website=[[Company:IBM|IBM]] |url=https://www.ibm.com/support/knowledgecenter/ssw_ibm_i_74/rzahz/rzahzpdf.pdf?view=kc |access-date=2020-09-05 }}</ref>

== Syntax ==
<code>rm</code> deletes the file specified after options are added.  Users can use a full path or a relative file path to specify the files to delete.  <code>rm</code> doesn't delete a directory by default.<ref>{{Cite web|url=https://man7.org/linux/man-pages/man1/rm.1.html|title=rm(1) - Linux manual page|website=man7.org}}</ref><code>rm foo</code> deletes the file "foo" in the directory the user is currently in.

<code>rm</code>, like other commands, uses options to specify how it will behave:

*'''<code>-r</code>''', "recursive," which removes directories, removing the contents recursively beforehand (so as not to leave files without a directory to reside in).
*'''<code>-i</code>''', "interactive" which asks for every deletion to be confirmed.
*'''<code>-f</code>''', "force," which ignores non-existent files and overrides any confirmation prompts (effectively canceling <code>-i</code>), although it will not remove files from a directory if the directory is write-protected.
*'''<code>-v</code>''', "verbose," which prints what <code>rm</code> is doing onto the terminal
*'''<code>-d</code>''', "directory," which deletes an empty directory, and only works if the specified directory is empty.
*'''<code>--one-file-system</code>''', only removes files on the same [[File system|file system]] as the argument, and will ignore mounted file systems.

<code>rm</code> can be overlain by a [[Software:Shell (computing)|shell]] alias ([[Software:C shell|C shell]] [[Aliasing|alias]], [[Software:Bourne shell|Bourne shell]] or Bash) function of "<code>rm -i</code>" so as to avoid accidental deletion of files. If a user still wishes to delete a large number of files without confirmation, they can manually cancel out the <code>-i</code> argument by adding the <code>-f</code> option (as the option specified later on the expanded command line "<code>rm -i -f</code>" takes precedence).  Unfortunately this approach generates dangerous habits towards the use of wildcarding, leading to its own version of accidental removals.

<code>rm -rf</code> (variously, <code>rm -rf /</code>, <code>rm -rf *</code>, and others) is frequently used in jokes and anecdotes about Unix disasters,<ref name="Linux/UNIX: Delete a file">{{cite web|last=Gite|first=Vivek|title=Linux/UNIX: Delete a file|url=http://www.cyberciti.biz/faq/howto-linux-unix-delete-remove-file/|publisher=Nixcraft|access-date=24 November 2011}}</ref> such as the loss of many files during the production of film ''Toy Story 2'' at Pixar.<ref name="Panzarino">{{cite web |last1=Panzarino |first1=Matthew |title=How Toy Story 2 Got Deleted Twice, Once on Accident, Again on purpose |url=https://thenextweb.com/news/how-pixars-toy-story-2-was-deleted-twice-once-by-technology-and-again-for-its-own-good |website=TNW {{!}} Media |access-date=27 September 2022 |language=en |date=21 May 2012}}</ref> The <code>rm -rf /</code> variant of the command, if run by a [[Superuser|superuser]], would cause every file accessible from the present file system to be deleted from the machine.

<code>rm</code> is often used in conjunction with [[Software:Xargs|xargs]] to supply a list of files to delete:

<source lang="bash">
 xargs rm < filelist
</source>

Or, to remove all [[Portable Network Graphics|PNG images]] in all directories below the current one:

<source lang="bash">
 find . -name '*.png' -exec rm {} +
</source>

== Permissions ==
Usually, on most filesystems, deleting a file requires write permission on the parent directory (and execute permission, in order to enter the directory in the first place). (Note that, confusingly for beginners, permissions on the file itself are irrelevant.  However, GNU <code>rm</code> asks for confirmation if a write-protected file is to be deleted, unless the -f option is used.)<ref>{{Cite news|url=https://www.theinquirer.net/inquirer/news/2454743/man-destroys-his-entire-company-with-a-five-character-bash-command|archive-url=https://web.archive.org/web/20160416214235/http://www.theinquirer.net/inquirer/news/2454743/man-destroys-his-entire-company-with-a-five-character-bash-command|url-status=unfit|archive-date=April 16, 2016|title=Linux rm command help and examples|date=24 January 2018|work=ComputerHope|access-date=24 January 2019}}</ref>

To delete a directory (with <code>rm -r</code>), one must delete all of its contents recursively. This requires that one must have read and write and execute permission to that directory (if it's not empty) and all non-empty subdirectories recursively (if there are any). The read permissions are needed to list the contents of the directory in order to delete them. This sometimes leads to an odd situation where a non-empty directory cannot be deleted because one doesn't have write permission to it and so cannot delete its contents; but if the same directory were empty, one would be able to delete it.<ref>{{Cite news|url=https://www.macworld.com/article/2082021/master-the-command-line-deleting-files-and-folders.html|title=Master the command line: Deleting files and folders|last=McElhearn|first=Kirk|date=2 January 2014|work=Macworld|access-date=24 January 2019}}</ref>

If a file resides in a directory with the [[Sticky bit|sticky bit]] set, then deleting the file requires one to be the owner of the file.

== Protection of the filesystem root ==
[[Company:Sun Microsystems|Sun Microsystems]] introduced "<code>rm -rf /</code>" protection in [[Software:Solaris (operating system)|Solaris]] 10, first released in 2005. Upon executing the command, the system now reports that the removal of / is not allowed.<ref>{{Cite web|url=https://blogs.oracle.com/jbeck/date/20041001%23rm_rf_protection|archive-url=https://web.archive.org/web/20161103124127/https://blogs.oracle.com/jbeck/date/20041001|archive-date=2016-11-03|url-status=dead|title=Meddling in the Affairs of Wizards}}</ref>  Shortly after, the same functionality was introduced into [[Software:FreeBSD|FreeBSD]] version of <code>rm</code> utility.<ref>{{Cite web|url=https://github.com/freebsd/freebsd/commit/d6b7bd90c2776d9ccd8bb7f33a899bd213aebf85|title=The previous commit added code to rm(1) to warn about and remove any · freebsd/freebsd@d6b7bd9|website=GitHub}}</ref>  [[Software:GNU|GNU]] <code>rm</code> refuses to execute <code>rm -rf /</code> if the <code>--preserve-root</code> option is given,<ref>{{Cite web|url=https://www.gnu.org/software/coreutils/manual/html_node/rm-invocation.html|title=rm invocation (GNU Coreutils)|website=www.gnu.org}}</ref> which has been the default since version 6.4 of [[Software:GNU Core Utilities|GNU Core Utilities]] was released in 2006.  In newer systems, this [[Fail-safe|failsafe]] is always active, even without the option. To run the command, user must bypass the failsafe by adding the option <code>--no-preserve-root</code>, even if they are the superuser.

== User-proofing ==
Systems administrators, designers, and even users often attempt to defend themselves against accidentally deleting files by creating an alias or function along the lines of:

<source lang="bash">
alias rm="rm -i"
rm () { /bin/rm -i "$@" ; }
</source>

This results in <code>rm</code> asking the user to confirm on a file-by-file basis whether it should be deleted, by pressing the Y or N key. Unfortunately, this tends to train users to be careless about the wildcards they hand into their <code>rm</code> commands, as well as encouraging a tendency to alternately pound <code>y</code> and the return key to affirm removes - until just past the one file they needed to keep.{{Citation needed|date=July 2012}}  Users have even been seen going as far as "<code>yes | rm ''files''</code>", which automatically inserts "y" for each file. {{Citation needed|date=July 2012}}

A compromise that allows users to confirm just once, encourages proper wildcarding, and makes verification of the list  easier can be achieved with something like:

<source lang="bash">
if [ -n "$PS1" ] ; then
  rm () 
  { 
      ls -FCsd "$@"
      echo 'remove[ny]? ' | tr -d '\012' ; read
      if [ "_$REPLY" = "_y" ]; then
          /bin/rm -rf "$@"
      else
          echo '(cancelled)'
      fi
  }
fi
</source>

It is important to note that this function should not be made into a shell script, which would run a risk of it being found ahead of the system <code>rm</code> in the search path, nor should it be allowed in non-interactive shells where it could break batch jobs. Enclosing the definition in the <code>if [ -n "$PS1" ] ; then ....  ; fi</code> construct protects against the latter.

There exist third-party alternatives which prevent accidental deletion of important files, such as "safe-rm"<ref>{{Cite web|url=https://launchpad.net/safe-rm/+index|title=Safe-rm in Launchpad|website=Launchpad}}</ref> or "trash".<ref>{{Cite web|url=https://github.com/andreafrancia/trash-cli|title=andreafrancia/trash-cli|date=September 12, 2020|via=GitHub}}</ref>

==Maximum command line argument limitation==
[[Software:GNU Core Utilities|GNU Core Utilities]] implementation used in multiple [[Software:Linux distribution|Linux distribution]]s will be limited in command line arguments bytes number of pages that are allocated within the kernel for command-line arguments before kernel 2.6.23 Released on 9 October 2007<ref>{{Cite web|url=https://kernelnewbies.org/Linux_2_6_23#Variable_argument_length|title=Linux_2_6_23 - Linux Kernel Newbies|website=kernelnewbies.org}}</ref><ref>{{Cite web|url=https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=b6a2fea39318e43fee84fa7b0b90d68bed92d2ba|title=kernel/git/torvalds/linux.git - Linux kernel source tree|website=git.kernel.org}}</ref> were defined at kernel compile time at variable <code>MAX_ARG_PAGES</code> in <code>include/linux/binfmts.h</code> file but new kernels limits the maximum argument length to 25% of the maximum stack limit (ulimit -s). Error: <code>/bin/rm: Argument list too long.</code> will prompt if command-line argument limit is exceed<ref>{{Cite web|url=https://www.linuxjournal.com/article/6060|title="Argument list too long": Beyond Arguments and Limitations &#124; Linux Journal|website=www.linuxjournal.com}}</ref>

== See also ==
* [[Software:Srm (Unix)|srm (Unix)]]: secure remove file in Unix
* [[Software:Unlink (Unix)|unlink()]]: the underlying [[System call|system call]] called by this [[User space|user space]] program for its main functionality
* [[Software:Del (command)|del (command)]]
* deltree
* [[Software:Dsw (command)|dsw (command)]] - an obsolete Unix command for deleting difficult files

== References ==
{{Reflist}}

== Further reading ==
*{{Cite book|author-last=McElhearn|author-first=Kirk|title=The Mac OS X Command Line: Unix Under the Hood|date=2006|publisher={{wipe|John Wiley & Sons}}|isbn=978-0470113851}}

== External links ==
*{{man|cu|rm|SUS|remove directory entries}}
*{{man|1|rm|Plan 9}}
*{{man|1|rm|Inferno}}

{{Unix commands}}

[[Category:Standard Unix programs]]

{{Sourceattribution|Rm (Unix)}}