How to Use modprobe Command in Linux with Examples

The modprobe command is a crucial utility in the Linux operating system, designed for managing kernel modules. Kernel modules are dynamic pieces of code that extend the functionality of the kernel, providing support for additional hardware, filesystems, and other system capabilities without requiring a reboot. The ability to dynamically load and unload these modules makes Linux exceptionally flexible and adaptable to various environments and use cases.

Basic of modprobe

Understanding the basic usage of the modprobe command is crucial for effectively managing kernel modules in a Linux environment. This section will cover the essential aspects of using modprobe, including its syntax, how to load and remove modules, and how to list currently loaded modules.


The syntax for the modprobe command is straightforward. It follows a simple structure:

modprobe [options] module_name
  • module_name: The name of the kernel module you wish to load or remove.
  • [options]: Various options that modify the behavior of modprobe (covered in the next section).

Loading Modules

Loading a kernel module with modprobe is a common task that enables specific hardware or features. To load a module, you simply specify its name:

modprobe module_name

For example, to load a module named e1000 (a common Intel network driver), you would use:

modprobe e1000

Upon execution, modprobe will automatically handle any dependencies required by the e1000 module, ensuring they are loaded in the correct order. This automation simplifies the process significantly compared to manually managing dependencies.

Verifying the Module is Loaded

lsmod | grep e1000

Removing Modules

Just as important as loading modules is the ability to remove them when they are no longer needed. Removing a module can free up system resources and prevent conflicts. To remove a module, use the -r or --remove option:

modprobe -r module_name

Continuing with the previous example, to remove the e1000 module, you would use:

modprobe -r e1000

Modprobe will ensure that the module is safely removed, checking for dependencies and preventing the removal if it would cause issues with other modules.

Listing Modules

While modprobe itself does not list currently loaded modules, it works in conjunction with other commands such as lsmod to provide a comprehensive view of the kernel’s status. To list all currently loaded modules, use the lsmod command:


The lsmod command outputs a list of all loaded modules along with their dependencies and usage counts. This information is crucial for system diagnostics and understanding the current state of the kernel.

Blacklisting Modules

Blacklisting a module prevents it from being loaded automatically, which can be useful for troubleshooting or preventing conflicts.

To blacklist a module, create a blacklist configuration file:

sudo nano /etc/modprobe.d/blacklist.conf

Add the following line to blacklist the nouveau module:

blacklist nouveau

This prevents the nouveau module from being loaded.

Common Options modprobe Command

The modprobe command offers a range of options and parameters that allow users to fine-tune how kernel modules are managed. These options enhance the flexibility and control of the modprobe utility, enabling administrators to handle various scenarios and requirements with precision.

-r / –removeRemove a kernel module from the system, handling dependencies safely.
-v / –verboseEnable verbose mode, providing detailed output for debugging module loading and removal.
-f / –forceForce modprobe to insert or remove a module, bypassing safety checks (use with caution).
-a / –allLoad multiple modules simultaneously, ensuring dependencies are handled correctly.
-C / –configSpecify an alternative configuration file for modprobe, allowing customized settings.

Removing a Kernel Module

The -r or --remove option is used to remove a kernel module from the system. This option ensures that the specified module, along with any dependent modules, is safely unloaded.

To remove the e1000 module:

modprobe -r e1000

This command will unload the e1000 module, checking for dependencies to prevent any issues.

Enabling Verbose Mode

The -v or --verbose option enables verbose mode, providing detailed output about the actions performed by modprobe. This is particularly useful for debugging and understanding what happens when a module is loaded or removed.

To load the e1000 module with verbose output:

modprobe -v e1000

This command will display detailed information about the loading process, including any dependencies that are being loaded.

Forcing Module Operations

The -f or --force option forces modprobe to insert or remove a module, even if there are issues such as version mismatches or unresolved dependencies. This option should be used with caution, as it can lead to system instability.

To force the removal of the e1000 module:

modprobe -r -f e1000

This command will forcefully remove the e1000 module, bypassing any safety checks.

