Skip to content

L
linux
Commit 498a1cf9 authored by Linus Torvalds's avatar Linus Torvalds
Browse files
Options

Merge tag 'kbuild-v6.3' of git://git.kernel.org/pub/scm/linux/kernel/git/masahiroy/linux-kbuild 

Pull Kbuild updates from Masahiro Yamada:

 - Change V=1 option to print both short log and full command log

 - Allow V=1 and V=2 to be combined as V=12

 - Make W=1 detect wrong .gitignore files

 - Tree-wide cleanups for unused command line arguments passed to Clang

 - Stop using -Qunused-arguments with Clang

 - Make scripts/setlocalversion handle only correct release tags instead
   of any arbitrary annotated tag

 - Create Debian and RPM source packages without cleaning the source
   tree

 - Various cleanups for packaging

* tag 'kbuild-v6.3' of git://git.kernel.org/pub/scm/linux/kernel/git/masahiroy/linux-kbuild: (74 commits)
  kbuild: rpm-pkg: remove unneeded KERNELRELEASE from modules/headers_install
  docs: kbuild: remove description of KBUILD_LDS_MODULE
  .gitattributes: use 'dts' diff driver for *.dtso files
  kbuild: deb-pkg: improve the usability of source package
  kbuild: deb-pkg: fix binary-arch and clean in debian/rules
  kbuild: tar-pkg: use tar rules in scripts/Makefile.package
  kbuild: make perf-tar*-src-pkg work without relying on git
  kbuild: deb-pkg: switch over to source format 3.0 (quilt)
  kbuild: deb-pkg: make .orig tarball a hard link if possible
  kbuild: deb-pkg: hide KDEB_SOURCENAME from Makefile
  kbuild: srcrpm-pkg: create source package without cleaning
  kbuild: rpm-pkg: build binary packages from source rpm
  kbuild: deb-pkg: create source package without cleaning
  kbuild: add a tool to list files ignored by git
  Documentation/llvm: add Chimera Linux, Google and Meta datacenters
  setlocalversion: use only the correct release tag for git-describe
  setlocalversion: clean up the construction of version output
  .gitignore: ignore *.cover and *.mbx
  kbuild: remove --include-dir MAKEFLAG from top Makefile
  kbuild: fix trivial typo in comment
  ...
