linux启动时对编译进内核驱动模块的加载

[init/main.c]start_kernel()->rest_init()->kernel_thread创建核心线程init()->do_basic_setup()->do_initcalls()
    在/include/linux/init.h中

#define __init  __attribute__ ((__section__ (".init.text")))
#define __initdata __attribute__ ((__section__ (".init.data")))
#define __exitdata __attribute__ ((__section__(".exit.data")))
#define __exit_call __attribute_used__ __attribute__ ((__section__ (".exitcall.exit")))

#ifdef MODULE
#define __exit  __attribute__ ((__section__(".exit.text")))
#else
#define __exit  __attribute_used__ __attribute__ ((__section__(".exit.text")))
#endif

/* For assembly routines */
#define __INIT  .section ".init.text","ax"
#define __FINIT  .previous
#define __INITDATA .section ".init.data","aw"

#ifndef __ASSEMBLY__
/*
 * Used for initialization calls..
 */
typedef int (*initcall_t)(void);
typedef void (*exitcall_t)(void);

extern initcall_t __con_initcall_start[], __con_initcall_end[];
extern initcall_t __security_initcall_start[], __security_initcall_end[];

/* Defined in init/main.c */
extern char saved_command_line[];

/* used by init/main.c */
extern void setup_arch(char **);

#endif
 
#ifndef MODULE

#ifndef __ASSEMBLY__

/* initcalls are now grouped by functionality into separate
 * subsections. Ordering inside the subsections is determined
 * by link order.
 * For backwards compatibility, initcall() puts the call in
 * the device init subsection.
 */

#define __define_initcall(level,fn) \
 static initcall_t __initcall_##fn __attribute_used__ \
 __attribute__((__section__(".initcall" level ".init"))) = fn

#define core_initcall(fn)  __define_initcall("1",fn)
#define postcore_initcall(fn)  __define_initcall("2",fn)
#define arch_initcall(fn)  __define_initcall("3",fn)
#define subsys_initcall(fn)  __define_initcall("4",fn)
#define fs_initcall(fn)   __define_initcall("5",fn)
#define device_initcall(fn)  __define_initcall("6",fn)
#define late_initcall(fn)  __define_initcall("7",fn)

#define __initcall(fn) device_initcall(fn)

#define __exitcall(fn) \
 static exitcall_t __exitcall_##fn __exit_call = fn

#define console_initcall(fn) \
 static initcall_t __initcall_##fn \
 __attribute_used__ __attribute__((__section__(".con_initcall.init")))=fn

#define security_initcall(fn) \
 static initcall_t __initcall_##fn \
 __attribute_used__ __attribute__((__section__(".security_initcall.init"))) = fn

struct obs_kernel_param {
 const char *str;
 int (*setup_func)(char *);
 int early;
};

/*
 * Only for really core code.  See moduleparam.h for the normal way.
 *
 * Force the alignment so the compiler doesn't space elements of the
 * obs_kernel_param "array" too far apart in .init.setup.
 */
#define __setup_param(str, unique_id, fn, early)   \
 static char __setup_str_##unique_id[] __initdata = str; \
 static struct obs_kernel_param __setup_##unique_id \
  __attribute_used__    \
  __attribute__((__section__(".init.setup"))) \
  __attribute__((aligned((sizeof(long))))) \
  = { __setup_str_##unique_id, fn, early }

#define __setup_null_param(str, unique_id)   \
 __setup_param(str, unique_id, NULL, 0)

#define __setup(str, fn)     \
 __setup_param(str, fn, fn, 0)

#define __obsolete_setup(str)     \
 __setup_null_param(str, __LINE__)

/* NOTE: fn is as per module_param, not __setup!  Emits warning if fn
 * returns non-zero. */
#define early_param(str, fn)     \
 __setup_param(str, fn, fn, 1)

/* Relies on saved_command_line being set */
void __init parse_early_param(void);
#endif /* __ASSEMBLY__ */

/**
 * module_init() - driver initialization entry point
 * @x: function to be run at kernel boot time or module insertion
 *
 * module_init() will either be called during do_initcalls (if
 * builtin) or at module insertion time (if a module).  There can only
 * be one per module.
 */
#define module_init(x) __initcall(x);

/**
 * module_exit() - driver exit entry point
 * @x: function to be run when driver is removed
 *
 * module_exit() will wrap the driver clean-up code
 * with cleanup_module() when used with rmmod when
 * the driver is a module.  If the driver is statically
 * compiled into the kernel, module_exit() has no effect.
 * There can only be one per module.
 */
#define module_exit(x) __exitcall(x);