Co oznacza __init w kodzie jądra Linuksa?

W kodzie źródłowym jądra Linux znalazłem tę funkcję:

static int __init clk_disable_unused(void) 
{
   // some code
}

Tutaj nie mogę zrozumieć, co to __initznaczy.

include/linux/init.h

/* These macros are used to mark some functions or 
 * initialized data (doesn't apply to uninitialized data)
 * as `initialization' functions. The kernel can take this
 * as hint that the function is used only during the initialization
 * phase and free up used memory resources after
 *
 * Usage:
 * For functions:
 * 
 * You should add __init immediately before the function name, like:
 *
 * static void __init initme(int x, int y)
 * {
 *    extern int z; z = x * y;
 * }
 *
 * If the function has a prototype somewhere, you can also add
 * __init between closing brace of the prototype and semicolon:
 *
 * extern int initialize_foobar_device(int, int, int) __init;
 *
 * For initialized data:
 * You should insert __initdata between the variable name and equal
 * sign followed by value, e.g.:
 *
 * static int init_variable __initdata = 0;
 * static const char linux_logo[] __initconst = { 0x32, 0x36, ... };
 *
 * Don't forget to initialize data not at file scope, i.e. within a function,
 * as gcc otherwise puts the data into the bss section and not into the init
 * section.
 * 
 * Also note, that this data cannot be "const".
 */

/* These are for everybody (although not all archs will actually
   discard it in modules) */
#define __init      __section(.init.text) __cold notrace
#define __initdata  __section(.init.data)
#define __initconst __section(.init.rodata)
#define __exitdata  __section(.exit.data)
#define __exit_call __used __section(.exitcall.exit)

Są to tylko makra do zlokalizowania niektórych części kodu Linuksa w specjalnych obszarach w końcowym pliku binarnym. __init, na przykład (lub lepiej, gdy __attribute__ ((__section__ (".init.text")))makro to rozwija się do) instruuje kompilator, aby oznaczył tę funkcję w specjalny sposób. Na końcu konsolidator zbiera wszystkie funkcje z tym znakiem na końcu (lub początku) pliku binarnego.

Kiedy jądro się uruchamia, ten kod jest uruchamiany tylko raz (inicjalizacja). Po uruchomieniu jądro może zwolnić tę pamięć, aby ją ponownie wykorzystać, a zobaczysz komunikat jądra:

Zwolnienie nieużywanej pamięci jądra: zwolniono 108 KB

Aby skorzystać z tej funkcji, potrzebujesz specjalnego pliku skryptu konsolidatora, który powie linkerowi, gdzie zlokalizować wszystkie zaznaczone funkcje.

To demonstruje cechę jądra 2.2 i późniejszych. Zwróć uwagę na zmianę w definicjach funkcji initi cleanup. __initMakro wywołuje initfunkcję do wyrzucenia a pamięć zwolniona raz w initwykończeniach funkcyjnych dla wbudowanych sterowników, lecz nie ładowalne moduły. Jeśli myślisz o initwywołaniu funkcji, ma to sens.

źródło

__init to makro zdefiniowane w ./include/linux/init.h, które rozwija się do __attribute__ ((__section__(".init.text"))).

Instruuje kompilator, aby oznaczył tę funkcję w specjalny sposób. Na końcu konsolidator zbiera wszystkie funkcje z tym znacznikiem na końcu (lub początku) pliku binarnego. Kiedy jądro się uruchamia, ten kod jest uruchamiany tylko raz (inicjalizacja). Po uruchomieniu jądro może zwolnić tę pamięć i użyć jej ponownie, a zobaczysz jądro

Przeczytaj komentarz (i dokumentacja w tym samym czasie) w linux / init.h .

Powinieneś także wiedzieć, że gcc ma kilka rozszerzeń stworzonych specjalnie dla kodu jądra Linuksa i wygląda na to, że to makro używa jednego z nich.

Kiedy kompilujesz i wstawiasz moduł jądra Linuksa do jądra, pierwszą funkcją do wykonania jest __init.Ta funkcja jest zasadniczo używana do wykonywania inicjalizacji przed wykonaniem głównych operacji, takich jak rejestracja sterownika urządzenia itp. __exit, który jest wywoływany po usunięciu modułu jądra, który jest ponownie używany do usunięcia zarejestrowanego urządzenia lub podobnej funkcji