Kbuild: add Rust support

*.o

*.o.*

*.patch

*.rmeta

*.rsi

*.s

*.so

*.so.dbg

export KBUILD_CHECKSRC

# Enable "clippy" (a linter) as part of the Rust compilation.

#

# Use 'make CLIPPY=1' to enable it.

ifeq ("$(origin CLIPPY)", "command line")

  KBUILD_CLIPPY := $(CLIPPY)

endif

export KBUILD_CLIPPY

# Use make M=dir or set the environment variable KBUILD_EXTMOD to specify the

# directory of external module to build. Setting M= takes precedence.

ifeq ("$(origin M)", "command line")

			 cscope gtags TAGS tags help% %docs check% coccicheck \

			 $(version_h) headers headers_% archheaders archscripts \

			 %asm-generic kernelversion %src-pkg dt_binding_check \

			 outputmakefile

			 outputmakefile rustavailable rustfmt rustfmtcheck

# 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 \

			headers_install modules_install kernelrelease image_name

no-sync-config-targets := $(no-dot-config-targets) %install kernelrelease \

			  image_name

single-targets := %.a %.i %.ko %.lds %.ll %.lst %.mod %.o %.s %.symtypes %/

single-targets := %.a %.i %.rsi %.ko %.lds %.ll %.lst %.mod %.o %.s %.symtypes %/

config-build	:=

mixed-build	:=

HOSTCC	= gcc

HOSTCXX	= g++

endif

HOSTRUSTC = rustc

HOSTPKG_CONFIG	= pkg-config

KBUILD_USERHOSTCFLAGS := -Wall -Wmissing-prototypes -Wstrict-prototypes \

KBUILD_USERCFLAGS  := $(KBUILD_USERHOSTCFLAGS) $(USERCFLAGS)

KBUILD_USERLDFLAGS := $(USERLDFLAGS)

# These flags apply to all Rust code in the tree, including the kernel and

# host programs.

export rust_common_flags := --edition=2021 \

			    -Zbinary_dep_depinfo=y \

			    -Dunsafe_op_in_unsafe_fn -Drust_2018_idioms \

			    -Dunreachable_pub -Dnon_ascii_idents \

			    -Wmissing_docs \

			    -Drustdoc::missing_crate_level_docs \

			    -Dclippy::correctness -Dclippy::style \

			    -Dclippy::suspicious -Dclippy::complexity \

			    -Dclippy::perf \

			    -Dclippy::let_unit_value -Dclippy::mut_mut \

			    -Dclippy::needless_bitwise_bool \

			    -Dclippy::needless_continue \

			    -Wclippy::dbg_macro

KBUILD_HOSTCFLAGS   := $(KBUILD_USERHOSTCFLAGS) $(HOST_LFS_CFLAGS) $(HOSTCFLAGS)

KBUILD_HOSTCXXFLAGS := -Wall -O2 $(HOST_LFS_CFLAGS) $(HOSTCXXFLAGS)

KBUILD_HOSTRUSTFLAGS := $(rust_common_flags) -O -Cstrip=debuginfo \

			-Zallow-features= $(HOSTRUSTFLAGS)

KBUILD_HOSTLDFLAGS  := $(HOST_LFS_LDFLAGS) $(HOSTLDFLAGS)

KBUILD_HOSTLDLIBS   := $(HOST_LFS_LIBS) $(HOSTLDLIBS)

READELF		= $(CROSS_COMPILE)readelf

STRIP		= $(CROSS_COMPILE)strip

endif

RUSTC		= rustc

RUSTDOC		= rustdoc

RUSTFMT		= rustfmt

CLIPPY_DRIVER	= clippy-driver

BINDGEN		= bindgen

CARGO		= cargo

PAHOLE		= pahole

RESOLVE_BTFIDS	= $(objtree)/tools/bpf/resolve_btfids/resolve_btfids

LEX		= flex

		  -Wbitwise -Wno-return-void -Wno-unknown-attribute $(CF)

NOSTDINC_FLAGS :=

CFLAGS_MODULE   =

RUSTFLAGS_MODULE =

