Dentro del núcleo Linux 2.4 - Inicialización de Alto Nivel

Por "Inicialización de Alto Nivel" consideramos cualquier cosa que no está directamente relacionada con la fase de arranque, incluso aquellas partes del código que están escritas en ensamblador, esto es arch/i386/kernel/head.S, que es el comienzo del núcleo descomprimido. Los siguientes pasos son realizados:

1. Inicializa los valores de segmento (%ds = %es = %fs = %gs = KERNEL_DS = 0x18).
2. Inicializa las tablas de páginas.
3. Habilita el paginamiento estableciendo el bit PG en %cr0.
4. Limpia a cero BSS (en SMP, sólo la primera CPU realiza esto).
5. Copia los primeros 2k de los parámetros de arranque (linea de comandos del núcleo).
6. Chequea el tipo de CPU usando EFLAGS y, si es posible, cpuid, capaz de detectar 386 y superiores.
7. La primera CPU llama a start_kernel(),y si ready=1 todas las otras llaman a arch/i386/kernel/smpboot.c:initialize_secondary() el cual recarga esp/eip y no retorna.

La función init/main.c:start_kernel() está escrita en C y realiza lo siguiente:

1. Realiza un cierre global del núcleo (es necesario para que sólo una CPU realice la inicialización).
2. Realiza configuraciones específicas de la arquitectura (análisis de la capa de memoria, copia de la linea de comandos de arranque otra vez, etc.).
3. Muestra el "anuncio" del núcleo Linux conteniendo la versión, el compilador usado para construirlo, etc ..., a la memoria intermedia con forma de anillo del núcleo para los mensajes. Esto es tomado desde la variable linux_banner definida en init/version.c y es la misma cadena mostrada por cat /proc/version.
4. Inicializa las traps.
5. Inicializa las irqs.
6. Inicializa los datos requeridos por el planificador (scheduler).
7. Inicializa el tiempo manteniendo los datos.
8. Inicializa el subsistema softirq.
9. Analiza las opciones del arranque de la linea de comandos.
10. Inicializa la consola.
11. Si el soporte para módulos ha sido compilado en el núcleo, inicializa la facilidad para la carga dinámica de módulos.
12. Si la linea de comandos "profile=" ha sido suministrada, inicializa los perfiles de memoria intermedia.
13. kmem_cache_init(), inicializa la mayoría del asignador slab.
14. Habilita las interrupciones.
15. Calcula el valor BogoMips para esta CPU.
16. Llama a mem_init(), que calcula max_mapnr, totalram_pages y high_memory y muestra la linea "Memory: ...".
17. kmem_cache_sizes_init(), finaliza la inicialización del asignador slab.
18. Inicializa las estructuras de datos usadas por procfs.
19. fork_init(), crea uid_cache, inicializa max_threx_threads basándose en la cantidad de memoria disponible y configura RLIMIT_NPROC para que init_task sea max_threads/2.
20. Crea varias antememorias slab necesitadas para VFS, VM, la antememoria intermedia, etc.
21. Si el soporte para System V IPC ha sido compilado en el núcleo, inicializa el subsistema. Nótese que para System V shm, esto incluye el montaje de una instancia (dentro del núcleo) del sistema de archivos shmfs.
22. Si el soporte de quota ha sido compilado en el núcleo, crea e inicializa una antememoria slab especial para él.
23. Realiza "chequeos de fallos" específicos de la arquitectura y, cuando es posible, activa las correcciones para los fallos de procesadores/bus/etc. Comparando varias arquitecturas vemos que "ia64 no tiene fallos" e "ia32 tiene unos pocos". Un buen ejemplo es el "fallo f00f", el cual es sólo chequeado si el núcleo ha sido compilado para menos de un 686 y corregido adecuadamente.
24. Establece una bandera para indicar que un planificador debería de ser llamado en la "siguiente oportunidad" y crea un hilo del núcleo init() que ejecuta execute_command si este ha sido suministrado a través del parámetro de inicio "init=", o intenta ejecutar /sbin/init, /etc/init, /bin/init, /bin/sh en este orden; si todos estos fallan, ocurre una situación de pánico con la "sugerencia" de usar el parámetro "init=".
25. Se va a un bucle vacío, este es un hilo vacío con pid=0.

Una cosa importante que hay que hacer notar aquí es que el hilo del núcleo init() llama a do_basic_setup(), el cual cuando vuelve llama a do_initcalls(), que va a través de la lista de funciones registradas por medio de las macros initcall o module_init() y las invoca. Estas funciones no dependen de otras o sus dependencias han sido manualmente arregladas por el orden de enlazado en los Makefiles. Esto significa que, dependiendo de las posición de los directorios en los árboles y de las estructuras en los Makefiles, el orden en el cual estas funciones de inicialización son llamadas puede cambiar. A veces esto es importante, imagínate dos subsistemas A y B, con B dependiendo de alguna inicialización realizada por A. Si A es compilada estáticamente y B es un módulo entonces el punto de entrada de B está garantizado para ser llamado después de que A prepare todo el entorno necesario. Si A es un módulo, entonces B es también necesariamente un módulo para que no existan problemas. Pero, ¿qué pasa si A y B están estáticamente enlazadas en el núcleo? El orden en el cual son llamadas depende del desplazamiento relativo del punto de entrada en la sección ELF .initcall.init de la imagen del núcleo. Rogier Wolff propuso introducir una infraestructura jerárquica de "prioridades" donde los módulos pueden dejar que el enlazador conozca en que orden (relativo) deberían de ser enlazados, pero todavía no existen parches disponibles que implementen esto de una forma suficientemente elegante para ser aceptada en el núcleo. Por consiguiente, asegúrate de que el orden de enlace es correcto, Si, en el ejemplo anterior, A y B trabajan bien cuando han sido compilados estáticamente una vez, trabajarán siempre, tal como han sido listados secuencialmente en el mismo Makefile. Si no trabajan, cambia el orden en el cual sus archivos objetos son listados.

Otra cosa de algún valor es la habilidad de Linux de ejecutar un "programa init alternativo" por medio del pase de la linea de comandos "init=". Esto es útil para la recuperación desde un /sbin/init accidentalmente sobreescrito o para depurar a mano los guiones de inicialización (rc) y /etc/inittab, ejecutándolos de uno en uno.