2 In this document you will find information about:
3 - how to build external modules
4 - how to make your module use kbuild infrastructure
5 - how kbuild will install a kernel
6 - how to install modules in a non-standard location
11 === 2 How to build external modules
12 --- 2.1 Building external modules
13 --- 2.2 Available targets
14 --- 2.3 Available options
15 --- 2.4 Preparing the kernel tree for module build
16 --- 2.5 Building separate files for a module
17 === 3. Example commands
18 === 4. Creating a kbuild file for an external module
20 --- 5.1 How to include files from the kernel include dir
21 --- 5.2 External modules using an include/ dir
22 --- 5.3 External modules using several directories
23 === 6. Module installation
24 --- 6.1 INSTALL_MOD_PATH
25 --- 6.2 INSTALL_MOD_DIR
26 === 7. Module versioning
28 --- 8.1 Testing for CONFIG_FOO_BAR
34 kbuild includes functionality for building modules both
35 within the kernel source tree and outside the kernel source tree.
36 The latter is usually referred to as external modules and is used
37 both during development and for modules that are not planned to be
38 included in the kernel tree.
40 What is covered within this file is mainly information to authors
41 of modules. The author of an external modules should supply
42 a makefile that hides most of the complexity so one only has to type
43 'make' to build the module. A complete example will be present in
44 chapter ยค. Creating a kbuild file for an external module".
47 === 2. How to build external modules
49 kbuild offers functionality to build external modules, with the
50 prerequisite that there is a pre-built kernel available with full source.
51 A subset of the targets available when building the kernel is available
52 when building an external module.
54 --- 2.1 Building external modules
56 Use the following command to build an external module:
58 make -C <path-to-kernel> M=`pwd`
60 For the running kernel use:
61 make -C /lib/modules/`uname -r`/build M=`pwd`
63 For the above command to succeed the kernel must have been built with
66 To install the modules that were just built:
68 make -C <path-to-kernel> M=`pwd` modules_install
70 More complex examples later, the above should get you going.
72 --- 2.2 Available targets
74 $KDIR refers to the path to the kernel source top-level directory
77 Will build the module(s) located in current directory.
78 All output files will be located in the same directory
80 No attempts are made to update the kernel source, and it is
81 a precondition that a successful make has been executed
84 make -C $KDIR M=`pwd` modules
85 The modules target is implied when no target is given.
86 Same functionality as if no target was specified.
87 See description above.
89 make -C $KDIR M=$PWD modules_install
90 Install the external module(s).
91 Installation default is in /lib/modules/<kernel-version>/extra,
92 but may be prefixed with INSTALL_MOD_PATH - see separate chapter.
94 make -C $KDIR M=$PWD clean
95 Remove all generated files for the module - the kernel
96 source directory is not modified.
98 make -C $KDIR M=`pwd` help
99 help will list the available target when building external
102 --- 2.3 Available options:
104 $KDIR refers to the path to the kernel source top-level directory
107 Used to specify where to find the kernel source.
108 '$KDIR' represent the directory where the kernel source is.
109 Make will actually change directory to the specified directory
110 when executed but change back when finished.
112 make -C $KDIR M=`pwd`
113 M= is used to tell kbuild that an external module is
115 The option given to M= is the directory where the external
116 module (kbuild file) is located.
117 When an external module is being built only a subset of the
118 usual targets are available.
120 make -C $KDIR SUBDIRS=`pwd`
121 Same as M=. The SUBDIRS= syntax is kept for backwards
124 --- 2.4 Preparing the kernel tree for module build
126 To make sure the kernel contains the information required to
127 build external modules the target 'modules_prepare' must be used.
128 'module_prepare' solely exists as a simple way to prepare
129 a kernel for building external modules.
130 Note: modules_prepare will not build Module.symvers even if
131 CONFIG_MODULEVERSIONING is set.
132 Therefore a full kernel build needs to be executed to make
133 module versioning work.
135 --- 2.5 Building separate files for a module
136 It is possible to build single files which is part of a module.
137 This works equal for the kernel, a module and even for external
139 Examples (module foo.ko, consist of bar.o, baz.o):
140 make -C $KDIR M=`pwd` bar.lst
141 make -C $KDIR M=`pwd` bar.o
142 make -C $KDIR M=`pwd` foo.ko
143 make -C $KDIR M=`pwd` /
146 === 3. Example commands
148 This example shows the actual commands to be executed when building
149 an external module for the currently running kernel.
150 In the example below the distribution is supposed to use the
151 facility to locate output files for a kernel compile in a different
152 directory than the kernel source - but the examples will also work
153 when the source and the output files are mixed in the same directory.
156 /lib/modules/<kernel-version>/source -> /usr/src/linux-<version>
158 # Output from kernel compile
159 /lib/modules/<kernel-version>/build -> /usr/src/linux-<version>-up
161 Change to the directory where the kbuild file is located and execute
162 the following commands to build the module:
164 cd /home/user/src/module
165 make -C /usr/src/`uname -r`/source \
166 O=/lib/modules/`uname-r`/build \
169 Then to install the module use the following command:
171 make -C /usr/src/`uname -r`/source \
172 O=/lib/modules/`uname-r`/build \
176 If one looks closely you will see that this is the same commands as
177 listed before - with the directories spelled out.
179 The above are rather long commands, and the following chapter
180 lists a few tricks to make it all easier.
183 === 4. Creating a kbuild file for an external module
185 kbuild is the build system for the kernel, and external modules
186 must use kbuild to stay compatible with changes in the build system
187 and to pick up the right flags to gcc etc.
189 The kbuild file used as input shall follow the syntax described
190 in Documentation/kbuild/makefiles.txt. This chapter will introduce a few
191 more tricks to be used when dealing with external modules.
193 In the following a Makefile will be created for a module with the
198 8123_bin.o_shipped <= Binary blob
200 --- 4.1 Shared Makefile for module and kernel
202 An external module always includes a wrapper Makefile supporting
203 building the module using 'make' with no arguments.
204 The Makefile provided will most likely include additional
205 functionality such as test targets etc. and this part shall
206 be filtered away from kbuild since it may impact kbuild if
210 --> filename: Makefile
211 ifneq ($(KERNELRELEASE),)
212 # kbuild part of makefile
214 8123-y := 8123_if.o 8123_pci.o 8123_bin.o
219 KERNELDIR := /lib/modules/`uname -r`/build
221 $(MAKE) -C $(KERNELDIR) M=`pwd` $@
223 # Module specific targets
225 echo "X" > 8123_bin.o_shipped
229 In example 1 the check for KERNELRELEASE is used to separate
230 the two parts of the Makefile. kbuild will only see the two
231 assignments whereas make will see everything except the two
234 In recent versions of the kernel, kbuild will look for a file named
235 Kbuild and as second option look for a file named Makefile.
236 Utilising the Kbuild file makes us split up the Makefile in example 1
237 into two files as shown in example 2:
242 8123-y := 8123_if.o 8123_pci.o 8123_bin.o
244 --> filename: Makefile
245 KERNELDIR := /lib/modules/`uname -r`/build
247 $(MAKE) -C $KERNELDIR M=`pwd` $@
249 # Module specific targets
251 echo "X" > 8123_bin_shipped
254 In example 2 we are down to two fairly simple files and for simple
255 files as used in this example the split is questionable. But some
256 external modules use Makefiles of several hundred lines and here it
257 really pays off to separate the kbuild part from the rest.
258 Example 3 shows a backward compatible version.
263 8123-y := 8123_if.o 8123_pci.o 8123_bin.o
265 --> filename: Makefile
266 ifneq ($(KERNELRELEASE),)
271 KERNELDIR := /lib/modules/`uname -r`/build
273 $(MAKE) -C $KERNELDIR M=`pwd` $@
275 # Module specific targets
277 echo "X" > 8123_bin_shipped
281 The trick here is to include the Kbuild file from Makefile so
282 if an older version of kbuild picks up the Makefile the Kbuild
283 file will be included.
285 --- 4.2 Binary blobs included in a module
287 Some external modules needs to include a .o as a blob. kbuild
288 has support for this, but requires the blob file to be named
289 <filename>_shipped. In our example the blob is named
290 8123_bin.o_shipped and when the kbuild rules kick in the file
291 8123_bin.o is created as a simple copy off the 8213_bin.o_shipped file
292 with the _shipped part stripped of the filename.
293 This allows the 8123_bin.o filename to be used in the assignment to
298 8123-y := 8123_if.o 8123_pci.o 8123_bin.o
300 In example 4 there is no distinction between the ordinary .c/.h files
301 and the binary file. But kbuild will pick up different rules to create
307 Include files are a necessity when a .c file uses something from another .c
308 files (not strictly in the sense of .c but if good programming practice is
309 used). Any module that consist of more than one .c file will have a .h file
310 for one of the .c files.
311 - If the .h file only describes a module internal interface then the .h file
312 shall be placed in the same directory as the .c files.
313 - If the .h files describe an interface used by other parts of the kernel
314 located in different directories, the .h files shall be located in
315 include/linux/ or other include/ directories as appropriate.
317 One exception for this rule is larger subsystems that have their own directory
318 under include/ such as include/scsi. Another exception is arch-specific
319 .h files which are located under include/asm-$(ARCH)/*.
321 External modules have a tendency to locate include files in a separate include/
322 directory and therefore needs to deal with this in their kbuild file.
324 --- 5.1 How to include files from the kernel include dir
326 When a module needs to include a file from include/linux/ then one
329 #include <linux/modules.h>
331 kbuild will make sure to add options to gcc so the relevant
332 directories are searched.
333 Likewise for .h files placed in the same directory as the .c file.
339 --- 5.2 External modules using an include/ dir
341 External modules often locate their .h files in a separate include/
342 directory although this is not usual kernel style. When an external
343 module uses an include/ dir then kbuild needs to be told so.
344 The trick here is to use either EXTRA_CFLAGS (take effect for all .c
345 files) or CFLAGS_$F.o (take effect only for a single file).
347 In our example if we move 8123_if.h to a subdirectory named include/
348 the resulting Kbuild file would look like:
353 EXTRA_CFLAGS := -Iinclude
354 8123-y := 8123_if.o 8123_pci.o 8123_bin.o
356 Note that in the assignment there is no space between -I and the path.
357 This is a kbuild limitation: there must be no space present.
359 --- 5.3 External modules using several directories
361 If an external module does not follow the usual kernel style but
362 decide to spread files over several directories then kbuild can
365 Consider the following example:
368 +- src/complex_main.c
369 | +- hal/hardwareif.c
370 | +- hal/include/hardwareif.h
373 To build a single module named complex.ko we then need the following
378 complex-y := src/complex_main.o
379 complex-y += src/hal/hardwareif.o
381 EXTRA_CFLAGS := -I$(src)/include
382 EXTRA_CFLAGS += -I$(src)src/hal/include
385 kbuild knows how to handle .o files located in another directory -
386 although this is NOT reccommended practice. The syntax is to specify
387 the directory relative to the directory where the Kbuild file is
390 To find the .h files we have to explicitly tell kbuild where to look
391 for the .h files. When kbuild executes current directory is always
392 the root of the kernel tree (argument to -C) and therefore we have to
393 tell kbuild how to find the .h files using absolute paths.
394 $(src) will specify the absolute path to the directory where the
395 Kbuild file are located when being build as an external module.
396 Therefore -I$(src)/ is used to point out the directory of the Kbuild
397 file and any additional path are just appended.
399 === 6. Module installation
401 Modules which are included in the kernel are installed in the directory:
403 /lib/modules/$(KERNELRELEASE)/kernel
405 External modules are installed in the directory:
407 /lib/modules/$(KERNELRELEASE)/extra
409 --- 6.1 INSTALL_MOD_PATH
411 Above are the default directories, but as always some level of
412 customization is possible. One can prefix the path using the variable
415 $ make INSTALL_MOD_PATH=/frodo modules_install
416 => Install dir: /frodo/lib/modules/$(KERNELRELEASE)/kernel
418 INSTALL_MOD_PATH may be set as an ordinary shell variable or as in the
419 example above be specified on the command line when calling make.
420 INSTALL_MOD_PATH has effect both when installing modules included in
421 the kernel as well as when installing external modules.
423 --- 6.2 INSTALL_MOD_DIR
425 When installing external modules they are default installed in a
426 directory under /lib/modules/$(KERNELRELEASE)/extra, but one may wish
427 to locate modules for a specific functionality in a separate
428 directory. For this purpose one can use INSTALL_MOD_DIR to specify an
429 alternative name than 'extra'.
431 $ make INSTALL_MOD_DIR=gandalf -C KERNELDIR \
432 M=`pwd` modules_install
433 => Install dir: /lib/modules/$(KERNELRELEASE)/gandalf
436 === 7. Module versioning
438 Module versioning is enabled by the CONFIG_MODVERSIONS tag.
440 Module versioning is used as a simple ABI consistency check. The Module
441 versioning creates a CRC value of the full prototype for an exported symbol and
442 when a module is loaded/used then the CRC values contained in the kernel are
443 compared with similar values in the module. If they are not equal then the
444 kernel refuses to load the module.
446 During a kernel build a file named Module.symvers will be generated. This
447 file includes the symbol version of all symbols within the kernel. If the
448 Module.symvers file is saved from the last full kernel compile one does not
449 have to do a full kernel compile to build a module version's compatible module.
453 --- 8.1 Testing for CONFIG_FOO_BAR
455 Modules often needs to check for certain CONFIG_ options to decide if
456 a specific feature shall be included in the module. When kbuild is used
457 this is done by referencing the CONFIG_ variable directly.
460 obj-$(CONFIG_EXT2_FS) += ext2.o
462 ext2-y := balloc.o bitmap.o dir.o
463 ext2-$(CONFIG_EXT2_FS_XATTR) += xattr.o
465 External modules have traditionally used grep to check for specific
466 CONFIG_ settings directly in .config. This usage is broken.
467 As introduced before external modules shall use kbuild when building
468 and therefore can use the same methods as in-kernel modules when testing
469 for CONFIG_ definitions.