Linux command: locate

You need a file and you know its name, but not where it lives. It could be anywhere on a server with millions of files. You could walk the whole disk with find and wait, or you could ask a tool that already knows where everything is and answers before you finish typing. That tool is locate. It does not search the disk at all; it looks the answer up in an index, and that is why it feels instant.

2. Where the Name Comes From

Like find, the name locate is not an acronym or a joke. It is the plain English verb for the task: to locate a file. The early Unix authors preferred short, ordinary words for ordinary jobs, and this was as short as the word gets.

The interesting part is the letter in front of it. On a modern Linux system the command you run is almost never called plain locate; it is one of a family whose single-letter prefix records the tool's history:

So when you type locate today, you are almost certainly running plocate or mlocate under that friendly name. Each prefix marks a step forward: first make it secure, then make the daily update cheap, then make the search itself blazing fast. Reading the prefix is reading the changelog.

4. Simple Use Cases

4.1 The Simplest Possible Use

Give locate a word, and it prints every path in the database that contains that word anywhere:

$ locate sshd_config
/etc/ssh/sshd_config
/usr/share/man/man5/sshd_config.5.gz

Notice that the word can appear anywhere in the path, not only at the end. By default the pattern is treated as a plain substring: locate hosts matches /etc/hosts and also /usr/lib/ghostscript, because the letters hosts sit inside ghostscript. This is the number-one surprise for new users, and section 5 shows how to tighten it.

4.2 Search Case-Insensitively

By default the match is case-sensitive. The -i flag (short for ignore case) makes it match regardless of capitals, which is what you want when you are not sure how a file was named:

$ locate -i readme
/opt/app/README.md
/usr/share/doc/bash/readme.txt

4.3 Count Instead of List

When you only want to know how many matches exist, the -c flag (short for count) prints a number instead of a long list:

$ locate -c .conf
1873

This is a fast way to gauge the size of a result before you flood your screen with it.

4.4 Search for Several Words at Once

You can pass more than one pattern. Here is the one behavior where plocate and the older mlocate genuinely differ, so it is worth knowing which you have. On plocate, giving several patterns means "match all of them", like an AND:

$ locate nginx conf         # plocate: paths containing BOTH "nginx" and "conf"
/etc/nginx/nginx.conf
/etc/nginx/conf.d/default.conf

On mlocate, the same command means "match any of them" (an OR), and you would add -A (short for all) to require all of them. plocate accepts -A too but ignores it, because AND is already its default.

6. Advanced Use Cases

6.1 Where the Database Comes From: updatedb

Everything locate knows comes from one file, the database, and one command builds it: updatedb. It runs as root so it can see the whole disk, walks the filesystem, and writes the index that locate later reads. On a modern system it runs automatically once a day through a systemd timer or a cron job:

$ systemctl list-timers | grep updatedb
plocate-updatedb.timer  plocate-updatedb.service

If you just created files and want to search for them now, you do not have to wait for tomorrow's run. Trigger it yourself:

$ sudo updatedb          # rebuild the index now, then locate sees new files

6.2 Controlling What Gets Indexed

You rarely want every path in the index. Temporary files, network mounts, and virtual filesystems would only bloat it and slow the daily run. The file /etc/updatedb.conf tells updatedb what to skip:

PRUNEPATHS="/tmp /var/spool /media"
PRUNEFS="nfs cifs tmpfs proc sysfs devtmpfs"
PRUNENAMES=".git .svn .hg"

• PRUNEPATHS lists directories to skip entirely.
• PRUNEFS lists filesystem types to skip, so a mounted network share or a virtual /proc is never crawled.
• PRUNENAMES lists directory names to skip wherever they appear, such as .git folders.

This is why locate usually will not find a file under /tmp: that path is pruned on purpose. If a whole area of your disk seems invisible to locate, this file is the first place to look.

6.3 Searching a Different Database

You are not limited to the system index. The -d flag (short for database) points locate at another index file, which is handy for a custom index of a large project or an external drive:

