Rm (Unix)

Unix command utility

The `rm` command

Original author(s)| Ken Thompson, Dennis Ritchie
(AT&T Bell Laboratories)
Developer(s)| Various open-source and commercial developers
Initial release| November 3, 1971; 52 years ago (1971-11-03)
Written in| C
Operating system| Unix, Unix-like, V, Plan 9, Inferno, KolibriOS, IBM i
Platform| Cross-platform
Type| Command
License| coreutils: GPLv3+
Plan 9: MIT License

`rm` (short for remove) is a basic command on Unix and Unix-like operating systems used to remove objects such as computer files, directories and symbolic links from file systems and also special files such as device nodes, pipes and sockets, similar to the `del` command in MS-DOS, OS/2, and Microsoft Windows. The command is also available in the EFI shell.[1]

## Overview

[edit]

The `rm` command removes references to objects from the filesystem using the 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 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 shred and srm are available which specifically provide data wiping capability.

`rm` 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,[2] hence the tendency for users to enclose `rm` 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

[edit]

On some old versions of Unix, the `rm` command would delete directories if they were empty.[3] This behaviour can still be obtained in some versions of `rm` with the `-d` flag, e.g., the BSDs (such as FreeBSD,[4] NetBSD,[5] OpenBSD[6] and macOS) derived from 4.4BSD-Lite2.

The version of `rm` bundled in GNU coreutils was written by Paul Rubin, David MacKenzie, Richard Stallman, and Jim Meyering.[7] This version also provides `-d` option, to help with compatibility.[8] The same functionality is provided by the standard `rmdir` command.

The `-i` option in Version 7 replaced `dsw`, or "delete from switches", which debuted in Version 1. Doug McIlroy wrote that `dsw` "was a desperation tool designed to clean up files with unutterable names".[9]

The command is available as a separate package for Microsoft Windows as part of the UnxUtils collection of native Win32 ports of common GNU Unix-like utilities.[10] KolibriOS includes an implementation of the `rm` command.[11] The rm command has also been ported to the IBM i operating system.[12]

## Syntax

[edit]

`rm` 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. `rm` doesn't delete a directory by default.[13]`rm foo` deletes the file "foo" in the directory the user is currently in.

`rm`, like other commands, uses options to specify how it will behave:

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

`rm` can be overlain by a shell alias (C shell alias, Bourne shell or Bash) function of "`rm -i`" 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 `-i` argument by adding the `-f` option (as the option specified later on the expanded command line "`rm -i -f`" takes precedence). Unfortunately this approach generates dangerous habits towards the use of wildcarding, leading to its own version of accidental removals.

`rm -rf` (variously, `rm -rf /`, `rm -rf *`, and others) is frequently used in jokes and anecdotes about Unix disasters,[14] such as the loss of many files during the production of film Toy Story 2 at Pixar.[15] The `rm -rf /` variant of the command, if run by a superuser, would cause every file accessible from the present file system to be deleted from the machine.

`rm` is often used in conjunction with xargs to supply a list of files to delete:

xargs rm < filelist

Or, to remove all PNG images in all directories below the current one:

find . -name '*.png' -exec rm {} +

## Permissions

[edit]

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 `rm` asks for confirmation if a write-protected file is to be deleted, unless the -f option is used.)[16]

To delete a directory (with `rm -r`), 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.[17]

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

## Protection of the filesystem root

[edit]

Sun Microsystems introduced "`rm -rf /`" protection in Solaris 10, first released in 2005. Upon executing the command, the system now reports that the removal of / is not allowed.[18] Shortly after, the same functionality was introduced into FreeBSD version of `rm` utility.[19] GNU `rm` refuses to execute `rm -rf /` if the `--preserve-root` option is given,[20] which has been the default since version 6.4 of GNU Core Utilities was released in 2006. In newer systems, this failsafe is always active, even without the option. To run the command, user must bypass the failsafe by adding the option `--no-preserve-root`, even if they are the superuser.

## User-proofing

[edit]

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:

alias rm="rm -i"
rm () { /bin/rm -i "$@" ; }

