Whereis Command in Linux with Examples

The Linux operating system offers a wide range of powerful command-line tools that help users and system administrators manage their systems efficiently. Among these utilities, the whereis command stands out as a valuable tool for locating binary executables, source files, and manual pages. Whether you’re troubleshooting software installations, developing applications, or simply learning about your Linux system’s organization, the whereis command provides a quick and straightforward way to find the files you need.

Understanding the Whereis Command

The whereis command is a utility designed to locate the binary, source, and manual page files for a specified command or program. Unlike other search utilities that scan the entire filesystem, whereis focuses on specific locations where these files are typically stored, making it significantly faster for its intended purpose.

At its core, whereis strips leading pathname components and trailing extensions from the command name you provide, then searches for files in standard Linux locations and directories specified in environment variables like $PATH and $MANPATH. This approach allows whereis to efficiently find program-related files without consuming excessive system resources.

The command is particularly useful for:

• Quickly identifying the location of executable programs
• Finding documentation for commands
• Locating source code files for development purposes
• Verifying that commands are properly installed
• Understanding how Linux organizes system files

For system administrators and developers, whereis offers an efficient way to navigate the Linux file system and gather important information about installed programs without manually searching through numerous directories.

Syntax and Basic Structure

The basic syntax for the whereis command is straightforward:

whereis [OPTIONS] FILENAME...

When used without any options, whereis searches for the binary, source, and manual files for the command specified as an argument. For example, to find information about the bash command, you would type:

whereis bash

This might produce output similar to:

bash: /bin/bash /etc/bash.bashrc /usr/share/man/man1/bash.1.gz

In this output, /bin/bash is the path to the binary executable, /etc/bash.bashrc is the source file, and /usr/share/man/man1/bash.1.gz is the manual page.

If the command you’re searching for doesn’t exist on your system, whereis will print only the command name, indicating that no files were found. You can also provide multiple arguments to search for several commands simultaneously:

whereis netcat uptime

This would return information about both the netcat and uptime commands:

netcat: /bin/netcat /usr/share/man/man1/netcat.1.gz
uptime: /usr/bin/uptime /usr/share/man/man1/uptime.1.gz

Understanding this basic output format is essential for interpreting the results of whereis queries and effectively using the command in your workflow.

Standard Command Options

The whereis command offers several options that allow you to customize its behavior and narrow down your search. These options help you find specific types of files or limit the search to particular directories.

Binary File Search Options:

• -b: Searches only for binary (executable) files of the specified command
• -B [directory]: Limits the search for binary files to the specified directory

Manual Page Search Options:

• -m: Searches only for manual page files of the specified command
• -M [directory]: Limits the search for manual pages to the specified directory

Source File Search Options:

• -s: Searches only for source files of the specified command
• -S [directory]: Limits the search for source files to the specified directory

Other Useful Options:

• -u: Searches for unusual entries, which are files that don’t have exactly one entry of each requested type (binary, manual, and source)
• -l: Lists all directories that whereis searches by default
• -f: Terminates the directory list and indicates the start of filenames (used with -B, -M, or -S options)
• -h or --help: Displays help information about the command
• -V or --version: Shows version information

These options can be combined to create more specific and targeted searches. For example, if you only need to find the binary file for a command, using the -b option will streamline the output and show you just what you need.

Basic Usage Examples

Let’s explore some practical examples of the whereis command to demonstrate its utility in daily Linux usage.

Finding a Single Command Location

To locate a single command, simply use whereis followed by the command name:

whereis bash

This will show you where the bash executable, source files, and manual pages are located:

bash: /bin/bash /etc/bash.bashrc /usr/share/man/man1/bash.1.gz

Locating Multiple Commands Simultaneously

You can search for multiple commands in one go by listing them after the whereis command:

whereis ls cat whoami

The output will display information for each command:

ls: /bin/ls /usr/share/man/man1/ls.1.gz
cat: /bin/cat /usr/share/man/man1/cat.1.gz
whoami: /usr/bin/whoami /usr/share/man/man1/whoami.1.gz

Identifying Whereis Search Directories