AFLAGS_MODULE   =

LDFLAGS_MODULE  =

CFLAGS_KERNEL	=

RUSTFLAGS_KERNEL =

AFLAGS_KERNEL	=

LDFLAGS_vmlinux =

		   -Werror=return-type -Wno-format-security \

		   -std=gnu11

KBUILD_CPPFLAGS := -D__KERNEL__

KBUILD_RUSTFLAGS := $(rust_common_flags) \

		    --target=$(objtree)/rust/target.json \

		    -Cpanic=abort -Cembed-bitcode=n -Clto=n \

		    -Cforce-unwind-tables=n -Ccodegen-units=1 \

		    -Csymbol-mangling-version=v0 \

		    -Crelocation-model=static \

		    -Zfunction-sections=n \

		    -Dclippy::float_arithmetic

KBUILD_AFLAGS_KERNEL :=

KBUILD_CFLAGS_KERNEL :=

KBUILD_RUSTFLAGS_KERNEL :=

KBUILD_AFLAGS_MODULE  := -DMODULE

KBUILD_CFLAGS_MODULE  := -DMODULE

KBUILD_RUSTFLAGS_MODULE := --cfg MODULE

KBUILD_LDFLAGS_MODULE :=

KBUILD_LDFLAGS :=

CLANG_FLAGS :=

ifeq ($(KBUILD_CLIPPY),1)

	RUSTC_OR_CLIPPY_QUIET := CLIPPY

	RUSTC_OR_CLIPPY = $(CLIPPY_DRIVER)

else

	RUSTC_OR_CLIPPY_QUIET := RUSTC

	RUSTC_OR_CLIPPY = $(RUSTC)

endif

ifdef RUST_LIB_SRC

	export RUST_LIB_SRC

endif

# Allows the usage of unstable features in stable compilers.

export RUSTC_BOOTSTRAP := 1

export ARCH SRCARCH CONFIG_SHELL BASH HOSTCC KBUILD_HOSTCFLAGS CROSS_COMPILE LD CC HOSTPKG_CONFIG

export RUSTC RUSTDOC RUSTFMT RUSTC_OR_CLIPPY_QUIET RUSTC_OR_CLIPPY BINDGEN CARGO

export HOSTRUSTC KBUILD_HOSTRUSTFLAGS

export CPP AR NM STRIP OBJCOPY OBJDUMP READELF PAHOLE RESOLVE_BTFIDS LEX YACC AWK INSTALLKERNEL

export PERL PYTHON3 CHECK CHECKFLAGS MAKE UTS_MACHINE HOSTCXX

export KGZIP KBZIP2 KLZOP LZMA LZ4 XZ ZSTD

export KBUILD_CPPFLAGS NOSTDINC_FLAGS LINUXINCLUDE OBJCOPYFLAGS KBUILD_LDFLAGS

export KBUILD_CFLAGS CFLAGS_KERNEL CFLAGS_MODULE

export KBUILD_RUSTFLAGS RUSTFLAGS_KERNEL RUSTFLAGS_MODULE

export KBUILD_AFLAGS AFLAGS_KERNEL AFLAGS_MODULE

export KBUILD_AFLAGS_MODULE KBUILD_CFLAGS_MODULE KBUILD_LDFLAGS_MODULE

export KBUILD_AFLAGS_KERNEL KBUILD_CFLAGS_KERNEL

export KBUILD_AFLAGS_MODULE KBUILD_CFLAGS_MODULE KBUILD_RUSTFLAGS_MODULE KBUILD_LDFLAGS_MODULE

export KBUILD_AFLAGS_KERNEL KBUILD_CFLAGS_KERNEL KBUILD_RUSTFLAGS_KERNEL

export PAHOLE_FLAGS

# Files to ignore in find ... statements

#

# Do not use $(call cmd,...) here. That would suppress prompts from syncconfig,

# so you cannot notice that Kconfig is waiting for the user input.

%/config/auto.conf %/config/auto.conf.cmd %/generated/autoconf.h: $(KCONFIG_CONFIG)