This results in `rm` 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 `rm` commands, as well as encouraging a tendency to alternately pound `y` and the return key to affirm removes - until just past the one file they needed to keep.[citation needed] Users have even been seen going as far as "`yes | rm files`", which automatically inserts "y" for each file. [citation needed]

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:

if [ -n "$PS1" ] ; then
rm ()

ls -FCsd "$@"
echo 'remove[ny]? ' | tr -d '\012' ; read
if [ "_$REPLY" = "_y" ]; then
/bin/rm -rf "$@"
else
echo '(cancelled)'

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 `rm` in the search path, nor should it be allowed in non-interactive shells where it could break batch jobs. Enclosing the definition in the `if [ -n "$PS1" ] ; then ....  ; fi` construct protects against the latter.

There exist third-party alternatives which prevent accidental deletion of important files, such as "safe-rm"[21] or "trash".[22]

## Maximum command line argument limitation

[edit]

GNU Core Utilities implementation used in multiple Linux distributions 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[23][24] were defined at kernel compile time at variable `MAX_ARG_PAGES` in `include/linux/binfmts.h` file but new kernels limits the maximum argument length to 25% of the maximum stack limit (ulimit -s). Error: `/bin/rm: Argument list too long.` will prompt if command-line argument limit is exceed[25]

## See also

[edit]

* srm (Unix): secure remove file in Unix
* unlink(): the underlying system call called by this user space program for its main functionality
* del (command)
* deltree
* dsw (command) \- an obsolete Unix command for deleting difficult files

## References

[edit]

1. ^ "EFI Shells and Scripting". Intel. Retrieved 2013-09-25.
2. ^ "Unix - Frequently Asked Questions (3/7) [Frequent posting]Section - How do I "undelete" a file?". www.faqs.org.
3. ^ "rm page from Section 1 of the unix 8th manual". man.cat-v.org.
4. ^ "RM(1)", FreeBSD-5.4-RELEASE, retrieved February 5, 2015
5. ^ "RM(1)", NetBSD-2.0, retrieved February 5, 2015
6. ^ "RM(1)", OpenBSD-3.6, retrieved February 5, 2015
7. ^ "rm(1): remove files/directories - Linux man page". linux.die.net.
8. ^ Krzysztof Goj (January 22, 2012). "rm: new option --dir (-d) to remove empty directories". coreutils.git.
9. ^ McIlroy, M. D. (1987). A Research Unix reader: annotated excerpts from the Programmer's Manual, 1971–1986 (PDF) (Technical report). CSTR. Bell Labs. 139.
10. ^ "Native Win32 ports of some GNU utilities". unxutils.sourceforge.net.
11. ^ "Shell - KolibriOS wiki". wiki.kolibrios.org.
12. ^ IBM. "IBM System i Version 7.2 Programming Qshell" (PDF). IBM. Retrieved 2020-09-05.
13. ^ "rm(1) - Linux manual page". man7.org.
14. ^ Gite, Vivek. "Linux/UNIX: Delete a file". Nixcraft. Retrieved 24 November 2011.
15. ^ Panzarino, Matthew (21 May 2012). "How Toy Story 2 Got Deleted Twice, Once on Accident, Again on purpose". TNW | Media. Retrieved 27 September 2022.
16. ^ "Linux rm command help and examples". ComputerHope. 24 January 2018. Archived from the original on April 16, 2016. Retrieved 24 January 2019.`{{cite news}}`: CS1 maint: unfit URL (link)
17. ^ McElhearn, Kirk (2 January 2014). "Master the command line: Deleting files and folders". Macworld. Retrieved 24 January 2019.
18. ^ "Meddling in the Affairs of Wizards". Archived from the original on 2016-11-03.
19. ^ "The previous commit added code to rm(1) to warn about and remove any · freebsd/freebsd@d6b7bd9". GitHub.
20. ^ "rm invocation (GNU Coreutils)". www.gnu.org.
21. ^ "Safe-rm in Launchpad". Launchpad.
22. ^ "andreafrancia/trash-cli". September 12, 2020 - via GitHub.
23. ^ "Linux_2_6_23 - Linux Kernel Newbies". kernelnewbies.org.
24. ^ "kernel/git/torvalds/linux.git - Linux kernel source tree". git.kernel.org.
25. ^ ""Argument list too long": Beyond Arguments and Limitations | Linux Journal". www.linuxjournal.com.