$ updatedb -l 0 -o photos.db -U /mnt/photos     # build a private index
$ locate -d photos.db beach                      # search only that index

The -l 0 above turns off the permission-visibility feature for a private index you build yourself, and -U tells updatedb which directory to index. You can also set the LOCATE_PATH environment variable to add an extra database to every search automatically.

6.4 Real Regular Expressions

When globs are not expressive enough, locate can match with regular expressions. The -r flag (short for regexp) uses POSIX basic regex, and --regex uses the extended flavour, the same as grep -E:

$ locate --regex '/(nginx|apache2)/.*\.conf$'
/etc/nginx/nginx.conf
/etc/apache2/apache2.conf

There is a cost worth understanding. Normally plocate jumps straight to candidates using its index and barely touches the database. A regex cannot use that index, so it forces a slow linear scan of every entry. Use regex when you need it, but prefer a glob when a glob will do.

6.5 Why locate Does Not Leak Private Files

The index is built by root and lists files that ordinary users cannot read. So how does locate avoid showing you your neighbour's private paths? It runs with the setgid bit, which lets it open the protected index, but before printing any result it checks whether you have permission to reach that path. If you lack read and execute permission on the parent directories, the match is silently dropped. The catalog is complete, but everyone sees only their own section of it.

8. Best Practices

• Reach for locate first, find second. For a plain "where is this file" question it is far faster; use find when you need live results or metadata tests.
• Run sudo updatedb after big changes. If you just installed software or created files and locate cannot see them, the index is simply stale. Refresh it.
• Quote patterns with wildcards. Write locate '*/passwd', not locate */passwd, or the shell expands the pattern before locate sees it.
• Use -b to cut noise. When a common word hides in many folder names, match only the basename.
• Add -e when you will act on the results. It drops paths that no longer exist, so you do not chase a deleted file.
• Prefer a glob over a regex. A glob uses the fast index; -r and --regex force a full scan.
• Use -0 | xargs -0 in pipes. It is the only safe way to pass results with spaces or newlines to another command.

When you need the full detail, the documentation is one command away:

$ man locate      # the manual for your locate (often plocate or mlocate)
$ locate --help   # a quick summary of every option
$ man updatedb    # how the index is built and scheduled

10. Summary

The locate command finds files by name across the whole system almost instantly, by looking them up in a prepared index instead of searching the disk.

• locate reads a database built once a day by updatedb; it is fast because it never walks the live filesystem.
• The trade-off is freshness: brand-new files are missing until the index updates, so run sudo updatedb when you need current results.
• The name you type is usually plocate or mlocate; the prefix records the tool's history from secure to merging to posting-list.
• Patterns match as a substring by default; a wildcard turns the pattern into an anchored glob, and -b limits the match to the file name.
• Everyday flags: -i (ignore case), -c (count), -e (only existing), -l (limit), -0 (safe piping).
• Control what is indexed through /etc/updatedb.conf, and use find when you need freshness, metadata, or content search.

This is the quick reference worth keeping:

locate hosts                 paths containing "hosts" anywhere
locate -i readme             same, ignoring upper/lower case
locate -c .conf              count the matches instead of listing them
locate nginx conf            plocate: paths matching BOTH words
locate -b '\.conf'           match the file name only, not the folders
locate '*/passwd'            glob: path must end in /passwd
locate -e report.pdf         only results that still exist on disk
locate -l 5 .service         stop after the first 5 matches
locate -0 '*.bak' | xargs -0 ls -lh   safe pipe for odd names
locate --regex '\.log$'      match with an extended regular expression
sudo updatedb                rebuild the index now
man updatedb                 how the index is built and pruned

Once locate is part of your habits, a large server stops feeling like a maze. You stop guessing where things live and simply ask, and the answer arrives before you have finished the thought. If your servers have grown into something no one can quite navigate anymore, sorting that out, and keeping it fast and tidy, is exactly the kind of work I help with.