Loading Multiple Modules

The -a or --all option allows you to load multiple modules simultaneously. This can be efficient when several modules are required to support a specific hardware component or feature.

To load the e1000 and e100 modules at the same time:

modprobe -a e1000 e100

This command will load both modules, handling their dependencies appropriately.

Using Custom Configuration

The -C or --config option specifies an alternative configuration file for modprobe. This is useful in scenarios where you need to test or use different configurations without modifying the default settings.

To use a custom configuration file located at /etc/modprobe.d/custom.conf:

modprobe -C /etc/modprobe.d/custom.conf e1000

This command will load the e1000 module using the specified configuration file, allowing for customized settings and behaviors.

Real Life Examples

This section presents a series of practical examples demonstrating how to use modprobe for common tasks such as loading network drivers, removing graphics drivers, and debugging module dependencies.

Removing a Graphics Driver

Removing a graphics driver module can be necessary when troubleshooting display issues or preparing to install a different driver.

Assume you need to remove the nvidia graphics driver module.

Check if the module is in use

lsmod | grep nvidia

Ensure no processes are using the module before removing it. You may need to stop the display manager or any applications using the GPU.

Remove the module

modprobe -r nvidia

Verify the module is removed

lsmod | grep nvidia

The nvidia module should no longer be listed.

Restart the display manager (if applicable)

sudo systemctl start gdm    # For GNOME Display Manager

Debugging Module Dependencies

When a module fails to load due to dependency issues, using modprobe with verbose output can help identify and resolve the problem.

Assume you are trying to load the snd_hda_intel sound driver module, but it fails due to dependency issues.

Attempt to load the module with verbose output

modprobe -v snd_hda_intel

The verbose output will provide detailed information about the loading process and highlight any missing dependencies.

Identify missing dependencies

Review the output to identify which dependencies are causing the issue. For instance, if it mentions that snd_hda_codec is required, you will need to load that module first.

Load missing dependencies

modprobe snd_hda_codec

Retry loading the original module

modprobe snd_hda_intel

Verify the module is loaded

lsmod | grep snd_hda_intel

The snd_hda_intel module should now be listed along with its dependencies.

Handling Dependencies

One of the standout features of modprobe is its ability to automatically handle module dependencies. When you load a module, modprobe ensures that all required dependencies are loaded in the correct order. However, there are times when understanding and manually managing these dependencies becomes necessary.

Viewing Module Dependencies

To view the dependencies of a module, you can use the modinfo command:

modinfo -F depends module_name

For example, to view the dependencies of the e1000 module:

modinfo -F depends e1000

This command will list all modules that e1000 depends on.

Loading Modules with Dependencies

When loading a module with dependencies, you simply use the modprobe command:

modprobe module_name

Modprobe will automatically load the necessary dependencies. However, if you encounter issues, you can manually load dependencies before the main module:

modprobe dependency1
modprobe dependency2
modprobe module_name

Custom Configuration

Modprobe can be configured using custom configuration files, allowing for more granular control over module behavior. These configuration files are typically located in the /etc/modprobe.d/ directory.

Creating a Custom Configuration File

To create a custom configuration file, you can use any text editor. For instance, to create a configuration file for the i915 graphics driver:

sudo nano /etc/modprobe.d/custom_i915.conf

Add the desired options:

options i915 enable_rc6=1

This sets the enable_rc6 option to 1 for the i915 module.

Applying the Custom Configuration

Once the configuration file is created, load the module:

modprobe i915

Verify the options are applied:

systool -vm i915 | grep enable_rc6


The modprobe command is a powerful tool for managing Linux kernel modules. By understanding its basic and advanced usage, configuration options, and troubleshooting techniques, you can effectively control the functionality of your Linux system. Whether you’re loading drivers, managing filesystems, or troubleshooting issues, modprobe provides the flexibility and control needed for efficient system administration.

Share your love

Newsletter Updates

Stay updated with our latest guides and tutorials about Linux.

Leave a Reply

Your email address will not be published. Required fields are marked *