Follow+Star Public Account Number, don’t miss out on exciting content
Source | Baiwen Technology
WeChat Public Account | Embedded Column
The Linux kernel source code contains numerous files, and it can be confusing to understand the relationship between Makefile, Kconfig, and .config. Without a clear understanding of the kernel compilation system, one may struggle with compiling and modifying the kernel, integrating custom drivers, or configuring the kernel. These issues are all related to Makefile, Kconfig, and .config. Below, we will briefly discuss Makefile, Kconfig, and .config. I hope this will inspire you.
Embedded Column
1
The Role of the Three Files
In simple terms, it’s like ordering dishes at a restaurant: Kconfig is the menu, Makefile is the recipe, and .config is the dish you ordered.
Makefile: A text file that defines how to compile source files.
Kconfig: A text file that serves as the configuration menu for the kernel.
.config: The configuration file used for compiling the kernel.
Embedded Column
2
The Syntax of the Three Files
1. Makefile
Reference: linux-3.4.2/drivers/Makefile
Function: Used to define which components are compiled as modules and under what conditions. The subdirectory Makefile is included by the top-level Makefile.
(1) Direct Compilation
obj-y += xxx.o
This indicates that xxx.c or xxx.s is compiled into xxx.o and directly integrated into the kernel.
(2) Conditional Compilation
obj -$(CONFIG_HELLO) += xxx.o
This determines whether the file is included in the kernel based on the CONFIG_XXX in the .config file.
(3) Module Compilation
obj-m +=xxx.o
This indicates that xxx is compiled as a module, meaning it will only be compiled when executing make modules.
2. Kconfig
Each config menu item has a type definition: bool (boolean), tristate (built-in, module, removed), string, hex, and integer.
Function: Determines the menu items displayed during make menuconfig.
Reference: linux-3.4.2/drivers/leds/Kconfig:
config LEDS_S3C24XX
tristate “LED Support for Samsung S3C24XX GPIO LEDs”
depends on LEDS_CLASS
depends on ARCH_S3C24XX
help
This option enables support for LEDs connected to GPIO lines
on Samsung S3C24XX series CPUs, such as the S3C2410 and S3C2440.
LEDS_S3C24XX: The name of the configuration option, omitting the prefix “CONFIG_”
Tristate:
Indicates whether the item is compiled into the kernel or as a module. It is displayed as < >. If selected to compile as a kernel module, a CONFIG_HELLO_MODULE=m configuration will be generated in .config. Selecting Y means it is directly compiled into the kernel, generating a CONFIG_HELLO_MODULE=y configuration item in .config. The string following tristate is the name displayed during make menuconfig.
bool:
This type can only be checked or unchecked, displayed as [ ] during make menuconfig, meaning it cannot be configured as a module.
dependon:
This option depends on another option, and the prompt for the current configuration item will only appear if the dependency is selected, allowing the current configuration item to be set.
select:
A reverse dependency; when this option is selected, the item defined after select is also selected.
help:
Help information.
Directory Hierarchy Iteration:
Kconfig contains statements like: source “drivers/usb/Kconfig” to include (or nest) new Kconfig files, allowing each directory to manage its own configuration content without having to write all configurations in a single file, making it easier to modify and manage.
3. .config
Reference: linux-3.4.2/.config
From the analysis of the previous two files, the meaning of .config is clear: it is a reference file for kernel compilation, and by checking its contents, one can see which drivers are compiled into the kernel.
There are three ways to configure the kernel (choose one):
(1) make menuconfig
(2) make xxx_defconfig
(3) Directly modify .config
Note: If you directly modify .config, it may not take effect, as some configurations may have dependencies. During make, the rules will be checked based on these dependencies, and direct modifications to .config may sometimes be ineffective, so it is not recommended to modify it directly.
The above may be a bit abstract, so let’s illustrate with an example:
Write a simple entry function that outputs hello world and compile it into the kernel.
Steps:
(1) Create a new folder named hello in the drivers directory, and implement hello.c, Makefile, and Kconfig inside it.
hello.c:
#include <linux/module.h> #include <linux/kernel.h> #include <linux/init.h> static int first_drv_init(void) { printk("------------------hello world !--------------------"); return 0; } static void first_drv_exit(void) { printk("------------------exit hello world !--------------------"); } module_init(first_drv_init); module_exit(first_drv_exit); MODULE_LICENSE("GPL");Makefile:
obj-$(CONFIG_HELLO) += hello.o
Kconfig:
config HELLO
tristate “Hello World for fengyuwuzu”
help
Hello for fengyuwuzu
config HELLO determines the name: CONFIG_HELLO.
Hello World for fengyuwuzu: determines the name displayed during make menuconfig
(2) Modify the upper-level (Linux-3.4.2/drivers) Makefile and Kconfig.
Makefile:
obj-y += hello/
Kconfig:
source “drivers/hello/Kconfig”
(3) make menuconfig
(4) make uImage and then flash it to the development board.
Check the kernel boot log, and the great hello world appears! This indicates that hello.c has been successfully compiled into the kernel.
Feel free to refer to this experiment, and I believe you will have a clearer understanding of the kernel’s organizational structure.
Disclaimer: The materials in this article are sourced from the internet, and the copyright belongs to the original author. If there are any copyright issues, please contact me for removal.
———— END ————
Reply with ‘Linux’ or ‘File Format’ to read more related articles.
Follow the WeChat Public Account ‘Embedded Column’ for more content, and reply ‘Join Group’ to join the technical exchange group according to the rules.
Click ‘Read Original’ to see more shares, and feel free to share, bookmark, like, and view.