 The rm command | |
| Original author(s) | Ken Thompson,Dennis Ritchie (AT&T Bell Laboratories) |
|---|---|
| Developer(s) | Variousopen-source andcommercial developers |
| Initial release | November 3, 1971; 53 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 forremove) is a basiccommand onUnix andUnix-likeoperating systems used to remove objects such ascomputer files,directories andsymbolic links fromfile systems and alsospecial files such asdevice nodes,pipes andsockets, similar to thedel command inMS-DOS,OS/2, andMicrosoft Windows. The command is also available in theEFI shell.[1]
Therm command removes references to objects from the filesystem using theunlink 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 tounlink 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 asshred andsrm are available which specifically provide data wiping capability.
rm is generally only seen onUNIX-derived operating systems, which typically do not provide for recovery of deleted files through a mechanism like therecycle bin,[2] hence the tendency for users to encloserm in some kind of wrapper to limit accidental file deletion.
There areundelete utilities that will attempt to reconstruct the index and can bring the file back if the parts were not reused.
On some old versions of Unix, therm command would delete directories if they were empty.[3] This behaviour can still be obtained in some versions ofrm with the-d flag, e.g., theBSDs (such asFreeBSD,[4]NetBSD,[5]OpenBSD[6] andmacOS) derived from 4.4BSD-Lite2.
The version ofrm bundled inGNUcoreutils 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 standardrmdir command.
The-i option inVersion 7 replaceddsw, or "delete from switches", which debuted inVersion 1.Doug McIlroy wrote thatdsw "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 theUnxUtils collection ofnativeWin32ports of common GNU Unix-like utilities.[10]KolibriOS includes an implementation of therm command.[11] Therm command has also been ported to theIBM i operating system.[12]
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 whatrm 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 samefile system as the argument, and will ignore mounted file systems.rm can be overlain by ashell alias (C shellalias,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 filmToy Story 2 atPixar.[15] Therm -rf / variant of the command, if run by asuperuser, would cause every file accessible from the present file system to be deleted from the machine.
rm is often used in conjunction withxargs to supply a list of files to delete:
xargsrm<filelist
Or, to remove allPNG images in all directories below the current one:
find.-name'*.png'-execrm{}+
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, GNUrm asks for confirmation if a write-protected file is to be deleted, unless the -f option is used.)[16]
To delete a directory (withrm -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 thesticky bit set, then deleting the file requires one to be the owner of the file.
Sun Microsystems introduced "rm -rf /" protection inSolaris 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 intoFreeBSD version ofrm utility.[19]GNUrm refuses to executerm -rf / if the--preserve-root option is given,[20] which has been the default since version 6.4 ofGNU Core Utilities was released in 2006. In newer systems, thisfailsafe 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.
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:
aliasrm="rm -i"rm(){/bin/rm-i"$@";}
This results inrm 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 theirrm commands, as well as encouraging a tendency to alternately poundy 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 | rmfiles", 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"];thenrm(){ls-FCsd"$@"echo'remove[ny]? '|tr-d'\012';readif["_$REPLY"="_y"];then/bin/rm-rf"$@"elseecho'(cancelled)'fi}fi
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 systemrm in the search path, nor should it be allowed in non-interactive shells where it could break batch jobs. Enclosing the definition in theif [ -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]
 | This sectionmay contain materialnot related to the topic of the article. Please helpimprove this section or discuss this issue on thetalk page.(January 2025) (Learn how and when to remove this message) |
GNU Core Utilities implementation used in multipleLinux distributions have limits on command line arguments. Arguments are nominally limited to 32 times the kernel's allocated page size. Systems with 4KB page size would thus have a argument size limit of 128KB.[23]
For command-line arguments before kernel 2.6.23, (released on 9 October 2007,) the limits were defined at kernel compile time and can be modified by changing the variableMAX_ARG_PAGES ininclude/linux/binfmts.h file.[24][25]
Newer kernels[which?] limit the maximum argument length to 25% of the maximum stack limit (ulimit -s). Exceeding the limit would prompt the display of the error message/bin/rm: Argument list too long.[26][clarification needed]
With the coupling of ARG_MAX to ulim -s / 4 came the introduction of MAX_ARG_STRLEN as max. length of an argument [...] MAX_ARG_STRLEN is defined as 32 times the page size in linux/include/uapi/linux/binfmts.h [...] The default page size is 4 KB so you cannot pass arguments longer than 128 KB [...]
rm: remove directory entries – Shell and Utilities Reference,The Single UNIX Specification, Version 4 fromThe Open Grouprm(1) – Plan 9 Programmer's Manual, Volume 1rm(1) – Inferno General commandsManual| File system | |
|---|---|
| Processes | |
| User environment | |
| Text processing | |
| Shell builtins | |
| Searching | |
| Documentation | |
| Software development | |
| Miscellaneous | |
| File system | |
|---|---|
| Processes | |
| User environment | |
| Text processing | |
| Shell builtins | |
| Networking | |
| Searching | |
| Software development | |
| Miscellaneous | |
