Linux File/Command Finding

Introduction

In Linux systems, locating files and commands efficiently is an essential skill for all users. When working with the command line, you often need to find where programs are installed, where to access their documentation, or where configuration files are stored.

This lab focuses on the whereis command, a powerful utility that helps locate binary files, source code, and manual pages for commands in Linux. By learning how to use this command effectively, you can navigate the Linux filesystem with greater confidence and improve your productivity.

Throughout this lab, you will learn various ways to use the whereis command to find different components of Linux commands, giving you practical skills that will be valuable in your Linux journey.

Skills Graph

Understanding the whereis Command

The whereis command in Linux is designed to locate the binary, source, and manual page files for a command. This is particularly useful when you need to find where a program is installed or where its documentation is stored.

Let's start by exploring how the whereis command works. First, ensure you are in the project directory:

cd ~/project

To get a better understanding of the whereis command, let's look at its help information:

whereis --help

You should see output similar to the following, showing the various options available with the whereis command:

Usage:
 whereis [options] [-BMS <dir>... -f] <name>...

Locate the binary, source, and manual page files for a command.

Options:
 -b         search only for binaries
 -B <dirs>  define binaries lookup path
 -m         search only for manuals and infos
 -M <dirs>  define man and info lookup path
 -s         search only for sources
 -S <dirs>  define sources lookup path
 -f         terminate <dirs> argument list
 -u         search for unusual entries
 -l         output effective lookup paths

For more details see whereis(1).

This output explains that whereis can be used to find binaries (executable files), source files, and manual pages for commands. It also shows the various options you can use to refine your search.

Finding Binary Executables with whereis

In Linux, binary executables are the compiled, ready-to-run programs that you can execute from the command line. These are typically stored in directories like /usr/bin, /bin, or /usr/local/bin.

Let's use the whereis command to find the location of some commonly used Linux commands.

First, let's find the binary for the grep command, which is used for pattern searching in files:

whereis grep

You should see output similar to:

grep: /usr/bin/grep /usr/share/man/man1/grep.1.gz

This output tells you two important things:

• The binary executable for grep is located at /usr/bin/grep
• The manual page for grep is at /usr/share/man/man1/grep.1.gz

If you're only interested in finding the binary executable and not the manual pages or source files, you can use the -b option:

whereis -b grep

The output will show only the binary location:

grep: /usr/bin/grep

Now, let's find the location of another common command, ls, which is used to list directory contents:

whereis ls

You should see output similar to:

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

This shows that the ls command's binary is in /usr/bin/ls and its manual page is at /usr/share/man/man1/ls.1.gz.

The whereis command searches through predefined paths to find these files. These paths typically include the standard locations where Linux stores binaries, manual pages, and source files.

Finding Manual Pages with whereis

Manual pages (man pages) provide documentation for commands and programs in Linux. They contain detailed information about how to use a command, what options are available, and examples of common usage.

The whereis command can help you locate these manual pages using the -m option. Let's see how to find manual pages for various commands.

First, let's find the manual page for the find command, which is used to search for files in a directory hierarchy:

whereis -m find

You should see output similar to:

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

This shows that the manual page for the find command is located at /usr/share/man/man1/find.1.gz.

Manual pages in Linux are typically stored in the /usr/share/man directory, organized into numbered sections:

• Section 1: User commands (executable programs or shell commands)
• Section 2: System calls (functions provided by the kernel)
• Section 3: Library calls (functions within program libraries)
• Section 4: Special files (usually found in /dev)
• Section 5: File formats and conventions
• Section 6: Games
• Section 7: Miscellaneous
• Section 8: System administration commands

Most commonly used commands have their manual pages in section 1, which is why you'll often see filenames ending with .1.gz (compressed files in section 1).

Let's find the manual page for the passwd command, which is used to change user passwords:

whereis -m passwd

You might see output similar to:

passwd: /usr/share/man/man1/passwd.1.gz /usr/share/man/man5/passwd.5.gz

Notice that passwd has manual pages in two different sections - section 1 for the command itself and section 5 for the password file format.