%/config/auto.conf %/config/auto.conf.cmd %/generated/autoconf.h %/generated/rustc_cfg: $(KCONFIG_CONFIG)

	$(Q)$(kecho) "  SYNC    $@"

	$(Q)$(MAKE) -f $(srctree)/Makefile syncconfig

else # !may-sync-config

ifdef CONFIG_CC_OPTIMIZE_FOR_PERFORMANCE

KBUILD_CFLAGS += -O2

KBUILD_RUSTFLAGS += -Copt-level=2

else ifdef CONFIG_CC_OPTIMIZE_FOR_SIZE

KBUILD_CFLAGS += -Os

KBUILD_RUSTFLAGS += -Copt-level=s

endif

# Always set `debug-assertions` and `overflow-checks` because their default

# depends on `opt-level` and `debug-assertions`, respectively.

KBUILD_RUSTFLAGS += -Cdebug-assertions=$(if $(CONFIG_RUST_DEBUG_ASSERTIONS),y,n)

KBUILD_RUSTFLAGS += -Coverflow-checks=$(if $(CONFIG_RUST_OVERFLOW_CHECKS),y,n)

# Tell gcc to never replace conditional load with a non-conditional one

ifdef CONFIG_CC_IS_GCC

# gcc-10 renamed --param=allow-store-data-races=0 to

KBUILD_CFLAGS-$(CONFIG_CC_NO_ARRAY_BOUNDS) += -Wno-array-bounds

KBUILD_CFLAGS += $(KBUILD_CFLAGS-y) $(CONFIG_CC_IMPLICIT_FALLTHROUGH)

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.

ifdef CONFIG_FRAME_POINTER

KBUILD_CFLAGS	+= -fno-omit-frame-pointer -fno-optimize-sibling-calls

KBUILD_RUSTFLAGS += -Cforce-frame-pointers=y

else

# Some targets (ARM with Thumb2, for example), can't be built with frame

# pointers.  For those, we don't have FUNCTION_TRACER automatically

# select FRAME_POINTER.  However, FUNCTION_TRACER adds -pg, and this is

# incompatible with -fomit-frame-pointer with current GCC, so we don't use

# -fomit-frame-pointer with FUNCTION_TRACER.

# In the Rust target specification, "frame-pointer" is set explicitly

# to "may-omit".

ifndef CONFIG_FUNCTION_TRACER

KBUILD_CFLAGS	+= -fomit-frame-pointer

endif

KBUILD_CFLAGS += -fno-inline-functions-called-once

endif

# `rustc`'s `-Zfunction-sections` applies to data too (as of 1.59.0).

ifdef CONFIG_LD_DEAD_CODE_DATA_ELIMINATION

KBUILD_CFLAGS_KERNEL += -ffunction-sections -fdata-sections

KBUILD_RUSTFLAGS_KERNEL += -Zfunction-sections=y

LDFLAGS_vmlinux += --gc-sections

endif

# Do not add $(call cc-option,...) below this line. When you build the kernel

# from the clean source tree, the GCC plugins do not exist at this point.

# Add user supplied CPPFLAGS, AFLAGS and CFLAGS as the last assignments

# Add user supplied CPPFLAGS, AFLAGS, CFLAGS and RUSTFLAGS as the last assignments

KBUILD_CPPFLAGS += $(KCPPFLAGS)

KBUILD_AFLAGS   += $(KAFLAGS)

KBUILD_CFLAGS   += $(KCFLAGS)

KBUILD_RUSTFLAGS += $(KRUSTFLAGS)

KBUILD_LDFLAGS_MODULE += --build-id=sha1

LDFLAGS_vmlinux += --build-id=sha1

core-y			+= kernel/ certs/ mm/ fs/ ipc/ security/ crypto/

core-$(CONFIG_BLOCK)	+= block/

core-$(CONFIG_IO_URING)	+= io_uring/

core-$(CONFIG_RUST)	+= rust/