parents 4b8c673b 7adf14d8
Hide whitespace changes
Inline Side-by-side
Showing with 2873 additions and 1777 deletions
.gitattributes
View file @ 498a1cf9
*.c diff=cpp
*.h diff=cpp
*.dtsi diff=dts
*.dts diff=dts
# SPDX-License-Identifier: GPL-2.0-only
*.[ch] diff=cpp
*.dts diff=dts
*.dts[io] diff=dts
.gitignore
View file @ 498a1cf9
......@@ -4,7 +4,7 @@
# subdirectories here. Add them in the ".gitignore" file
# in that subdirectory instead.
#
# NOTE! Please use 'git ls-files -i --exclude-standard'
# NOTE! Please use 'git ls-files -i -c --exclude-per-directory=.gitignore'
# command after changing this file, to see if there are
# any tracked files which get ignored after the change.
#
......@@ -16,6 +16,7 @@
*.bin
*.bz2
*.c.[012]*.*
*.cover
*.dt.yaml
*.dtb
*.dtbo
......@@ -33,6 +34,7 @@
*.lz4
*.lzma
*.lzo
*.mbx
*.mod
*.mod.c
*.o
......
Documentation/Makefile
View file @ 498a1cf9
......@@ -28,7 +28,7 @@ BUILDDIR = $(obj)/output
PDFLATEX = xelatex
LATEXOPTS = -interaction=batchmode -no-shell-escape
ifeq ($(KBUILD_VERBOSE),0)
ifeq ($(findstring 1, $(KBUILD_VERBOSE)),)
SPHINXOPTS += "-q"
endif
......
Documentation/dontdiff
View file @ 498a1cf9
......@@ -91,7 +91,6 @@ asm_offsets.h
autoconf.h*
av_permissions.h
bbootsect
bin2c
binkernel.spec
bootsect
bounds.h
......
Documentation/kbuild/llvm.rst
View file @ 498a1cf9
......@@ -15,12 +15,15 @@ such as GCC and binutils. Ongoing work has allowed for `Clang
<https://clang.llvm.org/>`_ and `LLVM <https://llvm.org/>`_ utilities to be
used as viable substitutes. Distributions such as `Android
<https://www.android.com/>`_, `ChromeOS
<https://www.chromium.org/chromium-os>`_, and `OpenMandriva
<https://www.openmandriva.org/>`_ use Clang built kernels. `LLVM is a
collection of toolchain components implemented in terms of C++ objects
<https://www.aosabook.org/en/llvm.html>`_. Clang is a front-end to LLVM that
supports C and the GNU C extensions required by the kernel, and is pronounced
"klang," not "see-lang."
<https://www.chromium.org/chromium-os>`_, `OpenMandriva
<https://www.openmandriva.org/>`_, and `Chimera Linux
<https://chimera-linux.org/>`_ use Clang built kernels. Google's and Meta's
datacenter fleets also run kernels built with Clang.
`LLVM is a collection of toolchain components implemented in terms of C++
objects <https://www.aosabook.org/en/llvm.html>`_. Clang is a front-end to LLVM
that supports C and the GNU C extensions required by the kernel, and is
pronounced "klang," not "see-lang."
Clang
-----
......
Documentation/kbuild/makefiles.rst
View file @ 498a1cf9
......@@ -4,69 +4,8 @@ Linux Kernel Makefiles
This document describes the Linux kernel Makefiles.
.. Table of Contents
=== 1 Overview
=== 2 Who does what
=== 3 The kbuild files
--- 3.1 Goal definitions
--- 3.2 Built-in object goals - obj-y
--- 3.3 Loadable module goals - obj-m
--- 3.4 <deleted>
--- 3.5 Library file goals - lib-y
--- 3.6 Descending down in directories
--- 3.7 Non-builtin vmlinux targets - extra-y
--- 3.8 Always built goals - always-y
--- 3.9 Compilation flags
--- 3.10 Dependency tracking
--- 3.11 Custom Rules
--- 3.12 Command change detection
--- 3.13 $(CC) support functions
--- 3.14 $(LD) support functions
--- 3.15 Script Invocation
=== 4 Host Program support
--- 4.1 Simple Host Program
--- 4.2 Composite Host Programs
--- 4.3 Using C++ for host programs
--- 4.4 Using Rust for host programs
--- 4.5 Controlling compiler options for host programs
--- 4.6 When host programs are actually built
=== 5 Userspace Program support
--- 5.1 Simple Userspace Program
--- 5.2 Composite Userspace Programs
--- 5.3 Controlling compiler options for userspace programs
--- 5.4 When userspace programs are actually built
=== 6 Kbuild clean infrastructure
=== 7 Architecture Makefiles
--- 7.1 Set variables to tweak the build to the architecture
--- 7.2 Add prerequisites to archheaders
--- 7.3 Add prerequisites to archprepare
--- 7.4 List directories to visit when descending
--- 7.5 Architecture-specific boot images
--- 7.6 Building non-kbuild targets
--- 7.7 Commands useful for building a boot image
--- 7.8 <deleted>
--- 7.9 Preprocessing linker scripts
--- 7.10 Generic header files
--- 7.11 Post-link pass
=== 8 Kbuild syntax for exported headers
--- 8.1 no-export-headers
--- 8.2 generic-y
--- 8.3 generated-y
--- 8.4 mandatory-y
=== 9 Kbuild Variables
=== 10 Makefile language
=== 11 Credits
=== 12 TODO
1 Overview
==========
Overview
========
The Makefiles have five parts::
......@@ -83,6 +22,7 @@ The top Makefile is responsible for building two major products: vmlinux
(the resident kernel image) and modules (any module files).
It builds these goals by recursively descending into the subdirectories of
the kernel source tree.
The list of subdirectories which are visited depends upon the kernel
configuration. The top Makefile textually includes an arch Makefile
with the name arch/$(SRCARCH)/Makefile. The arch Makefile supplies
......@@ -96,14 +36,13 @@ any built-in or modular targets.
scripts/Makefile.* contains all the definitions/rules etc. that
are used to build the kernel based on the kbuild makefiles.
2 Who does what
===============
Who does what
=============
People have four different relationships with the kernel Makefiles.
*Users* are people who build kernels. These people type commands such as
"make menuconfig" or "make". They usually do not read or edit
``make menuconfig`` or ``make``. They usually do not read or edit
any kernel Makefiles (or any other source files).
*Normal developers* are people who work on features such as device
......@@ -123,1402 +62,1429 @@ These people need to know about all aspects of the kernel Makefiles.
This document is aimed towards normal developers and arch developers.
3 The kbuild files
==================
The kbuild files
================
Most Makefiles within the kernel are kbuild Makefiles that use the
kbuild infrastructure. This chapter introduces the syntax used in the
kbuild makefiles.
The preferred name for the kbuild files are 'Makefile' but 'Kbuild' can
be used and if both a 'Makefile' and a 'Kbuild' file exists, then the 'Kbuild'
The preferred name for the kbuild files are ``Makefile`` but ``Kbuild`` can
be used and if both a ``Makefile`` and a ``Kbuild`` file exists, then the ``Kbuild``
file will be used.
Section 3.1 "Goal definitions" is a quick intro; further chapters provide
Section `Goal definitions`_ is a quick intro; further chapters provide
more details, with real examples.
3.1 Goal definitions
--------------------
Goal definitions
----------------
Goal definitions are the main part (heart) of the kbuild Makefile.
These lines define the files to be built, any special compilation
options, and any subdirectories to be entered recursively.
Goal definitions are the main part (heart) of the kbuild Makefile.
These lines define the files to be built, any special compilation
options, and any subdirectories to be entered recursively.
The most simple kbuild makefile contains one line:
The most simple kbuild makefile contains one line:
Example::
Example::
obj-y += foo.o
obj-y += foo.o
This tells kbuild that there is one object in that directory, named
foo.o. foo.o will be built from foo.c or foo.S.
This tells kbuild that there is one object in that directory, named
foo.o. foo.o will be built from foo.c or foo.S.
If foo.o shall be built as a module, the variable obj-m is used.
Therefore the following pattern is often used:
If foo.o shall be built as a module, the variable obj-m is used.
Therefore the following pattern is often used:
Example::
Example::
obj-$(CONFIG_FOO) += foo.o
obj-$(CONFIG_FOO) += foo.o
$(CONFIG_FOO) evaluates to either y (for built-in) or m (for module).
If CONFIG_FOO is neither y nor m, then the file will not be compiled
nor linked.
$(CONFIG_FOO) evaluates to either y (for built-in) or m (for module).
If CONFIG_FOO is neither y nor m, then the file will not be compiled
nor linked.
3.2 Built-in object goals - obj-y
---------------------------------
Built-in object goals - obj-y
-----------------------------
The kbuild Makefile specifies object files for vmlinux
in the $(obj-y) lists. These lists depend on the kernel
configuration.
The kbuild Makefile specifies object files for vmlinux
in the $(obj-y) lists. These lists depend on the kernel
configuration.
Kbuild compiles all the $(obj-y) files. It then calls
"$(AR) rcSTP" to merge these files into one built-in.a file.
This is a thin archive without a symbol table. It will be later
linked into vmlinux by scripts/link-vmlinux.sh
Kbuild compiles all the $(obj-y) files. It then calls
``$(AR) rcSTP`` to merge these files into one built-in.a file.
This is a thin archive without a symbol table. It will be later
linked into vmlinux by scripts/link-vmlinux.sh
The order of files in $(obj-y) is significant. Duplicates in
the lists are allowed: the first instance will be linked into
built-in.a and succeeding instances will be ignored.
The order of files in $(obj-y) is significant. Duplicates in
the lists are allowed: the first instance will be linked into
built-in.a and succeeding instances will be ignored.
Link order is significant, because certain functions
(module_init() / __initcall) will be called during boot in the
order they appear. So keep in mind that changing the link
order may e.g. change the order in which your SCSI
controllers are detected, and thus your disks are renumbered.
Link order is significant, because certain functions
(module_init() / __initcall) will be called during boot in the
order they appear. So keep in mind that changing the link
order may e.g. change the order in which your SCSI
controllers are detected, and thus your disks are renumbered.
Example::
Example::
#drivers/isdn/i4l/Makefile
# Makefile for the kernel ISDN subsystem and device drivers.
# Each configuration option enables a list of files.
obj-$(CONFIG_ISDN_I4L) += isdn.o
obj-$(CONFIG_ISDN_PPP_BSDCOMP) += isdn_bsdcomp.o
#drivers/isdn/i4l/Makefile
# Makefile for the kernel ISDN subsystem and device drivers.
# Each configuration option enables a list of files.
obj-$(CONFIG_ISDN_I4L) += isdn.o
obj-$(CONFIG_ISDN_PPP_BSDCOMP) += isdn_bsdcomp.o
3.3 Loadable module goals - obj-m
---------------------------------
Loadable module goals - obj-m
-----------------------------
$(obj-m) specifies object files which are built as loadable
kernel modules.
$(obj-m) specifies object files which are built as loadable
kernel modules.
A module may be built from one source file or several source
files. In the case of one source file, the kbuild makefile
simply adds the file to $(obj-m).
A module may be built from one source file or several source
files. In the case of one source file, the kbuild makefile
simply adds the file to $(obj-m).
Example::
Example::
#drivers/isdn/i4l/Makefile
obj-$(CONFIG_ISDN_PPP_BSDCOMP) += isdn_bsdcomp.o
#drivers/isdn/i4l/Makefile
obj-$(CONFIG_ISDN_PPP_BSDCOMP) += isdn_bsdcomp.o
Note: In this example $(CONFIG_ISDN_PPP_BSDCOMP) evaluates to 'm'
Note: In this example $(CONFIG_ISDN_PPP_BSDCOMP) evaluates to "m"
If a kernel module is built from several source files, you specify
that you want to build a module in the same way as above; however,
kbuild needs to know which object files you want to build your
module from, so you have to tell it by setting a $(<module_name>-y)
variable.
If a kernel module is built from several source files, you specify
that you want to build a module in the same way as above; however,
kbuild needs to know which object files you want to build your
module from, so you have to tell it by setting a $(<module_name>-y)
variable.
Example::
Example::
#drivers/isdn/i4l/Makefile
obj-$(CONFIG_ISDN_I4L) += isdn.o
isdn-y := isdn_net_lib.o isdn_v110.o isdn_common.o
#drivers/isdn/i4l/Makefile
obj-$(CONFIG_ISDN_I4L) += isdn.o
isdn-y := isdn_net_lib.o isdn_v110.o isdn_common.o
In this example, the module name will be isdn.o. Kbuild will
compile the objects listed in $(isdn-y) and then run
"$(LD) -r" on the list of these files to generate isdn.o.
In this example, the module name will be isdn.o. Kbuild will
compile the objects listed in $(isdn-y) and then run
``$(LD) -r`` on the list of these files to generate isdn.o.
Due to kbuild recognizing $(<module_name>-y) for composite objects,
you can use the value of a `CONFIG_` symbol to optionally include an
object file as part of a composite object.
Due to kbuild recognizing $(<module_name>-y) for composite objects,
you can use the value of a ``CONFIG_`` symbol to optionally include an
object file as part of a composite object.
Example::
Example::
#fs/ext2/Makefile
obj-$(CONFIG_EXT2_FS) += ext2.o
ext2-y := balloc.o dir.o file.o ialloc.o inode.o ioctl.o \
namei.o super.o symlink.o
ext2-$(CONFIG_EXT2_FS_XATTR) += xattr.o xattr_user.o \
xattr_trusted.o
#fs/ext2/Makefile
obj-$(CONFIG_EXT2_FS) += ext2.o
ext2-y := balloc.o dir.o file.o ialloc.o inode.o ioctl.o \
namei.o super.o symlink.o
ext2-$(CONFIG_EXT2_FS_XATTR) += xattr.o xattr_user.o \
xattr_trusted.o
In this example, xattr.o, xattr_user.o and xattr_trusted.o are only
part of the composite object ext2.o if $(CONFIG_EXT2_FS_XATTR)
evaluates to 'y'.
In this example, xattr.o, xattr_user.o and xattr_trusted.o are only
part of the composite object ext2.o if $(CONFIG_EXT2_FS_XATTR)
evaluates to "y".
Note: Of course, when you are building objects into the kernel,
the syntax above will also work. So, if you have CONFIG_EXT2_FS=y,
kbuild will build an ext2.o file for you out of the individual
parts and then link this into built-in.a, as you would expect.
Note: Of course, when you are building objects into the kernel,
the syntax above will also work. So, if you have CONFIG_EXT2_FS=y,
kbuild will build an ext2.o file for you out of the individual
parts and then link this into built-in.a, as you would expect.
3.5 Library file goals - lib-y
------------------------------
Library file goals - lib-y
--------------------------
Objects listed with obj-* are used for modules, or
combined in a built-in.a for that specific directory.
There is also the possibility to list objects that will
be included in a library, lib.a.
All objects listed with lib-y are combined in a single
library for that directory.
Objects that are listed in obj-y and additionally listed in
lib-y will not be included in the library, since they will
be accessible anyway.
For consistency, objects listed in lib-m will be included in lib.a.
Objects listed with obj-* are used for modules, or
combined in a built-in.a for that specific directory.
There is also the possibility to list objects that will
be included in a library, lib.a.
All objects listed with lib-y are combined in a single
library for that directory.
Objects that are listed in obj-y and additionally listed in
lib-y will not be included in the library, since they will
be accessible anyway.
For consistency, objects listed in lib-m will be included in lib.a.
Note that the same kbuild makefile may list files to be built-in
and to be part of a library. Therefore the same directory
may contain both a built-in.a and a lib.a file.
Note that the same kbuild makefile may list files to be built-in
and to be part of a library. Therefore the same directory
may contain both a built-in.a and a lib.a file.
Example::
Example::
#arch/x86/lib/Makefile
lib-y := delay.o
#arch/x86/lib/Makefile
lib-y := delay.o
This will create a library lib.a based on delay.o. For kbuild to
actually recognize that there is a lib.a being built, the directory
shall be listed in libs-y.
This will create a library lib.a based on delay.o. For kbuild to
actually recognize that there is a lib.a being built, the directory
shall be listed in libs-y.
See also "7.4 List directories to visit when descending".
See also `List directories to visit when descending`_.
Use of lib-y is normally restricted to `lib/` and `arch/*/lib`.
Use of lib-y is normally restricted to ``lib/`` and ``arch/*/lib``.
3.6 Descending down in directories
----------------------------------
Descending down in directories
------------------------------
A Makefile is only responsible for building objects in its own
directory. Files in subdirectories should be taken care of by
Makefiles in these subdirs. The build system will automatically
invoke make recursively in subdirectories, provided you let it know of
them.
A Makefile is only responsible for building objects in its own
directory. Files in subdirectories should be taken care of by
Makefiles in these subdirs. The build system will automatically
invoke make recursively in subdirectories, provided you let it know of
them.
To do so, obj-y and obj-m are used.
ext2 lives in a separate directory, and the Makefile present in fs/
tells kbuild to descend down using the following assignment.
To do so, obj-y and obj-m are used.
ext2 lives in a separate directory, and the Makefile present in fs/
tells kbuild to descend down using the following assignment.
Example::
Example::
#fs/Makefile
obj-$(CONFIG_EXT2_FS) += ext2/
#fs/Makefile
obj-$(CONFIG_EXT2_FS) += ext2/
If CONFIG_EXT2_FS is set to either 'y' (built-in) or 'm' (modular)
the corresponding obj- variable will be set, and kbuild will descend
down in the ext2 directory.
If CONFIG_EXT2_FS is set to either "y" (built-in) or "m" (modular)
the corresponding obj- variable will be set, and kbuild will descend
down in the ext2 directory.
Kbuild uses this information not only to decide that it needs to visit
the directory, but also to decide whether or not to link objects from
the directory into vmlinux.
Kbuild uses this information not only to decide that it needs to visit
the directory, but also to decide whether or not to link objects from
the directory into vmlinux.
When Kbuild descends into the directory with 'y', all built-in objects
from that directory are combined into the built-in.a, which will be
eventually linked into vmlinux.
When Kbuild descends into the directory with "y", all built-in objects
from that directory are combined into the built-in.a, which will be
eventually linked into vmlinux.
When Kbuild descends into the directory with 'm', in contrast, nothing
from that directory will be linked into vmlinux. If the Makefile in
that directory specifies obj-y, those objects will be left orphan.
It is very likely a bug of the Makefile or of dependencies in Kconfig.
When Kbuild descends into the directory with "m", in contrast, nothing
from that directory will be linked into vmlinux. If the Makefile in
that directory specifies obj-y, those objects will be left orphan.
It is very likely a bug of the Makefile or of dependencies in Kconfig.
Kbuild also supports dedicated syntax, subdir-y and subdir-m, for
descending into subdirectories. It is a good fit when you know they
do not contain kernel-space objects at all. A typical usage is to let
Kbuild descend into subdirectories to build tools.
Kbuild also supports dedicated syntax, subdir-y and subdir-m, for
descending into subdirectories. It is a good fit when you know they
do not contain kernel-space objects at all. A typical usage is to let
Kbuild descend into subdirectories to build tools.
Examples::
Examples::
# scripts/Makefile
subdir-$(CONFIG_GCC_PLUGINS) += gcc-plugins
subdir-$(CONFIG_MODVERSIONS) += genksyms
subdir-$(CONFIG_SECURITY_SELINUX) += selinux
# scripts/Makefile
subdir-$(CONFIG_GCC_PLUGINS) += gcc-plugins
subdir-$(CONFIG_MODVERSIONS) += genksyms
subdir-$(CONFIG_SECURITY_SELINUX) += selinux
Unlike obj-y/m, subdir-y/m does not need the trailing slash since this
syntax is always used for directories.
Unlike obj-y/m, subdir-y/m does not need the trailing slash since this
syntax is always used for directories.
It is good practice to use a `CONFIG_` variable when assigning directory
names. This allows kbuild to totally skip the directory if the
corresponding `CONFIG_` option is neither 'y' nor 'm'.
It is good practice to use a ``CONFIG_`` variable when assigning directory
names. This allows kbuild to totally skip the directory if the
corresponding ``CONFIG_`` option is neither "y" nor "m".
3.7 Non-builtin vmlinux targets - extra-y
-----------------------------------------
Non-builtin vmlinux targets - extra-y
-------------------------------------
extra-y specifies targets which are needed for building vmlinux,
but not combined into built-in.a.
extra-y specifies targets which are needed for building vmlinux,
but not combined into built-in.a.
Examples are:
Examples are:
1) vmlinux linker script
1) vmlinux linker script
The linker script for vmlinux is located at
arch/$(SRCARCH)/kernel/vmlinux.lds
The linker script for vmlinux is located at
arch/$(SRCARCH)/kernel/vmlinux.lds
Example::
Example::
# arch/x86/kernel/Makefile
extra-y += vmlinux.lds
# arch/x86/kernel/Makefile
extra-y += vmlinux.lds
$(extra-y) should only contain targets needed for vmlinux.
$(extra-y) should only contain targets needed for vmlinux.
Kbuild skips extra-y when vmlinux is apparently not a final goal.
(e.g. 'make modules', or building external modules)
Kbuild skips extra-y when vmlinux is apparently not a final goal.
(e.g. ``make modules``, or building external modules)
If you intend to build targets unconditionally, always-y (explained
in the next section) is the correct syntax to use.
If you intend to build targets unconditionally, always-y (explained
in the next section) is the correct syntax to use.
3.8 Always built goals - always-y
---------------------------------
Always built goals - always-y
-----------------------------
always-y specifies targets which are literally always built when
Kbuild visits the Makefile.
always-y specifies targets which are literally always built when
Kbuild visits the Makefile.
Example::
# ./Kbuild
offsets-file := include/generated/asm-offsets.h
always-y += $(offsets-file)
Example::
3.9 Compilation flags
---------------------
# ./Kbuild
offsets-file := include/generated/asm-offsets.h
always-y += $(offsets-file)
ccflags-y, asflags-y and ldflags-y
These three flags apply only to the kbuild makefile in which they
are assigned. They are used for all the normal cc, as and ld
invocations happening during a recursive build.
Note: Flags with the same behaviour were previously named:
EXTRA_CFLAGS, EXTRA_AFLAGS and EXTRA_LDFLAGS.
They are still supported but their usage is deprecated.
Compilation flags
-----------------
ccflags-y specifies options for compiling with $(CC).
ccflags-y, asflags-y and ldflags-y
These three flags apply only to the kbuild makefile in which they
are assigned. They are used for all the normal cc, as and ld
invocations happening during a recursive build.
Note: Flags with the same behaviour were previously named:
EXTRA_CFLAGS, EXTRA_AFLAGS and EXTRA_LDFLAGS.
They are still supported but their usage is deprecated.
Example::
ccflags-y specifies options for compiling with $(CC).
# drivers/acpi/acpica/Makefile
ccflags-y := -Os -D_LINUX -DBUILDING_ACPICA
ccflags-$(CONFIG_ACPI_DEBUG) += -DACPI_DEBUG_OUTPUT
Example::
This variable is necessary because the top Makefile owns the
variable $(KBUILD_CFLAGS) and uses it for compilation flags for the
entire tree.
# drivers/acpi/acpica/Makefile
ccflags-y := -Os -D_LINUX -DBUILDING_ACPICA
ccflags-$(CONFIG_ACPI_DEBUG) += -DACPI_DEBUG_OUTPUT
asflags-y specifies assembler options.
This variable is necessary because the top Makefile owns the
variable $(KBUILD_CFLAGS) and uses it for compilation flags for the
entire tree.
Example::
asflags-y specifies assembler options.
#arch/sparc/kernel/Makefile
asflags-y := -ansi
Example::
ldflags-y specifies options for linking with $(LD).
#arch/sparc/kernel/Makefile
asflags-y := -ansi
Example::
ldflags-y specifies options for linking with $(LD).
#arch/cris/boot/compressed/Makefile
ldflags-y += -T $(srctree)/$(src)/decompress_$(arch-y).lds
Example::
subdir-ccflags-y, subdir-asflags-y
The two flags listed above are similar to ccflags-y and asflags-y.
The difference is that the subdir- variants have effect for the kbuild
file where they are present and all subdirectories.
Options specified using subdir-* are added to the commandline before
the options specified using the non-subdir variants.
#arch/cris/boot/compressed/Makefile
ldflags-y += -T $(srctree)/$(src)/decompress_$(arch-y).lds
Example::
subdir-ccflags-y, subdir-asflags-y
The two flags listed above are similar to ccflags-y and asflags-y.
The difference is that the subdir- variants have effect for the kbuild
file where they are present and all subdirectories.
Options specified using subdir-* are added to the commandline before
the options specified using the non-subdir variants.
subdir-ccflags-y := -Werror
Example::
ccflags-remove-y, asflags-remove-y
These flags are used to remove particular flags for the compiler,
assembler invocations.
subdir-ccflags-y := -Werror
Example::
ccflags-remove-y, asflags-remove-y
These flags are used to remove particular flags for the compiler,
assembler invocations.
ccflags-remove-$(CONFIG_MCOUNT) += -pg
Example::
CFLAGS_$@, AFLAGS_$@
CFLAGS_$@ and AFLAGS_$@ only apply to commands in current
kbuild makefile.
ccflags-remove-$(CONFIG_MCOUNT) += -pg
$(CFLAGS_$@) specifies per-file options for $(CC). The $@
part has a literal value which specifies the file that it is for.
CFLAGS_$@, AFLAGS_$@
CFLAGS_$@ and AFLAGS_$@ only apply to commands in current
kbuild makefile.
CFLAGS_$@ has the higher priority than ccflags-remove-y; CFLAGS_$@
can re-add compiler flags that were removed by ccflags-remove-y.
$(CFLAGS_$@) specifies per-file options for $(CC). The $@
part has a literal value which specifies the file that it is for.
Example::
CFLAGS_$@ has the higher priority than ccflags-remove-y; CFLAGS_$@
can re-add compiler flags that were removed by ccflags-remove-y.
# drivers/scsi/Makefile
CFLAGS_aha152x.o = -DAHA152X_STAT -DAUTOCONF
Example::
This line specify compilation flags for aha152x.o.
# drivers/scsi/Makefile
CFLAGS_aha152x.o = -DAHA152X_STAT -DAUTOCONF
$(AFLAGS_$@) is a similar feature for source files in assembly
languages.
This line specify compilation flags for aha152x.o.
AFLAGS_$@ has the higher priority than asflags-remove-y; AFLAGS_$@
can re-add assembler flags that were removed by asflags-remove-y.
$(AFLAGS_$@) is a similar feature for source files in assembly
languages.
Example::
AFLAGS_$@ has the higher priority than asflags-remove-y; AFLAGS_$@
can re-add assembler flags that were removed by asflags-remove-y.
# arch/arm/kernel/Makefile
AFLAGS_head.o := -DTEXT_OFFSET=$(TEXT_OFFSET)
AFLAGS_crunch-bits.o := -Wa,-mcpu=ep9312
AFLAGS_iwmmxt.o := -Wa,-mcpu=iwmmxt
Example::
# arch/arm/kernel/Makefile
AFLAGS_head.o := -DTEXT_OFFSET=$(TEXT_OFFSET)
AFLAGS_crunch-bits.o := -Wa,-mcpu=ep9312
AFLAGS_iwmmxt.o := -Wa,-mcpu=iwmmxt
3.10 Dependency tracking
------------------------
Dependency tracking
-------------------
Kbuild tracks dependencies on the following:
Kbuild tracks dependencies on the following:
1) All prerequisite files (both `*.c` and `*.h`)
2) `CONFIG_` options used in all prerequisite files
3) Command-line used to compile target
1) All prerequisite files (both ``*.c`` and ``*.h``)
2) ``CONFIG_`` options used in all prerequisite files
3) Command-line used to compile target
Thus, if you change an option to $(CC) all affected files will
be re-compiled.
Thus, if you change an option to $(CC) all affected files will
be re-compiled.
3.11 Custom Rules
-----------------
Custom Rules
------------
Custom rules are used when the kbuild infrastructure does
not provide the required support. A typical example is
header files generated during the build process.
Another example are the architecture-specific Makefiles which
need custom rules to prepare boot images etc.
Custom rules are used when the kbuild infrastructure does
not provide the required support. A typical example is
header files generated during the build process.
Another example are the architecture-specific Makefiles which
need custom rules to prepare boot images etc.
Custom rules are written as normal Make rules.
Kbuild is not executing in the directory where the Makefile is
located, so all custom rules shall use a relative
path to prerequisite files and target files.
Custom rules are written as normal Make rules.
Kbuild is not executing in the directory where the Makefile is
located, so all custom rules shall use a relative
path to prerequisite files and target files.
Two variables are used when defining custom rules:
Two variables are used when defining custom rules:
$(src)
$(src) is a relative path which points to the directory
where the Makefile is located. Always use $(src) when
referring to files located in the src tree.
$(src)
$(src) is a relative path which points to the directory
where the Makefile is located. Always use $(src) when
referring to files located in the src tree.
$(obj)
$(obj) is a relative path which points to the directory
where the target is saved. Always use $(obj) when
referring to generated files.
$(obj)
$(obj) is a relative path which points to the directory
where the target is saved. Always use $(obj) when
referring to generated files.
Example::
Example::
#drivers/scsi/Makefile
$(obj)/53c8xx_d.h: $(src)/53c7,8xx.scr $(src)/script_asm.pl
$(CPP) -DCHIP=810 - < $< | ... $(src)/script_asm.pl
#drivers/scsi/Makefile
$(obj)/53c8xx_d.h: $(src)/53c7,8xx.scr $(src)/script_asm.pl
$(CPP) -DCHIP=810 - < $< | ... $(src)/script_asm.pl
This is a custom rule, following the normal syntax
required by make.
This is a custom rule, following the normal syntax
required by make.
The target file depends on two prerequisite files. References
to the target file are prefixed with $(obj), references
to prerequisites are referenced with $(src) (because they are not
generated files).
The target file depends on two prerequisite files. References
to the target file are prefixed with $(obj), references
to prerequisites are referenced with $(src) (because they are not
generated files).
$(kecho)
echoing information to user in a rule is often a good practice
but when execution "make -s" one does not expect to see any output
except for warnings/errors.
To support this kbuild defines $(kecho) which will echo out the
text following $(kecho) to stdout except if "make -s" is used.
$(kecho)
echoing information to user in a rule is often a good practice
but when execution ``make -s`` one does not expect to see any output
except for warnings/errors.
To support this kbuild defines $(kecho) which will echo out the
text following $(kecho) to stdout except if ``make -s`` is used.
Example::
Example::
# arch/arm/Makefile
$(BOOT_TARGETS): vmlinux
$(Q)$(MAKE) $(build)=$(boot) MACHINE=$(MACHINE) $(boot)/$@
@$(kecho) ' Kernel: $(boot)/$@ is ready'
# arch/arm/Makefile
$(BOOT_TARGETS): vmlinux
$(Q)$(MAKE) $(build)=$(boot) MACHINE=$(MACHINE) $(boot)/$@
@$(kecho) ' Kernel: $(boot)/$@ is ready'
When kbuild is executing with KBUILD_VERBOSE=0, then only a shorthand
of a command is normally displayed.
To enable this behaviour for custom commands kbuild requires
two variables to be set::
When kbuild is executing with KBUILD_VERBOSE unset, then only a shorthand
of a command is normally displayed.
To enable this behaviour for custom commands kbuild requires
two variables to be set::
quiet_cmd_<command> - what shall be echoed
cmd_<command> - the command to execute
quiet_cmd_<command> - what shall be echoed
cmd_<command> - the command to execute
Example::
Example::
# lib/Makefile
quiet_cmd_crc32 = GEN $@
cmd_crc32 = $< > $@
# lib/Makefile
quiet_cmd_crc32 = GEN $@
cmd_crc32 = $< > $@
$(obj)/crc32table.h: $(obj)/gen_crc32table
$(call cmd,crc32)
$(obj)/crc32table.h: $(obj)/gen_crc32table
$(call cmd,crc32)
When updating the $(obj)/crc32table.h target, the line:
When updating the $(obj)/crc32table.h target, the line::
GEN lib/crc32table.h
GEN lib/crc32table.h
will be displayed with "make KBUILD_VERBOSE=0".
will be displayed with ``make KBUILD_VERBOSE=``.
3.12 Command change detection
-----------------------------
Command change detection
------------------------
When the rule is evaluated, timestamps are compared between the target
and its prerequisite files. GNU Make updates the target when any of the
prerequisites is newer than that.
When the rule is evaluated, timestamps are compared between the target
and its prerequisite files. GNU Make updates the target when any of the
prerequisites is newer than that.
The target should be rebuilt also when the command line has changed
since the last invocation. This is not supported by Make itself, so
Kbuild achieves this by a kind of meta-programming.
The target should be rebuilt also when the command line has changed
since the last invocation. This is not supported by Make itself, so
Kbuild achieves this by a kind of meta-programming.
if_changed is the macro used for this purpose, in the following form::
if_changed is the macro used for this purpose, in the following form::
quiet_cmd_<command> = ...
cmd_<command> = ...
quiet_cmd_<command> = ...
cmd_<command> = ...
<target>: <source(s)> FORCE
$(call if_changed,<command>)
<target>: <source(s)> FORCE
$(call if_changed,<command>)
Any target that utilizes if_changed must be listed in $(targets),
otherwise the command line check will fail, and the target will
always be built.
Any target that utilizes if_changed must be listed in $(targets),
otherwise the command line check will fail, and the target will
always be built.
If the target is already listed in the recognized syntax such as
obj-y/m, lib-y/m, extra-y/m, always-y/m, hostprogs, userprogs, Kbuild
automatically adds it to $(targets). Otherwise, the target must be
explicitly added to $(targets).
If the target is already listed in the recognized syntax such as
obj-y/m, lib-y/m, extra-y/m, always-y/m, hostprogs, userprogs, Kbuild
automatically adds it to $(targets). Otherwise, the target must be
explicitly added to $(targets).
Assignments to $(targets) are without $(obj)/ prefix. if_changed may be
used in conjunction with custom rules as defined in "3.11 Custom Rules".
Assignments to $(targets) are without $(obj)/ prefix. if_changed may be
used in conjunction with custom rules as defined in `Custom Rules`_.
Note: It is a typical mistake to forget the FORCE prerequisite.
Another common pitfall is that whitespace is sometimes significant; for
instance, the below will fail (note the extra space after the comma)::
Note: It is a typical mistake to forget the FORCE prerequisite.
Another common pitfall is that whitespace is sometimes significant; for
instance, the below will fail (note the extra space after the comma)::
target: source(s) FORCE
target: source(s) FORCE
**WRONG!** $(call if_changed, objcopy)
**WRONG!** $(call if_changed, objcopy)
Note:
if_changed should not be used more than once per target.
It stores the executed command in a corresponding .cmd
file and multiple calls would result in overwrites and
unwanted results when the target is up to date and only the
tests on changed commands trigger execution of commands.
Note:
if_changed should not be used more than once per target.
It stores the executed command in a corresponding .cmd
file and multiple calls would result in overwrites and
unwanted results when the target is up to date and only the
tests on changed commands trigger execution of commands.
3.13 $(CC) support functions
----------------------------
$(CC) support functions
-----------------------
The kernel may be built with several different versions of
$(CC), each supporting a unique set of features and options.
kbuild provides basic support to check for valid options for $(CC).
$(CC) is usually the gcc compiler, but other alternatives are
available.
The kernel may be built with several different versions of
$(CC), each supporting a unique set of features and options.
kbuild provides basic support to check for valid options for $(CC).
$(CC) is usually the gcc compiler, but other alternatives are
available.
as-option
as-option is used to check if $(CC) -- when used to compile
assembler (`*.S`) files -- supports the given option. An optional
second option may be specified if the first option is not supported.
as-option
as-option is used to check if $(CC) -- when used to compile
assembler (``*.S``) files -- supports the given option. An optional
second option may be specified if the first option is not supported.
Example::
Example::
#arch/sh/Makefile
cflags-y += $(call as-option,-Wa$(comma)-isa=$(isa-y),)
#arch/sh/Makefile
cflags-y += $(call as-option,-Wa$(comma)-isa=$(isa-y),)
In the above example, cflags-y will be assigned the option
-Wa$(comma)-isa=$(isa-y) if it is supported by $(CC).
The second argument is optional, and if supplied will be used
if first argument is not supported.
In the above example, cflags-y will be assigned the option
-Wa$(comma)-isa=$(isa-y) if it is supported by $(CC).
The second argument is optional, and if supplied will be used
if first argument is not supported.
as-instr
as-instr checks if the assembler reports a specific instruction
and then outputs either option1 or option2
C escapes are supported in the test instruction
Note: as-instr-option uses KBUILD_AFLAGS for assembler options
as-instr
as-instr checks if the assembler reports a specific instruction
and then outputs either option1 or option2
C escapes are supported in the test instruction
Note: as-instr-option uses KBUILD_AFLAGS for assembler options
cc-option
cc-option is used to check if $(CC) supports a given option, and if
not supported to use an optional second option.
cc-option
cc-option is used to check if $(CC) supports a given option, and if
not supported to use an optional second option.
Example::
Example::
#arch/x86/Makefile
cflags-y += $(call cc-option,-march=pentium-mmx,-march=i586)
#arch/x86/Makefile
cflags-y += $(call cc-option,-march=pentium-mmx,-march=i586)
In the above example, cflags-y will be assigned the option
-march=pentium-mmx if supported by $(CC), otherwise -march=i586.
The second argument to cc-option is optional, and if omitted,
cflags-y will be assigned no value if first option is not supported.
Note: cc-option uses KBUILD_CFLAGS for $(CC) options
In the above example, cflags-y will be assigned the option
-march=pentium-mmx if supported by $(CC), otherwise -march=i586.
The second argument to cc-option is optional, and if omitted,
cflags-y will be assigned no value if first option is not supported.
Note: cc-option uses KBUILD_CFLAGS for $(CC) options
cc-option-yn
cc-option-yn is used to check if gcc supports a given option
and return 'y' if supported, otherwise 'n'.
cc-option-yn
cc-option-yn is used to check if gcc supports a given option
and return "y" if supported, otherwise "n".
Example::
Example::
#arch/ppc/Makefile
biarch := $(call cc-option-yn, -m32)
aflags-$(biarch) += -a32
cflags-$(biarch) += -m32
#arch/ppc/Makefile
biarch := $(call cc-option-yn, -m32)
aflags-$(biarch) += -a32
cflags-$(biarch) += -m32
In the above example, $(biarch) is set to y if $(CC) supports the -m32
option. When $(biarch) equals 'y', the expanded variables $(aflags-y)
and $(cflags-y) will be assigned the values -a32 and -m32,
respectively.
Note: cc-option-yn uses KBUILD_CFLAGS for $(CC) options
In the above example, $(biarch) is set to y if $(CC) supports the -m32
option. When $(biarch) equals "y", the expanded variables $(aflags-y)
and $(cflags-y) will be assigned the values -a32 and -m32,
respectively.
cc-disable-warning
cc-disable-warning checks if gcc supports a given warning and returns
the commandline switch to disable it. This special function is needed,
because gcc 4.4 and later accept any unknown -Wno-* option and only
warn about it if there is another warning in the source file.
Note: cc-option-yn uses KBUILD_CFLAGS for $(CC) options
Example::
cc-disable-warning
cc-disable-warning checks if gcc supports a given warning and returns
the commandline switch to disable it. This special function is needed,
because gcc 4.4 and later accept any unknown -Wno-* option and only
warn about it if there is another warning in the source file.
KBUILD_CFLAGS += $(call cc-disable-warning, unused-but-set-variable)
Example::
In the above example, -Wno-unused-but-set-variable will be added to
KBUILD_CFLAGS only if gcc really accepts it.
KBUILD_CFLAGS += $(call cc-disable-warning, unused-but-set-variable)
gcc-min-version
gcc-min-version tests if the value of $(CONFIG_GCC_VERSION) is greater than
or equal to the provided value and evaluates to y if so.
In the above example, -Wno-unused-but-set-variable will be added to
KBUILD_CFLAGS only if gcc really accepts it.
Example::
gcc-min-version
gcc-min-version tests if the value of $(CONFIG_GCC_VERSION) is greater than
or equal to the provided value and evaluates to y if so.
cflags-$(call gcc-min-version, 70100) := -foo
Example::
In this example, cflags-y will be assigned the value -foo if $(CC) is gcc and
$(CONFIG_GCC_VERSION) is >= 7.1.
cflags-$(call gcc-min-version, 70100) := -foo
clang-min-version
clang-min-version tests if the value of $(CONFIG_CLANG_VERSION) is greater
than or equal to the provided value and evaluates to y if so.
In this example, cflags-y will be assigned the value -foo if $(CC) is gcc and
$(CONFIG_GCC_VERSION) is >= 7.1.
Example::
clang-min-version
clang-min-version tests if the value of $(CONFIG_CLANG_VERSION) is greater
than or equal to the provided value and evaluates to y if so.
cflags-$(call clang-min-version, 110000) := -foo
Example::
In this example, cflags-y will be assigned the value -foo if $(CC) is clang
and $(CONFIG_CLANG_VERSION) is >= 11.0.0.
cflags-$(call clang-min-version, 110000) := -foo
cc-cross-prefix
cc-cross-prefix is used to check if there exists a $(CC) in path with
one of the listed prefixes. The first prefix where there exist a
prefix$(CC) in the PATH is returned - and if no prefix$(CC) is found
then nothing is returned.
Additional prefixes are separated by a single space in the
call of cc-cross-prefix.
This functionality is useful for architecture Makefiles that try
to set CROSS_COMPILE to well-known values but may have several
values to select between.
It is recommended only to try to set CROSS_COMPILE if it is a cross
build (host arch is different from target arch). And if CROSS_COMPILE
is already set then leave it with the old value.
In this example, cflags-y will be assigned the value -foo if $(CC) is clang
and $(CONFIG_CLANG_VERSION) is >= 11.0.0.
Example::
cc-cross-prefix
cc-cross-prefix is used to check if there exists a $(CC) in path with
one of the listed prefixes. The first prefix where there exist a
prefix$(CC) in the PATH is returned - and if no prefix$(CC) is found
then nothing is returned.
#arch/m68k/Makefile
ifneq ($(SUBARCH),$(ARCH))
ifeq ($(CROSS_COMPILE),)
CROSS_COMPILE := $(call cc-cross-prefix, m68k-linux-gnu-)
endif
endif
Additional prefixes are separated by a single space in the
call of cc-cross-prefix.
3.14 $(LD) support functions
----------------------------
This functionality is useful for architecture Makefiles that try
to set CROSS_COMPILE to well-known values but may have several
values to select between.
ld-option
ld-option is used to check if $(LD) supports the supplied option.
ld-option takes two options as arguments.
The second argument is an optional option that can be used if the
first option is not supported by $(LD).
It is recommended only to try to set CROSS_COMPILE if it is a cross
build (host arch is different from target arch). And if CROSS_COMPILE
is already set then leave it with the old value.
Example::
Example::
#Makefile
LDFLAGS_vmlinux += $(call ld-option, -X)
#arch/m68k/Makefile
ifneq ($(SUBARCH),$(ARCH))
ifeq ($(CROSS_COMPILE),)
CROSS_COMPILE := $(call cc-cross-prefix, m68k-linux-gnu-)
endif
endif
3.15 Script invocation
----------------------
$(LD) support functions
-----------------------
Make rules may invoke scripts to build the kernel. The rules shall
always provide the appropriate interpreter to execute the script. They
shall not rely on the execute bits being set, and shall not invoke the
script directly. For the convenience of manual script invocation, such
as invoking ./scripts/checkpatch.pl, it is recommended to set execute
bits on the scripts nonetheless.
ld-option
ld-option is used to check if $(LD) supports the supplied option.
ld-option takes two options as arguments.
Kbuild provides variables $(CONFIG_SHELL), $(AWK), $(PERL),
and $(PYTHON3) to refer to interpreters for the respective
scripts.
The second argument is an optional option that can be used if the
first option is not supported by $(LD).
Example::
Example::
#Makefile
cmd_depmod = $(CONFIG_SHELL) $(srctree)/scripts/depmod.sh $(DEPMOD) \
$(KERNELRELEASE)
#Makefile
LDFLAGS_vmlinux += $(call ld-option, -X)
4 Host Program support
======================
Script invocation
-----------------
Make rules may invoke scripts to build the kernel. The rules shall
always provide the appropriate interpreter to execute the script. They
shall not rely on the execute bits being set, and shall not invoke the
script directly. For the convenience of manual script invocation, such
as invoking ./scripts/checkpatch.pl, it is recommended to set execute
bits on the scripts nonetheless.
Kbuild provides variables $(CONFIG_SHELL), $(AWK), $(PERL),
and $(PYTHON3) to refer to interpreters for the respective
scripts.
Example::
#Makefile
cmd_depmod = $(CONFIG_SHELL) $(srctree)/scripts/depmod.sh $(DEPMOD) \
$(KERNELRELEASE)
Host Program support
====================
Kbuild supports building executables on the host for use during the
compilation stage.
Two steps are required in order to use a host executable.
The first step is to tell kbuild that a host program exists. This is
done utilising the variable "hostprogs".
done utilising the variable ``hostprogs``.
The second step is to add an explicit dependency to the executable.
This can be done in two ways. Either add the dependency in a rule,
or utilise the variable "always-y".
or utilise the variable ``always-y``.
Both possibilities are described in the following.
4.1 Simple Host Program
-----------------------
Simple Host Program
-------------------
In some cases there is a need to compile and run a program on the
computer where the build is running.
The following line tells kbuild that the program bin2hex shall be
built on the build host.
In some cases there is a need to compile and run a program on the
computer where the build is running.
Example::
The following line tells kbuild that the program bin2hex shall be
built on the build host.
hostprogs := bin2hex
Example::
Kbuild assumes in the above example that bin2hex is made from a single
c-source file named bin2hex.c located in the same directory as
the Makefile.
hostprogs := bin2hex
4.2 Composite Host Programs
---------------------------
Kbuild assumes in the above example that bin2hex is made from a single
c-source file named bin2hex.c located in the same directory as
the Makefile.
Host programs can be made up based on composite objects.
The syntax used to define composite objects for host programs is
similar to the syntax used for kernel objects.
$(<executable>-objs) lists all objects used to link the final
executable.
Composite Host Programs
-----------------------
Example::
Host programs can be made up based on composite objects.
The syntax used to define composite objects for host programs is
similar to the syntax used for kernel objects.
$(<executable>-objs) lists all objects used to link the final
executable.
#scripts/lxdialog/Makefile
hostprogs := lxdialog
lxdialog-objs := checklist.o lxdialog.o
Example::
Objects with extension .o are compiled from the corresponding .c
files. In the above example, checklist.c is compiled to checklist.o
and lxdialog.c is compiled to lxdialog.o.
#scripts/lxdialog/Makefile
hostprogs := lxdialog
lxdialog-objs := checklist.o lxdialog.o
Finally, the two .o files are linked to the executable, lxdialog.
Note: The syntax <executable>-y is not permitted for host-programs.
Objects with extension .o are compiled from the corresponding .c
files. In the above example, checklist.c is compiled to checklist.o
and lxdialog.c is compiled to lxdialog.o.
4.3 Using C++ for host programs
-------------------------------
Finally, the two .o files are linked to the executable, lxdialog.
Note: The syntax <executable>-y is not permitted for host-programs.
kbuild offers support for host programs written in C++. This was
introduced solely to support kconfig, and is not recommended
for general use.
Using C++ for host programs
---------------------------
Example::
kbuild offers support for host programs written in C++. This was
introduced solely to support kconfig, and is not recommended
for general use.
#scripts/kconfig/Makefile
hostprogs := qconf
qconf-cxxobjs := qconf.o
Example::
In the example above the executable is composed of the C++ file
qconf.cc - identified by $(qconf-cxxobjs).
#scripts/kconfig/Makefile
hostprogs := qconf
qconf-cxxobjs := qconf.o
If qconf is composed of a mixture of .c and .cc files, then an
additional line can be used to identify this.
In the example above the executable is composed of the C++ file
qconf.cc - identified by $(qconf-cxxobjs).
Example::
If qconf is composed of a mixture of .c and .cc files, then an
additional line can be used to identify this.
#scripts/kconfig/Makefile
hostprogs := qconf
qconf-cxxobjs := qconf.o
qconf-objs := check.o
Example::
4.4 Using Rust for host programs
--------------------------------
#scripts/kconfig/Makefile
hostprogs := qconf
qconf-cxxobjs := qconf.o
qconf-objs := check.o
Kbuild offers support for host programs written in Rust. However,
since a Rust toolchain is not mandatory for kernel compilation,
it may only be used in scenarios where Rust is required to be
available (e.g. when ``CONFIG_RUST`` is enabled).
Using Rust for host programs
----------------------------
Example::
Kbuild offers support for host programs written in Rust. However,
since a Rust toolchain is not mandatory for kernel compilation,
it may only be used in scenarios where Rust is required to be
available (e.g. when ``CONFIG_RUST`` is enabled).
hostprogs := target
target-rust := y
Example::
Kbuild will compile ``target`` using ``target.rs`` as the crate root,
located in the same directory as the ``Makefile``. The crate may
consist of several source files (see ``samples/rust/hostprogs``).
hostprogs := target
target-rust := y
4.5 Controlling compiler options for host programs
--------------------------------------------------
Kbuild will compile ``target`` using ``target.rs`` as the crate root,
located in the same directory as the ``Makefile``. The crate may
consist of several source files (see ``samples/rust/hostprogs``).
When compiling host programs, it is possible to set specific flags.
The programs will always be compiled utilising $(HOSTCC) passed
the options specified in $(KBUILD_HOSTCFLAGS).
To set flags that will take effect for all host programs created
in that Makefile, use the variable HOST_EXTRACFLAGS.
Controlling compiler options for host programs
----------------------------------------------
Example::
When compiling host programs, it is possible to set specific flags.
The programs will always be compiled utilising $(HOSTCC) passed
the options specified in $(KBUILD_HOSTCFLAGS).
#scripts/lxdialog/Makefile
HOST_EXTRACFLAGS += -I/usr/include/ncurses
To set flags that will take effect for all host programs created
in that Makefile, use the variable HOST_EXTRACFLAGS.
To set specific flags for a single file the following construction
is used:
Example::
Example::
#scripts/lxdialog/Makefile
HOST_EXTRACFLAGS += -I/usr/include/ncurses
#arch/ppc64/boot/Makefile
HOSTCFLAGS_piggyback.o := -DKERNELBASE=$(KERNELBASE)
To set specific flags for a single file the following construction
is used:
It is also possible to specify additional options to the linker.
Example::
Example::
#arch/ppc64/boot/Makefile
HOSTCFLAGS_piggyback.o := -DKERNELBASE=$(KERNELBASE)
#scripts/kconfig/Makefile
HOSTLDLIBS_qconf := -L$(QTDIR)/lib
It is also possible to specify additional options to the linker.
When linking qconf, it will be passed the extra option
"-L$(QTDIR)/lib".
Example::
4.6 When host programs are actually built
-----------------------------------------
#scripts/kconfig/Makefile
HOSTLDLIBS_qconf := -L$(QTDIR)/lib
Kbuild will only build host-programs when they are referenced
as a prerequisite.
This is possible in two ways:
When linking qconf, it will be passed the extra option
``-L$(QTDIR)/lib``.
(1) List the prerequisite explicitly in a custom rule.
When host programs are actually built
-------------------------------------
Example::
Kbuild will only build host-programs when they are referenced
as a prerequisite.
#drivers/pci/Makefile
hostprogs := gen-devlist
$(obj)/devlist.h: $(src)/pci.ids $(obj)/gen-devlist
( cd $(obj); ./gen-devlist ) < $<
This is possible in two ways:
The target $(obj)/devlist.h will not be built before
$(obj)/gen-devlist is updated. Note that references to
the host programs in custom rules must be prefixed with $(obj).
(1) List the prerequisite explicitly in a custom rule.
(2) Use always-y
Example::
When there is no suitable custom rule, and the host program
shall be built when a makefile is entered, the always-y
variable shall be used.
#drivers/pci/Makefile
hostprogs := gen-devlist
$(obj)/devlist.h: $(src)/pci.ids $(obj)/gen-devlist
( cd $(obj); ./gen-devlist ) < $<
Example::
The target $(obj)/devlist.h will not be built before
$(obj)/gen-devlist is updated. Note that references to
the host programs in custom rules must be prefixed with $(obj).
#scripts/lxdialog/Makefile
hostprogs := lxdialog
always-y := $(hostprogs)
(2) Use always-y
Kbuild provides the following shorthand for this:
When there is no suitable custom rule, and the host program
shall be built when a makefile is entered, the always-y
variable shall be used.
hostprogs-always-y := lxdialog
Example::
This will tell kbuild to build lxdialog even if not referenced in
any rule.
#scripts/lxdialog/Makefile
hostprogs := lxdialog
always-y := $(hostprogs)
5 Userspace Program support
===========================
Kbuild provides the following shorthand for this::
hostprogs-always-y := lxdialog
This will tell kbuild to build lxdialog even if not referenced in
any rule.
Userspace Program support
=========================
Just like host programs, Kbuild also supports building userspace executables
for the target architecture (i.e. the same architecture as you are building
the kernel for).
The syntax is quite similar. The difference is to use "userprogs" instead of
"hostprogs".
The syntax is quite similar. The difference is to use ``userprogs`` instead of
``hostprogs``.
5.1 Simple Userspace Program
----------------------------
Simple Userspace Program
------------------------
The following line tells kbuild that the program bpf-direct shall be
built for the target architecture.
The following line tells kbuild that the program bpf-direct shall be
built for the target architecture.
Example::
Example::
userprogs := bpf-direct
userprogs := bpf-direct
Kbuild assumes in the above example that bpf-direct is made from a
single C source file named bpf-direct.c located in the same directory
as the Makefile.
Kbuild assumes in the above example that bpf-direct is made from a
single C source file named bpf-direct.c located in the same directory
as the Makefile.
5.2 Composite Userspace Programs
--------------------------------
Composite Userspace Programs
----------------------------
Userspace programs can be made up based on composite objects.
The syntax used to define composite objects for userspace programs is
similar to the syntax used for kernel objects.
$(<executable>-objs) lists all objects used to link the final
executable.
Userspace programs can be made up based on composite objects.
The syntax used to define composite objects for userspace programs is
similar to the syntax used for kernel objects.
$(<executable>-objs) lists all objects used to link the final
executable.
Example::
Example::
#samples/seccomp/Makefile
userprogs := bpf-fancy
bpf-fancy-objs := bpf-fancy.o bpf-helper.o
#samples/seccomp/Makefile
userprogs := bpf-fancy
bpf-fancy-objs := bpf-fancy.o bpf-helper.o
Objects with extension .o are compiled from the corresponding .c
files. In the above example, bpf-fancy.c is compiled to bpf-fancy.o
and bpf-helper.c is compiled to bpf-helper.o.
Objects with extension .o are compiled from the corresponding .c
files. In the above example, bpf-fancy.c is compiled to bpf-fancy.o
and bpf-helper.c is compiled to bpf-helper.o.
Finally, the two .o files are linked to the executable, bpf-fancy.
Note: The syntax <executable>-y is not permitted for userspace programs.
Finally, the two .o files are linked to the executable, bpf-fancy.
Note: The syntax <executable>-y is not permitted for userspace programs.
5.3 Controlling compiler options for userspace programs
-------------------------------------------------------
Controlling compiler options for userspace programs
---------------------------------------------------
When compiling userspace programs, it is possible to set specific flags.
The programs will always be compiled utilising $(CC) passed
the options specified in $(KBUILD_USERCFLAGS).
To set flags that will take effect for all userspace programs created
in that Makefile, use the variable userccflags.
When compiling userspace programs, it is possible to set specific flags.
The programs will always be compiled utilising $(CC) passed
the options specified in $(KBUILD_USERCFLAGS).
Example::
To set flags that will take effect for all userspace programs created
in that Makefile, use the variable userccflags.
# samples/seccomp/Makefile
userccflags += -I usr/include
Example::
To set specific flags for a single file the following construction
is used:
# samples/seccomp/Makefile
userccflags += -I usr/include
Example::
To set specific flags for a single file the following construction
is used:
bpf-helper-userccflags += -I user/include
Example::
It is also possible to specify additional options to the linker.
bpf-helper-userccflags += -I user/include
Example::
It is also possible to specify additional options to the linker.
# net/bpfilter/Makefile
bpfilter_umh-userldflags += -static
Example::
When linking bpfilter_umh, it will be passed the extra option -static.
# net/bpfilter/Makefile
bpfilter_umh-userldflags += -static
From command line, :ref:`USERCFLAGS and USERLDFLAGS <userkbuildflags>` will also be used.
When linking bpfilter_umh, it will be passed the extra option -static.
5.4 When userspace programs are actually built
----------------------------------------------
From command line, :ref:`USERCFLAGS and USERLDFLAGS <userkbuildflags>` will also be used.
When userspace programs are actually built
------------------------------------------
Kbuild builds userspace programs only when told to do so.
There are two ways to do this.
Kbuild builds userspace programs only when told to do so.
There are two ways to do this.
(1) Add it as the prerequisite of another file
(1) Add it as the prerequisite of another file
Example::
Example::
#net/bpfilter/Makefile
userprogs := bpfilter_umh
$(obj)/bpfilter_umh_blob.o: $(obj)/bpfilter_umh
#net/bpfilter/Makefile
userprogs := bpfilter_umh
$(obj)/bpfilter_umh_blob.o: $(obj)/bpfilter_umh
$(obj)/bpfilter_umh is built before $(obj)/bpfilter_umh_blob.o
$(obj)/bpfilter_umh is built before $(obj)/bpfilter_umh_blob.o
(2) Use always-y
(2) Use always-y
Example::
Example::
userprogs := binderfs_example
always-y := $(userprogs)
userprogs := binderfs_example
always-y := $(userprogs)
Kbuild provides the following shorthand for this:
Kbuild provides the following shorthand for this::
userprogs-always-y := binderfs_example
userprogs-always-y := binderfs_example
This will tell Kbuild to build binderfs_example when it visits this
Makefile.
This will tell Kbuild to build binderfs_example when it visits this
Makefile.
6 Kbuild clean infrastructure
=============================
Kbuild clean infrastructure
===========================
"make clean" deletes most generated files in the obj tree where the kernel
``make clean`` deletes most generated files in the obj tree where the kernel
is compiled. This includes generated files such as host programs.
Kbuild knows targets listed in $(hostprogs), $(always-y), $(always-m),
$(always-), $(extra-y), $(extra-) and $(targets). They are all deleted
during "make clean". Files matching the patterns "*.[oas]", "*.ko", plus
during ``make clean``. Files matching the patterns ``*.[oas]``, ``*.ko``, plus
some additional files generated by kbuild are deleted all over the kernel
source tree when "make clean" is executed.
source tree when ``make clean`` is executed.
Additional files or directories can be specified in kbuild makefiles by use of
$(clean-files).
Example::
Example::
#lib/Makefile
clean-files := crc32table.h
#lib/Makefile
clean-files := crc32table.h
When executing "make clean", the file "crc32table.h" will be deleted.
When executing ``make clean``, the file ``crc32table.h`` will be deleted.
Kbuild will assume files to be in the same relative directory as the
Makefile.
To exclude certain files or directories from make clean, use the
$(no-clean-files) variable.
Usually kbuild descends down in subdirectories due to "obj-* := dir/",
Usually kbuild descends down in subdirectories due to ``obj-* := dir/``,
but in the architecture makefiles where the kbuild infrastructure
is not sufficient this sometimes needs to be explicit.
Example::
Example::
#arch/x86/boot/Makefile
subdir- := compressed
#arch/x86/boot/Makefile
subdir- := compressed
The above assignment instructs kbuild to descend down in the
directory compressed/ when "make clean" is executed.
directory compressed/ when ``make clean`` is executed.
Note 1: arch/$(SRCARCH)/Makefile cannot use "subdir-", because that file is
Note 1: arch/$(SRCARCH)/Makefile cannot use ``subdir-``, because that file is
included in the top level makefile. Instead, arch/$(SRCARCH)/Kbuild can use
"subdir-".
``subdir-``.
Note 2: All directories listed in core-y, libs-y, drivers-y and net-y will
be visited during "make clean".
be visited during ``make clean``.
7 Architecture Makefiles
========================
Architecture Makefiles
======================
The top level Makefile sets up the environment and does the preparation,
before starting to descend down in the individual directories.
The top level makefile contains the generic part, whereas
arch/$(SRCARCH)/Makefile contains what is required to set up kbuild
for said architecture.
To do so, arch/$(SRCARCH)/Makefile sets up a number of variables and defines
a few targets.
When kbuild executes, the following steps are followed (roughly):
1) Configuration of the kernel => produce .config
2) Store kernel version in include/linux/version.h
3) Updating all other prerequisites to the target prepare:
- Additional prerequisites are specified in arch/$(SRCARCH)/Makefile
4) Recursively descend down in all directories listed in
init-* core* drivers-* net-* libs-* and build all targets.
- The values of the above variables are expanded in arch/$(SRCARCH)/Makefile.
5) All object files are then linked and the resulting file vmlinux is
located at the root of the obj tree.
The very first objects linked are listed in scripts/head-object-list.txt.
6) Finally, the architecture-specific part does any required post processing
and builds the final bootimage.
- This includes building boot records
- Preparing initrd images and the like
Set variables to tweak the build to the architecture
----------------------------------------------------
KBUILD_LDFLAGS
Generic $(LD) options
Flags used for all invocations of the linker.
Often specifying the emulation is sufficient.
Example::
7.1 Set variables to tweak the build to the architecture
--------------------------------------------------------
#arch/s390/Makefile
KBUILD_LDFLAGS := -m elf_s390
KBUILD_LDFLAGS
Generic $(LD) options
Note: ldflags-y can be used to further customise
the flags used. See `Non-builtin vmlinux targets - extra-y`_.
Flags used for all invocations of the linker.
Often specifying the emulation is sufficient.
LDFLAGS_vmlinux
Options for $(LD) when linking vmlinux
Example::
LDFLAGS_vmlinux is used to specify additional flags to pass to
the linker when linking the final vmlinux image.
#arch/s390/Makefile
KBUILD_LDFLAGS := -m elf_s390
LDFLAGS_vmlinux uses the LDFLAGS_$@ support.
Note: ldflags-y can be used to further customise
the flags used. See section 3.7.
Example::
LDFLAGS_vmlinux
Options for $(LD) when linking vmlinux
#arch/x86/Makefile
LDFLAGS_vmlinux := -e stext
LDFLAGS_vmlinux is used to specify additional flags to pass to
the linker when linking the final vmlinux image.
LDFLAGS_vmlinux uses the LDFLAGS_$@ support.
OBJCOPYFLAGS
objcopy flags
Example::
When $(call if_changed,objcopy) is used to translate a .o file,
the flags specified in OBJCOPYFLAGS will be used.
#arch/x86/Makefile
LDFLAGS_vmlinux := -e stext
$(call if_changed,objcopy) is often used to generate raw binaries on
vmlinux.
OBJCOPYFLAGS
objcopy flags
Example::
When $(call if_changed,objcopy) is used to translate a .o file,
the flags specified in OBJCOPYFLAGS will be used.
$(call if_changed,objcopy) is often used to generate raw binaries on
vmlinux.
#arch/s390/Makefile
OBJCOPYFLAGS := -O binary
Example::
#arch/s390/boot/Makefile
$(obj)/image: vmlinux FORCE
$(call if_changed,objcopy)
#arch/s390/Makefile
OBJCOPYFLAGS := -O binary
In this example, the binary $(obj)/image is a binary version of
vmlinux. The usage of $(call if_changed,xxx) will be described later.
#arch/s390/boot/Makefile
$(obj)/image: vmlinux FORCE
$(call if_changed,objcopy)
KBUILD_AFLAGS
Assembler flags
In this example, the binary $(obj)/image is a binary version of
vmlinux. The usage of $(call if_changed,xxx) will be described later.
Default value - see top level Makefile.
KBUILD_AFLAGS
Assembler flags
Append or modify as required per architecture.
Default value - see top level Makefile
Append or modify as required per architecture.
Example::
Example::
#arch/sparc64/Makefile
KBUILD_AFLAGS += -m64 -mcpu=ultrasparc
#arch/sparc64/Makefile
KBUILD_AFLAGS += -m64 -mcpu=ultrasparc
KBUILD_CFLAGS
$(CC) compiler flags
KBUILD_CFLAGS
$(CC) compiler flags
Default value - see top level Makefile.
Default value - see top level Makefile
Append or modify as required per architecture.
Append or modify as required per architecture.
Often, the KBUILD_CFLAGS variable depends on the configuration.
Often, the KBUILD_CFLAGS variable depends on the configuration.
Example::
Example::
#arch/x86/boot/compressed/Makefile
cflags-$(CONFIG_X86_32) := -march=i386
cflags-$(CONFIG_X86_64) := -mcmodel=small
KBUILD_CFLAGS += $(cflags-y)
#arch/x86/boot/compressed/Makefile
cflags-$(CONFIG_X86_32) := -march=i386
cflags-$(CONFIG_X86_64) := -mcmodel=small
KBUILD_CFLAGS += $(cflags-y)
Many arch Makefiles dynamically run the target C compiler to
probe supported options::
Many arch Makefiles dynamically run the target C compiler to
probe supported options::
#arch/x86/Makefile
#arch/x86/Makefile
...
cflags-$(CONFIG_MPENTIUMII) += $(call cc-option,\
...
cflags-$(CONFIG_MPENTIUMII) += $(call cc-option,\
-march=pentium2,-march=i686)
...
# Disable unit-at-a-time mode ...
KBUILD_CFLAGS += $(call cc-option,-fno-unit-at-a-time)
...
...
# Disable unit-at-a-time mode ...
KBUILD_CFLAGS += $(call cc-option,-fno-unit-at-a-time)
...
The first example utilises the trick that a config option expands
to 'y' when selected.
The first example utilises the trick that a config option expands
to "y" when selected.
KBUILD_RUSTFLAGS
$(RUSTC) compiler flags
KBUILD_RUSTFLAGS
$(RUSTC) compiler flags
Default value - see top level Makefile
Append or modify as required per architecture.
Default value - see top level Makefile.
Often, the KBUILD_RUSTFLAGS variable depends on the configuration.
Append or modify as required per architecture.
Note that target specification file generation (for ``--target``)
is handled in ``scripts/generate_rust_target.rs``.
Often, the KBUILD_RUSTFLAGS variable depends on the configuration.
KBUILD_AFLAGS_KERNEL
Assembler options specific for built-in
Note that target specification file generation (for ``--target``)
is handled in ``scripts/generate_rust_target.rs``.
$(KBUILD_AFLAGS_KERNEL) contains extra C compiler flags used to compile
resident kernel code.
KBUILD_AFLAGS_KERNEL
Assembler options specific for built-in
KBUILD_AFLAGS_MODULE
Assembler options specific for modules
$(KBUILD_AFLAGS_KERNEL) contains extra C compiler flags used to compile
resident kernel code.
$(KBUILD_AFLAGS_MODULE) is used to add arch-specific options that
are used for assembler.
KBUILD_AFLAGS_MODULE
Assembler options specific for modules
From commandline AFLAGS_MODULE shall be used (see kbuild.rst).
$(KBUILD_AFLAGS_MODULE) is used to add arch-specific options that
are used for assembler.
KBUILD_CFLAGS_KERNEL
$(CC) options specific for built-in
From commandline AFLAGS_MODULE shall be used (see kbuild.rst).
$(KBUILD_CFLAGS_KERNEL) contains extra C compiler flags used to compile
resident kernel code.
KBUILD_CFLAGS_KERNEL
$(CC) options specific for built-in
KBUILD_CFLAGS_MODULE
Options for $(CC) when building modules
$(KBUILD_CFLAGS_KERNEL) contains extra C compiler flags used to compile
resident kernel code.
$(KBUILD_CFLAGS_MODULE) is used to add arch-specific options that
are used for $(CC).
From commandline CFLAGS_MODULE shall be used (see kbuild.rst).
KBUILD_CFLAGS_MODULE
Options for $(CC) when building modules
KBUILD_RUSTFLAGS_KERNEL
$(RUSTC) options specific for built-in
$(KBUILD_CFLAGS_MODULE) is used to add arch-specific options that
are used for $(CC).
$(KBUILD_RUSTFLAGS_KERNEL) contains extra Rust compiler flags used to
compile resident kernel code.
From commandline CFLAGS_MODULE shall be used (see kbuild.rst).
KBUILD_RUSTFLAGS_MODULE
Options for $(RUSTC) when building modules
KBUILD_RUSTFLAGS_KERNEL
$(RUSTC) options specific for built-in
$(KBUILD_RUSTFLAGS_MODULE) is used to add arch-specific options that
are used for $(RUSTC).
From commandline RUSTFLAGS_MODULE shall be used (see kbuild.rst).
$(KBUILD_RUSTFLAGS_KERNEL) contains extra Rust compiler flags used to
compile resident kernel code.
KBUILD_LDFLAGS_MODULE
Options for $(LD) when linking modules
KBUILD_RUSTFLAGS_MODULE
Options for $(RUSTC) when building modules
$(KBUILD_LDFLAGS_MODULE) is used to add arch-specific options
used when linking modules. This is often a linker script.
$(KBUILD_RUSTFLAGS_MODULE) is used to add arch-specific options that
are used for $(RUSTC).
From commandline LDFLAGS_MODULE shall be used (see kbuild.rst).
From commandline RUSTFLAGS_MODULE shall be used (see kbuild.rst).
KBUILD_LDS
KBUILD_LDFLAGS_MODULE
Options for $(LD) when linking modules
The linker script with full path. Assigned by the top-level Makefile.
$(KBUILD_LDFLAGS_MODULE) is used to add arch-specific options
used when linking modules. This is often a linker script.
KBUILD_LDS_MODULE
From commandline LDFLAGS_MODULE shall be used (see kbuild.rst).
The module linker script with full path. Assigned by the top-level
Makefile and additionally by the arch Makefile.
KBUILD_LDS
The linker script with full path. Assigned by the top-level Makefile.
KBUILD_VMLINUX_OBJS
KBUILD_VMLINUX_OBJS
All object files for vmlinux. They are linked to vmlinux in the same
order as listed in KBUILD_VMLINUX_OBJS.
All object files for vmlinux. They are linked to vmlinux in the same
order as listed in KBUILD_VMLINUX_OBJS.
The objects listed in scripts/head-object-list.txt are exceptions;
they are placed before the other objects.
The objects listed in scripts/head-object-list.txt are exceptions;
they are placed before the other objects.
KBUILD_VMLINUX_LIBS
All .a ``lib`` files for vmlinux. KBUILD_VMLINUX_OBJS and
KBUILD_VMLINUX_LIBS together specify all the object files used to
link vmlinux.
KBUILD_VMLINUX_LIBS
Add prerequisites to archheaders
--------------------------------
All .a "lib" files for vmlinux. KBUILD_VMLINUX_OBJS and
KBUILD_VMLINUX_LIBS together specify all the object files used to
link vmlinux.
The archheaders: rule is used to generate header files that
may be installed into user space by ``make header_install``.
7.2 Add prerequisites to archheaders
------------------------------------
It is run before ``make archprepare`` when run on the
architecture itself.
The archheaders: rule is used to generate header files that
may be installed into user space by "make header_install".
Add prerequisites to archprepare
--------------------------------
It is run before "make archprepare" when run on the
architecture itself.
The archprepare: rule is used to list prerequisites that need to be
built before starting to descend down in the subdirectories.
This is usually used for header files containing assembler constants.
7.3 Add prerequisites to archprepare
------------------------------------
Example::
The archprepare: rule is used to list prerequisites that need to be
built before starting to descend down in the subdirectories.
This is usually used for header files containing assembler constants.
#arch/arm/Makefile
archprepare: maketools
Example::
In this example, the file target maketools will be processed
before descending down in the subdirectories.
#arch/arm/Makefile
archprepare: maketools
See also chapter XXX-TODO that describes how kbuild supports
generating offset header files.
In this example, the file target maketools will be processed
before descending down in the subdirectories.
See also chapter XXX-TODO that describes how kbuild supports
generating offset header files.
List directories to visit when descending
-----------------------------------------
An arch Makefile cooperates with the top Makefile to define variables
which specify how to build the vmlinux file. Note that there is no
corresponding arch-specific section for modules; the module-building
machinery is all architecture-independent.
7.4 List directories to visit when descending
---------------------------------------------
core-y, libs-y, drivers-y
$(libs-y) lists directories where a lib.a archive can be located.
An arch Makefile cooperates with the top Makefile to define variables
which specify how to build the vmlinux file. Note that there is no
corresponding arch-specific section for modules; the module-building
machinery is all architecture-independent.
The rest list directories where a built-in.a object file can be
located.
Then the rest follows in this order:
core-y, libs-y, drivers-y
$(core-y), $(libs-y), $(drivers-y)
$(libs-y) lists directories where a lib.a archive can be located.
The top level Makefile defines values for all generic directories,
and arch/$(SRCARCH)/Makefile only adds architecture-specific
directories.
The rest list directories where a built-in.a object file can be
located.
Example::
Then the rest follows in this order:
# arch/sparc/Makefile
core-y += arch/sparc/
$(core-y), $(libs-y), $(drivers-y)
libs-y += arch/sparc/prom/
libs-y += arch/sparc/lib/
The top level Makefile defines values for all generic directories,
and arch/$(SRCARCH)/Makefile only adds architecture-specific
directories.
drivers-$(CONFIG_PM) += arch/sparc/power/
Example::
Architecture-specific boot images
---------------------------------
# arch/sparc/Makefile
core-y += arch/sparc/
An arch Makefile specifies goals that take the vmlinux file, compress
it, wrap it in bootstrapping code, and copy the resulting files
somewhere. This includes various kinds of installation commands.
The actual goals are not standardized across architectures.
libs-y += arch/sparc/prom/
libs-y += arch/sparc/lib/
It is common to locate any additional processing in a boot/
directory below arch/$(SRCARCH)/.
drivers-$(CONFIG_PM) += arch/sparc/power/
Kbuild does not provide any smart way to support building a
target specified in boot/. Therefore arch/$(SRCARCH)/Makefile shall
call make manually to build a target in boot/.
7.5 Architecture-specific boot images
-------------------------------------
The recommended approach is to include shortcuts in
arch/$(SRCARCH)/Makefile, and use the full path when calling down
into the arch/$(SRCARCH)/boot/Makefile.
An arch Makefile specifies goals that take the vmlinux file, compress
it, wrap it in bootstrapping code, and copy the resulting files
somewhere. This includes various kinds of installation commands.
The actual goals are not standardized across architectures.
Example::
It is common to locate any additional processing in a boot/
directory below arch/$(SRCARCH)/.
#arch/x86/Makefile
boot := arch/x86/boot
bzImage: vmlinux
$(Q)$(MAKE) $(build)=$(boot) $(boot)/$@
Kbuild does not provide any smart way to support building a
target specified in boot/. Therefore arch/$(SRCARCH)/Makefile shall
call make manually to build a target in boot/.
``$(Q)$(MAKE) $(build)=<dir>`` is the recommended way to invoke
make in a subdirectory.
The recommended approach is to include shortcuts in
arch/$(SRCARCH)/Makefile, and use the full path when calling down
into the arch/$(SRCARCH)/boot/Makefile.
There are no rules for naming architecture-specific targets,
but executing ``make help`` will list all relevant targets.
To support this, $(archhelp) must be defined.
Example::
Example::
#arch/x86/Makefile
boot := arch/x86/boot
bzImage: vmlinux
$(Q)$(MAKE) $(build)=$(boot) $(boot)/$@
#arch/x86/Makefile
define archhelp
echo '* bzImage - Compressed kernel image (arch/x86/boot/bzImage)'
endif
"$(Q)$(MAKE) $(build)=<dir>" is the recommended way to invoke
make in a subdirectory.
When make is executed without arguments, the first goal encountered
will be built. In the top level Makefile the first goal present
is all:.
There are no rules for naming architecture-specific targets,
but executing "make help" will list all relevant targets.
To support this, $(archhelp) must be defined.
An architecture shall always, per default, build a bootable image.
In ``make help``, the default goal is highlighted with a ``*``.
Example::
Add a new prerequisite to all: to select a default goal different
from vmlinux.
#arch/x86/Makefile
define archhelp
echo '* bzImage - Compressed kernel image (arch/x86/boot/bzImage)'
endif
Example::
When make is executed without arguments, the first goal encountered
will be built. In the top level Makefile the first goal present
is all:.
An architecture shall always, per default, build a bootable image.
In "make help", the default goal is highlighted with a '*'.
Add a new prerequisite to all: to select a default goal different
from vmlinux.
#arch/x86/Makefile
all: bzImage
Example::
When ``make`` is executed without arguments, bzImage will be built.
#arch/x86/Makefile
all: bzImage
Commands useful for building a boot image
-----------------------------------------
When "make" is executed without arguments, bzImage will be built.
Kbuild provides a few macros that are useful when building a
boot image.
7.7 Commands useful for building a boot image
---------------------------------------------
ld
Link target. Often, LDFLAGS_$@ is used to set specific options to ld.
Kbuild provides a few macros that are useful when building a
boot image.
Example::
ld
Link target. Often, LDFLAGS_$@ is used to set specific options to ld.
#arch/x86/boot/Makefile
LDFLAGS_bootsect := -Ttext 0x0 -s --oformat binary
LDFLAGS_setup := -Ttext 0x0 -s --oformat binary -e begtext
Example::
targets += setup setup.o bootsect bootsect.o
$(obj)/setup $(obj)/bootsect: %: %.o FORCE
$(call if_changed,ld)
#arch/x86/boot/Makefile
LDFLAGS_bootsect := -Ttext 0x0 -s --oformat binary
LDFLAGS_setup := -Ttext 0x0 -s --oformat binary -e begtext
In this example, there are two possible targets, requiring different
options to the linker. The linker options are specified using the
LDFLAGS_$@ syntax - one for each potential target.
targets += setup setup.o bootsect bootsect.o
$(obj)/setup $(obj)/bootsect: %: %.o FORCE
$(call if_changed,ld)
$(targets) are assigned all potential targets, by which kbuild knows
the targets and will:
In this example, there are two possible targets, requiring different
options to the linker. The linker options are specified using the
LDFLAGS_$@ syntax - one for each potential target.
$(targets) are assigned all potential targets, by which kbuild knows
the targets and will:
1) check for commandline changes
2) delete target during make clean
1) check for commandline changes
2) delete target during make clean
The ``: %: %.o`` part of the prerequisite is a shorthand that
frees us from listing the setup.o and bootsect.o files.
The ": %: %.o" part of the prerequisite is a shorthand that
frees us from listing the setup.o and bootsect.o files.
Note:
It is a common mistake to forget the ``targets :=`` assignment,
resulting in the target file being recompiled for no
obvious reason.
Note:
It is a common mistake to forget the "targets :=" assignment,
resulting in the target file being recompiled for no
obvious reason.
objcopy
Copy binary. Uses OBJCOPYFLAGS usually specified in
arch/$(SRCARCH)/Makefile.
objcopy
Copy binary. Uses OBJCOPYFLAGS usually specified in
arch/$(SRCARCH)/Makefile.
OBJCOPYFLAGS_$@ may be used to set additional options.
OBJCOPYFLAGS_$@ may be used to set additional options.
gzip
Compress target. Use maximum compression to compress target.
gzip
Compress target. Use maximum compression to compress target.
Example::
Example::
#arch/x86/boot/compressed/Makefile
$(obj)/vmlinux.bin.gz: $(vmlinux.bin.all-y) FORCE
$(call if_changed,gzip)
#arch/x86/boot/compressed/Makefile
$(obj)/vmlinux.bin.gz: $(vmlinux.bin.all-y) FORCE
$(call if_changed,gzip)
dtc
Create flattened device tree blob object suitable for linking
into vmlinux. Device tree blobs linked into vmlinux are placed
in an init section in the image. Platform code *must* copy the
blob to non-init memory prior to calling unflatten_device_tree().
dtc
Create flattened device tree blob object suitable for linking
into vmlinux. Device tree blobs linked into vmlinux are placed
in an init section in the image. Platform code *must* copy the
blob to non-init memory prior to calling unflatten_device_tree().
To use this command, simply add `*.dtb` into obj-y or targets, or make
some other target depend on `%.dtb`
To use this command, simply add ``*.dtb`` into obj-y or targets, or make
some other target depend on ``%.dtb``
A central rule exists to create `$(obj)/%.dtb` from `$(src)/%.dts`;
architecture Makefiles do no need to explicitly write out that rule.
A central rule exists to create ``$(obj)/%.dtb`` from ``$(src)/%.dts``;
architecture Makefiles do no need to explicitly write out that rule.
Example::
Example::
targets += $(dtb-y)
DTC_FLAGS ?= -p 1024
targets += $(dtb-y)
DTC_FLAGS ?= -p 1024
7.9 Preprocessing linker scripts
--------------------------------
Preprocessing linker scripts
----------------------------
When the vmlinux image is built, the linker script
arch/$(SRCARCH)/kernel/vmlinux.lds is used.
The script is a preprocessed variant of the file vmlinux.lds.S
located in the same directory.
kbuild knows .lds files and includes a rule `*lds.S` -> `*lds`.
When the vmlinux image is built, the linker script
arch/$(SRCARCH)/kernel/vmlinux.lds is used.
Example::
The script is a preprocessed variant of the file vmlinux.lds.S
located in the same directory.
#arch/x86/kernel/Makefile
extra-y := vmlinux.lds
kbuild knows .lds files and includes a rule ``*lds.S`` -> ``*lds``.
The assignment to extra-y is used to tell kbuild to build the
target vmlinux.lds.
The assignment to $(CPPFLAGS_vmlinux.lds) tells kbuild to use the
specified options when building the target vmlinux.lds.
Example::
When building the `*.lds` target, kbuild uses the variables::
#arch/x86/kernel/Makefile
extra-y := vmlinux.lds
KBUILD_CPPFLAGS : Set in top-level Makefile
cppflags-y : May be set in the kbuild makefile
CPPFLAGS_$(@F) : Target-specific flags.
Note that the full filename is used in this
assignment.
The assignment to extra-y is used to tell kbuild to build the
target vmlinux.lds.
The kbuild infrastructure for `*lds` files is used in several
architecture-specific files.
The assignment to $(CPPFLAGS_vmlinux.lds) tells kbuild to use the
specified options when building the target vmlinux.lds.
7.10 Generic header files
-------------------------
When building the ``*.lds`` target, kbuild uses the variables::
The directory include/asm-generic contains the header files
that may be shared between individual architectures.
The recommended approach how to use a generic header file is
to list the file in the Kbuild file.
See "8.2 generic-y" for further info on syntax etc.
KBUILD_CPPFLAGS : Set in top-level Makefile
cppflags-y : May be set in the kbuild makefile
CPPFLAGS_$(@F) : Target-specific flags.
Note that the full filename is used in this
assignment.
7.11 Post-link pass
-------------------
The kbuild infrastructure for ``*lds`` files is used in several
architecture-specific files.
Generic header files
--------------------
If the file arch/xxx/Makefile.postlink exists, this makefile
will be invoked for post-link objects (vmlinux and modules.ko)
for architectures to run post-link passes on. Must also handle
the clean target.
The directory include/asm-generic contains the header files
that may be shared between individual architectures.
This pass runs after kallsyms generation. If the architecture
needs to modify symbol locations, rather than manipulate the
kallsyms, it may be easier to add another postlink target for
.tmp_vmlinux? targets to be called from link-vmlinux.sh.
The recommended approach how to use a generic header file is
to list the file in the Kbuild file.
For example, powerpc uses this to check relocation sanity of
the linked vmlinux file.
See `generic-y`_ for further info on syntax etc.
8 Kbuild syntax for exported headers
------------------------------------
Post-link pass
--------------
If the file arch/xxx/Makefile.postlink exists, this makefile
will be invoked for post-link objects (vmlinux and modules.ko)
for architectures to run post-link passes on. Must also handle
the clean target.
This pass runs after kallsyms generation. If the architecture
needs to modify symbol locations, rather than manipulate the
kallsyms, it may be easier to add another postlink target for
.tmp_vmlinux? targets to be called from link-vmlinux.sh.
For example, powerpc uses this to check relocation sanity of
the linked vmlinux file.
Kbuild syntax for exported headers
==================================
The kernel includes a set of headers that is exported to userspace.
Many headers can be exported as-is but other headers require a
minimal pre-processing before they are ready for user-space.
The pre-processing does:
- drop kernel-specific annotations
- drop include of compiler.h
- drop all sections that are kernel internal (guarded by `ifdef __KERNEL__`)
- drop all sections that are kernel internal (guarded by ``ifdef __KERNEL__``)
All headers under include/uapi/, include/generated/uapi/,
arch/<arch>/include/uapi/ and arch/<arch>/include/generated/uapi/
......@@ -1526,139 +1492,139 @@ are exported.
A Kbuild file may be defined under arch/<arch>/include/uapi/asm/ and
arch/<arch>/include/asm/ to list asm files coming from asm-generic.
See subsequent chapter for the syntax of the Kbuild file.
8.1 no-export-headers
---------------------
no-export-headers
-----------------
no-export-headers is essentially used by include/uapi/linux/Kbuild to
avoid exporting specific headers (e.g. kvm.h) on architectures that do
not support it. It should be avoided as much as possible.
no-export-headers is essentially used by include/uapi/linux/Kbuild to
avoid exporting specific headers (e.g. kvm.h) on architectures that do
not support it. It should be avoided as much as possible.
8.2 generic-y
-------------
generic-y
---------
If an architecture uses a verbatim copy of a header from
include/asm-generic then this is listed in the file
arch/$(SRCARCH)/include/asm/Kbuild like this:
If an architecture uses a verbatim copy of a header from
include/asm-generic then this is listed in the file
arch/$(SRCARCH)/include/asm/Kbuild like this:
Example::
Example::
#arch/x86/include/asm/Kbuild
generic-y += termios.h
generic-y += rtc.h
#arch/x86/include/asm/Kbuild
generic-y += termios.h
generic-y += rtc.h
During the prepare phase of the build a wrapper include
file is generated in the directory::
During the prepare phase of the build a wrapper include
file is generated in the directory::
arch/$(SRCARCH)/include/generated/asm
arch/$(SRCARCH)/include/generated/asm
When a header is exported where the architecture uses
the generic header a similar wrapper is generated as part
of the set of exported headers in the directory::
When a header is exported where the architecture uses
the generic header a similar wrapper is generated as part
of the set of exported headers in the directory::
usr/include/asm
usr/include/asm
The generated wrapper will in both cases look like the following:
The generated wrapper will in both cases look like the following:
Example: termios.h::
Example: termios.h::
#include <asm-generic/termios.h>
#include <asm-generic/termios.h>
8.3 generated-y
---------------
generated-y
-----------
If an architecture generates other header files alongside generic-y
wrappers, generated-y specifies them.
If an architecture generates other header files alongside generic-y
wrappers, generated-y specifies them.
This prevents them being treated as stale asm-generic wrappers and
removed.
This prevents them being treated as stale asm-generic wrappers and
removed.
Example::
Example::
#arch/x86/include/asm/Kbuild
generated-y += syscalls_32.h
#arch/x86/include/asm/Kbuild
generated-y += syscalls_32.h
8.4 mandatory-y
---------------
mandatory-y
-----------
mandatory-y is essentially used by include/(uapi/)asm-generic/Kbuild
to define the minimum set of ASM headers that all architectures must have.
mandatory-y is essentially used by include/(uapi/)asm-generic/Kbuild
to define the minimum set of ASM headers that all architectures must have.
This works like optional generic-y. If a mandatory header is missing
in arch/$(SRCARCH)/include/(uapi/)/asm, Kbuild will automatically
generate a wrapper of the asm-generic one.
This works like optional generic-y. If a mandatory header is missing
in arch/$(SRCARCH)/include/(uapi/)/asm, Kbuild will automatically
generate a wrapper of the asm-generic one.
9 Kbuild Variables
==================
Kbuild Variables
================
The top Makefile exports the following variables:
VERSION, PATCHLEVEL, SUBLEVEL, EXTRAVERSION
These variables define the current kernel version. A few arch
Makefiles actually use these values directly; they should use
$(KERNELRELEASE) instead.
$(VERSION), $(PATCHLEVEL), and $(SUBLEVEL) define the basic
three-part version number, such as "2", "4", and "0". These three
values are always numeric.
VERSION, PATCHLEVEL, SUBLEVEL, EXTRAVERSION
These variables define the current kernel version. A few arch
Makefiles actually use these values directly; they should use
$(KERNELRELEASE) instead.
$(EXTRAVERSION) defines an even tinier sublevel for pre-patches
or additional patches. It is usually some non-numeric string
such as "-pre4", and is often blank.
$(VERSION), $(PATCHLEVEL), and $(SUBLEVEL) define the basic
three-part version number, such as "2", "4", and "0". These three
values are always numeric.
KERNELRELEASE
$(KERNELRELEASE) is a single string such as "2.4.0-pre4", suitable
for constructing installation directory names or showing in
version strings. Some arch Makefiles use it for this purpose.
$(EXTRAVERSION) defines an even tinier sublevel for pre-patches
or additional patches. It is usually some non-numeric string
such as "-pre4", and is often blank.
ARCH
This variable defines the target architecture, such as "i386",
"arm", or "sparc". Some kbuild Makefiles test $(ARCH) to
determine which files to compile.
KERNELRELEASE
$(KERNELRELEASE) is a single string such as "2.4.0-pre4", suitable
for constructing installation directory names or showing in
version strings. Some arch Makefiles use it for this purpose.
By default, the top Makefile sets $(ARCH) to be the same as the
host system architecture. For a cross build, a user may
override the value of $(ARCH) on the command line::
ARCH
This variable defines the target architecture, such as "i386",
"arm", or "sparc". Some kbuild Makefiles test $(ARCH) to
determine which files to compile.
make ARCH=m68k ...
By default, the top Makefile sets $(ARCH) to be the same as the
host system architecture. For a cross build, a user may
override the value of $(ARCH) on the command line::
SRCARCH
This variable specifies the directory in arch/ to build.
make ARCH=m68k ...
ARCH and SRCARCH may not necessarily match. A couple of arch
directories are biarch, that is, a single `arch/*/` directory supports
both 32-bit and 64-bit.
SRCARCH
This variable specifies the directory in arch/ to build.
For example, you can pass in ARCH=i386, ARCH=x86_64, or ARCH=x86.
For all of them, SRCARCH=x86 because arch/x86/ supports both i386 and
x86_64.
ARCH and SRCARCH may not necessarily match. A couple of arch
directories are biarch, that is, a single ``arch/*/`` directory supports
both 32-bit and 64-bit.
INSTALL_PATH
This variable defines a place for the arch Makefiles to install
the resident kernel image and System.map file.
Use this for architecture-specific install targets.
For example, you can pass in ARCH=i386, ARCH=x86_64, or ARCH=x86.
For all of them, SRCARCH=x86 because arch/x86/ supports both i386 and
x86_64.
INSTALL_MOD_PATH, MODLIB
$(INSTALL_MOD_PATH) specifies a prefix to $(MODLIB) for module
installation. This variable is not defined in the Makefile but
may be passed in by the user if desired.
INSTALL_PATH
This variable defines a place for the arch Makefiles to install
the resident kernel image and System.map file.
Use this for architecture-specific install targets.
$(MODLIB) specifies the directory for module installation.
The top Makefile defines $(MODLIB) to
$(INSTALL_MOD_PATH)/lib/modules/$(KERNELRELEASE). The user may
override this value on the command line if desired.
INSTALL_MOD_PATH, MODLIB
$(INSTALL_MOD_PATH) specifies a prefix to $(MODLIB) for module
installation. This variable is not defined in the Makefile but
may be passed in by the user if desired.
INSTALL_MOD_STRIP
If this variable is specified, it will cause modules to be stripped
after they are installed. If INSTALL_MOD_STRIP is '1', then the
default option --strip-debug will be used. Otherwise, the
INSTALL_MOD_STRIP value will be used as the option(s) to the strip
command.
$(MODLIB) specifies the directory for module installation.
The top Makefile defines $(MODLIB) to
$(INSTALL_MOD_PATH)/lib/modules/$(KERNELRELEASE). The user may
override this value on the command line if desired.
INSTALL_MOD_STRIP
If this variable is specified, it will cause modules to be stripped
after they are installed. If INSTALL_MOD_STRIP is "1", then the
default option --strip-debug will be used. Otherwise, the
INSTALL_MOD_STRIP value will be used as the option(s) to the strip
command.
10 Makefile language
====================
Makefile language
=================
The kernel Makefiles are designed to be run with GNU Make. The Makefiles
use only the documented features of GNU Make, but they do use many
......@@ -1666,27 +1632,27 @@ GNU extensions.
GNU Make supports elementary list-processing functions. The kernel
Makefiles use a novel style of list building and manipulation with few
"if" statements.
``if`` statements.
GNU Make has two assignment operators, ":=" and "=". ":=" performs
GNU Make has two assignment operators, ``:=`` and ``=``. ``:=`` performs
immediate evaluation of the right-hand side and stores an actual string
into the left-hand side. "=" is like a formula definition; it stores the
into the left-hand side. ``=`` is like a formula definition; it stores the
right-hand side in an unevaluated form and then evaluates this form each
time the left-hand side is used.
There are some cases where "=" is appropriate. Usually, though, ":="
There are some cases where ``=`` is appropriate. Usually, though, ``:=``
is the right choice.
11 Credits
==========
Credits
=======
- Original version made by Michael Elizabeth Chastain, <mailto:mec@shout.net>
- Updates by Kai Germaschewski <kai@tp1.ruhr-uni-bochum.de>
- Updates by Sam Ravnborg <sam@ravnborg.org>
- Language QA by Jan Engelhardt <jengelh@gmx.de>
12 TODO
=======
TODO
====
- Describe how kbuild supports shipped files with _shipped.
- Generating offset header files.
......
MAINTAINERS
View file @ 498a1cf9
......@@ -11085,7 +11085,7 @@ M: Masahiro Yamada <masahiroy@kernel.org>
L: linux-kbuild@vger.kernel.org
S: Maintained
Q: https://patchwork.kernel.org/project/linux-kbuild/list/
T: git git://git.kernel.org/pub/scm/linux/kernel/git/masahiroy/linux-kbuild.git kconfig
T: git git://git.kernel.org/pub/scm/linux/kernel/git/masahiroy/linux-kbuild.git kbuild
F: Documentation/kbuild/kconfig*
F: scripts/Kconfig.include
F: scripts/kconfig/
......
Makefile
View file @ 498a1cf9
......@@ -56,26 +56,21 @@ unexport GREP_OPTIONS
# Beautify output
# ---------------------------------------------------------------------------
#
# Normally, we echo the whole command before executing it. By making
# that echo $($(quiet)$(cmd)), we now have the possibility to set
# $(quiet) to choose other forms of output instead, e.g.
# Most of build commands in Kbuild start with "cmd_". You can optionally define
# "quiet_cmd_*". If defined, the short log is printed. Otherwise, no log from
# that command is printed by default.
#
# quiet_cmd_cc_o_c = Compiling $(RELDIR)/$@
# cmd_cc_o_c = $(CC) $(c_flags) -c -o $@ $<
#
# If $(quiet) is empty, the whole command will be printed.
# If it is set to "quiet_", only the short version will be printed.
# If it is set to "silent_", nothing will be printed at all, since
# the variable $(silent_cmd_cc_o_c) doesn't exist.
# e.g.)
# quiet_cmd_depmod = DEPMOD $(MODLIB)
# cmd_depmod = $(srctree)/scripts/depmod.sh $(DEPMOD) $(KERNELRELEASE)
#
# A simple variant is to prefix commands with $(Q) - that's useful
# for commands that shall be hidden in non-verbose mode.
#
# $(Q)ln $@ :<
# $(Q)$(MAKE) $(build)=scripts/basic
#
# If KBUILD_VERBOSE equals 0 then the above command will be hidden.
# If KBUILD_VERBOSE equals 1 then the above command is displayed.
# If KBUILD_VERBOSE equals 2 then give the reason why each target is rebuilt.
# If KBUILD_VERBOSE contains 1, the whole command is echoed.
# If KBUILD_VERBOSE contains 2, the reason for rebuilding is printed.
#
# To put more focus on warnings, be less verbose as default
# Use 'make V=1' to see the full commands
......@@ -83,16 +78,13 @@ unexport GREP_OPTIONS
ifeq ("$(origin V)", "command line")
KBUILD_VERBOSE = $(V)
endif
ifndef KBUILD_VERBOSE
KBUILD_VERBOSE = 0
endif
ifeq ($(KBUILD_VERBOSE),1)
quiet = quiet_
Q = @
ifneq ($(findstring 1, $(KBUILD_VERBOSE)),)
quiet =
Q =
else
quiet=quiet_
Q = @
endif
# If the user is running make -s (silent mode), suppress echoing of
......@@ -100,14 +92,14 @@ endif
# make-4.0 (and later) keep single letter options in the 1st word of MAKEFLAGS.
ifeq ($(filter 3.%,$(MAKE_VERSION)),)
silence:=$(findstring s,$(firstword -$(MAKEFLAGS)))
short-opts := $(firstword -$(MAKEFLAGS))
else
silence:=$(findstring s,$(filter-out --%,$(MAKEFLAGS)))
short-opts := $(filter-out --%,$(MAKEFLAGS))
endif
ifeq ($(silence),s)
ifneq ($(findstring s,$(short-opts)),)
quiet=silent_
KBUILD_VERBOSE = 0
override KBUILD_VERBOSE :=
endif
export quiet Q KBUILD_VERBOSE
......@@ -211,14 +203,6 @@ ifneq ($(words $(subst :, ,$(abs_srctree))), 1)
$(error source directory cannot contain spaces or colons)
endif
ifneq ($(abs_srctree),$(abs_objtree))
# Look for make include files relative to root of kernel src
#
# --included-dir is added for backward compatibility, but you should not rely on
# it. Please add $(srctree)/ prefix to include Makefiles in the source tree.
MAKEFLAGS += --include-dir=$(abs_srctree)
endif
ifneq ($(filter 3.%,$(MAKE_VERSION)),)
# 'MAKEFLAGS += -rR' does not immediately become effective for GNU Make 3.x
# We need to invoke sub-make to avoid implicit rules in the top Makefile.
......@@ -290,7 +274,8 @@ no-dot-config-targets := $(clean-targets) \
cscope gtags TAGS tags help% %docs check% coccicheck \
$(version_h) headers headers_% archheaders archscripts \
%asm-generic kernelversion %src-pkg dt_binding_check \
outputmakefile rustavailable rustfmt rustfmtcheck
outputmakefile rustavailable rustfmt rustfmtcheck \
scripts_package
# Installation targets should not require compiler. Unfortunately, vdso_install
# is an exception where build artifacts may be updated. This must be fixed.
no-compiler-targets := $(no-dot-config-targets) install dtbs_install \
......@@ -577,7 +562,7 @@ KBUILD_CFLAGS := -Wall -Wundef -Werror=strict-prototypes -Wno-trigraphs \
-std=gnu11
KBUILD_CPPFLAGS := -D__KERNEL__
KBUILD_RUSTFLAGS := $(rust_common_flags) \
--target=$(objtree)/rust/target.json \
--target=$(objtree)/scripts/target.json \
-Cpanic=abort -Cembed-bitcode=n -Clto=n \
-Cforce-unwind-tables=n -Ccodegen-units=1 \
-Csymbol-mangling-version=v0 \
......@@ -878,7 +863,6 @@ KBUILD_RUSTFLAGS-$(CONFIG_WERROR) += -Dwarnings
KBUILD_RUSTFLAGS += $(KBUILD_RUSTFLAGS-y)
ifdef CONFIG_CC_IS_CLANG
KBUILD_CPPFLAGS += -Qunused-arguments
# The kernel builds with '-std=gnu11' so use of GNU extensions is acceptable.
KBUILD_CFLAGS += -Wno-gnu
else
......@@ -921,7 +905,9 @@ ifdef CONFIG_INIT_STACK_ALL_ZERO
KBUILD_CFLAGS += -ftrivial-auto-var-init=zero
ifdef CONFIG_CC_HAS_AUTO_VAR_INIT_ZERO_ENABLER
# https://github.com/llvm/llvm-project/issues/44842
KBUILD_CFLAGS += -enable-trivial-auto-var-init-zero-knowing-it-will-be-removed-from-clang
CC_AUTO_VAR_INIT_ZERO_ENABLER := -enable-trivial-auto-var-init-zero-knowing-it-will-be-removed-from-clang
export CC_AUTO_VAR_INIT_ZERO_ENABLER
KBUILD_CFLAGS += $(CC_AUTO_VAR_INIT_ZERO_ENABLER)
endif
endif
......@@ -1267,8 +1253,11 @@ vmlinux: vmlinux.o $(KBUILD_LDS) modpost
# make sure no implicit rule kicks in
$(sort $(KBUILD_LDS) $(KBUILD_VMLINUX_OBJS) $(KBUILD_VMLINUX_LIBS)): . ;
filechk_kernel.release = \
echo "$(KERNELVERSION)$$($(CONFIG_SHELL) $(srctree)/scripts/setlocalversion $(srctree))"
ifeq ($(origin KERNELRELEASE),file)
filechk_kernel.release = $(srctree)/scripts/setlocalversion $(srctree)
else
filechk_kernel.release = echo $(KERNELRELEASE)
endif
# Store (new) KERNELRELEASE string in include/config/kernel.release
include/config/kernel.release: FORCE
......@@ -1545,7 +1534,7 @@ endif
# Build modules
#
# *.ko are usually independent of vmlinux, but CONFIG_DEBUG_INFOBTF_MODULES
# *.ko are usually independent of vmlinux, but CONFIG_DEBUG_INFO_BTF_MODULES
# is an exception.
ifdef CONFIG_DEBUG_INFO_BTF_MODULES
KBUILD_BUILTIN := 1
......@@ -1617,7 +1606,7 @@ MRPROPER_FILES += include/config include/generated \
certs/x509.genkey \
vmlinux-gdb.py \
*.spec \
rust/target.json rust/libmacros.so
rust/libmacros.so
# clean - Delete most, but leave enough to build external modules
#
......@@ -1667,6 +1656,10 @@ distclean: mrproper
%pkg: include/config/kernel.release FORCE
$(Q)$(MAKE) -f $(srctree)/scripts/Makefile.package $@
PHONY += scripts_package
scripts_package: scripts_basic
$(Q)$(MAKE) $(build)=scripts scripts/list-gitignored
# Brief documentation of the typical targets used
# ---------------------------------------------------------------------------
......@@ -1782,8 +1775,9 @@ help:
printf " %-16s - Show all of the above\\n" help-boards; \
echo '')
@echo ' make V=0|1 [targets] 0 => quiet build (default), 1 => verbose build'
@echo ' make V=2 [targets] 2 => give reason for rebuild of target'
@echo ' make V=n [targets] 1: verbose build'
@echo ' 2: give reason for rebuild of target'
@echo ' V=1 and V=2 can be combined with V=12'
@echo ' make O=dir [targets] Locate all output files in "dir", including .config'
@echo ' make C=1 [targets] Check re-compiled c source with $$CHECK'
@echo ' (sparse by default)'
......@@ -1875,6 +1869,12 @@ rust-analyzer:
# Misc
# ---------------------------------------------------------------------------
PHONY += misc-check
misc-check:
$(Q)$(srctree)/scripts/misc-check
all: misc-check
PHONY += scripts_gdb
scripts_gdb: prepare0
$(Q)$(MAKE) $(build)=scripts/gdb
......@@ -2046,11 +2046,12 @@ clean: $(clean-dirs)
-o -name '*.lex.c' -o -name '*.tab.[ch]' \
-o -name '*.asn1.[ch]' \
-o -name '*.symtypes' -o -name 'modules.order' \
-o -name '.tmp_*' \
-o -name '*.c.[012]*.*' \
-o -name '*.ll' \
-o -name '*.gcno' \
-o -name '*.*.symversions' \) -type f -print | xargs rm -f
-o -name '*.*.symversions' \) -type f -print \
-o -name '.tmp_*' -print \
| xargs rm -rf
# Generate tags for editors
# ---------------------------------------------------------------------------
......@@ -2132,7 +2133,7 @@ checkstack:
$(PERL) $(srctree)/scripts/checkstack.pl $(CHECKSTACK_ARCH)
kernelrelease:
@echo "$(KERNELVERSION)$$($(CONFIG_SHELL) $(srctree)/scripts/setlocalversion $(srctree))"
@$(filechk_kernel.release)
kernelversion:
@echo $(KERNELVERSION)
......
arch/arm/mach-s3c/Makefile
View file @ 498a1cf9
......@@ -2,7 +2,7 @@
#
# Copyright 2009 Simtec Electronics
include $(src)/Makefile.s3c64xx
include $(srctree)/$(src)/Makefile.s3c64xx
# Objects we always build independent of SoC choice
......
arch/ia64/kernel/Makefile
View file @ 498a1cf9
......@@ -43,4 +43,4 @@ obj-$(CONFIG_ELF_CORE) += elfcore.o
CFLAGS_traps.o += -mfixed-range=f2-f5,f16-f31
# The gate DSO image is built using a special linker script.
include $(src)/Makefile.gate
include $(srctree)/$(src)/Makefile.gate
arch/mips/Kbuild
View file @ 498a1cf9
......@@ -7,7 +7,7 @@ subdir-ccflags-y := -Werror
endif
# platform specific definitions
include arch/mips/Kbuild.platforms
include $(srctree)/arch/mips/Kbuild.platforms
obj-y := $(platform-y)
# make clean traverses $(obj-) without having included .config, so
......
arch/mips/Makefile
View file @ 498a1cf9
......@@ -95,7 +95,7 @@ all-$(CONFIG_SYS_SUPPORTS_ZBOOT)+= vmlinuz
# crossformat linking we rely on the elf2ecoff tool for format conversion.
#
cflags-y += -G 0 -mno-abicalls -fno-pic -pipe
cflags-y += -msoft-float
cflags-y += -msoft-float -Wa,-msoft-float
LDFLAGS_vmlinux += -G 0 -static -n -nostdlib
KBUILD_AFLAGS_MODULE += -mlong-calls
KBUILD_CFLAGS_MODULE += -mlong-calls
......@@ -104,15 +104,6 @@ ifeq ($(CONFIG_RELOCATABLE),y)
LDFLAGS_vmlinux += --emit-relocs
endif
#
# pass -msoft-float to GAS if it supports it. However on newer binutils
# (specifically newer than 2.24.51.20140728) we then also need to explicitly
# set ".set hardfloat" in all files which manipulate floating point registers.
#
ifneq ($(call as-option,-Wa$(comma)-msoft-float,),)
cflags-y += -DGAS_HAS_SET_HARDFLOAT -Wa,-msoft-float
endif
cflags-y += -ffreestanding
cflags-$(CONFIG_CPU_BIG_ENDIAN) += -EB
......@@ -152,7 +143,7 @@ cflags-y += -fno-stack-check
#
# Avoid this by explicitly disabling that assembler behaviour.
#
cflags-y += $(call as-option,-Wa$(comma)-mno-fix-loongson3-llsc,)
cflags-y += $(call cc-option,-Wa$(comma)-mno-fix-loongson3-llsc,)
#
# CPU-dependent compiler/assembler options for optimization.
......
arch/mips/Makefile.postlink
View file @ 498a1cf9
......@@ -10,7 +10,7 @@ PHONY := __archpost
__archpost:
-include include/config/auto.conf
include scripts/Kbuild.include
include $(srctree)/scripts/Kbuild.include
CMD_LS3_LLSC = arch/mips/tools/loongson3-llsc-check
quiet_cmd_ls3_llsc = LLSCCHK $@
......
arch/mips/include/asm/asmmacro-32.h
View file @ 498a1cf9
......@@ -15,7 +15,7 @@
.macro fpu_save_single thread tmp=t0
.set push
SET_HARDFLOAT
.set hardfloat
cfc1 \tmp, fcr31
s.d $f0, THREAD_FPR0(\thread)
s.d $f2, THREAD_FPR2(\thread)
......@@ -39,7 +39,7 @@
.macro fpu_restore_single thread tmp=t0
.set push
SET_HARDFLOAT
.set hardfloat
lw \tmp, THREAD_FCR31(\thread)
l.d $f0, THREAD_FPR0(\thread)
l.d $f2, THREAD_FPR2(\thread)
......
arch/mips/include/asm/asmmacro.h
View file @ 498a1cf9
......@@ -83,7 +83,7 @@
.macro fpu_save_16even thread tmp=t0
.set push
SET_HARDFLOAT
.set hardfloat
cfc1 \tmp, fcr31
sdc1 $f0, THREAD_FPR0(\thread)
sdc1 $f2, THREAD_FPR2(\thread)
......@@ -109,7 +109,7 @@
.set push
.set mips64r2
.set fp=64
SET_HARDFLOAT
.set hardfloat
sdc1 $f1, THREAD_FPR1(\thread)
sdc1 $f3, THREAD_FPR3(\thread)
sdc1 $f5, THREAD_FPR5(\thread)
......@@ -142,7 +142,7 @@
.macro fpu_restore_16even thread tmp=t0
.set push
SET_HARDFLOAT
.set hardfloat
lw \tmp, THREAD_FCR31(\thread)
ldc1 $f0, THREAD_FPR0(\thread)
ldc1 $f2, THREAD_FPR2(\thread)
......@@ -168,7 +168,7 @@
.set push
.set mips64r2
.set fp=64
SET_HARDFLOAT
.set hardfloat
ldc1 $f1, THREAD_FPR1(\thread)
ldc1 $f3, THREAD_FPR3(\thread)
ldc1 $f5, THREAD_FPR5(\thread)
......@@ -373,7 +373,7 @@
.macro _cfcmsa rd, cs
.set push
.set noat
SET_HARDFLOAT
.set hardfloat
insn_if_mips 0x787e0059 | (\cs << 11)
insn32_if_mm 0x587e0056 | (\cs << 11)
move \rd, $1
......@@ -383,7 +383,7 @@
.macro _ctcmsa cd, rs
.set push
.set noat
SET_HARDFLOAT
.set hardfloat
move $1, \rs
insn_if_mips 0x783e0819 | (\cd << 6)
insn32_if_mm 0x583e0816 | (\cd << 6)
......@@ -393,7 +393,7 @@
.macro ld_b wd, off, base
.set push
.set noat
SET_HARDFLOAT
.set hardfloat
PTR_ADDU $1, \base, \off
insn_if_mips 0x78000820 | (\wd << 6)
insn32_if_mm 0x58000807 | (\wd << 6)
......@@ -403,7 +403,7 @@
.macro ld_h wd, off, base
.set push
.set noat
SET_HARDFLOAT
.set hardfloat
PTR_ADDU $1, \base, \off
insn_if_mips 0x78000821 | (\wd << 6)
insn32_if_mm 0x58000817 | (\wd << 6)
......@@ -413,7 +413,7 @@
.macro ld_w wd, off, base
.set push
.set noat
SET_HARDFLOAT
.set hardfloat
PTR_ADDU $1, \base, \off
insn_if_mips 0x78000822 | (\wd << 6)
insn32_if_mm 0x58000827 | (\wd << 6)
......@@ -423,7 +423,7 @@
.macro ld_d wd, off, base
.set push
.set noat
SET_HARDFLOAT
.set hardfloat
PTR_ADDU $1, \base, \off
insn_if_mips 0x78000823 | (\wd << 6)
insn32_if_mm 0x58000837 | (\wd << 6)
......@@ -433,7 +433,7 @@
.macro st_b wd, off, base
.set push
.set noat
SET_HARDFLOAT
.set hardfloat
PTR_ADDU $1, \base, \off
insn_if_mips 0x78000824 | (\wd << 6)
insn32_if_mm 0x5800080f | (\wd << 6)
......@@ -443,7 +443,7 @@
.macro st_h wd, off, base
.set push
.set noat
SET_HARDFLOAT
.set hardfloat
PTR_ADDU $1, \base, \off
insn_if_mips 0x78000825 | (\wd << 6)
insn32_if_mm 0x5800081f | (\wd << 6)
......@@ -453,7 +453,7 @@
.macro st_w wd, off, base
.set push
.set noat
SET_HARDFLOAT
.set hardfloat
PTR_ADDU $1, \base, \off
insn_if_mips 0x78000826 | (\wd << 6)
insn32_if_mm 0x5800082f | (\wd << 6)
......@@ -463,7 +463,7 @@
.macro st_d wd, off, base
.set push
.set noat
SET_HARDFLOAT
.set hardfloat
PTR_ADDU $1, \base, \off
insn_if_mips 0x78000827 | (\wd << 6)
insn32_if_mm 0x5800083f | (\wd << 6)
......@@ -473,7 +473,7 @@
.macro copy_s_w ws, n
.set push
.set noat
SET_HARDFLOAT
.set hardfloat
insn_if_mips 0x78b00059 | (\n << 16) | (\ws << 11)
insn32_if_mm 0x58b00056 | (\n << 16) | (\ws << 11)
.set pop
......@@ -482,7 +482,7 @@
.macro copy_s_d ws, n
.set push
.set noat
SET_HARDFLOAT
.set hardfloat
insn_if_mips 0x78b80059 | (\n << 16) | (\ws << 11)
insn32_if_mm 0x58b80056 | (\n << 16) | (\ws << 11)
.set pop
......@@ -491,7 +491,7 @@
.macro insert_w wd, n
.set push
.set noat
SET_HARDFLOAT
.set hardfloat
insn_if_mips 0x79300819 | (\n << 16) | (\wd << 6)
insn32_if_mm 0x59300816 | (\n << 16) | (\wd << 6)
.set pop
......@@ -500,7 +500,7 @@
.macro insert_d wd, n
.set push
.set noat
SET_HARDFLOAT
.set hardfloat
insn_if_mips 0x79380819 | (\n << 16) | (\wd << 6)
insn32_if_mm 0x59380816 | (\n << 16) | (\wd << 6)
.set pop
......@@ -553,7 +553,7 @@
st_d 29, THREAD_FPR29 - FPR_BASE_OFFS, FPR_BASE
st_d 30, THREAD_FPR30 - FPR_BASE_OFFS, FPR_BASE
st_d 31, THREAD_FPR31 - FPR_BASE_OFFS, FPR_BASE
SET_HARDFLOAT
.set hardfloat
_cfcmsa $1, MSA_CSR
sw $1, THREAD_MSA_CSR(\thread)
.set pop
......@@ -562,7 +562,7 @@
.macro msa_restore_all thread
.set push
.set noat
SET_HARDFLOAT
.set hardfloat
lw $1, THREAD_MSA_CSR(\thread)
_ctcmsa MSA_CSR, $1
#ifdef TOOLCHAIN_SUPPORTS_MSA
......@@ -618,7 +618,7 @@
.macro msa_init_all_upper
.set push
.set noat
SET_HARDFLOAT
.set hardfloat
not $1, zero
msa_init_upper 0
msa_init_upper 1
......
arch/mips/include/asm/fpregdef.h
View file @ 498a1cf9
......@@ -14,20 +14,6 @@
#include <asm/sgidefs.h>
/*
* starting with binutils 2.24.51.20140729, MIPS binutils warn about mixing
* hardfloat and softfloat object files. The kernel build uses soft-float by
* default, so we also need to pass -msoft-float along to GAS if it supports it.
* But this in turn causes assembler errors in files which access hardfloat
* registers. We detect if GAS supports "-msoft-float" in the Makefile and
* explicitly put ".set hardfloat" where floating point registers are touched.
*/
#ifdef GAS_HAS_SET_HARDFLOAT
#define SET_HARDFLOAT .set hardfloat
#else
#define SET_HARDFLOAT
#endif
#if _MIPS_SIM == _MIPS_SIM_ABI32
/*
......
arch/mips/include/asm/mipsregs.h
View file @ 498a1cf9
......@@ -2367,7 +2367,7 @@ do { \
/*
* Macros to access the floating point coprocessor control registers
*/
#define _read_32bit_cp1_register(source, gas_hardfloat) \
#define read_32bit_cp1_register(source) \
({ \
unsigned int __res; \
\
......@@ -2377,36 +2377,24 @@ do { \
" # gas fails to assemble cfc1 for some archs, \n" \
" # like Octeon. \n" \
" .set mips1 \n" \
" "STR(gas_hardfloat)" \n" \
" .set hardfloat \n" \
" cfc1 %0,"STR(source)" \n" \
" .set pop \n" \
: "=r" (__res)); \
__res; \
})
#define _write_32bit_cp1_register(dest, val, gas_hardfloat) \
#define write_32bit_cp1_register(dest, val) \
do { \
__asm__ __volatile__( \
" .set push \n" \
" .set reorder \n" \
" "STR(gas_hardfloat)" \n" \
" .set hardfloat \n" \
" ctc1 %0,"STR(dest)" \n" \
" .set pop \n" \
: : "r" (val)); \
} while (0)
#ifdef GAS_HAS_SET_HARDFLOAT
#define read_32bit_cp1_register(source) \
_read_32bit_cp1_register(source, .set hardfloat)
#define write_32bit_cp1_register(dest, val) \
_write_32bit_cp1_register(dest, val, .set hardfloat)
#else
#define read_32bit_cp1_register(source) \
_read_32bit_cp1_register(source, )
#define write_32bit_cp1_register(dest, val) \
_write_32bit_cp1_register(dest, val, )
#endif
#ifdef TOOLCHAIN_SUPPORTS_DSP
#define rddsp(mask) \
({ \
......
arch/mips/kernel/genex.S
View file @ 498a1cf9
......@@ -480,7 +480,7 @@ NESTED(nmi_handler, PT_SIZE, sp)
.set push
/* gas fails to assemble cfc1 for some archs (octeon).*/ \
.set mips1
SET_HARDFLOAT
.set hardfloat
cfc1 a1, fcr31
.set pop
.endm
......
arch/mips/kernel/r2300_fpu.S
View file @ 498a1cf9
......@@ -64,7 +64,7 @@ LEAF(_restore_fp)
*/
LEAF(_save_fp_context)
.set push
SET_HARDFLOAT
.set hardfloat
li v0, 0 # assume success
cfc1 t1, fcr31
EX2(s.d $f0, 0(a0))
......@@ -98,7 +98,7 @@ LEAF(_save_fp_context)
*/
LEAF(_restore_fp_context)
.set push
SET_HARDFLOAT
.set hardfloat
li v0, 0 # assume success
EX(lw t0, (a1))
EX2(l.d $f0, 0(a0))
......
arch/mips/kernel/r4k_fpu.S
View file @ 498a1cf9
......@@ -26,7 +26,7 @@
.macro EX insn, reg, src
.set push
SET_HARDFLOAT
.set hardfloat
.set nomacro
.ex\@: \insn \reg, \src
.set pop
......@@ -98,14 +98,14 @@ LEAF(_init_msa_upper)
*/
LEAF(_save_fp_context)
.set push
SET_HARDFLOAT
.set hardfloat
cfc1 t1, fcr31
.set pop
#if defined(CONFIG_64BIT) || defined(CONFIG_CPU_MIPSR2) || \
defined(CONFIG_CPU_MIPSR5) || defined(CONFIG_CPU_MIPSR6)
.set push
SET_HARDFLOAT
.set hardfloat
#if defined(CONFIG_CPU_MIPSR2) || defined(CONFIG_CPU_MIPSR5)
.set mips32r2
.set fp=64
......@@ -135,7 +135,7 @@ LEAF(_save_fp_context)
#endif
.set push
SET_HARDFLOAT
.set hardfloat
/* Store the 16 even double precision registers */
EX sdc1 $f0, 0(a0)
EX sdc1 $f2, 16(a0)
......@@ -173,7 +173,7 @@ LEAF(_restore_fp_context)
#if defined(CONFIG_64BIT) || defined(CONFIG_CPU_MIPSR2) || \
defined(CONFIG_CPU_MIPSR5) || defined(CONFIG_CPU_MIPSR6)
.set push
SET_HARDFLOAT
.set hardfloat
#if defined(CONFIG_CPU_MIPSR2) || defined(CONFIG_CPU_MIPSR5)
.set mips32r2
.set fp=64
......@@ -201,7 +201,7 @@ LEAF(_restore_fp_context)
1: .set pop
#endif
.set push
SET_HARDFLOAT
.set hardfloat
EX ldc1 $f0, 0(a0)
EX ldc1 $f2, 16(a0)
EX ldc1 $f4, 32(a0)
......
arch/mips/kvm/fpu.S
View file @ 498a1cf9
......@@ -22,7 +22,7 @@
LEAF(__kvm_save_fpu)
.set push
SET_HARDFLOAT
.set hardfloat
.set fp=64
mfc0 t0, CP0_STATUS
sll t0, t0, 5 # is Status.FR set?
......@@ -66,7 +66,7 @@ LEAF(__kvm_save_fpu)
LEAF(__kvm_restore_fpu)
.set push
SET_HARDFLOAT
.set hardfloat
.set fp=64
mfc0 t0, CP0_STATUS
sll t0, t0, 5 # is Status.FR set?
......@@ -110,7 +110,7 @@ LEAF(__kvm_restore_fpu)
LEAF(__kvm_restore_fcsr)
.set push
SET_HARDFLOAT
.set hardfloat
lw t0, VCPU_FCR31(a0)
/*
* The ctc1 must stay at this offset in __kvm_restore_fcsr.
......
arch/mips/loongson2ef/Platform
View file @ 498a1cf9
......@@ -25,7 +25,7 @@ cflags-$(CONFIG_CPU_LOONGSON2F) += -march=loongson2f
# binutils does not merge support for the flag then we can revisit & remove
# this later - for now it ensures vendor toolchains don't cause problems.
#
cflags-$(CONFIG_CPU_LOONGSON2EF) += $(call as-option,-Wa$(comma)-mno-fix-loongson3-llsc,)
cflags-$(CONFIG_CPU_LOONGSON2EF) += $(call cc-option,-Wa$(comma)-mno-fix-loongson3-llsc,)
# Enable the workarounds for Loongson2f
ifdef CONFIG_CPU_LOONGSON2F_WORKAROUNDS
......
arch/powerpc/Makefile
View file @ 498a1cf9
......@@ -90,7 +90,7 @@ aflags-$(CONFIG_CPU_LITTLE_ENDIAN) += -mlittle-endian
ifeq ($(HAS_BIARCH),y)
KBUILD_CFLAGS += -m$(BITS)
KBUILD_AFLAGS += -m$(BITS) -Wl,-a$(BITS)
KBUILD_AFLAGS += -m$(BITS)
KBUILD_LDFLAGS += -m elf$(BITS)$(LDEMULATION)
endif
......
arch/powerpc/Makefile.postlink
View file @ 498a1cf9
......@@ -9,7 +9,7 @@ PHONY := __archpost
__archpost:
-include include/config/auto.conf
include scripts/Kbuild.include
include $(srctree)/scripts/Kbuild.include
quiet_cmd_head_check = CHKHEAD $@
cmd_head_check = $(CONFIG_SHELL) $(srctree)/arch/powerpc/tools/head_check.sh "$(NM)" "$@"
......
arch/powerpc/kernel/prom_init_check.sh
View file @ 498a1cf9
......@@ -51,11 +51,10 @@ do
# a leading . on the name, so strip it off here.
UNDEF="${UNDEF#.}"
if [ $KBUILD_VERBOSE ]; then
if [ $KBUILD_VERBOSE -ne 0 ]; then
echo "Checking prom_init.o symbol '$UNDEF'"
fi
fi
case "$KBUILD_VERBOSE" in
*1*)
echo "Checking prom_init.o symbol '$UNDEF'" ;;
esac
OK=0
for WHITE in $WHITELIST
......
arch/powerpc/kernel/vdso/Makefile
View file @ 498a1cf9
......@@ -16,6 +16,11 @@ ifneq ($(c-gettimeofday-y),)
CFLAGS_vgettimeofday-32.o += -ffreestanding -fasynchronous-unwind-tables
CFLAGS_REMOVE_vgettimeofday-32.o = $(CC_FLAGS_FTRACE)
CFLAGS_REMOVE_vgettimeofday-32.o += -mcmodel=medium -mabi=elfv1 -mabi=elfv2 -mcall-aixdesc
# This flag is supported by clang for 64-bit but not 32-bit so it will cause
# an unused command line flag warning for this file.
ifdef CONFIG_CC_IS_CLANG
CFLAGS_REMOVE_vgettimeofday-32.o += -fno-stack-clash-protection
endif
CFLAGS_vgettimeofday-64.o += -include $(c-gettimeofday-y)
CFLAGS_vgettimeofday-64.o += $(DISABLE_LATENT_ENTROPY_PLUGIN)
CFLAGS_vgettimeofday-64.o += $(call cc-option, -fno-stack-protector)
......@@ -48,14 +53,18 @@ UBSAN_SANITIZE := n
KASAN_SANITIZE := n
KCSAN_SANITIZE := n
ccflags-y := -shared -fno-common -fno-builtin -nostdlib -Wl,--hash-style=both
ccflags-$(CONFIG_LD_IS_LLD) += $(call cc-option,--ld-path=$(LD),-fuse-ld=lld)
ccflags-y := -fno-common -fno-builtin
ldflags-y := -Wl,--hash-style=both -nostdlib -shared -z noexecstack
ldflags-$(CONFIG_LD_IS_LLD) += $(call cc-option,--ld-path=$(LD),-fuse-ld=lld)
# Filter flags that clang will warn are unused for linking
ldflags-y += $(filter-out $(CC_AUTO_VAR_INIT_ZERO_ENABLER) $(CC_FLAGS_FTRACE) -Wa$(comma)%, $(KBUILD_CFLAGS))
CC32FLAGS := -Wl,-soname=linux-vdso32.so.1 -m32
AS32FLAGS := -D__VDSO32__ -s
CC32FLAGS := -m32
LD32FLAGS := -Wl,-soname=linux-vdso32.so.1
AS32FLAGS := -D__VDSO32__
CC64FLAGS := -Wl,-soname=linux-vdso64.so.1
AS64FLAGS := -D__VDSO64__ -s
LD64FLAGS := -Wl,-soname=linux-vdso64.so.1
AS64FLAGS := -D__VDSO64__
targets += vdso32.lds
CPPFLAGS_vdso32.lds += -P -C -Upowerpc
......@@ -93,15 +102,15 @@ include/generated/vdso64-offsets.h: $(obj)/vdso64.so.dbg FORCE
# actual build commands
quiet_cmd_vdso32ld_and_check = VDSO32L $@
cmd_vdso32ld_and_check = $(VDSOCC) $(c_flags) $(CC32FLAGS) -o $@ -Wl,-T$(filter %.lds,$^) $(filter %.o,$^) -z noexecstack ; $(cmd_vdso_check)
cmd_vdso32ld_and_check = $(VDSOCC) $(ldflags-y) $(CC32FLAGS) $(LD32FLAGS) -o $@ -Wl,-T$(filter %.lds,$^) $(filter %.o,$^); $(cmd_vdso_check)
quiet_cmd_vdso32as = VDSO32A $@
cmd_vdso32as = $(VDSOCC) $(a_flags) $(CC32FLAGS) $(AS32FLAGS) -c -o $@ $<
quiet_cmd_vdso32cc = VDSO32C $@
cmd_vdso32cc = $(VDSOCC) $(c_flags) $(CC32FLAGS) -c -o $@ $<
quiet_cmd_vdso64ld_and_check = VDSO64L $@
cmd_vdso64ld_and_check = $(VDSOCC) $(c_flags) $(CC64FLAGS) -o $@ -Wl,-T$(filter %.lds,$^) $(filter %.o,$^) -z noexecstack ; $(cmd_vdso_check)
cmd_vdso64ld_and_check = $(VDSOCC) $(ldflags-y) $(LD64FLAGS) -o $@ -Wl,-T$(filter %.lds,$^) $(filter %.o,$^); $(cmd_vdso_check)
quiet_cmd_vdso64as = VDSO64A $@
cmd_vdso64as = $(VDSOCC) $(a_flags) $(CC64FLAGS) $(AS64FLAGS) -c -o $@ $<
cmd_vdso64as = $(VDSOCC) $(a_flags) $(AS64FLAGS) -c -o $@ $<
OBJECT_FILES_NON_STANDARD := y
arch/s390/kernel/vdso64/Makefile
View file @ 498a1cf9
......@@ -22,10 +22,10 @@ KBUILD_AFLAGS += -DBUILD_VDSO
KBUILD_CFLAGS += -DBUILD_VDSO -DDISABLE_BRANCH_PROFILING
KBUILD_AFLAGS_64 := $(filter-out -m64,$(KBUILD_AFLAGS))
KBUILD_AFLAGS_64 += -m64 -s
KBUILD_AFLAGS_64 += -m64
KBUILD_CFLAGS_64 := $(filter-out -m64,$(KBUILD_CFLAGS))
KBUILD_CFLAGS_64 += -m64 -fPIC -shared -fno-common -fno-builtin
KBUILD_CFLAGS_64 += -m64 -fPIC -fno-common -fno-builtin
ldflags-y := -fPIC -shared -soname=linux-vdso64.so.1 \
--hash-style=both --build-id=sha1 -T
......
arch/s390/purgatory/Makefile
View file @ 498a1cf9
......@@ -24,7 +24,7 @@ KCSAN_SANITIZE := n
KBUILD_CFLAGS := -fno-strict-aliasing -Wall -Wstrict-prototypes
KBUILD_CFLAGS += -Wno-pointer-sign -Wno-sign-compare
KBUILD_CFLAGS += -fno-zero-initialized-in-bss -fno-builtin -ffreestanding
KBUILD_CFLAGS += -c -MD -Os -m64 -msoft-float -fno-common
KBUILD_CFLAGS += -Os -m64 -msoft-float -fno-common
KBUILD_CFLAGS += -fno-stack-protector
KBUILD_CFLAGS += $(CLANG_FLAGS)
KBUILD_CFLAGS += $(call cc-option,-fno-PIE)
......
arch/sh/boot/compressed/Makefile
View file @ 498a1cf9
......@@ -8,13 +8,6 @@
OBJECTS := head_32.o misc.o cache.o piggy.o \
ashiftrt.o ashldi3.o ashrsi3.o ashlsi3.o lshrsi3.o
# These were previously generated files. When you are building the kernel
# with O=, make sure to remove the stale files in the output tree. Otherwise,
# the build system wrongly compiles the stale ones.
ifdef building_out_of_srctree
$(shell rm -f $(addprefix $(obj)/, ashiftrt.S ashldi3.c ashrsi3.S ashlsi3.S lshrsi3.S))
endif
targets := vmlinux vmlinux.bin vmlinux.bin.gz vmlinux.bin.bz2 \
vmlinux.bin.lzma vmlinux.bin.xz vmlinux.bin.lzo $(OBJECTS)
......
arch/um/drivers/Makefile
View file @ 498a1cf9
......@@ -72,4 +72,4 @@ CFLAGS_null.o = -DDEV_NULL=$(DEV_NULL_PATH)
CFLAGS_xterm.o += '-DCONFIG_XTERM_CHAN_DEFAULT_EMULATOR="$(CONFIG_XTERM_CHAN_DEFAULT_EMULATOR)"'
include arch/um/scripts/Makefile.rules
include $(srctree)/arch/um/scripts/Makefile.rules
arch/um/kernel/Makefile
View file @ 498a1cf9
......@@ -29,7 +29,7 @@ obj-$(CONFIG_GENERIC_PCI_IOMAP) += ioport.o
USER_OBJS := config.o
include arch/um/scripts/Makefile.rules
include $(srctree)/arch/um/scripts/Makefile.rules
targets := config.c config.tmp capflags.c
......
arch/um/kernel/skas/Makefile
View file @ 498a1cf9
......@@ -14,4 +14,4 @@ UNPROFILE_OBJS := clone.o
KCOV_INSTRUMENT := n
include arch/um/scripts/Makefile.rules
include $(srctree)/arch/um/scripts/Makefile.rules
arch/um/os-Linux/Makefile
View file @ 498a1cf9
......@@ -18,4 +18,4 @@ USER_OBJS := $(user-objs-y) elf_aux.o execvp.o file.o helper.o irq.o \
main.o mem.o process.o registers.o sigio.o signal.o start_up.o time.o \
tty.o umid.o util.o
include arch/um/scripts/Makefile.rules
include $(srctree)/arch/um/scripts/Makefile.rules
arch/um/os-Linux/drivers/Makefile
View file @ 498a1cf9
......@@ -10,4 +10,4 @@ obj-y =
obj-$(CONFIG_UML_NET_ETHERTAP) += ethertap.o
obj-$(CONFIG_UML_NET_TUNTAP) += tuntap.o
include arch/um/scripts/Makefile.rules
include $(srctree)/arch/um/scripts/Makefile.rules
arch/um/os-Linux/skas/Makefile
View file @ 498a1cf9
......@@ -7,4 +7,4 @@ obj-y := mem.o process.o
USER_OBJS := $(obj-y)
include arch/um/scripts/Makefile.rules
include $(srctree)/arch/um/scripts/Makefile.rules
arch/x86/Makefile.um
View file @ 498a1cf9
......@@ -17,7 +17,7 @@ LDS_EXTRA := -Ui386
export LDS_EXTRA
# First of all, tune CFLAGS for the specific CPU. This actually sets cflags-y.
include arch/x86/Makefile_32.cpu
include $(srctree)/arch/x86/Makefile_32.cpu
# prevent gcc from keeping the stack 16 byte aligned. Taken from i386.
cflags-y += $(call cc-option,-mpreferred-stack-boundary=2)
......
arch/x86/boot/compressed/Makefile
View file @ 498a1cf9
......@@ -50,7 +50,7 @@ KBUILD_CFLAGS += $(call cc-option,-fmacro-prefix-map=$(srctree)/=)
KBUILD_CFLAGS += -fno-asynchronous-unwind-tables
KBUILD_CFLAGS += -D__DISABLE_EXPORTS
# Disable relocation relaxation in case the link is not PIE.
KBUILD_CFLAGS += $(call as-option,-Wa$(comma)-mrelax-relocations=no)
KBUILD_CFLAGS += $(call cc-option,-Wa$(comma)-mrelax-relocations=no)
KBUILD_CFLAGS += -include $(srctree)/include/linux/hidden.h
# sev.c indirectly inludes inat-table.h which is generated during
......
arch/x86/tools/Makefile
View file @ 498a1cf9
# SPDX-License-Identifier: GPL-2.0
PHONY += posttest
ifeq ($(KBUILD_VERBOSE),1)
ifneq ($(findstring 1, $(KBUILD_VERBOSE)),)
posttest_verbose = -v
else
posttest_verbose =
......
arch/x86/um/Makefile
View file @ 498a1cf9
......@@ -48,4 +48,4 @@ include/generated/user_constants.h: $(obj)/user-offsets.s FORCE
UNPROFILE_OBJS := stub_segv.o
CFLAGS_stub_segv.o := $(CFLAGS_NO_HARDENING)
include arch/um/scripts/Makefile.rules
include $(srctree)/arch/um/scripts/Makefile.rules
arch/x86/um/os-Linux/Makefile
View file @ 498a1cf9
......@@ -10,4 +10,4 @@ obj-$(CONFIG_64BIT) += prctl.o
USER_OBJS := $(obj-y)
include arch/um/scripts/Makefile.rules
include $(srctree)/arch/um/scripts/Makefile.rules
certs/extract-cert.c
View file @ 498a1cf9
......@@ -78,7 +78,7 @@ static void drain_openssl_errors(void)
static const char *key_pass;
static BIO *wb;
static char *cert_dst;
static int kbuild_verbose;
static bool verbose;
static void write_cert(X509 *x509)
{
......@@ -90,19 +90,22 @@ static void write_cert(X509 *x509)
}
X509_NAME_oneline(X509_get_subject_name(x509), buf, sizeof(buf));
ERR(!i2d_X509_bio(wb, x509), "%s", cert_dst);
if (kbuild_verbose)
if (verbose)
fprintf(stderr, "Extracted cert: %s\n", buf);
}
int main(int argc, char **argv)
{
char *cert_src;
char *verbose_env;
OpenSSL_add_all_algorithms();
ERR_load_crypto_strings();
ERR_clear_error();
kbuild_verbose = atoi(getenv("KBUILD_VERBOSE")?:"0");
verbose_env = getenv("KBUILD_VERBOSE");
if (verbose_env && strchr(verbose_env, '1'))
verbose = true;
key_pass = getenv("KBUILD_SIGN_PIN");
......
drivers/Makefile
View file @ 498a1cf9
......@@ -6,6 +6,11 @@
# Rewritten to use lists instead of if-statements.
#
# Some driver Makefiles miss $(srctree)/ for include directive.
ifdef building_out_of_srctree
MAKEFLAGS += --include-dir=$(srctree)
endif
obj-y += irqchip/
obj-y += bus/
......
drivers/gpu/drm/amd/display/dc/dml/Makefile
View file @ 498a1cf9
......@@ -26,7 +26,8 @@
# subcomponents.
ifdef CONFIG_X86
dml_ccflags := -mhard-float -msse
dml_ccflags-$(CONFIG_CC_IS_GCC) := -mhard-float
dml_ccflags := $(dml_ccflags-y) -msse
endif
ifdef CONFIG_PPC64
......
fs/hostfs/Makefile
View file @ 498a1cf9
......@@ -8,4 +8,4 @@ hostfs-objs := hostfs_kern.o hostfs_user.o
obj-y :=
obj-$(CONFIG_HOSTFS) += hostfs.o
include arch/um/scripts/Makefile.rules
include $(srctree)/arch/um/scripts/Makefile.rules
init/Kconfig
View file @ 498a1cf9
......@@ -682,10 +682,6 @@ config CPU_ISOLATION
source "kernel/rcu/Kconfig"
config BUILD_BIN2C
bool
default n
config IKCONFIG
tristate "Kernel .config support"
help
......
kernel/gen_kheaders.sh
View file @ 498a1cf9
......@@ -7,7 +7,7 @@ set -e
sfile="$(readlink -f "$0")"
outdir="$(pwd)"
tarfile=$1
cpio_dir=$outdir/$tarfile.tmp
cpio_dir=$outdir/${tarfile%/*}/.tmp_cpio_dir
dir_list="
include/
......
rust/.gitignore
View file @ 498a1cf9
# SPDX-License-Identifier: GPL-2.0
target.json
bindings_generated.rs
bindings_helpers_generated.rs
exports_*_generated.h
......
rust/Makefile
View file @ 498a1cf9
# SPDX-License-Identifier: GPL-2.0
always-$(CONFIG_RUST) += target.json
no-clean-files += target.json
obj-$(CONFIG_RUST) += core.o compiler_builtins.o
always-$(CONFIG_RUST) += exports_core_generated.h
......@@ -232,11 +229,6 @@ rusttest-kernel: $(src)/kernel/lib.rs rusttest-prepare \
$(call if_changed,rustc_test)
$(call if_changed,rustc_test_library)
filechk_rust_target = $(objtree)/scripts/generate_rust_target < $<
$(obj)/target.json: $(objtree)/include/config/auto.conf FORCE
$(call filechk,rust_target)
ifdef CONFIG_CC_IS_CLANG
bindgen_c_flags = $(c_flags)
else
......@@ -332,11 +324,9 @@ $(obj)/exports_kernel_generated.h: $(obj)/kernel.o FORCE
quiet_cmd_rustc_procmacro = $(RUSTC_OR_CLIPPY_QUIET) P $@
cmd_rustc_procmacro = \
$(RUSTC_OR_CLIPPY) $(rust_common_flags) \
--emit=dep-info,link --extern proc_macro \
--crate-type proc-macro --out-dir $(objtree)/$(obj) \
--crate-name $(patsubst lib%.so,%,$(notdir $@)) $<; \
mv $(objtree)/$(obj)/$(patsubst lib%.so,%,$(notdir $@)).d $(depfile); \
sed -i '/^\#/d' $(depfile)
--emit=dep-info=$(depfile) --emit=link=$@ --extern proc_macro \
--crate-type proc-macro \
--crate-name $(patsubst lib%.so,%,$(notdir $@)) $<
# Procedural macros can only be used with the `rustc` that compiled it.
# Therefore, to get `libmacros.so` automatically recompiled when the compiler
......@@ -349,11 +339,10 @@ quiet_cmd_rustc_library = $(if $(skip_clippy),RUSTC,$(RUSTC_OR_CLIPPY_QUIET)) L
OBJTREE=$(abspath $(objtree)) \
$(if $(skip_clippy),$(RUSTC),$(RUSTC_OR_CLIPPY)) \
$(filter-out $(skip_flags),$(rust_flags) $(rustc_target_flags)) \
--emit=dep-info,obj,metadata --crate-type rlib \
--out-dir $(objtree)/$(obj) -L$(objtree)/$(obj) \
--crate-name $(patsubst %.o,%,$(notdir $@)) $<; \
mv $(objtree)/$(obj)/$(patsubst %.o,%,$(notdir $@)).d $(depfile); \
sed -i '/^\#/d' $(depfile) \
--emit=dep-info=$(depfile) --emit=obj=$@ \
--emit=metadata=$(dir $@)$(patsubst %.o,lib%.rmeta,$(notdir $@)) \
--crate-type rlib -L$(objtree)/$(obj) \
--crate-name $(patsubst %.o,%,$(notdir $@)) $< \
$(if $(rustc_objcopy),;$(OBJCOPY) $(rustc_objcopy) $@)
rust-analyzer:
......@@ -377,7 +366,7 @@ $(obj)/core.o: private skip_clippy = 1
$(obj)/core.o: private skip_flags = -Dunreachable_pub
$(obj)/core.o: private rustc_objcopy = $(foreach sym,$(redirect-intrinsics),--redefine-sym $(sym)=__rust$(sym))
$(obj)/core.o: private rustc_target_flags = $(core-cfgs)
$(obj)/core.o: $(RUST_LIB_SRC)/core/src/lib.rs $(obj)/target.json FORCE
$(obj)/core.o: $(RUST_LIB_SRC)/core/src/lib.rs scripts/target.json FORCE
$(call if_changed_dep,rustc_library)
$(obj)/compiler_builtins.o: private rustc_objcopy = -w -W '__*'
......
scripts/.gitignore
View file @ 498a1cf9
# SPDX-License-Identifier: GPL-2.0-only
/asn1_compiler
/bin2c
/generate_rust_target
/insert-sys-cert
/kallsyms
/list-gitignored
/module.lds
/recordmcount
/sign-file
/sorttable
/target.json
/unifdef
scripts/Kbuild.include
View file @ 498a1cf9
......@@ -99,11 +99,11 @@ define filechk
$(check-FORCE)
$(Q)set -e; \
mkdir -p $(dir $@); \
trap "rm -f $(dot-target).tmp" EXIT; \
{ $(filechk_$(1)); } > $(dot-target).tmp; \
if [ ! -r $@ ] || ! cmp -s $@ $(dot-target).tmp; then \
trap "rm -f $(tmp-target)" EXIT; \
{ $(filechk_$(1)); } > $(tmp-target); \
if [ ! -r $@ ] || ! cmp -s $@ $(tmp-target); then \
$(kecho) ' UPD $@'; \
mv -f $(dot-target).tmp $@; \
mv -f $(tmp-target) $@; \
fi
endef
......@@ -125,15 +125,15 @@ dtbinst := -f $(srctree)/scripts/Makefile.dtbinst obj
# $(Q)$(MAKE) $(clean)=dir
clean := -f $(srctree)/scripts/Makefile.clean obj
# echo command.
# Short version is used, if $(quiet) equals `quiet_', otherwise full one.
echo-cmd = $(if $($(quiet)cmd_$(1)),\
echo ' $(call escsq,$($(quiet)cmd_$(1)))$(echo-why)';)
# sink stdout for 'make -s'
redirect :=
quiet_redirect :=
silent_redirect := exec >/dev/null;
# pring log
#
# If quiet is "silent_", print nothing and sink stdout
# If quiet is "quiet_", print short log
# If quiet is empty, print short log and whole command
silent_log_print = exec >/dev/null;
quiet_log_print = $(if $(quiet_cmd_$1), echo ' $(call escsq,$(quiet_cmd_$1)$(why))';)
log_print = echo '$(pound) $(call escsq,$(or $(quiet_cmd_$1),cmd_$1 $@)$(why))'; \
echo ' $(call escsq,$(cmd_$1))';
# Delete the target on interruption
#
......@@ -156,8 +156,8 @@ delete-on-interrupt = \
$(foreach sig, HUP INT QUIT TERM PIPE, \
trap 'rm -f $@; trap - $(sig); kill -s $(sig) $$$$' $(sig);))
# printing commands
cmd = @set -e; $(echo-cmd) $($(quiet)redirect) $(delete-on-interrupt) $(cmd_$(1))
# print and execute commands
cmd = @$(if $(cmd_$(1)),set -e; $($(quiet)log_print) $(delete-on-interrupt) $(cmd_$(1)),:)
###
# if_changed - execute command if any prerequisite is newer than
......@@ -170,10 +170,14 @@ cmd = @set -e; $(echo-cmd) $($(quiet)redirect) $(delete-on-interrupt) $(cmd_$(1)
ifneq ($(KBUILD_NOCMDDEP),1)
# Check if both commands are the same including their order. Result is empty
# string if equal. User may override this check using make KBUILD_NOCMDDEP=1
cmd-check = $(filter-out $(subst $(space),$(space_escape),$(strip $(cmd_$@))), \
# If the target does not exist, the *.cmd file should not be included so
# $(savedcmd_$@) gets empty. Then, target will be built even if $(newer-prereqs)
# happens to become empty.
cmd-check = $(filter-out $(subst $(space),$(space_escape),$(strip $(savedcmd_$@))), \
$(subst $(space),$(space_escape),$(strip $(cmd_$1))))
else
cmd-check = $(if $(strip $(cmd_$@)),,1)
# We still need to detect missing targets.
cmd-check = $(if $(strip $(savedcmd_$@)),,1)
endif
# Replace >$< with >$$< to preserve $ when reloading the .cmd file
......@@ -186,6 +190,8 @@ make-cmd = $(call escsq,$(subst $(pound),$$(pound),$(subst $$,$$$$,$(cmd_$(1))))
# Find any prerequisites that are newer than target or that do not exist.
# PHONY targets skipped in both cases.
# If there is no prerequisite other than phony targets, $(newer-prereqs) becomes
# empty even if the target does not exist. cmd-check saves this corner case.
newer-prereqs = $(filter-out $(PHONY),$?)
# It is a typical mistake to forget the FORCE prerequisite. Check it here so
......@@ -199,7 +205,7 @@ if_changed = $(if $(if-changed-cond),$(cmd_and_savecmd),@:)
cmd_and_savecmd = \
$(cmd); \
printf '%s\n' 'cmd_$@ := $(make-cmd)' > $(dot-target).cmd
printf '%s\n' 'savedcmd_$@ := $(make-cmd)' > $(dot-target).cmd
# Execute the command and also postprocess generated .d dependencies file.
if_changed_dep = $(if $(if-changed-cond),$(cmd_and_fixdep),@:)
......@@ -233,13 +239,13 @@ if_changed_rule = $(if $(if-changed-cond),$(rule_$(1)),@:)
# (5) No dir/.target.cmd file (used to store command line)
# (6) No dir/.target.cmd file and target not listed in $(targets)
# This is a good hint that there is a bug in the kbuild file
ifeq ($(KBUILD_VERBOSE),2)
why = \
ifneq ($(findstring 2, $(KBUILD_VERBOSE)),)
_why = \
$(if $(filter $@, $(PHONY)),- due to target is PHONY, \
$(if $(wildcard $@), \
$(if $(newer-prereqs),- due to: $(newer-prereqs), \
$(if $(cmd-check), \
$(if $(cmd_$@),- due to command line change, \
$(if $(savedcmd_$@),- due to command line change, \
$(if $(filter $@, $(targets)), \
- due to missing .cmd file, \
- due to $(notdir $@) not in $$(targets) \
......@@ -251,7 +257,7 @@ why = \
) \
)
echo-why = $(call escsq, $(strip $(why)))
why = $(space)$(strip $(_why))
endif
###############################################################################
......
scripts/Kconfig.include
View file @ 498a1cf9
......@@ -33,7 +33,7 @@ ld-option = $(success,$(LD) -v $(1))
# $(as-instr,<instr>)
# Return y if the assembler supports <instr>, n otherwise
as-instr = $(success,printf "%b\n" "$(1)" | $(CC) $(CLANG_FLAGS) -c -x assembler -o /dev/null -)
as-instr = $(success,printf "%b\n" "$(1)" | $(CC) $(CLANG_FLAGS) -c -x assembler-with-cpp -o /dev/null -)
# check if $(CC) and $(LD) exist
$(error-if,$(failure,command -v $(CC)),C compiler '$(CC)' not found)
......
scripts/Makefile
View file @ 498a1cf9
......@@ -3,15 +3,20 @@
# scripts contains sources for various helper programs used throughout
# the kernel for the build process.
hostprogs-always-$(CONFIG_BUILD_BIN2C) += bin2c
hostprogs-always-$(CONFIG_KALLSYMS) += kallsyms
hostprogs-always-$(BUILD_C_RECORDMCOUNT) += recordmcount
hostprogs-always-$(CONFIG_BUILDTIME_TABLE_SORT) += sorttable
hostprogs-always-$(CONFIG_ASN1) += asn1_compiler
hostprogs-always-$(CONFIG_MODULE_SIG_FORMAT) += sign-file
hostprogs-always-$(CONFIG_SYSTEM_EXTRA_CERTIFICATE) += insert-sys-cert
hostprogs-always-$(CONFIG_RUST) += generate_rust_target
always-$(CONFIG_RUST) += target.json
filechk_rust_target = $< < include/config/auto.conf
$(obj)/target.json: scripts/generate_rust_target include/config/auto.conf FORCE
$(call filechk,rust_target)
hostprogs += generate_rust_target
generate_rust_target-rust := y
HOSTCFLAGS_sorttable.o = -I$(srctree)/tools/include
......@@ -33,7 +38,7 @@ HOSTCFLAGS_sorttable.o += -DMCOUNT_SORT_ENABLED
endif
# The following programs are only built on demand
hostprogs += unifdef
hostprogs += list-gitignored unifdef
# The module linker script is preprocessed on demand
targets += module.lds
......
scripts/Makefile.build
View file @ 498a1cf9
......@@ -285,12 +285,9 @@ rust_common_cmd = \
-Zcrate-attr=no_std \
-Zcrate-attr='feature($(rust_allowed_features))' \
--extern alloc --extern kernel \
--crate-type rlib --out-dir $(obj) -L $(objtree)/rust/ \
--crate-name $(basename $(notdir $@))
rust_handle_depfile = \
mv $(obj)/$(basename $(notdir $@)).d $(depfile); \
sed -i '/^\#/d' $(depfile)
--crate-type rlib -L $(objtree)/rust/ \
--crate-name $(basename $(notdir $@)) \
--emit=dep-info=$(depfile)
# `--emit=obj`, `--emit=asm` and `--emit=llvm-ir` imply a single codegen unit
# will be used. We explicitly request `-Ccodegen-units=1` in any case, and
......@@ -301,34 +298,27 @@ rust_handle_depfile = \
# would not match each other.
quiet_cmd_rustc_o_rs = $(RUSTC_OR_CLIPPY_QUIET) $(quiet_modtag) $@
cmd_rustc_o_rs = \
$(rust_common_cmd) --emit=dep-info,obj $<; \
$(rust_handle_depfile)
cmd_rustc_o_rs = $(rust_common_cmd) --emit=obj=$@ $<
$(obj)/%.o: $(src)/%.rs FORCE
$(call if_changed_dep,rustc_o_rs)
quiet_cmd_rustc_rsi_rs = $(RUSTC_OR_CLIPPY_QUIET) $(quiet_modtag) $@
cmd_rustc_rsi_rs = \
$(rust_common_cmd) --emit=dep-info -Zunpretty=expanded $< >$@; \
command -v $(RUSTFMT) >/dev/null && $(RUSTFMT) $@; \
$(rust_handle_depfile)
$(rust_common_cmd) -Zunpretty=expanded $< >$@; \
command -v $(RUSTFMT) >/dev/null && $(RUSTFMT) $@
$(obj)/%.rsi: $(src)/%.rs FORCE
$(call if_changed_dep,rustc_rsi_rs)
quiet_cmd_rustc_s_rs = $(RUSTC_OR_CLIPPY_QUIET) $(quiet_modtag) $@
cmd_rustc_s_rs = \
$(rust_common_cmd) --emit=dep-info,asm $<; \
$(rust_handle_depfile)
cmd_rustc_s_rs = $(rust_common_cmd) --emit=asm=$@ $<
$(obj)/%.s: $(src)/%.rs FORCE
$(call if_changed_dep,rustc_s_rs)
quiet_cmd_rustc_ll_rs = $(RUSTC_OR_CLIPPY_QUIET) $(quiet_modtag) $@
cmd_rustc_ll_rs = \
$(rust_common_cmd) --emit=dep-info,llvm-ir $<; \
$(rust_handle_depfile)
cmd_rustc_ll_rs = $(rust_common_cmd) --emit=llvm-ir=$@ $<
$(obj)/%.ll: $(src)/%.rs FORCE
$(call if_changed_dep,rustc_ll_rs)
......
scripts/Makefile.clang
View file @ 498a1cf9
......@@ -36,6 +36,8 @@ endif
# so they can be implemented or wrapped in cc-option.
CLANG_FLAGS += -Werror=unknown-warning-option
CLANG_FLAGS += -Werror=ignored-optimization-argument
CLANG_FLAGS += -Werror=option-ignored
CLANG_FLAGS += -Werror=unused-command-line-argument
KBUILD_CFLAGS += $(CLANG_FLAGS)
KBUILD_AFLAGS += $(CLANG_FLAGS)
export CLANG_FLAGS
scripts/Makefile.compiler
View file @ 498a1cf9
......@@ -29,16 +29,16 @@ try-run = $(shell set -e; \
fi)
# as-option
# Usage: cflags-y += $(call as-option,-Wa$(comma)-isa=foo,)
# Usage: aflags-y += $(call as-option,-Wa$(comma)-isa=foo,)
as-option = $(call try-run,\
$(CC) $(KBUILD_CFLAGS) $(1) -c -x assembler /dev/null -o "$$TMP",$(1),$(2))
$(CC) -Werror $(KBUILD_AFLAGS) $(1) -c -x assembler-with-cpp /dev/null -o "$$TMP",$(1),$(2))
# as-instr
# Usage: cflags-y += $(call as-instr,instr,option1,option2)
# Usage: aflags-y += $(call as-instr,instr,option1,option2)
as-instr = $(call try-run,\
printf "%b\n" "$(1)" | $(CC) $(KBUILD_AFLAGS) -c -x assembler -o "$$TMP" -,$(2),$(3))
printf "%b\n" "$(1)" | $(CC) -Werror $(KBUILD_AFLAGS) -c -x assembler-with-cpp -o "$$TMP" -,$(2),$(3))
# __cc-option
# Usage: MY_CFLAGS += $(call __cc-option,$(CC),$(MY_CFLAGS),-march=winchip-c6,-march=i586)
......
scripts/Makefile.host
View file @ 498a1cf9
......@@ -80,25 +80,24 @@ host-rust := $(addprefix $(obj)/,$(host-rust))
#####
# Handle options to gcc. Support building with separate output directory
_hostc_flags = $(KBUILD_HOSTCFLAGS) $(HOST_EXTRACFLAGS) \
hostc_flags = -Wp,-MMD,$(depfile) \
$(KBUILD_HOSTCFLAGS) $(HOST_EXTRACFLAGS) \
$(HOSTCFLAGS_$(target-stem).o)
_hostcxx_flags = $(KBUILD_HOSTCXXFLAGS) $(HOST_EXTRACXXFLAGS) \
hostcxx_flags = -Wp,-MMD,$(depfile) \
$(KBUILD_HOSTCXXFLAGS) $(HOST_EXTRACXXFLAGS) \
$(HOSTCXXFLAGS_$(target-stem).o)
_hostrust_flags = $(KBUILD_HOSTRUSTFLAGS) $(HOST_EXTRARUSTFLAGS) \
$(HOSTRUSTFLAGS_$(target-stem))
hostrust_flags = --emit=dep-info=$(depfile) \
$(KBUILD_HOSTRUSTFLAGS) $(HOST_EXTRARUSTFLAGS) \
$(HOSTRUSTFLAGS_$(target-stem))
# $(objtree)/$(obj) for including generated headers from checkin source files
ifeq ($(KBUILD_EXTMOD),)
ifdef building_out_of_srctree
_hostc_flags += -I $(objtree)/$(obj)
_hostcxx_flags += -I $(objtree)/$(obj)
hostc_flags += -I $(objtree)/$(obj)
hostcxx_flags += -I $(objtree)/$(obj)
endif
endif
hostc_flags = -Wp,-MMD,$(depfile) $(_hostc_flags)
hostcxx_flags = -Wp,-MMD,$(depfile) $(_hostcxx_flags)
hostrust_flags = $(_hostrust_flags)
#####
# Compile programs on the host
......@@ -149,10 +148,7 @@ $(host-cxxobjs): $(obj)/%.o: $(src)/%.cc FORCE
# host-rust -> Executable
quiet_cmd_host-rust = HOSTRUSTC $@
cmd_host-rust = \
$(HOSTRUSTC) $(hostrust_flags) --emit=dep-info,link \
--out-dir=$(obj)/ $<; \
mv $(obj)/$(target-stem).d $(depfile); \
sed -i '/^\#/d' $(depfile)
$(HOSTRUSTC) $(hostrust_flags) --emit=link=$@ $<
$(host-rust): $(obj)/%: $(src)/%.rs FORCE
$(call if_changed_dep,host-rust)
......
scripts/Makefile.lib
View file @ 498a1cf9
......@@ -368,40 +368,25 @@ DTC_FLAGS += $(DTC_FLAGS_$(basetarget))
DTC_FLAGS += $(if $(filter $(patsubst $(obj)/%,%,$@), $(base-dtb-y)), -@)
# Generate an assembly file to wrap the output of the device tree compiler
quiet_cmd_dt_S_dtb= DTBS $@
cmd_dt_S_dtb= \
{ \
echo '\#include <asm-generic/vmlinux.lds.h>'; \
echo '.section .dtb.init.rodata,"a"'; \
echo '.balign STRUCT_ALIGNMENT'; \
echo '.global __dtb_$(subst -,_,$(*F))_begin'; \
echo '__dtb_$(subst -,_,$(*F))_begin:'; \
echo '.incbin "$<" '; \
echo '__dtb_$(subst -,_,$(*F))_end:'; \
echo '.global __dtb_$(subst -,_,$(*F))_end'; \
echo '.balign STRUCT_ALIGNMENT'; \
} > $@
quiet_cmd_wrap_S_dtb = WRAP $@
cmd_wrap_S_dtb = { \
symbase=__$(patsubst .%,%,$(suffix $<))_$(subst -,_,$(notdir $*)); \
echo '\#include <asm-generic/vmlinux.lds.h>'; \
echo '.section .dtb.init.rodata,"a"'; \
echo '.balign STRUCT_ALIGNMENT'; \
echo ".global $${symbase}_begin"; \
echo "$${symbase}_begin:"; \
echo '.incbin "$<" '; \
echo ".global $${symbase}_end"; \
echo "$${symbase}_end:"; \
echo '.balign STRUCT_ALIGNMENT'; \
} > $@
$(obj)/%.dtb.S: $(obj)/%.dtb FORCE
$(call if_changed,dt_S_dtb)
# Generate an assembly file to wrap the output of the device tree compiler
quiet_cmd_dt_S_dtbo= DTBOS $@
cmd_dt_S_dtbo= \
{ \
echo '\#include <asm-generic/vmlinux.lds.h>'; \
echo '.section .dtb.init.rodata,"a"'; \
echo '.balign STRUCT_ALIGNMENT'; \
echo '.global __dtbo_$(subst -,_,$(*F))_begin'; \
echo '__dtbo_$(subst -,_,$(*F))_begin:'; \
echo '.incbin "$<" '; \
echo '__dtbo_$(subst -,_,$(*F))_end:'; \
echo '.global __dtbo_$(subst -,_,$(*F))_end'; \
echo '.balign STRUCT_ALIGNMENT'; \
} > $@
$(call if_changed,wrap_S_dtb)
$(obj)/%.dtbo.S: $(obj)/%.dtbo FORCE
$(call if_changed,dt_S_dtbo)
$(call if_changed,wrap_S_dtb)
quiet_cmd_dtc = DTC $@
cmd_dtc = $(HOSTCC) -E $(dtc_cpp_flags) -x assembler-with-cpp -o $(dtc-tmp) $< ; \
......
scripts/Makefile.modfinal
View file @ 498a1cf9
......@@ -54,7 +54,7 @@ newer_prereqs_except = $(filter-out $(PHONY) $(1),$?)
# Same as if_changed, but allows to exclude specified extra dependencies
if_changed_except = $(if $(call newer_prereqs_except,$(2))$(cmd-check), \
$(cmd); \
printf '%s\n' 'cmd_$@ := $(make-cmd)' > $(dot-target).cmd, @:)
printf '%s\n' 'savedcmd_$@ := $(make-cmd)' > $(dot-target).cmd, @:)
# Re-generate module BTFs if either module's .ko or vmlinux changed
%.ko: %.o %.mod.o scripts/module.lds $(and $(CONFIG_DEBUG_INFO_BTF_MODULES),$(KBUILD_BUILTIN),vmlinux) FORCE
......
scripts/Makefile.modpost
View file @ 498a1cf9
......@@ -121,16 +121,14 @@ modpost-args += -e $(addprefix -i , $(KBUILD_EXTRA_SYMBOLS))
endif # ($(KBUILD_EXTMOD),)
ifneq ($(missing-input),)
modpost-args += -w
endif
quiet_cmd_modpost = MODPOST $@
cmd_modpost = \
$(if $(missing-input), \
echo >&2 "WARNING: $(missing-input) is missing."; \
echo >&2 " Modules may not have dependencies or modversions."; \
echo >&2 " You may get many unresolved symbol warnings.";) \
echo >&2 " You may get many unresolved symbol errors."; \
echo >&2 " You can set KBUILD_MODPOST_WARN=1 to turn errors into warning"; \
echo >&2 " if you want to proceed at your own risk.";) \
$(MODPOST) $(modpost-args)
targets += $(output-symdump)
......
scripts/Makefile.package
View file @ 498a1cf9
......@@ -3,36 +3,13 @@
include $(srctree)/scripts/Kbuild.include
# RPM target
# ---------------------------------------------------------------------------
# The rpm target generates two rpm files:
# /usr/src/packages/SRPMS/kernel-2.6.7rc2-1.src.rpm
# /usr/src/packages/RPMS/i386/kernel-2.6.7rc2-1.<arch>.rpm
# The src.rpm files includes all source for the kernel being built
# The <arch>.rpm includes kernel configuration, modules etc.
#
# Process to create the rpm files
# a) clean the kernel
# b) Generate .spec file
# c) Build a tar ball, using symlink to make kernel version
# first entry in the path
# d) and pack the result to a tar.gz file
# e) generate the rpm files, based on kernel.spec
# - Use /. to avoid tar packing just the symlink
# Note that the rpm-pkg target cannot be used with KBUILD_OUTPUT,
# but the binrpm-pkg target can; for some reason O= gets ignored.
# Remove hyphens since they have special meaning in RPM filenames
KERNELPATH := kernel-$(subst -,_,$(KERNELRELEASE))
KDEB_SOURCENAME ?= linux-upstream
KBUILD_PKG_ROOTCMD ?="fakeroot -u"
export KDEB_SOURCENAME
# Include only those top-level files that are needed by make, plus the GPL copy
TAR_CONTENT := Documentation LICENSES arch block certs crypto drivers fs \
include init io_uring ipc kernel lib mm net rust \
samples scripts security sound tools usr virt \
.config .scmversion Makefile \
.config Makefile \
Kbuild Kconfig COPYING $(wildcard localversion*)
MKSPEC := $(srctree)/scripts/package/mkspec
......@@ -42,35 +19,77 @@ if test "$(objtree)" != "$(srctree)"; then \
echo >&2; \
echo >&2 " ERROR:"; \
echo >&2 " Building source tarball is not possible outside the"; \
echo >&2 " kernel source tree. Don't set KBUILD_OUTPUT, or use the"; \
echo >&2 " binrpm-pkg or bindeb-pkg target instead."; \
echo >&2 " kernel source tree. Don't set KBUILD_OUTPUT"; \
echo >&2; \
false; \
fi ; \
$(srctree)/scripts/setlocalversion --save-scmversion; \
tar -I $(KGZIP) -c $(RCS_TAR_IGNORE) -f $(2).tar.gz \
--transform 's:^:$(2)/:S' $(TAR_CONTENT) $(3); \
rm -f $(objtree)/.scmversion
--transform 's:^:$(2)/:S' $(TAR_CONTENT) $(3)
# .tmp_filelist .tmp_filelist_exclude
# ---------------------------------------------------------------------------
scripts/list-gitignored: FORCE
$(Q)$(MAKE) -f $(srctree)/Makefile scripts_package
# 1f5d3a6b6532e25a5cdf1f311956b2b03d343a48 removed '*.rej' from .gitignore,
# but it is definitely a generated file.
filechk_filelist = \
$< --exclude='*.rej' --output=$@_exclude --prefix=./ --rootdir=$(srctree) --stat=-
.tmp_filelist: scripts/list-gitignored FORCE
$(call filechk,filelist)
# tarball
# ---------------------------------------------------------------------------
quiet_cmd_tar = TAR $@
cmd_tar = tar -c -f $@ $(tar-compress-opt) $(tar-exclude-opt) \
--owner=0 --group=0 --sort=name \
--transform 's:^\.:$*:S' -C $(tar-rootdir) .
tar-rootdir := $(srctree)
%.tar:
$(call cmd,tar)
%.tar.gz: private tar-compress-opt := -I $(KGZIP)
%.tar.gz:
$(call cmd,tar)
%.tar.bz2: private tar-compress-opt := -I $(KBZIP2)
%.tar.bz2:
$(call cmd,tar)
%.tar.xz: private tar-compress-opt := -I $(XZ)
%.tar.xz:
$(call cmd,tar)
%.tar.zst: private tar-compress-opt := -I $(ZSTD)
%.tar.zst:
$(call cmd,tar)
# Linux source tarball
# ---------------------------------------------------------------------------
linux.tar.gz: tar-exclude-opt = --exclude=./$@ --exclude-from=$<_exclude
linux.tar.gz: .tmp_filelist
# rpm-pkg
# ---------------------------------------------------------------------------
PHONY += rpm-pkg
rpm-pkg:
$(MAKE) clean
$(CONFIG_SHELL) $(MKSPEC) >$(objtree)/kernel.spec
$(call cmd,src_tar,$(KERNELPATH),kernel.spec)
+rpmbuild $(RPMOPTS) --target $(UTS_MACHINE)-linux -ta $(KERNELPATH).tar.gz \
rpm-pkg: srpm = $(shell rpmspec --srpm --query --queryformat='%{name}-%{VERSION}-%{RELEASE}.src.rpm' kernel.spec)
rpm-pkg: srcrpm-pkg
+rpmbuild $(RPMOPTS) --target $(UTS_MACHINE)-linux -rb $(srpm) \
--define='_smp_mflags %{nil}'
# srcrpm-pkg
# ---------------------------------------------------------------------------
PHONY += srcrpm-pkg
srcrpm-pkg:
$(MAKE) clean
srcrpm-pkg: linux.tar.gz
$(CONFIG_SHELL) $(MKSPEC) >$(objtree)/kernel.spec
$(call cmd,src_tar,$(KERNELPATH),kernel.spec)
+rpmbuild $(RPMOPTS) --target $(UTS_MACHINE)-linux -ts $(KERNELPATH).tar.gz \
--define='_smp_mflags %{nil}' --define='_srcrpmdir $(srctree)'
+rpmbuild $(RPMOPTS) --target $(UTS_MACHINE)-linux -bs kernel.spec \
--define='_smp_mflags %{nil}' --define='_sourcedir .' --define='_srcrpmdir .'
# binrpm-pkg
# ---------------------------------------------------------------------------
......@@ -81,18 +100,30 @@ binrpm-pkg:
+rpmbuild $(RPMOPTS) --define "_builddir $(objtree)" --target \
$(UTS_MACHINE)-linux -bb $(objtree)/binkernel.spec
quiet_cmd_debianize = GEN $@
cmd_debianize = $(srctree)/scripts/package/mkdebian
debian: FORCE
$(call cmd,debianize)
PHONY += debian-orig
debian-orig: private source = $(shell dpkg-parsechangelog -S Source)
debian-orig: private version = $(shell dpkg-parsechangelog -S Version | sed 's/-[^-]*$$//')
debian-orig: private orig-name = $(source)_$(version).orig.tar.gz
debian-orig: linux.tar.gz debian
$(Q)if [ "$(df --output=target .. 2>/dev/null)" = "$(df --output=target $< 2>/dev/null)" ]; then \
ln -f $< ../$(orig-name); \
else \
cp $< ../$(orig-name); \
fi
PHONY += deb-pkg
deb-pkg:
$(MAKE) clean
$(CONFIG_SHELL) $(srctree)/scripts/package/mkdebian
$(call cmd,src_tar,$(KDEB_SOURCENAME))
origversion=$$(dpkg-parsechangelog -SVersion |sed 's/-[^-]*$$//');\
mv $(KDEB_SOURCENAME).tar.gz ../$(KDEB_SOURCENAME)_$${origversion}.orig.tar.gz
+dpkg-buildpackage -r$(KBUILD_PKG_ROOTCMD) -a$$(cat debian/arch) $(DPKG_FLAGS) -i.git -us -uc
deb-pkg: debian-orig
+dpkg-buildpackage -r$(KBUILD_PKG_ROOTCMD) -a$$(cat debian/arch) $(DPKG_FLAGS) \
--build=source,binary -nc -us -uc
PHONY += bindeb-pkg
bindeb-pkg:
$(CONFIG_SHELL) $(srctree)/scripts/package/mkdebian
bindeb-pkg: debian
+dpkg-buildpackage -r$(KBUILD_PKG_ROOTCMD) -a$$(cat debian/arch) $(DPKG_FLAGS) -b -nc -uc
PHONY += intdeb-pkg
......@@ -114,44 +145,77 @@ snap-pkg:
cd $(objtree)/snap && \
snapcraft --target-arch=$(UTS_MACHINE)
# tarball targets
# dir-pkg tar*-pkg - tarball targets
# ---------------------------------------------------------------------------
tar-pkgs := dir-pkg tar-pkg targz-pkg tarbz2-pkg tarxz-pkg tarzst-pkg
PHONY += $(tar-pkgs)
$(tar-pkgs):
$(MAKE) -f $(srctree)/Makefile
+$(CONFIG_SHELL) $(srctree)/scripts/package/buildtar $@
# perf-pkg - generate a source tarball with perf source
tar-pkg-tarball = linux-$(KERNELRELEASE)-$(ARCH).$(1)
tar-pkg-phony = $(subst .,,$(1))-pkg
tar-install: FORCE
$(Q)$(MAKE) -f $(srctree)/Makefile
+$(Q)$(srctree)/scripts/package/buildtar $@
PHONY += dir-pkg
dir-pkg: tar-install
@echo "Kernel tree successfully created in $<"
define tar-pkg-rule
PHONY += $(tar-pkg-phony)
$(tar-pkg-phony): $(tar-pkg-tarball)
@:
$(tar-pkg-tarball): private tar-rootdir := tar-install
$(tar-pkg-tarball): tar-install
endef
$(foreach x, tar tar.gz tar.bz2 tar.xz tar.zst, $(eval $(call tar-pkg-rule,$(x))))
# perf-tar*-src-pkg - generate a source tarball with perf source
# ---------------------------------------------------------------------------
perf-tar=perf-$(KERNELVERSION)
quiet_cmd_perf_tar = TAR
cmd_perf_tar = \
git --git-dir=$(srctree)/.git archive --prefix=$(perf-tar)/ \
HEAD^{tree} $$(cd $(srctree); \
echo $$(cat tools/perf/MANIFEST)) \
-o $(perf-tar).tar; \
mkdir -p $(perf-tar); \
git --git-dir=$(srctree)/.git rev-parse HEAD > $(perf-tar)/HEAD; \
(cd $(srctree)/tools/perf; \
util/PERF-VERSION-GEN $(CURDIR)/$(perf-tar)/); \
tar rf $(perf-tar).tar $(perf-tar)/HEAD $(perf-tar)/PERF-VERSION-FILE; \
rm -r $(perf-tar); \
$(if $(findstring tar-src,$@),, \
$(if $(findstring bz2,$@),$(KBZIP2), \
$(if $(findstring gz,$@),$(KGZIP), \
$(if $(findstring xz,$@),$(XZ), \
$(if $(findstring zst,$@),$(ZSTD), \
$(error unknown target $@))))) \
-f -9 $(perf-tar).tar)
perf-tar-pkgs := perf-tar-src-pkg perf-targz-src-pkg perf-tarbz2-src-pkg \
perf-tarxz-src-pkg perf-tarzst-src-pkg
PHONY += $(perf-tar-pkgs)
$(perf-tar-pkgs):
$(call cmd,perf_tar)
perf-tar-src-pkg-tarball = perf-$(KERNELVERSION).$(1)
perf-tar-src-pkg-phony = perf-$(subst .,,$(1))-src-pkg
quiet_cmd_stage_perf_src = STAGE $@
cmd_stage_perf_src = \
rm -rf $@; \
mkdir -p $@; \
tar -c -f - --exclude-from=$<_exclude -C $(srctree) --files-from=$(srctree)/tools/perf/MANIFEST | \
tar -x -f - -C $@
.tmp_perf: .tmp_filelist
$(call cmd,stage_perf_src)
filechk_perf_head = \
if test -z "$(git -C $(srctree) rev-parse --show-cdup 2>/dev/null)" && \
head=$$(git -C $(srctree) rev-parse --verify HEAD 2>/dev/null); then \
echo $$head; \
else \
echo "not a git tree"; \
fi
.tmp_perf/HEAD: .tmp_perf FORCE
$(call filechk,perf_head)
quiet_cmd_perf_version_file = GEN $@
cmd_perf_version_file = cd $(srctree)/tools/perf; util/PERF-VERSION-GEN $(dir $(abspath $@))
# PERF-VERSION-FILE and HEAD are independent, but this avoids updating the
# timestamp of PERF-VERSION-FILE.
# The best is to fix tools/perf/util/PERF-VERSION-GEN.
.tmp_perf/PERF-VERSION-FILE: .tmp_perf/HEAD $(srctree)/tools/perf/util/PERF-VERSION-GEN
$(call cmd,perf_version_file)
define perf-tar-src-pkg-rule
PHONY += $(perf-tar-src-pkg-phony)
$(perf-tar-src-pkg-phony): $(perf-tar-src-pkg-tarball)
@:
$(perf-tar-src-pkg-tarball): private tar-rootdir := .tmp_perf
$(perf-tar-src-pkg-tarball): .tmp_filelist .tmp_perf/HEAD .tmp_perf/PERF-VERSION-FILE
endef
$(foreach x, tar tar.gz tar.bz2 tar.xz tar.zst, $(eval $(call perf-tar-src-pkg-rule,$(x))))
# Help text displayed when executing 'make help'
# ---------------------------------------------------------------------------
......@@ -170,10 +234,13 @@ help:
@echo ' tarbz2-pkg - Build the kernel as a bzip2 compressed tarball'
@echo ' tarxz-pkg - Build the kernel as a xz compressed tarball'
@echo ' tarzst-pkg - Build the kernel as a zstd compressed tarball'
@echo ' perf-tar-src-pkg - Build $(perf-tar).tar source tarball'
@echo ' perf-targz-src-pkg - Build $(perf-tar).tar.gz source tarball'
@echo ' perf-tarbz2-src-pkg - Build $(perf-tar).tar.bz2 source tarball'
@echo ' perf-tarxz-src-pkg - Build $(perf-tar).tar.xz source tarball'
@echo ' perf-tarzst-src-pkg - Build $(perf-tar).tar.zst source tarball'
@echo ' perf-tar-src-pkg - Build the perf source tarball with no compression'
@echo ' perf-targz-src-pkg - Build the perf source tarball with gzip compression'
@echo ' perf-tarbz2-src-pkg - Build the perf source tarball with bz2 compression'
@echo ' perf-tarxz-src-pkg - Build the perf source tarball with xz compression'
@echo ' perf-tarzst-src-pkg - Build the perf source tarball with zst compression'
PHONY += FORCE
FORCE:
.PHONY: $(PHONY)
scripts/as-version.sh
View file @ 498a1cf9
......@@ -45,7 +45,7 @@ orig_args="$@"
# Get the first line of the --version output.
IFS='
'
set -- $(LC_ALL=C "$@" -Wa,--version -c -x assembler /dev/null -o /dev/null 2>/dev/null)
set -- $(LC_ALL=C "$@" -Wa,--version -c -x assembler-with-cpp /dev/null -o /dev/null 2>/dev/null)
# Split the line on spaces.
IFS=' '
......
scripts/asn1_compiler.c
View file @ 498a1cf9
......@@ -567,8 +567,8 @@ int main(int argc, char **argv)
int fd;
kbuild_verbose = getenv("KBUILD_VERBOSE");
if (kbuild_verbose)
verbose_opt = atoi(kbuild_verbose);
if (kbuild_verbose && strchr(kbuild_verbose, '1'))
verbose_opt = true;
while (argc > 4) {
if (strcmp(argv[1], "-v") == 0)
......
scripts/basic/fixdep.c
View file @ 498a1cf9
......@@ -70,7 +70,7 @@
*
* It first generates a line
*
* cmd_<target> = <cmdline>
* savedcmd_<target> = <cmdline>
*
* and then basically copies the .<target>.d file to stdout, in the
* process filtering out the dependency on autoconf.h and adding
......@@ -94,6 +94,7 @@
#include <unistd.h>
#include <fcntl.h>
#include <string.h>
#include <stdbool.h>
#include <stdlib.h>
#include <stdio.h>
#include <ctype.h>
......@@ -112,7 +113,7 @@ struct item {
};
#define HASHSZ 256
static struct item *hashtab[HASHSZ];
static struct item *config_hashtab[HASHSZ], *file_hashtab[HASHSZ];
static unsigned int strhash(const char *str, unsigned int sz)
{
......@@ -124,25 +125,11 @@ static unsigned int strhash(const char *str, unsigned int sz)
return hash;
}
/*
* Lookup a value in the configuration string.
*/
static int is_defined_config(const char *name, int len, unsigned int hash)
{
struct item *aux;
for (aux = hashtab[hash % HASHSZ]; aux; aux = aux->next) {
if (aux->hash == hash && aux->len == len &&
memcmp(aux->name, name, len) == 0)
return 1;
}
return 0;
}
/*
* Add a new value to the configuration string.
*/
static void define_config(const char *name, int len, unsigned int hash)
static void add_to_hashtable(const char *name, int len, unsigned int hash,
struct item *hashtab[])
{
struct item *aux = malloc(sizeof(*aux) + len);
......@@ -157,17 +144,34 @@ static void define_config(const char *name, int len, unsigned int hash)
hashtab[hash % HASHSZ] = aux;
}
/*
* Lookup a string in the hash table. If found, just return true.
* If not, add it to the hashtable and return false.
*/
static bool in_hashtable(const char *name, int len, struct item *hashtab[])
{
struct item *aux;
unsigned int hash = strhash(name, len);
for (aux = hashtab[hash % HASHSZ]; aux; aux = aux->next) {
if (aux->hash == hash && aux->len == len &&
memcmp(aux->name, name, len) == 0)
return true;
}
add_to_hashtable(name, len, hash, hashtab);
return false;
}
/*
* Record the use of a CONFIG_* word.
*/
static void use_config(const char *m, int slen)
{
unsigned int hash = strhash(m, slen);
if (is_defined_config(m, slen, hash))
return;
if (in_hashtable(m, slen, config_hashtab))
return;
define_config(m, slen, hash);
/* Print out a dependency path from a symbol name. */
printf(" $(wildcard include/config/%.*s) \\\n", slen, m);
}
......@@ -246,80 +250,158 @@ static int is_ignored_file(const char *s, int len)
str_ends_with(s, len, "include/generated/autoksyms.h");
}
/* Do not parse these files */
static int is_no_parse_file(const char *s, int len)
{
/* rustc may list binary files in dep-info */
return str_ends_with(s, len, ".rlib") ||
str_ends_with(s, len, ".rmeta") ||
str_ends_with(s, len, ".so");
}
/*
* Important: The below generated source_foo.o and deps_foo.o variable
* assignments are parsed not only by make, but also by the rather simple
* parser in scripts/mod/sumversion.c.
*/
static void parse_dep_file(char *m, const char *target)
static void parse_dep_file(char *p, const char *target)
{
char *p;
int is_last, is_target;
int saw_any_target = 0;
int is_first_dep = 0;
void *buf;
while (1) {
/* Skip any "white space" */
while (*m == ' ' || *m == '\\' || *m == '\n')
m++;
if (!*m)
bool saw_any_target = false;
bool is_target = true;
bool is_source = false;
bool need_parse;
char *q, saved_c;
while (*p) {
/* handle some special characters first. */
switch (*p) {
case '#':
/*
* skip comments.
* rustc may emit comments to dep-info.
*/
p++;
while (*p != '\0' && *p != '\n') {
/*
* escaped newlines continue the comment across
* multiple lines.
*/
if (*p == '\\')
p++;
p++;
}
continue;
case ' ':
case '\t':
/* skip whitespaces */
p++;
continue;
case '\\':
/*
* backslash/newline combinations continue the
* statement. Skip it just like a whitespace.
*/
if (*(p + 1) == '\n') {
p += 2;
continue;
}
break;
/* Find next "white space" */
p = m;
while (*p && *p != ' ' && *p != '\\' && *p != '\n')
case '\n':
/*
* Makefiles use a line-based syntax, where the newline
* is the end of a statement. After seeing a newline,
* we expect the next token is a target.
*/
p++;
is_last = (*p == '\0');
/* Is the token we found a target name? */
is_target = (*(p-1) == ':');
/* Don't write any target names into the dependency file */
if (is_target) {
/* The /next/ file is the first dependency */
is_first_dep = 1;
} else if (!is_ignored_file(m, p - m)) {
*p = '\0';
is_target = true;
continue;
case ':':
/*
* Do not list the source file as dependency, so that
* kbuild is not confused if a .c file is rewritten
* into .S or vice versa. Storing it in source_* is
* needed for modpost to compute srcversions.
* assume the first dependency after a colon as the
* source file.
*/
if (is_first_dep) {
p++;
is_target = false;
is_source = true;
continue;
}
/* find the end of the token */
q = p;
while (*q != ' ' && *q != '\t' && *q != '\n' && *q != '#' && *q != ':') {
if (*q == '\\') {
/*
* If processing the concatenation of multiple
* dependency files, only process the first
* target name, which will be the original
* source name, and ignore any other target
* names, which will be intermediate temporary
* files.
* backslash/newline combinations work like as
* a whitespace, so this is the end of token.
*/
if (!saw_any_target) {
saw_any_target = 1;
printf("source_%s := %s\n\n",
target, m);
printf("deps_%s := \\\n", target);
if (*(q + 1) == '\n')
break;
/* escaped special characters */
if (*(q + 1) == '#' || *(q + 1) == ':') {
memmove(p + 1, p, q - p);
p++;
}
is_first_dep = 0;
} else {
printf(" %s \\\n", m);
q++;
}
buf = read_file(m);
parse_config_file(buf);
free(buf);
if (*q == '\0')
break;
q++;
}
if (is_last)
break;
/* Just discard the target */
if (is_target) {
p = q;
continue;
}
saved_c = *q;
*q = '\0';
need_parse = false;
/*
* Start searching for next token immediately after the first
* "whitespace" character that follows this token.
* Do not list the source file as dependency, so that kbuild is
* not confused if a .c file is rewritten into .S or vice versa.
* Storing it in source_* is needed for modpost to compute
* srcversions.
*/
m = p + 1;
if (is_source) {
/*
* The DT build rule concatenates multiple dep files.
* When processing them, only process the first source
* name, which will be the original one, and ignore any
* other source names, which will be intermediate
* temporary files.
*
* rustc emits the same dependency list for each
* emission type. It is enough to list the source name
* just once.
*/
if (!saw_any_target) {
saw_any_target = true;
printf("source_%s := %s\n\n", target, p);
printf("deps_%s := \\\n", target);
need_parse = true;
}
} else if (!is_ignored_file(p, q - p) &&
!in_hashtable(p, q - p, file_hashtab)) {
printf(" %s \\\n", p);
need_parse = true;
}
if (need_parse && !is_no_parse_file(p, q - p)) {
void *buf;
buf = read_file(p);
parse_config_file(buf);
free(buf);
}
is_source = false;
*q = saved_c;
p = q;
}
if (!saw_any_target) {
......@@ -343,7 +425,7 @@ int main(int argc, char *argv[])
target = argv[2];
cmdline = argv[3];
printf("cmd_%s := %s\n\n", target, cmdline);
printf("savedcmd_%s := %s\n\n", target, cmdline);
buf = read_file(depfile);
parse_dep_file(buf, target);
......
scripts/bin2c.c deleted 100644 → 0
View file @ 4b8c673b
/*
* Unloved program to convert a binary on stdin to a C include on stdout
*
* Jan 1999 Matt Mackall <mpm@selenic.com>
*
* This software may be used and distributed according to the terms
* of the GNU General Public License, incorporated herein by reference.
*/
#include <stdio.h>
int main(int argc, char *argv[])
{
int ch, total = 0;
if (argc > 1)
printf("const char %s[] %s=\n",
argv[1], argc > 2 ? argv[2] : "");
do {
printf("\t\"");
while ((ch = getchar()) != EOF) {
total++;
printf("\\x%02x", ch);
if (total % 16 == 0)
break;
}
printf("\"\n");
} while (ch != EOF);
if (argc > 1)
printf("\t;\n\n#include <linux/types.h>\n\nconst size_t %s_size = %d;\n",
argv[1], total);
return 0;
}
scripts/checkkconfigsymbols.py
View file @ 498a1cf9
......@@ -115,7 +115,7 @@ def parse_options():
return args
def main():
def print_undefined_symbols():
"""Main function of this module."""
args = parse_options()
......@@ -467,5 +467,16 @@ def parse_kconfig_file(kfile):
return defined, references
def main():
try:
print_undefined_symbols()
except BrokenPipeError:
# Python flushes standard streams on exit; redirect remaining output
# to devnull to avoid another BrokenPipeError at shutdown
devnull = os.open(os.devnull, os.O_WRONLY)
os.dup2(devnull, sys.stdout.fileno())
sys.exit(1) # Python exits with error code 1 on EPIPE
if __name__ == "__main__":
main()
scripts/clang-tools/gen_compile_commands.py
View file @ 498a1cf9
......@@ -19,7 +19,7 @@ _DEFAULT_OUTPUT = 'compile_commands.json'
_DEFAULT_LOG_LEVEL = 'WARNING'
_FILENAME_PATTERN = r'^\..*\.cmd$'
_LINE_PATTERN = r'^cmd_[^ ]*\.o := (.* )([^ ]*\.c) *(;|$)'
_LINE_PATTERN = r'^savedcmd_[^ ]*\.o := (.* )([^ ]*\.c) *(;|$)'
_VALID_LOG_LEVELS = ['DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL']
# The tools/ directory adopts a different build system, and produces .cmd
# files in a different format. Do not support it.
......
scripts/clang-tools/run-clang-tools.py
View file @ 498a1cf9
......@@ -61,14 +61,21 @@ def run_analysis(entry):
def main():
args = parse_arguments()
try:
args = parse_arguments()
lock = multiprocessing.Lock()
pool = multiprocessing.Pool(initializer=init, initargs=(lock, args))
# Read JSON data into the datastore variable
with open(args.path, "r") as f:
datastore = json.load(f)
pool.map(run_analysis, datastore)
lock = multiprocessing.Lock()
pool = multiprocessing.Pool(initializer=init, initargs=(lock, args))
# Read JSON data into the datastore variable
with open(args.path, "r") as f:
datastore = json.load(f)
pool.map(run_analysis, datastore)
except BrokenPipeError:
# Python flushes standard streams on exit; redirect remaining output
# to devnull to avoid another BrokenPipeError at shutdown
devnull = os.open(os.devnull, os.O_WRONLY)
os.dup2(devnull, sys.stdout.fileno())
sys.exit(1) # Python exits with error code 1 on EPIPE
if __name__ == "__main__":
......
scripts/diffconfig
View file @ 498a1cf9
......@@ -65,7 +65,7 @@ def print_config(op, config, value, new_value):
else:
print(" %s %s -> %s" % (config, value, new_value))
def main():
def show_diff():
global merge_style
# parse command line args
......@@ -129,4 +129,16 @@ def main():
for config in new:
print_config("+", config, None, b[config])
main()
def main():
try:
show_diff()
except BrokenPipeError:
# Python flushes standard streams on exit; redirect remaining output
# to devnull to avoid another BrokenPipeError at shutdown
devnull = os.open(os.devnull, os.O_WRONLY)
os.dup2(devnull, sys.stdout.fileno())
sys.exit(1) # Python exits with error code 1 on EPIPE
if __name__ == '__main__':
main()
scripts/kernel-doc
View file @ 498a1cf9
......@@ -175,8 +175,8 @@ my $declaration_start_line;
my ($type, $declaration_name, $return_type);
my ($newsection, $newcontents, $prototype, $brcount, %source_map);
if (defined($ENV{'KBUILD_VERBOSE'})) {
$verbose = "$ENV{'KBUILD_VERBOSE'}";
if (defined($ENV{'KBUILD_VERBOSE'}) && $ENV{'KBUILD_VERBOSE'} =~ '1') {
$verbose = 1;
}
if (defined($ENV{'KCFLAGS'})) {
......
scripts/list-gitignored.c 0 → 100644
View file @ 498a1cf9
// SPDX-License-Identifier: GPL-2.0-only
//
// Traverse the source tree, parsing all .gitignore files, and print file paths
// that are ignored by git.
// The output is suitable to the --exclude-from option of tar.
// This is useful until the --exclude-vcs-ignores option gets working correctly.
//
// Copyright (C) 2023 Masahiro Yamada <masahiroy@kernel.org>
// (a lot of code imported from GIT)
#include <assert.h>
#include <dirent.h>
#include <errno.h>
#include <fcntl.h>
#include <getopt.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
// Imported from commit 23c56f7bd5f1667f8b793d796bf30e39545920f6 in GIT
//
//---------------------------(IMPORT FROM GIT BEGIN)---------------------------
// Copied from environment.c
static bool ignore_case;
// Copied from git-compat-util.h
/* Sane ctype - no locale, and works with signed chars */
#undef isascii
#undef isspace
#undef isdigit
#undef isalpha
#undef isalnum
#undef isprint
#undef islower
#undef isupper
#undef tolower
#undef toupper
#undef iscntrl
#undef ispunct
#undef isxdigit
static const unsigned char sane_ctype[256];
#define GIT_SPACE 0x01
#define GIT_DIGIT 0x02
#define GIT_ALPHA 0x04
#define GIT_GLOB_SPECIAL 0x08
#define GIT_REGEX_SPECIAL 0x10
#define GIT_PATHSPEC_MAGIC 0x20
#define GIT_CNTRL 0x40
#define GIT_PUNCT 0x80
#define sane_istest(x,mask) ((sane_ctype[(unsigned char)(x)] & (mask)) != 0)
#define isascii(x) (((x) & ~0x7f) == 0)
#define isspace(x) sane_istest(x,GIT_SPACE)
#define isdigit(x) sane_istest(x,GIT_DIGIT)
#define isalpha(x) sane_istest(x,GIT_ALPHA)
#define isalnum(x) sane_istest(x,GIT_ALPHA | GIT_DIGIT)
#define isprint(x) ((x) >= 0x20 && (x) <= 0x7e)
#define islower(x) sane_iscase(x, 1)
#define isupper(x) sane_iscase(x, 0)
#define is_glob_special(x) sane_istest(x,GIT_GLOB_SPECIAL)
#define iscntrl(x) (sane_istest(x,GIT_CNTRL))
#define ispunct(x) sane_istest(x, GIT_PUNCT | GIT_REGEX_SPECIAL | \
GIT_GLOB_SPECIAL | GIT_PATHSPEC_MAGIC)
#define isxdigit(x) (hexval_table[(unsigned char)(x)] != -1)
#define tolower(x) sane_case((unsigned char)(x), 0x20)
#define toupper(x) sane_case((unsigned char)(x), 0)
static inline int sane_case(int x, int high)
{
if (sane_istest(x, GIT_ALPHA))
x = (x & ~0x20) | high;
return x;
}
static inline int sane_iscase(int x, int is_lower)
{
if (!sane_istest(x, GIT_ALPHA))
return 0;
if (is_lower)
return (x & 0x20) != 0;
else
return (x & 0x20) == 0;
}
// Copied from ctype.c
enum {
S = GIT_SPACE,
A = GIT_ALPHA,
D = GIT_DIGIT,
G = GIT_GLOB_SPECIAL, /* *, ?, [, \\ */
R = GIT_REGEX_SPECIAL, /* $, (, ), +, ., ^, {, | */
P = GIT_PATHSPEC_MAGIC, /* other non-alnum, except for ] and } */
X = GIT_CNTRL,
U = GIT_PUNCT,
Z = GIT_CNTRL | GIT_SPACE
};
static const unsigned char sane_ctype[256] = {
X, X, X, X, X, X, X, X, X, Z, Z, X, X, Z, X, X, /* 0.. 15 */
X, X, X, X, X, X, X, X, X, X, X, X, X, X, X, X, /* 16.. 31 */
S, P, P, P, R, P, P, P, R, R, G, R, P, P, R, P, /* 32.. 47 */
D, D, D, D, D, D, D, D, D, D, P, P, P, P, P, G, /* 48.. 63 */
P, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, /* 64.. 79 */
A, A, A, A, A, A, A, A, A, A, A, G, G, U, R, P, /* 80.. 95 */
P, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, /* 96..111 */
A, A, A, A, A, A, A, A, A, A, A, R, R, U, P, X, /* 112..127 */
/* Nothing in the 128.. range */
};
// Copied from hex.c
static const signed char hexval_table[256] = {
-1, -1, -1, -1, -1, -1, -1, -1, /* 00-07 */
-1, -1, -1, -1, -1, -1, -1, -1, /* 08-0f */
-1, -1, -1, -1, -1, -1, -1, -1, /* 10-17 */
-1, -1, -1, -1, -1, -1, -1, -1, /* 18-1f */
-1, -1, -1, -1, -1, -1, -1, -1, /* 20-27 */
-1, -1, -1, -1, -1, -1, -1, -1, /* 28-2f */
0, 1, 2, 3, 4, 5, 6, 7, /* 30-37 */
8, 9, -1, -1, -1, -1, -1, -1, /* 38-3f */
-1, 10, 11, 12, 13, 14, 15, -1, /* 40-47 */
-1, -1, -1, -1, -1, -1, -1, -1, /* 48-4f */
-1, -1, -1, -1, -1, -1, -1, -1, /* 50-57 */
-1, -1, -1, -1, -1, -1, -1, -1, /* 58-5f */
-1, 10, 11, 12, 13, 14, 15, -1, /* 60-67 */
-1, -1, -1, -1, -1, -1, -1, -1, /* 68-67 */
-1, -1, -1, -1, -1, -1, -1, -1, /* 70-77 */
-1, -1, -1, -1, -1, -1, -1, -1, /* 78-7f */
-1, -1, -1, -1, -1, -1, -1, -1, /* 80-87 */
-1, -1, -1, -1, -1, -1, -1, -1, /* 88-8f */
-1, -1, -1, -1, -1, -1, -1, -1, /* 90-97 */
-1, -1, -1, -1, -1, -1, -1, -1, /* 98-9f */
-1, -1, -1, -1, -1, -1, -1, -1, /* a0-a7 */
-1, -1, -1, -1, -1, -1, -1, -1, /* a8-af */
-1, -1, -1, -1, -1, -1, -1, -1, /* b0-b7 */
-1, -1, -1, -1, -1, -1, -1, -1, /* b8-bf */
-1, -1, -1, -1, -1, -1, -1, -1, /* c0-c7 */
-1, -1, -1, -1, -1, -1, -1, -1, /* c8-cf */
-1, -1, -1, -1, -1, -1, -1, -1, /* d0-d7 */
-1, -1, -1, -1, -1, -1, -1, -1, /* d8-df */
-1, -1, -1, -1, -1, -1, -1, -1, /* e0-e7 */
-1, -1, -1, -1, -1, -1, -1, -1, /* e8-ef */
-1, -1, -1, -1, -1, -1, -1, -1, /* f0-f7 */
-1, -1, -1, -1, -1, -1, -1, -1, /* f8-ff */
};
// Copied from wildmatch.h
#define WM_CASEFOLD 1
#define WM_PATHNAME 2
#define WM_NOMATCH 1
#define WM_MATCH 0
#define WM_ABORT_ALL -1
#define WM_ABORT_TO_STARSTAR -2
// Copied from wildmatch.c
typedef unsigned char uchar;
// local modification: remove NEGATE_CLASS(2)
#define CC_EQ(class, len, litmatch) ((len) == sizeof (litmatch)-1 \
&& *(class) == *(litmatch) \
&& strncmp((char*)class, litmatch, len) == 0)
// local modification: simpilify macros
#define ISBLANK(c) ((c) == ' ' || (c) == '\t')
#define ISGRAPH(c) (isprint(c) && !isspace(c))
#define ISPRINT(c) isprint(c)
#define ISDIGIT(c) isdigit(c)
#define ISALNUM(c) isalnum(c)
#define ISALPHA(c) isalpha(c)
#define ISCNTRL(c) iscntrl(c)
#define ISLOWER(c) islower(c)
#define ISPUNCT(c) ispunct(c)
#define ISSPACE(c) isspace(c)
#define ISUPPER(c) isupper(c)
#define ISXDIGIT(c) isxdigit(c)
/* Match pattern "p" against "text" */
static int dowild(const uchar *p, const uchar *text, unsigned int flags)
{
uchar p_ch;
const uchar *pattern = p;
for ( ; (p_ch = *p) != '\0'; text++, p++) {
int matched, match_slash, negated;
uchar t_ch, prev_ch;
if ((t_ch = *text) == '\0' && p_ch != '*')
return WM_ABORT_ALL;
if ((flags & WM_CASEFOLD) && ISUPPER(t_ch))
t_ch = tolower(t_ch);
if ((flags & WM_CASEFOLD) && ISUPPER(p_ch))
p_ch = tolower(p_ch);
switch (p_ch) {
case '\\':
/* Literal match with following character. Note that the test
* in "default" handles the p[1] == '\0' failure case. */
p_ch = *++p;
/* FALLTHROUGH */
default:
if (t_ch != p_ch)
return WM_NOMATCH;
continue;
case '?':
/* Match anything but '/'. */
if ((flags & WM_PATHNAME) && t_ch == '/')
return WM_NOMATCH;
continue;
case '*':
if (*++p == '*') {
const uchar *prev_p = p - 2;
while (*++p == '*') {}
if (!(flags & WM_PATHNAME))
/* without WM_PATHNAME, '*' == '**' */
match_slash = 1;
else if ((prev_p < pattern || *prev_p == '/') &&
(*p == '\0' || *p == '/' ||
(p[0] == '\\' && p[1] == '/'))) {
/*
* Assuming we already match 'foo/' and are at
* <star star slash>, just assume it matches
* nothing and go ahead match the rest of the
* pattern with the remaining string. This
* helps make foo/<*><*>/bar (<> because
* otherwise it breaks C comment syntax) match
* both foo/bar and foo/a/bar.
*/
if (p[0] == '/' &&
dowild(p + 1, text, flags) == WM_MATCH)
return WM_MATCH;
match_slash = 1;
} else /* WM_PATHNAME is set */
match_slash = 0;
} else
/* without WM_PATHNAME, '*' == '**' */
match_slash = flags & WM_PATHNAME ? 0 : 1;
if (*p == '\0') {
/* Trailing "**" matches everything. Trailing "*" matches
* only if there are no more slash characters. */
if (!match_slash) {
if (strchr((char *)text, '/'))
return WM_NOMATCH;
}
return WM_MATCH;
} else if (!match_slash && *p == '/') {
/*
* _one_ asterisk followed by a slash
* with WM_PATHNAME matches the next
* directory
*/
const char *slash = strchr((char*)text, '/');
if (!slash)
return WM_NOMATCH;
text = (const uchar*)slash;
/* the slash is consumed by the top-level for loop */
break;
}
while (1) {
if (t_ch == '\0')
break;
/*
* Try to advance faster when an asterisk is
* followed by a literal. We know in this case
* that the string before the literal
* must belong to "*".
* If match_slash is false, do not look past
* the first slash as it cannot belong to '*'.
*/
if (!is_glob_special(*p)) {
p_ch = *p;
if ((flags & WM_CASEFOLD) && ISUPPER(p_ch))
p_ch = tolower(p_ch);
while ((t_ch = *text) != '\0' &&
(match_slash || t_ch != '/')) {
if ((flags & WM_CASEFOLD) && ISUPPER(t_ch))
t_ch = tolower(t_ch);
if (t_ch == p_ch)
break;
text++;
}
if (t_ch != p_ch)
return WM_NOMATCH;
}
if ((matched = dowild(p, text, flags)) != WM_NOMATCH) {
if (!match_slash || matched != WM_ABORT_TO_STARSTAR)
return matched;
} else if (!match_slash && t_ch == '/')
return WM_ABORT_TO_STARSTAR;
t_ch = *++text;
}
return WM_ABORT_ALL;
case '[':
p_ch = *++p;
if (p_ch == '^')
p_ch = '!';
/* Assign literal 1/0 because of "matched" comparison. */
negated = p_ch == '!' ? 1 : 0;
if (negated) {
/* Inverted character class. */
p_ch = *++p;
}
prev_ch = 0;
matched = 0;
do {
if (!p_ch)
return WM_ABORT_ALL;
if (p_ch == '\\') {
p_ch = *++p;
if (!p_ch)
return WM_ABORT_ALL;
if (t_ch == p_ch)
matched = 1;
} else if (p_ch == '-' && prev_ch && p[1] && p[1] != ']') {
p_ch = *++p;
if (p_ch == '\\') {
p_ch = *++p;
if (!p_ch)
return WM_ABORT_ALL;
}
if (t_ch <= p_ch && t_ch >= prev_ch)
matched = 1;
else if ((flags & WM_CASEFOLD) && ISLOWER(t_ch)) {
uchar t_ch_upper = toupper(t_ch);
if (t_ch_upper <= p_ch && t_ch_upper >= prev_ch)
matched = 1;
}
p_ch = 0; /* This makes "prev_ch" get set to 0. */
} else if (p_ch == '[' && p[1] == ':') {
const uchar *s;
int i;
for (s = p += 2; (p_ch = *p) && p_ch != ']'; p++) {} /*SHARED ITERATOR*/
if (!p_ch)
return WM_ABORT_ALL;
i = p - s - 1;
if (i < 0 || p[-1] != ':') {
/* Didn't find ":]", so treat like a normal set. */
p = s - 2;
p_ch = '[';
if (t_ch == p_ch)
matched = 1;
continue;
}
if (CC_EQ(s,i, "alnum")) {
if (ISALNUM(t_ch))
matched = 1;
} else if (CC_EQ(s,i, "alpha")) {
if (ISALPHA(t_ch))
matched = 1;
} else if (CC_EQ(s,i, "blank")) {
if (ISBLANK(t_ch))
matched = 1;
} else if (CC_EQ(s,i, "cntrl")) {
if (ISCNTRL(t_ch))
matched = 1;
} else if (CC_EQ(s,i, "digit")) {
if (ISDIGIT(t_ch))
matched = 1;
} else if (CC_EQ(s,i, "graph")) {
if (ISGRAPH(t_ch))
matched = 1;
} else if (CC_EQ(s,i, "lower")) {
if (ISLOWER(t_ch))
matched = 1;
} else if (CC_EQ(s,i, "print")) {
if (ISPRINT(t_ch))
matched = 1;
} else if (CC_EQ(s,i, "punct")) {
if (ISPUNCT(t_ch))
matched = 1;
} else if (CC_EQ(s,i, "space")) {
if (ISSPACE(t_ch))
matched = 1;
} else if (CC_EQ(s,i, "upper")) {
if (ISUPPER(t_ch))
matched = 1;
else if ((flags & WM_CASEFOLD) && ISLOWER(t_ch))
matched = 1;
} else if (CC_EQ(s,i, "xdigit")) {
if (ISXDIGIT(t_ch))
matched = 1;
} else /* malformed [:class:] string */
return WM_ABORT_ALL;
p_ch = 0; /* This makes "prev_ch" get set to 0. */
} else if (t_ch == p_ch)
matched = 1;
} while (prev_ch = p_ch, (p_ch = *++p) != ']');
if (matched == negated ||
((flags & WM_PATHNAME) && t_ch == '/'))
return WM_NOMATCH;
continue;
}
}
return *text ? WM_NOMATCH : WM_MATCH;
}
/* Match the "pattern" against the "text" string. */
static int wildmatch(const char *pattern, const char *text, unsigned int flags)
{
// local modification: move WM_CASEFOLD here
if (ignore_case)
flags |= WM_CASEFOLD;
return dowild((const uchar*)pattern, (const uchar*)text, flags);
}
// Copied from dir.h
#define PATTERN_FLAG_NODIR 1
#define PATTERN_FLAG_ENDSWITH 4
#define PATTERN_FLAG_MUSTBEDIR 8
#define PATTERN_FLAG_NEGATIVE 16
// Copied from dir.c
static int fspathncmp(const char *a, const char *b, size_t count)
{
return ignore_case ? strncasecmp(a, b, count) : strncmp(a, b, count);
}
static int simple_length(const char *match)
{
int len = -1;
for (;;) {
unsigned char c = *match++;
len++;
if (c == '\0' || is_glob_special(c))
return len;
}
}
static int no_wildcard(const char *string)
{
return string[simple_length(string)] == '\0';
}
static void parse_path_pattern(const char **pattern,
int *patternlen,
unsigned *flags,
int *nowildcardlen)
{
const char *p = *pattern;
size_t i, len;
*flags = 0;
if (*p == '!') {
*flags |= PATTERN_FLAG_NEGATIVE;
p++;
}
len = strlen(p);
if (len && p[len - 1] == '/') {
len--;
*flags |= PATTERN_FLAG_MUSTBEDIR;
}
for (i = 0; i < len; i++) {
if (p[i] == '/')
break;
}
if (i == len)
*flags |= PATTERN_FLAG_NODIR;
*nowildcardlen = simple_length(p);
/*
* we should have excluded the trailing slash from 'p' too,
* but that's one more allocation. Instead just make sure
* nowildcardlen does not exceed real patternlen
*/
if (*nowildcardlen > len)
*nowildcardlen = len;
if (*p == '*' && no_wildcard(p + 1))
*flags |= PATTERN_FLAG_ENDSWITH;
*pattern = p;
*patternlen = len;
}
static void trim_trailing_spaces(char *buf)
{
char *p, *last_space = NULL;
for (p = buf; *p; p++)
switch (*p) {
case ' ':
if (!last_space)
last_space = p;
break;
case '\\':
p++;
if (!*p)
return;
/* fallthrough */
default:
last_space = NULL;
}
if (last_space)
*last_space = '\0';
}
static int match_basename(const char *basename, int basenamelen,
const char *pattern, int prefix, int patternlen,
unsigned flags)
{
if (prefix == patternlen) {
if (patternlen == basenamelen &&
!fspathncmp(pattern, basename, basenamelen))
return 1;
} else if (flags & PATTERN_FLAG_ENDSWITH) {
/* "*literal" matching against "fooliteral" */
if (patternlen - 1 <= basenamelen &&
!fspathncmp(pattern + 1,
basename + basenamelen - (patternlen - 1),
patternlen - 1))
return 1;
} else {
// local modification: call wildmatch() directly
if (!wildmatch(pattern, basename, flags))
return 1;
}
return 0;
}
static int match_pathname(const char *pathname, int pathlen,
const char *base, int baselen,
const char *pattern, int prefix, int patternlen)
{
// local modification: remove local variables
/*
* match with FNM_PATHNAME; the pattern has base implicitly
* in front of it.
*/
if (*pattern == '/') {
pattern++;
patternlen--;
prefix--;
}
/*
* baselen does not count the trailing slash. base[] may or
* may not end with a trailing slash though.
*/
if (pathlen < baselen + 1 ||
(baselen && pathname[baselen] != '/') ||
fspathncmp(pathname, base, baselen))
return 0;
// local modification: simplified because always baselen > 0
pathname += baselen + 1;
pathlen -= baselen + 1;
if (prefix) {
/*
* if the non-wildcard part is longer than the
* remaining pathname, surely it cannot match.
*/
if (prefix > pathlen)
return 0;
if (fspathncmp(pattern, pathname, prefix))
return 0;
pattern += prefix;
patternlen -= prefix;
pathname += prefix;
pathlen -= prefix;
/*
* If the whole pattern did not have a wildcard,
* then our prefix match is all we need; we
* do not need to call fnmatch at all.
*/
if (!patternlen && !pathlen)
return 1;
}
// local modification: call wildmatch() directly
return !wildmatch(pattern, pathname, WM_PATHNAME);
}
// Copied from git/utf8.c
static const char utf8_bom[] = "\357\273\277";
//----------------------------(IMPORT FROM GIT END)----------------------------
struct pattern {
unsigned int flags;
int nowildcardlen;
int patternlen;
int dirlen;
char pattern[];
};
static struct pattern **pattern_list;
static int nr_patterns, alloced_patterns;
// Remember the number of patterns at each directory level
static int *nr_patterns_at;
// Track the current/max directory level;
static int depth, max_depth;
static bool debug_on;
static FILE *out_fp, *stat_fp;
static char *prefix = "";
static char *progname;
static void __attribute__((noreturn)) perror_exit(const char *s)
{
perror(s);
exit(EXIT_FAILURE);
}
static void __attribute__((noreturn)) error_exit(const char *fmt, ...)
{
va_list args;
fprintf(stderr, "%s: error: ", progname);
va_start(args, fmt);
vfprintf(stderr, fmt, args);
va_end(args);
exit(EXIT_FAILURE);
}
static void debug(const char *fmt, ...)
{
va_list args;
int i;
if (!debug_on)
return;
fprintf(stderr, "[DEBUG] ");
for (i = 0; i < depth * 2; i++)
fputc(' ', stderr);
va_start(args, fmt);
vfprintf(stderr, fmt, args);
va_end(args);
}
static void *xrealloc(void *ptr, size_t size)
{
ptr = realloc(ptr, size);
if (!ptr)
perror_exit(progname);
return ptr;
}
static void *xmalloc(size_t size)
{
return xrealloc(NULL, size);
}
// similar to last_matching_pattern_from_list() in GIT
static bool is_ignored(const char *path, int pathlen, int dirlen, bool is_dir)
{
int i;
// Search in the reverse order because the last matching pattern wins.
for (i = nr_patterns - 1; i >= 0; i--) {
struct pattern *p = pattern_list[i];
unsigned int flags = p->flags;
const char *gitignore_dir = p->pattern + p->patternlen + 1;
bool ignored;
if ((flags & PATTERN_FLAG_MUSTBEDIR) && !is_dir)
continue;
if (flags & PATTERN_FLAG_NODIR) {
if (!match_basename(path + dirlen + 1,
pathlen - dirlen - 1,
p->pattern,
p->nowildcardlen,
p->patternlen,
p->flags))
continue;
} else {
if (!match_pathname(path, pathlen,
gitignore_dir, p->dirlen,
p->pattern,
p->nowildcardlen,
p->patternlen))
continue;
}
debug("%s: matches %s%s%s (%s/.gitignore)\n", path,
flags & PATTERN_FLAG_NEGATIVE ? "!" : "", p->pattern,
flags & PATTERN_FLAG_MUSTBEDIR ? "/" : "",
gitignore_dir);
ignored = (flags & PATTERN_FLAG_NEGATIVE) == 0;
if (ignored)
debug("Ignore: %s\n", path);
return ignored;
}
debug("%s: no match\n", path);
return false;
}
static void add_pattern(const char *string, const char *dir, int dirlen)
{
struct pattern *p;
int patternlen, nowildcardlen;
unsigned int flags;
parse_path_pattern(&string, &patternlen, &flags, &nowildcardlen);
if (patternlen == 0)
return;
p = xmalloc(sizeof(*p) + patternlen + dirlen + 2);
memcpy(p->pattern, string, patternlen);
p->pattern[patternlen] = 0;
memcpy(p->pattern + patternlen + 1, dir, dirlen);
p->pattern[patternlen + 1 + dirlen] = 0;
p->patternlen = patternlen;
p->nowildcardlen = nowildcardlen;
p->dirlen = dirlen;
p->flags = flags;
debug("Add pattern: %s%s%s\n",
flags & PATTERN_FLAG_NEGATIVE ? "!" : "", p->pattern,
flags & PATTERN_FLAG_MUSTBEDIR ? "/" : "");
if (nr_patterns >= alloced_patterns) {
alloced_patterns += 128;
pattern_list = xrealloc(pattern_list,
sizeof(*pattern_list) * alloced_patterns);
}
pattern_list[nr_patterns++] = p;
}
// similar to add_patterns_from_buffer() in GIT
static void add_patterns_from_gitignore(const char *dir, int dirlen)
{
struct stat st;
char path[PATH_MAX], *buf, *entry;
size_t size;
int fd, pathlen, i;
pathlen = snprintf(path, sizeof(path), "%s/.gitignore", dir);
if (pathlen >= sizeof(path))
error_exit("%s: too long path was truncated\n", path);
fd = open(path, O_RDONLY | O_NOFOLLOW);
if (fd < 0) {
if (errno != ENOENT)
return perror_exit(path);
return;
}
if (fstat(fd, &st) < 0)
perror_exit(path);
size = st.st_size;
buf = xmalloc(size + 1);
if (read(fd, buf, st.st_size) != st.st_size)
perror_exit(path);
buf[st.st_size] = '\n';
if (close(fd))
perror_exit(path);
debug("Parse %s\n", path);
entry = buf;
// skip utf8 bom
if (!strncmp(entry, utf8_bom, strlen(utf8_bom)))
entry += strlen(utf8_bom);
for (i = entry - buf; i < size; i++) {
if (buf[i] == '\n') {
if (entry != buf + i && entry[0] != '#') {
buf[i - (i && buf[i-1] == '\r')] = 0;
trim_trailing_spaces(entry);
add_pattern(entry, dir, dirlen);
}
entry = buf + i + 1;
}
}
free(buf);
}
// Save the current number of patterns and increment the depth
static void increment_depth(void)
{
if (depth >= max_depth) {
max_depth += 1;
nr_patterns_at = xrealloc(nr_patterns_at,
sizeof(*nr_patterns_at) * max_depth);
}
nr_patterns_at[depth] = nr_patterns;
depth++;
}
// Decrement the depth, and free up the patterns of this directory level.
static void decrement_depth(void)
{
depth--;
assert(depth >= 0);
while (nr_patterns > nr_patterns_at[depth])
free(pattern_list[--nr_patterns]);
}
static void print_path(const char *path)
{
// The path always starts with "./"
assert(strlen(path) >= 2);
// Replace the root directory with a preferred prefix.
// This is useful for the tar command.
fprintf(out_fp, "%s%s\n", prefix, path + 2);
}
static void print_stat(const char *path, struct stat *st)
{
if (!stat_fp)
return;
if (!S_ISREG(st->st_mode) && !S_ISLNK(st->st_mode))
return;
assert(strlen(path) >= 2);
fprintf(stat_fp, "%c %9ld %10ld %s\n",
S_ISLNK(st->st_mode) ? 'l' : '-',
st->st_size, st->st_mtim.tv_sec, path + 2);
}
// Traverse the entire directory tree, parsing .gitignore files.
// Print file paths that are not tracked by git.
//
// Return true if all files under the directory are ignored, false otherwise.
static bool traverse_directory(const char *dir, int dirlen)
{
bool all_ignored = true;
DIR *dirp;
debug("Enter[%d]: %s\n", depth, dir);
increment_depth();
add_patterns_from_gitignore(dir, dirlen);
dirp = opendir(dir);
if (!dirp)
perror_exit(dir);
while (1) {
struct dirent *d;
struct stat st;
char path[PATH_MAX];
int pathlen;
bool ignored;
errno = 0;
d = readdir(dirp);
if (!d) {
if (errno)
perror_exit(dir);
break;
}
if (!strcmp(d->d_name, "..") || !strcmp(d->d_name, "."))
continue;
pathlen = snprintf(path, sizeof(path), "%s/%s", dir, d->d_name);
if (pathlen >= sizeof(path))
error_exit("%s: too long path was truncated\n", path);
if (lstat(path, &st) < 0)
perror_exit(path);
if ((!S_ISREG(st.st_mode) && !S_ISDIR(st.st_mode) && !S_ISLNK(st.st_mode)) ||
is_ignored(path, pathlen, dirlen, S_ISDIR(st.st_mode))) {
ignored = true;
} else {
if (S_ISDIR(st.st_mode) && !S_ISLNK(st.st_mode))
// If all the files in a directory are ignored,
// let's ignore that directory as well. This
// will avoid empty directories in the tarball.
ignored = traverse_directory(path, pathlen);
else
ignored = false;
}
if (ignored) {
print_path(path);
} else {
print_stat(path, &st);
all_ignored = false;
}
}
if (closedir(dirp))
perror_exit(dir);
decrement_depth();
debug("Leave[%d]: %s\n", depth, dir);
return all_ignored;
}
static void usage(void)
{
fprintf(stderr,
"usage: %s [options]\n"
"\n"
"Show files that are ignored by git\n"
"\n"
"options:\n"
" -d, --debug print debug messages to stderr\n"
" -e, --exclude PATTERN add the given exclude pattern\n"
" -h, --help show this help message and exit\n"
" -i, --ignore-case Ignore case differences between the patterns and the files\n"
" -o, --output FILE output the ignored files to a file (default: '-', i.e. stdout)\n"
" -p, --prefix PREFIX prefix added to each path (default: empty string)\n"
" -r, --rootdir DIR root of the source tree (default: current working directory)\n"
" -s, --stat FILE output the file stat of non-ignored files to a file\n",
progname);
}
static void open_output(const char *pathname, FILE **fp)
{
if (strcmp(pathname, "-")) {
*fp = fopen(pathname, "w");
if (!*fp)
perror_exit(pathname);
} else {
*fp = stdout;
}
}
static void close_output(const char *pathname, FILE *fp)
{
fflush(fp);
if (ferror(fp))
error_exit("not all data was written to the output\n");
if (fclose(fp))
perror_exit(pathname);
}
int main(int argc, char *argv[])
{
const char *output = "-";
const char *rootdir = ".";
const char *stat = NULL;
progname = strrchr(argv[0], '/');
if (progname)
progname++;
else
progname = argv[0];
while (1) {
static struct option long_options[] = {
{"debug", no_argument, NULL, 'd'},
{"help", no_argument, NULL, 'h'},
{"ignore-case", no_argument, NULL, 'i'},
{"output", required_argument, NULL, 'o'},
{"prefix", required_argument, NULL, 'p'},
{"rootdir", required_argument, NULL, 'r'},
{"stat", required_argument, NULL, 's'},
{"exclude", required_argument, NULL, 'x'},
{},
};
int c = getopt_long(argc, argv, "dhino:p:r:s:x:", long_options, NULL);
if (c == -1)
break;
switch (c) {
case 'd':
debug_on = true;
break;
case 'h':
usage();
exit(0);
case 'i':
ignore_case = true;
break;
case 'o':
output = optarg;
break;
case 'p':
prefix = optarg;
break;
case 'r':
rootdir = optarg;
break;
case 's':
stat = optarg;
break;
case 'x':
add_pattern(optarg, ".", strlen("."));
break;
case '?':
usage();
/* fallthrough */
default:
exit(EXIT_FAILURE);
}
}
open_output(output, &out_fp);
if (stat && stat[0])
open_output(stat, &stat_fp);
if (chdir(rootdir))
perror_exit(rootdir);
add_pattern(".git/", ".", strlen("."));
if (traverse_directory(".", strlen(".")))
print_path("./");
assert(depth == 0);
while (nr_patterns > 0)
free(pattern_list[--nr_patterns]);
free(pattern_list);
free(nr_patterns_at);
close_output(output, out_fp);
if (stat_fp)
close_output(stat, stat_fp);
return 0;
}
scripts/misc-check 0 → 100755
View file @ 498a1cf9
#!/bin/sh
# SPDX-License-Identifier: GPL-2.0-only
set -e
# Detect files that are tracked but ignored by git. This is checked only when
# ${KBUILD_EXTRA_WARN} contains 1, git is installed, and the source tree is
# tracked by git.
check_tracked_ignored_files () {
case "${KBUILD_EXTRA_WARN}" in
*1*) ;;
*) return;;
esac
git -C ${srctree:-.} ls-files -i -c --exclude-per-directory=.gitignore 2>/dev/null |
sed 's/$/: warning: ignored by one of the .gitignore files/' >&2
}
check_tracked_ignored_files
scripts/package/builddeb
View file @ 498a1cf9
......@@ -42,11 +42,9 @@ create_package() {
else
chown -R root:root "$pdir"
fi
chmod -R go-w "$pdir"
# in case we are in a restrictive umask environment like 0077
chmod -R a+rX "$pdir"
# in case we build in a setuid/setgid directory
chmod -R ug-s "$pdir"
# a+rX in case we are in a restrictive umask environment like 0077
# ug-s in case we build in a setuid/setgid directory
chmod -R go-w,a+rX,ug-s "$pdir"
# Create the package
dpkg-gencontrol -p$pname -P"$pdir"
......
scripts/package/buildtar
View file @ 498a1cf9
......@@ -16,39 +16,7 @@ set -e
#
# Some variables and settings used throughout the script
#
tmpdir="${objtree}/tar-install"
tarball="${objtree}/linux-${KERNELRELEASE}-${ARCH}.tar"
#
# Figure out how to compress, if requested at all
#
case "${1}" in
dir-pkg|tar-pkg)
opts=
;;
targz-pkg)
opts="-I ${KGZIP}"
tarball=${tarball}.gz
;;
tarbz2-pkg)
opts="-I ${KBZIP2}"
tarball=${tarball}.bz2
;;
tarxz-pkg)
opts="-I ${XZ}"
tarball=${tarball}.xz
;;
tarzst-pkg)
opts="-I ${ZSTD}"
tarball=${tarball}.zst
;;
*)
echo "Unknown tarball target \"${1}\" requested, please add it to ${0}." >&2
exit 1
;;
esac
tmpdir=$1
#
# Clean-up and re-create the temporary directory
......@@ -148,21 +116,3 @@ case "${ARCH}" in
sleep 5
;;
esac
if [ "${1}" = dir-pkg ]; then
echo "Kernel tree successfully created in $tmpdir"
exit 0
fi
#
# Create the tarball
#
if tar --owner=root --group=root --help >/dev/null 2>&1; then
opts="$opts --owner=root --group=root"
fi
tar cf $tarball -C $tmpdir $opts $dirs
echo "Tarball successfully created in $tarball"
exit 0
scripts/package/deb-build-option 0 → 100755
View file @ 498a1cf9
#!/bin/sh
# SPDX-License-Identifier: GPL-2.0-only
# Set up CROSS_COMPILE if we are cross-compiling, but not called from the
# kernel toplevel Makefile
if [ -z "${CROSS_COMPILE}${cross_compiling}" -a "${DEB_HOST_ARCH}" != "${DEB_BUILD_ARCH}" ]; then
echo CROSS_COMPILE=${DEB_HOST_GNU_TYPE}-
fi
version=$(dpkg-parsechangelog -S Version)
version_upstream="${version%-*}"
debian_revision="${version#${version_upstream}}"
debian_revision="${debian_revision#*-}"
echo KERNELRELEASE=${version_upstream}
echo KBUILD_BUILD_VERSION=${debian_revision}
scripts/package/mkdebian
View file @ 498a1cf9
......@@ -84,16 +84,16 @@ set_debarch() {
fi
}
rm -rf debian
# Some variables and settings used throughout the script
version=$KERNELRELEASE
if [ -n "$KDEB_PKGVERSION" ]; then
packageversion=$KDEB_PKGVERSION
revision=${packageversion##*-}
else
revision=$($srctree/init/build-version)
packageversion=$version-$revision
packageversion=$version-$($srctree/init/build-version)
fi
sourcename=$KDEB_SOURCENAME
sourcename=${KDEB_SOURCENAME:-linux-upstream}
if [ "$ARCH" = "um" ] ; then
packagename=user-mode-linux
......@@ -133,7 +133,24 @@ else
fi
mkdir -p debian/source/
echo "1.0" > debian/source/format
echo "3.0 (quilt)" > debian/source/format
{
echo "diff-ignore"
echo "extend-diff-ignore = .*"
} > debian/source/local-options
# Add .config as a patch
mkdir -p debian/patches
{
echo "Subject: Add .config"
echo "Author: ${maintainer}"
echo
echo "--- /dev/null"
echo "+++ linux/.config"
diff -u /dev/null "${KCONFIG_CONFIG}" | tail -n +3
} > debian/patches/config
echo config > debian/patches/series
echo $debarch > debian/arch
extra_build_depends=", $(if_enabled_echo CONFIG_UNWINDER_ORC libelf-dev:native)"
......@@ -225,19 +242,18 @@ srctree ?= .
build-indep:
build-arch:
\$(MAKE) KERNELRELEASE=${version} ARCH=${ARCH} \
KBUILD_BUILD_VERSION=${revision} -f \$(srctree)/Makefile
\$(MAKE) -f \$(srctree)/Makefile ARCH=${ARCH} \
\$(shell \$(srctree)/scripts/package/deb-build-option) \
olddefconfig all
build: build-arch
binary-indep:
binary-arch: build-arch
\$(MAKE) KERNELRELEASE=${version} ARCH=${ARCH} \
KBUILD_BUILD_VERSION=${revision} -f \$(srctree)/Makefile intdeb-pkg
\$(MAKE) -f \$(srctree)/Makefile ARCH=${ARCH} intdeb-pkg
clean:
rm -rf debian/*tmp debian/files
\$(MAKE) clean
rm -rf debian/files debian/linux-*
\$(MAKE) -f \$(srctree)/Makefile ARCH=${ARCH} clean
binary: binary-arch
EOF
......
scripts/package/mkspec
View file @ 498a1cf9
......@@ -33,8 +33,6 @@ EXCLUDES="$RCS_TAR_IGNORE --exclude=*vmlinux* --exclude=*.mod \
--exclude=*.o --exclude=*.ko --exclude=*.cmd --exclude=Documentation \
--exclude=.config.old --exclude=.missing-syscalls.d --exclude=*.s"
test -n "$LOCALVERSION" && MAKE="$MAKE LOCALVERSION=$LOCALVERSION"
# We can label the here-doc lines for conditional output to the spec file
#
# Labels:
......@@ -49,7 +47,8 @@ sed -e '/^DEL/d' -e 's/^\t*//' <<EOF
Group: System Environment/Kernel
Vendor: The Linux Community
URL: https://www.kernel.org
$S Source: kernel-$__KERNELRELEASE.tar.gz
$S Source0: linux.tar.gz
$S Source1: .config
Provides: $PROVIDES
$S BuildRequires: bc binutils bison dwarves
$S BuildRequires: (elfutils-libelf-devel or libelf-devel) flex
......@@ -85,12 +84,11 @@ $S$M This package provides kernel headers and makefiles sufficient to build modu
$S$M against the $__KERNELRELEASE kernel package.
$S$M
$S %prep
$S %setup -q
$S rm -f scripts/basic/fixdep scripts/kconfig/conf
$S rm -f tools/objtool/{fixdep,objtool}
$S %setup -q -n linux
$S cp %{SOURCE1} .
$S
$S %build
$S $MAKE %{?_smp_mflags} KBUILD_BUILD_VERSION=%{release}
$S $MAKE %{?_smp_mflags} KERNELRELEASE=$KERNELRELEASE KBUILD_BUILD_VERSION=%{release}
$S
%install
mkdir -p %{buildroot}/boot
......
scripts/remove-stale-files
View file @ 498a1cf9
......@@ -21,31 +21,15 @@ set -e
# then will be really dead and removed from the code base entirely.
rm -f arch/powerpc/purgatory/kexec-purgatory.c
# These were previously generated source files. When you are building the kernel
# with O=, make sure to remove the stale files in the output tree. Otherwise,
# the build system wrongly compiles the stale ones.
if [ -n "${building_out_of_srctree}" ]; then
for f in fdt_rw.c fdt_ro.c fdt_wip.c fdt.c ashldi3.S bswapsdi2.S font.c lib1funcs.S hyp-stub.S
do
rm -f arch/arm/boot/compressed/${f}
done
for f in uart-ath79.c ashldi3.c bswapdi.c bswapsi.c
do
rm -f arch/mips/boot/compressed/${f}
done
for f in firmware.c real2.S
do
rm -f arch/parisc/boot/compressed/${f}
done
fi
rm -f arch/riscv/purgatory/kexec-purgatory.c
rm -f arch/x86/purgatory/kexec-purgatory.c
rm -f scripts/extract-cert
rm -f arch/x86/purgatory/kexec-purgatory.c
rm -f scripts/kconfig/[gmnq]conf-cfg
rm -f rust/target.json
rm -f scripts/bin2c
rm -f .scmversion
scripts/setlocalversion
View file @ 498a1cf9
......@@ -11,16 +11,11 @@
#
usage() {
echo "Usage: $0 [--save-scmversion] [srctree]" >&2
echo "Usage: $0 [srctree]" >&2
exit 1
}
scm_only=false
srctree=.
if test "$1" = "--save-scmversion"; then
scm_only=true
shift
fi
if test $# -gt 0; then
srctree=$1
shift
......@@ -32,57 +27,69 @@ fi
scm_version()
{
local short
local tag
short=false
cd "$srctree"
if test -e .scmversion; then
cat .scmversion
return
fi
if test "$1" = "--short"; then
short=true
fi
# Check for git and a git repo.
if test -z "$(git rev-parse --show-cdup 2>/dev/null)" &&
head=$(git rev-parse --verify HEAD 2>/dev/null); then
# If we are at a tagged commit (like "v2.6.30-rc6"), we ignore
# it, because this version is defined in the top level Makefile.
if [ -z "$(git describe --exact-match 2>/dev/null)" ]; then
# If only the short version is requested, don't bother
# running further git commands
if $short; then
echo "+"
return
fi
# If we are past a tagged commit (like
# "v2.6.30-rc5-302-g72357d5"), we pretty print it.
if atag="$(git describe 2>/dev/null)"; then
echo "$atag" | awk -F- '{printf("-%05d", $(NF-1))}'
fi
# Add -g and exactly 12 hex chars.
printf '%s%s' -g "$(echo $head | cut -c1-12)"
fi
if test -n "$(git rev-parse --show-cdup 2>/dev/null)"; then
return
fi
if ! head=$(git rev-parse --verify HEAD 2>/dev/null); then
return
fi
# If a localversion*' file and the corresponding annotated tag exist,
# use it. This is the case in linux-next.
tag=${file_localversion#-}
tag=$(git describe --exact-match --match=$tag $tag 2>/dev/null)
# Otherwise, default to the annotated tag derived from KERNELVERSION.
# mainline kernel: 6.2.0-rc5 -> v6.2-rc5
# stable kernel: 6.1.7 -> v6.1.7
if [ -z "${tag}" ]; then
tag=v$(echo "${KERNELVERSION}" | sed -E 's/^([0-9]+\.[0-9]+)\.0(.*)$/\1\2/')
fi
# If we are at the tagged commit, we ignore it because the version is
# well-defined.
if [ -z "$(git describe --exact-match --match=$tag 2>/dev/null)" ]; then
# Check for uncommitted changes.
# This script must avoid any write attempt to the source tree,
# which might be read-only.
# You cannot use 'git describe --dirty' because it tries to
# create .git/index.lock .
# First, with git-status, but --no-optional-locks is only
# supported in git >= 2.14, so fall back to git-diff-index if
# it fails. Note that git-diff-index does not refresh the
# index, so it may give misleading results. See
# git-update-index(1), git-diff-index(1), and git-status(1).
if {
git --no-optional-locks status -uno --porcelain 2>/dev/null ||
git diff-index --name-only HEAD
} | read dummy; then
printf '%s' -dirty
# If only the short version is requested, don't bother
# running further git commands
if $short; then
echo "+"
return
fi
# If we are past the tagged commit, we pretty print it.
# (like 6.1.0-14595-g292a089d78d3)
if atag="$(git describe --match=$tag 2>/dev/null)"; then
echo "$atag" | awk -F- '{printf("-%05d", $(NF-1))}'
fi
# Add -g and exactly 12 hex chars.
printf '%s%s' -g "$(echo $head | cut -c1-12)"
fi
# Check for uncommitted changes.
# This script must avoid any write attempt to the source tree, which
# might be read-only.
# You cannot use 'git describe --dirty' because it tries to create
# .git/index.lock .
# First, with git-status, but --no-optional-locks is only supported in
# git >= 2.14, so fall back to git-diff-index if it fails. Note that
# git-diff-index does not refresh the index, so it may give misleading
# results.
# See git-update-index(1), git-diff-index(1), and git-status(1).
if {
git --no-optional-locks status -uno --porcelain 2>/dev/null ||
git diff-index --name-only HEAD
} | read dummy; then
printf '%s' -dirty
fi
}
......@@ -103,33 +110,29 @@ collect_files()
echo "$res"
}
if $scm_only; then
if test ! -e .scmversion; then
res=$(scm_version)
echo "$res" >.scmversion
fi
exit
fi
if ! test -e include/config/auto.conf; then
echo "Error: kernelrelease not valid - run 'make prepare' to update it" >&2
exit 1
fi
if [ -z "${KERNELVERSION}" ]; then
echo "KERNELVERSION is not set" >&2
exit 1
fi
# localversion* files in the build and source directory
res="$(collect_files localversion*)"
file_localversion="$(collect_files localversion*)"
if test ! "$srctree" -ef .; then
res="$res$(collect_files "$srctree"/localversion*)"
file_localversion="${file_localversion}$(collect_files "$srctree"/localversion*)"
fi
# CONFIG_LOCALVERSION and LOCALVERSION (if set)
# version string from CONFIG_LOCALVERSION
config_localversion=$(sed -n 's/^CONFIG_LOCALVERSION=\(.*\)$/\1/p' include/config/auto.conf)
res="${res}${config_localversion}${LOCALVERSION}"
# scm version string if not at a tagged commit
# scm version string if not at the kernel version tag or at the file_localversion
if grep -q "^CONFIG_LOCALVERSION_AUTO=y$" include/config/auto.conf; then
# full scm version string
res="$res$(scm_version)"
scm_version="$(scm_version)"
elif [ "${LOCALVERSION+set}" != "set" ]; then
# If the variable LOCALVERSION is not set, append a plus
# sign if the repository is not in a clean annotated or
......@@ -138,8 +141,7 @@ elif [ "${LOCALVERSION+set}" != "set" ]; then
#
# If the variable LOCALVERSION is set (including being set
# to an empty string), we don't want to append a plus sign.
scm=$(scm_version --short)
res="$res${scm:++}"
scm_version="$(scm_version --short)"
fi
echo "$res"
echo "${KERNELVERSION}${file_localversion}${config_localversion}${LOCALVERSION}${scm_version}"
scripts/tags.sh
View file @ 498a1cf9
......@@ -8,7 +8,7 @@
# Uses the following environment variables:
# SUBARCH, SRCARCH, srctree
if [ "$KBUILD_VERBOSE" = "1" ]; then
if [[ "$KBUILD_VERBOSE" =~ 1 ]]; then
set -x
fi
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7