Modules can take command line arguments, but not with the argc/argv you might be used to.
To allow arguments to be passed to your module, declare the variables that will take the values of the command line arguments as global and then use the MODULE_PARM() macro, (defined in linux/module.h) to set the mechanism up. At runtime, insmod will fill the variables with any command line arguments that are given. The variable declarations and macros should be placed at the beginning of the module for clarity. The example code should clear up my admittedly lousy explanation.
The MODULE_PARM() macro takes 2 arguments: the name of the variable and its type. The supported variable types are "b": single byte, "h": short int, "i": integer, "l": long int and "s": string. Strings should be declared as "char *" and insmod will allocate memory for them. You should always try to give the variables an initial default value. This is kernel code, and you should program defensively. For example:
int myint = 3; |
Arrays are supported too. An integer value preceding the type in MODULE_PARM will indicate an array of some maximum length. Two numbers separated by a '-' will give the minimum and maximum number of values. For example, an array of shorts with at least 2 and no more than 4 values could be declared as:
int myshortArray[4]; |
A good use for this is to have the module variable's default values set, like which IO port or IO memory to use. If the variables contain the default values, then perform autodetection (explained elsewhere). Otherwise, keep the current value. This will be made clear later on. For now, I just want to demonstrate passing arguments to a module.
Example 2-7. hello-5.c
/* hello-5.c - Demonstrates command line argument passing to a module. |
Supercalifragilisticexpialidocious
2.7. Modules Spanning Multiple Files
Sometimes it makes sense to divide a kernel module between several source files. In this case, you need to:
-
In all the source files but one, add the line #define __NO_VERSION__. This is important because module.h normally includes the definition of kernel_version, a global variable with the kernel version the module is compiled for. If you need version.h, you need to include it yourself, because module.h won't do it for you with __NO_VERSION__.
-
Compile all the source files as usual.
-
Combine all the object files into a single one. Under x86, use ld -m elf_i386 -r -o <module name.o> <1st src file.o> <2nd src file.o>.
Here's an example of such a kernel module.
Example 2-8. start.c
/* start.c - Illustration of multi filed modules |
The next file:
Example 2-9. stop.c
/* stop.c - Illustration of multi filed modules |
And finally, the makefile:
Example 2-10. Makefile for a multi-filed module
CC=gcc |