vmlinux-dirs	:= $(patsubst %/,%,$(filter %/, \

		     $(core-y) $(core-m) $(drivers-y) $(drivers-m) \

# All the preparing..

prepare: prepare0

ifdef CONFIG_RUST

	$(Q)$(CONFIG_SHELL) $(srctree)/scripts/rust_is_available.sh -v

	$(Q)$(MAKE) $(build)=rust

endif

PHONY += remove-stale-files

remove-stale-files:

# Directories & files removed with 'make clean'

CLEAN_FILES += include/ksym vmlinux.symvers modules-only.symvers \

	       modules.builtin modules.builtin.modinfo modules.nsdeps \

	       compile_commands.json .thinlto-cache

	       compile_commands.json .thinlto-cache rust/test rust/doc

# Directories & files removed with 'make mrproper'

MRPROPER_FILES += include/config include/generated          \

		  certs/signing_key.pem \

		  certs/x509.genkey \

		  vmlinux-gdb.py \

		  *.spec

		  *.spec \

		  rust/target.json rust/libmacros.so

# clean - Delete most, but leave enough to build external modules

#

mrproper: clean $(mrproper-dirs)

	$(call cmd,rmfiles)

	@find . $(RCS_FIND_IGNORE) \

		\( -name '*.rmeta' \) \

		-type f -print | xargs rm -f

# distclean

#

	@echo  '  kselftest-merge   - Merge all the config dependencies of'

	@echo  '		      kselftest to existing .config.'

	@echo  ''

	@echo  'Rust targets:'

	@echo  '  rustavailable   - Checks whether the Rust toolchain is'

	@echo  '		    available and, if not, explains why.'

	@echo  '  rustfmt	  - Reformat all the Rust code in the kernel'

	@echo  '  rustfmtcheck	  - Checks if all the Rust code in the kernel'

	@echo  '		    is formatted, printing a diff otherwise.'

	@echo  '  rustdoc	  - Generate Rust documentation'

	@echo  '		    (requires kernel .config)'

	@echo  '  rusttest        - Runs the Rust tests'

	@echo  '                    (requires kernel .config; downloads external repos)'

	@echo  '  rust-analyzer	  - Generate rust-project.json rust-analyzer support file'

	@echo  '		    (requires kernel .config)'

	@echo  '  dir/file.[os]   - Build specified target only'

	@echo  '  dir/file.rsi    - Build macro expanded source, similar to C preprocessing.'

	@echo  '                    Run with RUSTFMT=n to skip reformatting if needed.'

	@echo  '                    The output is not intended to be compilable.'

	@echo  '  dir/file.ll     - Build the LLVM assembly file'

	@echo  ''

	@$(if $(dtstree), \

		echo 'Devicetree:'; \

		echo '* dtbs             - Build device tree blobs for enabled boards'; \

$(DOC_TARGETS):

	$(Q)$(MAKE) $(build)=Documentation $@

# Rust targets

# ---------------------------------------------------------------------------

# "Is Rust available?" target

PHONY += rustavailable

rustavailable:

	$(Q)$(CONFIG_SHELL) $(srctree)/scripts/rust_is_available.sh -v && echo "Rust is available!"

# Documentation target

#

# Using the singular to avoid running afoul of `no-dot-config-targets`.

PHONY += rustdoc

rustdoc: prepare

	$(Q)$(MAKE) $(build)=rust $@

# Testing target

PHONY += rusttest

rusttest: prepare

	$(Q)$(MAKE) $(build)=rust $@

# Formatting targets

PHONY += rustfmt rustfmtcheck

# We skip `rust/alloc` since we want to minimize the diff w.r.t. upstream.

#

# We match using absolute paths since `find` does not resolve them

# when matching, which is a problem when e.g. `srctree` is `..`.

# We `grep` afterwards in order to remove the directory entry itself.

rustfmt:

	$(Q)find $(abs_srctree) -type f -name '*.rs' \

		-o -path $(abs_srctree)/rust/alloc -prune \

		-o -path $(abs_objtree)/rust/test -prune \

		| grep -Fv $(abs_srctree)/rust/alloc \

		| grep -Fv $(abs_objtree)/rust/test \

		| grep -Fv generated \

		| xargs $(RUSTFMT) $(rustfmt_flags)

rustfmtcheck: rustfmt_flags = --check

rustfmtcheck: rustfmt

# IDE support targets

PHONY += rust-analyzer

rust-analyzer:

	$(Q)$(MAKE) $(build)=rust $@

# Misc

# ---------------------------------------------------------------------------

clean: $(clean-dirs)

	$(call cmd,rmfiles)

	@find $(or $(KBUILD_EXTMOD), .) $(RCS_FIND_IGNORE) \

		\( -name '*.[aios]' -o -name '*.ko' -o -name '.*.cmd' \

		\( -name '*.[aios]' -o -name '*.rsi' -o -name '*.ko' -o -name '.*.cmd' \

		-o -name '*.ko.*' \

		-o -name '*.dtb' -o -name '*.dtbo' -o -name '*.dtb.S' -o -name '*.dt.yaml' \

		-o -name '*.dwo' -o -name '*.lst' \

	  This symbol should be selected by an architecture if it

	  supports an implementation of restartable sequences.

config HAVE_RUST

	bool

	help

	  This symbol should be selected by an architecture if it

	  supports Rust.

config HAVE_FUNCTION_ARG_ACCESS_API

	bool

	help

#ifndef __ASSEMBLY__

/*

 * Skipped when running bindgen due to a libclang issue;

 * see https://github.com/rust-lang/rust-bindgen/issues/2244.

 */

#if defined(CONFIG_DEBUG_INFO_BTF) && defined(CONFIG_PAHOLE_HAS_BTF_TAG) && \

	__has_attribute(btf_type_tag)

	__has_attribute(btf_type_tag) && !defined(__BINDGEN__)

# define BTF_TYPE_TAG(value) __attribute__((btf_type_tag(#value)))

#else

# define BTF_TYPE_TAG(value) /* nothing */

	default $(ld-version) if LD_IS_LLD

	default 0

config RUST_IS_AVAILABLE

	def_bool $(success,$(srctree)/scripts/rust_is_available.sh)

	help

	  This shows whether a suitable Rust toolchain is available (found).

	  Please see Documentation/rust/quick-start.rst for instructions on how

	  to satify the build requirements of Rust support.

	  In particular, the Makefile target 'rustavailable' is useful to check

	  why the Rust toolchain is not being detected.

config CC_CAN_LINK

	bool

	default $(success,$(srctree)/scripts/cc-can-link.sh $(CC) $(CLANG_FLAGS) $(USERCFLAGS) $(USERLDFLAGS) $(m64-flag)) if 64BIT

	default COMPILE_TEST

	help

	  A kernel build should not cause any compiler warnings, and this

	  enables the '-Werror' flag to enforce that rule by default.

	  enables the '-Werror' (for C) and '-Dwarnings' (for Rust) flags

	  to enforce that rule by default.

	  However, if you have a new (or very old) compiler with odd and

	  unusual warnings, or you have some architecture with problems,

	  Say Y here to enable the extended profiling support mechanisms used

	  by profilers.

config RUST

	bool "Rust support"

	depends on HAVE_RUST

	depends on RUST_IS_AVAILABLE

	depends on !MODVERSIONS

	depends on !GCC_PLUGINS

	depends on !RANDSTRUCT

	depends on !DEBUG_INFO_BTF

	select CONSTRUCTORS

	help

	  Enables Rust support in the kernel.

	  This allows other Rust-related options, like drivers written in Rust,

	  to be selected.

	  It is also required to be able to load external kernel modules

	  written in Rust.

	  See Documentation/rust/ for more information.

	  If unsure, say N.

config RUSTC_VERSION_TEXT

	string

	depends on RUST

	default $(shell,command -v $(RUSTC) >/dev/null 2>&1 && $(RUSTC) --version || echo n)

config BINDGEN_VERSION_TEXT

	string

	depends on RUST

	default $(shell,command -v $(BINDGEN) >/dev/null 2>&1 && $(BINDGEN) --version || echo n)

#

# Place an empty function call at each tracepoint site. Can be

# dynamically changed for a probe function.