## Further reading

[edit]

* McElhearn, Kirk (2006). The Mac OS X Command Line: Unix Under the Hood. John Wiley & Sons. ISBN 978-0470113851.

## External links

[edit]

The Wikibook Guide to Unix has a page on the topic of: rm

* `rm`: remove directory entries – Shell and Utilities Reference, The Single UNIX Specification, Version 4 from The Open Group
* `rm(1)` – Plan 9 Programmer's Manual, Volume 1
* `rm(1)` – Inferno General commands Manual

* v
* t
* e

Unix command-line interface programs and shell builtins

File system|

* cat
* chattr
* chmod
* chown
* chgrp
* cksum
* cmp
* cp
* dd
* du
* df
* file
* fuser
* ln
* ls
* mkdir
* mv
* pax
* pwd
* rm
* rmdir
* split
* tee
* touch
* type
* umask

Processes|

* at
* bg
* crontab
* fg
* kill
* nice
* ps
* time

User environment|

* env
* exit
* logname
* mesg
* talk
* tput
* uname
* who
* write

Text processing|

* awk
* basename
* comm
* csplit
* cut
* diff
* dirname
* ed
* ex
* fold
* head
* iconv
* join
* m4
* more
* nl
* paste
* patch
* printf
* read
* sed
* sort
* strings
* tail
* tr
* troff
* uniq
* vi
* wc
* xargs

Shell builtins|

* alias
* cd
* echo
* test
* unset
* wait

Searching|

* find
* grep

Documentation|

* man

Software development|

* ar
* ctags
* lex
* make
* nm
* strip
* yacc

Miscellaneous|

* bc
* cal
* expr
* lp
* od
* sleep
* true and false

* Categories
* Standard Unix programs
* Unix SUS2008 utilities
* List

* v
* t
* e

Plan 9 command-line interface programs and shell builtins

File system|

* chmod
* chgrp
* cmp
* cp
* dd
* du
* file
* gzip
* ls
* mkdir
* pwd
* rm
* split
* tee
* touch

Processes|

* kill
* ps

User environment|

* passwd
* who

Text processing|

* awk
* basename
* comm
* diff
* ed
* eqn
* join
* sed
* sort
* spell
* strings
* tail
* tr
* troff
* uniq
* wc

Shell builtins|

* echo
* test

Networking|

* ip/ipconfig
* ip/ping
* netstat

Searching|

* grep

Software development|

* ar
* hoc
* lex
* nm
* strip
* yacc

Miscellaneous|

* bc
* cal
* fortune
* sleep

* Category

* v
* t
* e

GNU Core Utilities command-line interface programs

File system|

* chcon
* chmod
* chown
* chgrp
* cksum
* cp
* dd
* df
* dir
* dircolors
* install
* ln
* ls
* mkdir
* mkfifo
* mknod
* mktemp
* mv
* realpath
* rm
* rmdir
* shred
* sync
* touch
* truncate
* vdir

Text utilities|

* b2sum
* base32
* base64
* cat
* cksum
* comm
* csplit
* cut
* expand
* fmt
* fold
* head
* join
* md5sum
* nl
* numfmt
* od
* paste
* ptx
* pr
* sha1sum
* shuf
* sort
* split
* sum
* tac
* tail
* tr
* tsort
* unexpand
* uniq
* wc

Shell utilities|

* arch
* basename
* chroot
* date
* dirname
* du
* echo
* env
* expr
* factor
* false
* groups
* hostid
* id
* link
* logname
* nice
* nohup
* nproc
* pathchk
* pinky
* printenv
* printf
* pwd
* readlink
* runcon
* seq
* sleep
* stat
* stdbuf
* stty
* tee
* test
* timeout
* true
* tty
* uname
* unlink
* uptime
* users
* who
* whoami
* yes

*[v]: View this template
*[t]: Discuss this template
*[e]: Edit this template