Jak działa kbuild?

Pliki Makefile Kbuilda nie są najłatwiejsze do odczytania, ale oto rozwikłanie wysokiego poziomu (używając jądra 4.0-rc3):

1. Makefile najwyższego poziomu robi

   include $(srctree)/scripts/Kbuild.include
   

   , gdzie $(srctree) jest katalogiem jądra najwyższego poziomu.

2. Kbuild.include definiuje różne wspólne rzeczy i pomocników. Wśród nich jest build:

   ###
   # Shorthand for $(Q)$(MAKE) -f scripts/Makefile.build obj=
   # Usage:
   # $(Q)$(MAKE) $(build)=dir
   build := -f $(srctree)/scripts/Makefile.build obj
   

   build jest używany z poleceniem takim jak $(MAKE) $(build)=dir do wykonania kompilacji dla katalogu dir. Korzysta z scripts/Makefile.build.

3. Wracając do Makefile najwyższego poziomu, jest następujące:

   $(vmlinux-dirs): prepare scripts
           $(Q)$(MAKE) $(build)=$@
   

   vmlinux-dirs zawiera listę podkatalogów do zbudowania ( init, usr, kernel , itd.). $(Q)$(MAKE) $(build)=<subdirectory> zostanie uruchomiony dla każdego podkatalogu.

   Powyższa reguła kompiluje pliki obiektowe zarówno dla obrazu jądra, jak i dla modułów. Poniżej w pliku Makefile najwyższego poziomu znajduje się kilka dodatkowych rzeczy specyficznych dla modułów:

   ifdef CONFIG_MODULES
   ...
   modules: $(vmlinux-dirs) $(if $(KBUILD_BUILTIN),vmlinux) modules.builtin
           # Do additional module-specific stuff using
           # scripts/Makefile.modpost among other things
           # (my comment).
           ...
   ...
   endif # CONFIG_MODULES
   

4. Patrząc w scripts/Makefile.build (plik Makefile używany przez $(build)) teraz zaczyna się od inicjalizacji list obj-* i różnych innych list:

   # Init all relevant variables used in kbuild files so
   # 1) they have correct type
   # 2) they do not inherit any value from the environment
   obj-y :=
   obj-m :=
   lib-y :=
   lib-m :=
   

   Nieco dalej, ładuje się w pliku Kbuild, gdzie obj-y, obj-m, itd., są ustawione:

   include $(kbuild-file)
   

   Dalej w dół znajduje się domyślna reguła, która ma listy $(obj-y) i $(obj-m) jako warunki wstępne:

   __build: $(if $(KBUILD_BUILTIN),$(builtin-target) $(lib-target) $(extra-y)) \
            $(if $(KBUILD_MODULES),$(obj-m) $(modorder-target)) \
            $(subdir-ym) $(always)
           @:
   

   Warunki wstępne pochodzą z $(builtin-target), które definiuje się następująco:

   builtin-target := $(obj)/built-in.o
   ...
   $(builtin-target): $(obj-y) FORCE
           $(call if_changed,link_o_target)
   

   Rzeczywisty budynek wydaje się być wykonywany przez następujące reguła:

   # Built-in and composite module parts
   $(obj)/%.o: $(src)/%.c $(recordmcount_source) FORCE
           $(call cmd,force_checksrc)
           $(call if_changed_rule,cc_o_c)
   

   if_changed_rule jest z Kbuild.include. Reguła kończy się uruchomieniem następujących poleceń w Makefile.build:

   define rule_cc_o_c
           $(call echo-cmd,checksrc) $(cmd_checksrc)                         \
           $(call echo-cmd,cc_o_c) $(cmd_cc_o_c);                            \
           ...
   endef
   

   $(cmd_cc_o_c) wydaje się, że jest to właściwa Komenda kompilacji. W 1999 roku, po raz pierwszy w historii AFAICS, pojawiła się nowa definicja AFAICS.]}

   cmd_cc_o_c = $(CC) $(c_flags) -c -o $@ $<
   

   Chyba, że ustawiono jawnie używając np. make CC=clang, CC domyślnie gcc, jak widać tutaj w pliku Makefile najwyższego poziomu:

   ifneq ($(CC),)
   ifeq ($(shell $(CC) -v 2>&1 | grep -c "clang version"), 1)
   COMPILER := clang
   else
   COMPILER := gcc
   endif
   export COMPILER
   endif
   

Sposób, w jaki to rozwikłałem, polegał na zrobieniu CTRL-C podczas budowania jądra i sprawdzanie gdzie make zgłosiło błąd. Inną przydatną techniką debugowania make jest użycie $(warning $(variable)) do wypisania wartości variable.