You can directly access these manual pages using the man command followed by the command name:

man find

Press q to exit the manual page viewer when you're done reading.

Finding Source Files with whereis

Source files are the original code files from which binary executables are compiled. The whereis command can also help you locate these source files when they are available in your system.

To search for source files, use the -s option with whereis. Let's try to find source files for some common commands:

whereis -s ls

Depending on your system configuration, you might not see any output or you might see something like:

ls:

This indicates that the source files for ls are not available in the standard locations on your system. This is common for many pre-installed programs in Linux distributions, as their source code is typically not included by default.

Some programs, especially those you compile from source or development tools, might have their source files available in the system. Let's try another command, like gcc (the GNU C Compiler):

whereis -s gcc

Again, the output depends on your system. You might see something like:

gcc: /usr/lib/gcc

This indicates that source files related to gcc might be found in the /usr/lib/gcc directory.

It's important to note that the -s option is looking for source files in predefined locations, which might not include all the places where source code could be stored on your system. Additionally, many programs in Linux distributions are installed from binary packages, so their source code might not be present locally.

Let's combine multiple options to get a more comprehensive view of where files related to a command are located. For example, to find all binary, manual, and source files for python:

whereis python

This should show all available locations for python-related files in your system, which might include multiple binaries, manual pages, and possibly source directories.

Combining Options and Searching for Multiple Commands

The whereis command offers flexibility in how you search for files and can be used to search for multiple commands at once. In this final step, we'll explore how to combine different options and search for multiple commands in a single query.

First, let's combine multiple options to refine our search. For example, if you want to find both binary files and manual pages (but not source files) for the tar command:

whereis -b -m tar

You should see output similar to:

tar: /usr/bin/tar /usr/share/man/man1/tar.1.gz

This shows both the binary and manual page locations for the tar command.

You can also search for multiple commands in a single whereis query. This is useful when you need to locate several related commands at once. Let's find the locations for three commands - cp, mv, and rm:

whereis cp mv rm

You should see output similar to:

cp: /usr/bin/cp /usr/share/man/man1/cp.1.gz
mv: /usr/bin/mv /usr/share/man/man1/mv.1.gz
rm: /usr/bin/rm /usr/share/man/man1/rm.1.gz

This gives you a quick overview of where these three common file manipulation commands are located in your system.

Another useful option is -l, which lists the directories that whereis searches when looking for files:

whereis -l

This will show a list of directories that whereis checks for binary files, manual pages, and source files. The output will vary depending on your system configuration but might look something like:

bin: /usr/bin
bin: /usr/sbin
bin: /usr/games
bin: /usr/local/bin
bin: /usr/local/sbin
man: /usr/man/all
man: /usr/share/man/all
man: /usr/local/man/all
man: /usr/local/share/man/all
src: /usr/src/linux
src: /usr/src/packages
src: /usr/local/src
...

This information is useful for understanding where whereis is looking and why it might not find certain files even if they exist on your system.

The whereis command is a quick way to locate important files associated with commands in your Linux system. While it has some limitations (like only searching in predefined paths), it provides a fast and straightforward method to find binary executables, manual pages, and in some cases, source files for the commands you use.

Summary

In this lab, you have learned how to use the whereis command in Linux to locate important files associated with commands in your system. Here's a recap of what you've accomplished:

1. You've learned the basic syntax and options of the whereis command
2. You've used whereis to find binary executable files for commands
3. You've discovered how to locate manual pages using the -m option
4. You've explored finding source files with the -s option, understanding its limitations
5. You've practiced combining options and searching for multiple commands at once

The whereis command is a valuable tool in your Linux toolkit, allowing you to quickly find where programs are installed and where their documentation is located. This knowledge helps you navigate the Linux filesystem more efficiently and understand how software is organized on your system.

As you continue your Linux journey, you might also explore related commands like which (which only finds executables in your PATH), locate (which can find any files by name using a database), and find (which can search for files using various criteria). Each of these commands has its own strengths and use cases, complementing what you've learned about whereis.