To see the directories that whereis searches by default, use the -l option:

whereis -l

This will show a list of all paths whereis checks when looking for binaries, sources, and manual pages.

Finding Only Binary Files

If you only need to locate the executable file for a command, use the -b option:

whereis -b ping

The output will show only the path to the ping binary:

ping: /bin/ping

Locating Only Manual Pages

Similarly, to find just the manual page for a command, use the -m option:

whereis -m ls

This will return only the path to the ls manual page:

ls: /usr/share/man/man1/ls.1.gz

Searching for Source Files Only

To locate source files for a command, use the -s option:

whereis -s bash

If source files exist, the command will show their locations:

bash: /etc/bash.bashrc

These basic examples demonstrate how whereis can be used to quickly find different types of files associated with Linux commands.

Advanced Usage Patterns

Once you’re comfortable with basic whereis functionality, you can leverage more advanced techniques to perform specialized searches.

Custom Search Path Specification

The whereis command allows you to specify custom directories to search using the -B, -M, and -S options for binaries, manuals, and source files respectively. These must be used with the -f option to indicate where the directory list ends and the filename begins:

whereis -b -B /bin -f cp

This example searches only the /bin directory for the cp binary:

cp: /bin/cp

Directory-Specific Searches

You can combine search restrictions with directory specifications for very targeted searches:

whereis -m ls -M /usr/share/man/man1 -f cal

This searches for the ls manual page in all default paths but looks for the cal manual only in the /usr/share/man/man1 directory.

Finding Unusual Entries

The -u option helps identify commands with unusual file configurations—those that don’t have exactly one file of each requested type:

cd /bin
whereis -m -u *

This example finds all binaries in the /bin directory that either don’t have a manual page or have more than one documentation file.

Combining Multiple Options

You can combine multiple options to create complex search patterns:

whereis -b -s -B /usr/bin -S /usr/src -f gcc

This searches for gcc binary files only in /usr/bin and source files only in /usr/src.

Using Whereis with Wildcards

Wildcards can be powerful when used with whereis, especially with the -u option:

whereis -u *

This finds all unusual entries in the current directory, which can be useful for identifying misconfigured or incomplete software installations.

These advanced usage patterns make whereis a versatile tool for system administration and troubleshooting tasks, allowing for precise file location based on specific criteria.

Practical Applications

The whereis command has numerous practical applications in Linux system administration, development, and everyday use.

System Troubleshooting

When troubleshooting software issues, whereis helps verify that all required components of a program are properly installed. If a program isn’t functioning correctly, you can use whereis to check if its binary, source, and manual files exist in the expected locations.

For example, if a command isn’t working as expected:

whereis problematic-command

If components are missing, you’ll know you need to reinstall or repair the package.

Software Installation Verification

After installing new software, use whereis to confirm that all components were placed in the correct locations:

whereis newly-installed-program

This helps verify that the installation process completed successfully and that the program is ready to use.

Learning System Organization

For those new to Linux, whereis provides insights into how the operating system organizes various types of files. By examining where binaries, sources, and documentation are stored, users can gain a better understanding of Linux file system conventions.

Finding Documentation Quickly

When you need to learn how to use a command, whereis provides a fast way to locate its manual page:

whereis -m command-name

Once you know the manual page location, you can view it with the man command.

Development and Debugging

Developers can use whereis to locate source files for programs they need to modify or study:

whereis -s program-name

This is particularly useful when working on open-source projects or debugging issues in system utilities.

Shell Scripting Applications

In shell scripts, whereis can be used to determine if certain commands are available on the system before attempting to use them, or to locate program components for automatic updates or maintenance tasks.

These practical applications demonstrate how whereis can be integrated into various Linux workflows to improve efficiency and system management.

Integration With Other Commands

The whereis command becomes even more powerful when combined with other Linux utilities through command pipes and output redirection.

Combining With Xargs

The xargs command allows you to build and execute commands from standard input. Combined with whereis, you can perform operations on the files it finds:

whereis ls | xargs ls -l

This displays detailed information about the ls command’s files.

Using With Grep for Filtering

Pipe whereis output to grep to filter for specific patterns:

whereis -b * | grep bin/python

This finds all python-related binaries in standard locations.

Creating Useful Aliases

You can create custom shell aliases to streamline common whereis operations:

alias findbin='whereis -b'
alias findman='whereis -m'
alias findsrc='whereis -s'

These aliases make it faster to locate specific types of files.

Combining With Find for Deep Searches

If whereis doesn’t locate a file in its standard paths, you can combine it with the find command for more thorough searches:

find / -name "$(whereis -b ls | cut -d ' ' -f 2 | xargs basename)" 2>/dev/null

This example finds all files with the same name as the ls binary throughout the filesystem.

Using in Shell Scripts for Conditional Logic

In shell scripts, whereis can help implement conditional logic based on the presence or absence of commands:

if [ "$(whereis -b custom-command)" != "custom-command:" ]; then
    echo "Command exists, proceeding..."
else
    echo "Command not found, installing..."
    # Installation commands here
fi

These integration examples show how whereis can be combined with other Linux commands to create more powerful and flexible file location workflows.

Performance Considerations

For performance comparison:

Choose whereis when you need quick information about program files, which for executable path verification, find for thorough searches with specific criteria, and locate for quick but potentially outdated general file searches.

Limitations and Considerations

While the whereis command is useful for many scenarios, it has several limitations and considerations to keep in mind.

Search Path Limitations

Whereis only searches in predefined paths and directories specified in environment variables. If files are installed in non-standard locations, whereis may not find them. For example, manually compiled software installed in custom directories might be missed.

Distribution Differences

The behavior of whereis can vary across different Linux distributions. Some distributions might include additional search paths or different default options, which can lead to inconsistent results when working across multiple systems.

No Recursive Directory Searching

Unlike the find command, whereis doesn’t search recursively through subdirectories. It only checks the specific locations in its predefined paths, which might miss files located in nested directories.

Limited to Command-Related Files

Whereis is specifically designed to find binary, source, and manual page files for commands. It’s not suitable for locating configuration files, data files, or other types of files that aren’t directly related to commands.

Permissions Issues

If you don’t have read permissions for certain directories, whereis might not find files even if they exist. This can be particularly problematic when searching for system files without appropriate privileges.

No Real-Time Updates

Whereis doesn’t monitor file system changes in real-time. If you’ve just installed or moved files, whereis might not immediately reflect these changes, unlike the find command which always performs a real-time search.

Common Misconceptions

A common misconception is that whereis searches the entire filesystem like find. In reality, it only checks specific locations, which makes it faster but less thorough. Another misconception is that it only finds executables, when it actually locates binary, source, and manual files.

Understanding these limitations will help you determine when whereis is the appropriate tool for your needs and when you should consider alternatives like find, locate, or which.

Best Practices

To make the most of the whereis command, consider these best practices for efficient and effective usage.

Use Specific Search Options

Rather than using whereis without options, specify exactly what you’re looking for with -b (binary), -m (manual), or -s (source) options. This provides cleaner output and faster searches:

whereis -b python

Combine With Other Commands

Create powerful search workflows by combining whereis with other commands like grep, cut, or xargs:

whereis -b * | grep bin/python

Verify Command Existence Before Use

In scripts, use whereis to check if commands exist before attempting to use them:

if [ "$(whereis -b custom-command)" != "custom-command:" ]; then
    # Command exists, proceed
fi

Use Custom Search Paths Wisely

When using the -B, -M, or -S options to specify custom search paths, be as specific as possible to improve search efficiency:

whereis -b -B /usr/local/bin -f python

Check Search Paths First

Before troubleshooting why a file can’t be found, use whereis -l to verify the search paths:

whereis -l

This helps you understand where whereis is looking and whether your files might be in non-standard locations.

Avoid Common Mistakes

Some common mistakes include:

• Forgetting to use the -f option when specifying search directories
• Assuming whereis searches the entire filesystem
• Not using sudo when searching for system files with restricted permissions
• Using whereis instead of which when you only need to know which executable would run

By following these best practices, you’ll be able to use whereis more effectively and integrate it seamlessly into your Linux workflow.