Exporting Module Symbols in Linux: 5 Powerful Steps to Master It Easily

Learn Exporting Module Symbols in Linux through a real-time driver example. Master EXPORT_SYMBOL in 5 easy, beginner-friendly steps.

Ever wondered how one Linux kernel module can use a function or variable from another module? . Imagine this — you’re working as an embedded Linux engineer, and your team is developing a new audio driver for a smart car infotainment system.

Your colleague has already written a sound codec driver module that handles the core audio processing. Meanwhile, you’re building a speaker control module that needs to use one of their functions — let’s say set_audio_volume().

Now, here’s the challenge:
Your module needs that function, but it’s defined inside another kernel module. You can’t just include a header file like in user-space programs. So, how do you make one kernel module talk to another safely?

That’s when you discover the magic of Exporting Module Symbols in Linux.

By simply using EXPORT_SYMBOL(set_audio_volume);, your teammate’s module can “share” that function with your module — just like opening a door between two kernel spaces. Suddenly, your speaker driver can call the function, and your audio stack works perfectly in sync in real time! 🔊🚗

This simple yet powerful mechanism — exporting module symbols — keeps the Linux kernel modular, flexible, and efficient.That’s where exporting module symbols in Linux comes into play!

In this guide, we’ll explore what exporting module symbols means, why it’s used, and how you can easily do it — step by step. By the end, you’ll confidently understand how Linux modules share information using exported symbols.

What Does “Exporting Module Symbols in Linux” Mean?

In simple terms, exporting module symbols in Linux allows one kernel module to make its functions or variables accessible to other modules.

Think of it like this:

• You write a helper function inside one module.
• Another module needs that function.
• Instead of rewriting it, you just export it!

This helps reusability and modularity — key principles of Linux kernel development.

Why Do We Export Symbols?

Let’s say you have:

• A driver module for a hardware component, and
• A utility module that performs logging or shared operations.

If both need to share code, exporting symbols is the perfect solution. It’s a common scenario when working with kernel modules in the Linux operating system, where different modules often depend on one another.

Instead of duplicating the same logic, you can export the symbol once and use it anywhere inside the kernel environment.

So in short:
Promotes code reuse
Makes debugging easier
Keeps the kernel modular and clean

How to Export Module Symbols in Linux

The Linux kernel provides two macros to export symbols:

• EXPORT_SYMBOL(symbol_name);
• EXPORT_SYMBOL_GPL(symbol_name);

The difference?

• EXPORT_SYMBOL — can be used by any module.
• EXPORT_SYMBOL_GPL — can be used only by modules with a GPL-compatible license.

Example: Exporting and Using Symbols

Let’s understand this with a simple example

Module 1: my_math.c

This module defines a function and exports it.

#include 
#include 

int add_numbers(int a, int b) {
    return a + b;
}
EXPORT_SYMBOL(add_numbers);  // Exporting the symbol

static int __init my_math_init(void) {
    printk(KERN_INFO "my_math module loaded\n");
    return 0;
}

static void __exit my_math_exit(void) {
    printk(KERN_INFO "my_math module unloaded\n");
}

module_init(my_math_init);
module_exit(my_math_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Nish");
MODULE_DESCRIPTION("Example of Exporting Module Symbols in Linux");

Module 2: use_math.c

This module imports and uses the exported function.

#include 
#include 

extern int add_numbers(int a, int b);  // Declare the external symbol

static int __init use_math_init(void) {
    int result = add_numbers(4, 5);
    printk(KERN_INFO "Result from exported symbol: %d\n", result);
    return 0;
}

static void __exit use_math_exit(void) {
    printk(KERN_INFO "use_math module unloaded\n");
}

module_init(use_math_init);
module_exit(use_math_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Nish");
MODULE_DESCRIPTION("Using Exported Module Symbols in Linux");

Steps to Try It Out

1. Compile both modules: make
2. Load the first module (exports the symbol): sudo insmod my_math.ko
3. Load the second module (uses the symbol): sudo insmod use_math.ko
4. Check dmesg for output: dmesg | tail
5. Unload both: sudo rmmod use_math sudo rmmod my_math

You’ll see the result of the shared function printed in your kernel log.

Common Errors While Exporting Module Symbols in Linux

If you face an error like:

Unknown symbol in module

It usually means:

• The module that exports the symbol isn’t loaded yet.
• The exported name doesn’t match exactly.
• You forgot to declare it as extern in the using module.

Always check dmesg for kernel logs — it gives clear hints about what went wrong.

Real-World Example

This mechanism is widely used in Linux device drivers.
For instance:

• The sound subsystem exports symbols for codecs and controllers.
• The network stack exports helper functions that other modules reuse.

It’s a clean way for the kernel to stay modular while still sharing functionality between components.

Pro Tip

If your module exports many symbols, you can list them in a Module.symvers file.
This helps the kernel link everything correctly during module compilation.

Wrapping Up

Exporting module symbols in Linux isn’t scary at all — it’s just about sharing functions safely between kernel modules.
It helps keep the Linux kernel modular, reusable, and easier to maintain.

So next time you want one module to use a function from another, just remember:

A simple EXPORT_SYMBOL() can do the magic!

Key Takeaways

EXPORT_SYMBOL(symbol_name);

extern data_type symbol_name;

Raj Kumar

Mr. Raj Kumar is a highly experienced Technical Content Engineer with 7 years of dedicated expertise in the intricate field of embedded systems. At Embedded Prep, Raj is at the forefront of creating and curating high-quality technical content designed to educate and empower aspiring and seasoned professionals in the embedded domain.

Throughout his career, Raj has honed a unique skill set that bridges the gap between deep technical understanding and effective communication. His work encompasses a wide range of educational materials, including in-depth tutorials, practical guides, course modules, and insightful articles focused on embedded hardware and software solutions. He possesses a strong grasp of embedded architectures, microcontrollers, real-time operating systems (RTOS), firmware development, and various communication protocols relevant to the embedded industry.

Raj is adept at collaborating closely with subject matter experts, engineers, and instructional designers to ensure the accuracy, completeness, and pedagogical effectiveness of the content. His meticulous attention to detail and commitment to clarity are instrumental in transforming complex embedded concepts into easily digestible and engaging learning experiences. At Embedded Prep, he plays a crucial role in building a robust knowledge base that helps learners master the complexities of embedded technologies.

embeddedprep.com/