Merge tag 'rust-v6.1-rc1' of https://github.com/Rust-for-Linux/linux
Pull Rust introductory support from Kees Cook: "The tree has a recent base, but has fundamentally been in linux-next for a year and a half[1]. It's been updated based on feedback from the Kernel Maintainer's Summit, and to gain recent Reviewed-by: tags. Miguel is the primary maintainer, with me helping where needed/wanted. Our plan is for the tree to switch to the standard non-rebasing practice once this initial infrastructure series lands. The contents are the absolute minimum to get Rust code building in the kernel, with many more interfaces[2] (and drivers - NVMe[3], 9p[4], M1 GPU[5]) on the way. The initial support of Rust-for-Linux comes in roughly 4 areas: - Kernel internals (kallsyms expansion for Rust symbols, %pA format) - Kbuild infrastructure (Rust build rules and support scripts) - Rust crates and bindings for initial minimum viable build - Rust kernel documentation and samples Rust support has been in linux-next for a year and a half now, and the short log doesn't do justice to the number of people who have contributed both to the Linux kernel side but also to the upstream Rust side to support the kernel's needs. Thanks to these 173 people, and many more, who have been involved in all kinds of ways: Miguel Ojeda, Wedson Almeida Filho, Alex Gaynor, Boqun Feng, Gary Guo, Björn Roy Baron, Andreas Hindborg, Adam Bratschi-Kaye, Benno Lossin, Maciej Falkowski, Finn Behrens, Sven Van Asbroeck, Asahi Lina, FUJITA Tomonori, John Baublitz, Wei Liu, Geoffrey Thomas, Philip Herron, Arthur Cohen, David Faust, Antoni Boucher, Philip Li, Yujie Liu, Jonathan Corbet, Greg Kroah-Hartman, Paul E. McKenney, Josh Triplett, Kent Overstreet, David Gow, Alice Ryhl, Robin Randhawa, Kees Cook, Nick Desaulniers, Matthew Wilcox, Linus Walleij, Joe Perches, Michael Ellerman, Petr Mladek, Masahiro Yamada, Arnaldo Carvalho de Melo, Andrii Nakryiko, Konstantin Shelekhin, Rasmus Villemoes, Konstantin Ryabitsev, Stephen Rothwell, Andy Shevchenko, Sergey Senozhatsky, John Paul Adrian Glaubitz, David Laight, Nathan Chancellor, Jonathan Cameron, Daniel Latypov, Shuah Khan, Brendan Higgins, Julia Lawall, Laurent Pinchart, Geert Uytterhoeven, Akira Yokosawa, Pavel Machek, David S. Miller, John Hawley, James Bottomley, Arnd Bergmann, Christian Brauner, Dan Robertson, Nicholas Piggin, Zhouyi Zhou, Elena Zannoni, Jose E. Marchesi, Leon Romanovsky, Will Deacon, Richard Weinberger, Randy Dunlap, Paolo Bonzini, Roland Dreier, Mark Brown, Sasha Levin, Ted Ts'o, Steven Rostedt, Jarkko Sakkinen, Michal Kubecek, Marco Elver, Al Viro, Keith Busch, Johannes Berg, Jan Kara, David Sterba, Connor Kuehl, Andy Lutomirski, Andrew Lunn, Alexandre Belloni, Peter Zijlstra, Russell King, Eric W. Biederman, Willy Tarreau, Christoph Hellwig, Emilio Cobos Álvarez, Christian Poveda, Mark Rousskov, John Ericson, TennyZhuang, Xuanwo, Daniel Paoliello, Manish Goregaokar, comex, Josh Stone, Stephan Sokolow, Philipp Krones, Guillaume Gomez, Joshua Nelson, Mats Larsen, Marc Poulhiès, Samantha Miller, Esteban Blanc, Martin Schmidt, Martin Rodriguez Reboredo, Daniel Xu, Viresh Kumar, Bartosz Golaszewski, Vegard Nossum, Milan Landaverde, Dariusz Sosnowski, Yuki Okushi, Matthew Bakhtiari, Wu XiangCheng, Tiago Lam, Boris-Chengbiao Zhou, Sumera Priyadarsini, Viktor Garske, Niklas Mohrin, Nándor István Krácser, Morgan Bartlett, Miguel Cano, Léo Lanteri Thauvin, Julian Merkle, Andreas Reindl, Jiapeng Chong, Fox Chen, Douglas Su, Antonio Terceiro, SeongJae Park, Sergio González Collado, Ngo Iok Ui (Wu Yu Wei), Joshua Abraham, Milan, Daniel Kolsoi, ahomescu, Manas, Luis Gerhorst, Li Hongyu, Philipp Gesang, Russell Currey, Jalil David Salamé Messina, Jon Olson, Raghvender, Angelos, Kaviraj Kanagaraj, Paul Römer, Sladyn Nunes, Mauro Baladés, Hsiang-Cheng Yang, Abhik Jain, Hongyu Li, Sean Nash, Yuheng Su, Peng Hao, Anhad Singh, Roel Kluin, Sara Saa, Geert Stappers, Garrett LeSage, IFo Hancroft, and Linus Torvalds" Link: https://lwn.net/Articles/849849/ [1] Link: https://github.com/Rust-for-Linux/linux/commits/rust [2] Link:d88c3744d6[3] Link:9367032607[4] Link: https://github.com/AsahiLinux/linux/commits/gpu/rust-wip [5] * tag 'rust-v6.1-rc1' of https://github.com/Rust-for-Linux/linux: (27 commits) MAINTAINERS: Rust samples: add first Rust examples x86: enable initial Rust support docs: add Rust documentation Kbuild: add Rust support rust: add `.rustfmt.toml` scripts: add `is_rust_module.sh` scripts: add `rust_is_available.sh` scripts: add `generate_rust_target.rs` scripts: add `generate_rust_analyzer.py` scripts: decode_stacktrace: demangle Rust symbols scripts: checkpatch: enable language-independent checks for Rust scripts: checkpatch: diagnose uses of `%pA` in the C side as errors vsprintf: add new `%pA` format specifier rust: export generated symbols rust: add `kernel` crate rust: add `bindings` crate rust: add `macros` crate rust: add `compiler_builtins` crate rust: adapt `alloc` crate to the kernel ...
This commit is contained in:
Linus Torvalds
1
scripts/.gitignore
vendored
1
scripts/.gitignore
vendored
@@ -1,6 +1,7 @@
|
||||
# SPDX-License-Identifier: GPL-2.0-only
|
||||
/asn1_compiler
|
||||
/bin2c
|
||||
/generate_rust_target
|
||||
/insert-sys-cert
|
||||
/kallsyms
|
||||
/module.lds
|
||||
|
||||
@@ -36,12 +36,12 @@ ld-option = $(success,$(LD) -v $(1))
|
||||
as-instr = $(success,printf "%b\n" "$(1)" | $(CC) $(CLANG_FLAGS) -c -x assembler -o /dev/null -)
|
||||
|
||||
# check if $(CC) and $(LD) exist
|
||||
$(error-if,$(failure,command -v $(CC)),compiler '$(CC)' not found)
|
||||
$(error-if,$(failure,command -v $(CC)),C compiler '$(CC)' not found)
|
||||
$(error-if,$(failure,command -v $(LD)),linker '$(LD)' not found)
|
||||
|
||||
# Get the compiler name, version, and error out if it is not supported.
|
||||
# Get the C compiler name, version, and error out if it is not supported.
|
||||
cc-info := $(shell,$(srctree)/scripts/cc-version.sh $(CC))
|
||||
$(error-if,$(success,test -z "$(cc-info)"),Sorry$(comma) this compiler is not supported.)
|
||||
$(error-if,$(success,test -z "$(cc-info)"),Sorry$(comma) this C compiler is not supported.)
|
||||
cc-name := $(shell,set -- $(cc-info) && echo $1)
|
||||
cc-version := $(shell,set -- $(cc-info) && echo $2)
|
||||
|
||||
|
||||
@@ -10,6 +10,9 @@ 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
|
||||
|
||||
generate_rust_target-rust := y
|
||||
|
||||
HOSTCFLAGS_sorttable.o = -I$(srctree)/tools/include
|
||||
HOSTLDLIBS_sorttable = -lpthread
|
||||
|
||||
@@ -26,6 +26,7 @@ EXTRA_CPPFLAGS :=
|
||||
EXTRA_LDFLAGS :=
|
||||
asflags-y :=
|
||||
ccflags-y :=
|
||||
rustflags-y :=
|
||||
cppflags-y :=
|
||||
ldflags-y :=
|
||||
|
||||
@@ -271,6 +272,65 @@ quiet_cmd_cc_lst_c = MKLST $@
|
||||
$(obj)/%.lst: $(src)/%.c FORCE
|
||||
$(call if_changed_dep,cc_lst_c)
|
||||
|
||||
# Compile Rust sources (.rs)
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
rust_allowed_features := core_ffi_c
|
||||
|
||||
rust_common_cmd = \
|
||||
RUST_MODFILE=$(modfile) $(RUSTC_OR_CLIPPY) $(rust_flags) \
|
||||
-Zallow-features=$(rust_allowed_features) \
|
||||
-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)
|
||||
|
||||
# `--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
|
||||
# the compiler shows a warning if it is not 1. However, if we ever stop
|
||||
# requesting it explicitly and we start using some other `--emit` that does not
|
||||
# imply it (and for which codegen is performed), then we would be out of sync,
|
||||
# i.e. the outputs we would get for the different single targets (e.g. `.ll`)
|
||||
# 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)
|
||||
|
||||
$(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)
|
||||
|
||||
$(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)
|
||||
|
||||
$(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)
|
||||
|
||||
$(obj)/%.ll: $(src)/%.rs FORCE
|
||||
$(call if_changed_dep,rustc_ll_rs)
|
||||
|
||||
# Compile assembler sources (.S)
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
|
||||
@@ -1,4 +1,6 @@
|
||||
DEBUG_CFLAGS :=
|
||||
DEBUG_RUSTFLAGS :=
|
||||
|
||||
debug-flags-y := -g
|
||||
|
||||
ifdef CONFIG_DEBUG_INFO_SPLIT
|
||||
@@ -17,9 +19,12 @@ KBUILD_AFLAGS += $(debug-flags-y)
|
||||
|
||||
ifdef CONFIG_DEBUG_INFO_REDUCED
|
||||
DEBUG_CFLAGS += -fno-var-tracking
|
||||
DEBUG_RUSTFLAGS += -Cdebuginfo=1
|
||||
ifdef CONFIG_CC_IS_GCC
|
||||
DEBUG_CFLAGS += -femit-struct-debug-baseonly
|
||||
endif
|
||||
else
|
||||
DEBUG_RUSTFLAGS += -Cdebuginfo=2
|
||||
endif
|
||||
|
||||
ifdef CONFIG_DEBUG_INFO_COMPRESSED
|
||||
@@ -30,3 +35,6 @@ endif
|
||||
|
||||
KBUILD_CFLAGS += $(DEBUG_CFLAGS)
|
||||
export DEBUG_CFLAGS
|
||||
|
||||
KBUILD_RUSTFLAGS += $(DEBUG_RUSTFLAGS)
|
||||
export DEBUG_RUSTFLAGS
|
||||
|
||||
@@ -22,6 +22,8 @@ $(obj)/%.tab.c $(obj)/%.tab.h: $(src)/%.y FORCE
|
||||
# to preprocess a data file.
|
||||
#
|
||||
# Both C and C++ are supported, but preferred language is C for such utilities.
|
||||
# Rust is also supported, but it may only be used in scenarios where a Rust
|
||||
# toolchain is required to be available (e.g. when `CONFIG_RUST` is enabled).
|
||||
#
|
||||
# Sample syntax (see Documentation/kbuild/makefiles.rst for reference)
|
||||
# hostprogs := bin2hex
|
||||
@@ -37,15 +39,20 @@ $(obj)/%.tab.c $(obj)/%.tab.h: $(src)/%.y FORCE
|
||||
# qconf-objs := menu.o
|
||||
# Will compile qconf as a C++ program, and menu as a C program.
|
||||
# They are linked as C++ code to the executable qconf
|
||||
#
|
||||
# hostprogs := target
|
||||
# target-rust := y
|
||||
# Will compile `target` as a Rust program, using `target.rs` as the crate root.
|
||||
# The crate may consist of several source files.
|
||||
|
||||
# C code
|
||||
# Executables compiled from a single .c file
|
||||
host-csingle := $(foreach m,$(hostprogs), \
|
||||
$(if $($(m)-objs)$($(m)-cxxobjs),,$(m)))
|
||||
$(if $($(m)-objs)$($(m)-cxxobjs)$($(m)-rust),,$(m)))
|
||||
|
||||
# C executables linked based on several .o files
|
||||
host-cmulti := $(foreach m,$(hostprogs),\
|
||||
$(if $($(m)-cxxobjs),,$(if $($(m)-objs),$(m))))
|
||||
$(if $($(m)-cxxobjs)$($(m)-rust),,$(if $($(m)-objs),$(m))))
|
||||
|
||||
# Object (.o) files compiled from .c files
|
||||
host-cobjs := $(sort $(foreach m,$(hostprogs),$($(m)-objs)))
|
||||
@@ -58,11 +65,17 @@ host-cxxmulti := $(foreach m,$(hostprogs),$(if $($(m)-cxxobjs),$(m)))
|
||||
# C++ Object (.o) files compiled from .cc files
|
||||
host-cxxobjs := $(sort $(foreach m,$(host-cxxmulti),$($(m)-cxxobjs)))
|
||||
|
||||
# Rust code
|
||||
# Executables compiled from a single Rust crate (which may consist of
|
||||
# one or more .rs files)
|
||||
host-rust := $(foreach m,$(hostprogs),$(if $($(m)-rust),$(m)))
|
||||
|
||||
host-csingle := $(addprefix $(obj)/,$(host-csingle))
|
||||
host-cmulti := $(addprefix $(obj)/,$(host-cmulti))
|
||||
host-cobjs := $(addprefix $(obj)/,$(host-cobjs))
|
||||
host-cxxmulti := $(addprefix $(obj)/,$(host-cxxmulti))
|
||||
host-cxxobjs := $(addprefix $(obj)/,$(host-cxxobjs))
|
||||
host-rust := $(addprefix $(obj)/,$(host-rust))
|
||||
|
||||
#####
|
||||
# Handle options to gcc. Support building with separate output directory
|
||||
@@ -71,6 +84,8 @@ _hostc_flags = $(KBUILD_HOSTCFLAGS) $(HOST_EXTRACFLAGS) \
|
||||
$(HOSTCFLAGS_$(target-stem).o)
|
||||
_hostcxx_flags = $(KBUILD_HOSTCXXFLAGS) $(HOST_EXTRACXXFLAGS) \
|
||||
$(HOSTCXXFLAGS_$(target-stem).o)
|
||||
_hostrust_flags = $(KBUILD_HOSTRUSTFLAGS) $(HOST_EXTRARUSTFLAGS) \
|
||||
$(HOSTRUSTFLAGS_$(target-stem))
|
||||
|
||||
# $(objtree)/$(obj) for including generated headers from checkin source files
|
||||
ifeq ($(KBUILD_EXTMOD),)
|
||||
@@ -82,6 +97,7 @@ endif
|
||||
|
||||
hostc_flags = -Wp,-MMD,$(depfile) $(_hostc_flags)
|
||||
hostcxx_flags = -Wp,-MMD,$(depfile) $(_hostcxx_flags)
|
||||
hostrust_flags = $(_hostrust_flags)
|
||||
|
||||
#####
|
||||
# Compile programs on the host
|
||||
@@ -128,5 +144,17 @@ quiet_cmd_host-cxxobjs = HOSTCXX $@
|
||||
$(host-cxxobjs): $(obj)/%.o: $(src)/%.cc FORCE
|
||||
$(call if_changed_dep,host-cxxobjs)
|
||||
|
||||
# Create executable from a single Rust crate (which may consist of
|
||||
# one or more `.rs` files)
|
||||
# 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)
|
||||
$(host-rust): $(obj)/%: $(src)/%.rs FORCE
|
||||
$(call if_changed_dep,host-rust)
|
||||
|
||||
targets += $(host-csingle) $(host-cmulti) $(host-cobjs) \
|
||||
$(host-cxxmulti) $(host-cxxobjs)
|
||||
$(host-cxxmulti) $(host-cxxobjs) $(host-rust)
|
||||
|
||||
@@ -8,6 +8,7 @@ ldflags-y += $(EXTRA_LDFLAGS)
|
||||
# flags that take effect in current and sub directories
|
||||
KBUILD_AFLAGS += $(subdir-asflags-y)
|
||||
KBUILD_CFLAGS += $(subdir-ccflags-y)
|
||||
KBUILD_RUSTFLAGS += $(subdir-rustflags-y)
|
||||
|
||||
# Figure out what we need to build from the various variables
|
||||
# ===========================================================================
|
||||
@@ -128,6 +129,10 @@ _c_flags = $(filter-out $(CFLAGS_REMOVE_$(target-stem).o), \
|
||||
$(filter-out $(ccflags-remove-y), \
|
||||
$(KBUILD_CPPFLAGS) $(KBUILD_CFLAGS) $(ccflags-y)) \
|
||||
$(CFLAGS_$(target-stem).o))
|
||||
_rust_flags = $(filter-out $(RUSTFLAGS_REMOVE_$(target-stem).o), \
|
||||
$(filter-out $(rustflags-remove-y), \
|
||||
$(KBUILD_RUSTFLAGS) $(rustflags-y)) \
|
||||
$(RUSTFLAGS_$(target-stem).o))
|
||||
_a_flags = $(filter-out $(AFLAGS_REMOVE_$(target-stem).o), \
|
||||
$(filter-out $(asflags-remove-y), \
|
||||
$(KBUILD_CPPFLAGS) $(KBUILD_AFLAGS) $(asflags-y)) \
|
||||
@@ -202,6 +207,11 @@ modkern_cflags = \
|
||||
$(KBUILD_CFLAGS_MODULE) $(CFLAGS_MODULE), \
|
||||
$(KBUILD_CFLAGS_KERNEL) $(CFLAGS_KERNEL) $(modfile_flags))
|
||||
|
||||
modkern_rustflags = \
|
||||
$(if $(part-of-module), \
|
||||
$(KBUILD_RUSTFLAGS_MODULE) $(RUSTFLAGS_MODULE), \
|
||||
$(KBUILD_RUSTFLAGS_KERNEL) $(RUSTFLAGS_KERNEL))
|
||||
|
||||
modkern_aflags = $(if $(part-of-module), \
|
||||
$(KBUILD_AFLAGS_MODULE) $(AFLAGS_MODULE), \
|
||||
$(KBUILD_AFLAGS_KERNEL) $(AFLAGS_KERNEL))
|
||||
@@ -211,6 +221,8 @@ c_flags = -Wp,-MMD,$(depfile) $(NOSTDINC_FLAGS) $(LINUXINCLUDE) \
|
||||
$(_c_flags) $(modkern_cflags) \
|
||||
$(basename_flags) $(modname_flags)
|
||||
|
||||
rust_flags = $(_rust_flags) $(modkern_rustflags) @$(objtree)/include/generated/rustc_cfg
|
||||
|
||||
a_flags = -Wp,-MMD,$(depfile) $(NOSTDINC_FLAGS) $(LINUXINCLUDE) \
|
||||
$(_a_flags) $(modkern_aflags)
|
||||
|
||||
|
||||
@@ -39,11 +39,13 @@ quiet_cmd_ld_ko_o = LD [M] $@
|
||||
|
||||
quiet_cmd_btf_ko = BTF [M] $@
|
||||
cmd_btf_ko = \
|
||||
if [ -f vmlinux ]; then \
|
||||
if [ ! -f vmlinux ]; then \
|
||||
printf "Skipping BTF generation for %s due to unavailability of vmlinux\n" $@ 1>&2; \
|
||||
elif [ -n "$(CONFIG_RUST)" ] && $(srctree)/scripts/is_rust_module.sh $@; then \
|
||||
printf "Skipping BTF generation for %s because it's a Rust module\n" $@ 1>&2; \
|
||||
else \
|
||||
LLVM_OBJCOPY="$(OBJCOPY)" $(PAHOLE) -J $(PAHOLE_FLAGS) --btf_base vmlinux $@; \
|
||||
$(RESOLVE_BTFIDS) -b vmlinux $@; \
|
||||
else \
|
||||
printf "Skipping BTF generation for %s due to unavailability of vmlinux\n" $@ 1>&2; \
|
||||
fi;
|
||||
|
||||
# Same as newer-prereqs, but allows to exclude specified extra dependencies
|
||||
|
||||
@@ -1,13 +1,13 @@
|
||||
#!/bin/sh
|
||||
# SPDX-License-Identifier: GPL-2.0
|
||||
#
|
||||
# Print the compiler name and its version in a 5 or 6-digit form.
|
||||
# Print the C compiler name and its version in a 5 or 6-digit form.
|
||||
# Also, perform the minimum version check.
|
||||
|
||||
set -e
|
||||
|
||||
# Print the compiler name and some version components.
|
||||
get_compiler_info()
|
||||
# Print the C compiler name and some version components.
|
||||
get_c_compiler_info()
|
||||
{
|
||||
cat <<- EOF | "$@" -E -P -x c - 2>/dev/null
|
||||
#if defined(__clang__)
|
||||
@@ -32,7 +32,7 @@ get_canonical_version()
|
||||
|
||||
# $@ instead of $1 because multiple words might be given, e.g. CC="ccache gcc".
|
||||
orig_args="$@"
|
||||
set -- $(get_compiler_info "$@")
|
||||
set -- $(get_c_compiler_info "$@")
|
||||
|
||||
name=$1
|
||||
|
||||
@@ -52,7 +52,7 @@ ICC)
|
||||
min_version=$($min_tool_version icc)
|
||||
;;
|
||||
*)
|
||||
echo "$orig_args: unknown compiler" >&2
|
||||
echo "$orig_args: unknown C compiler" >&2
|
||||
exit 1
|
||||
;;
|
||||
esac
|
||||
@@ -62,7 +62,7 @@ min_cversion=$(get_canonical_version $min_version)
|
||||
|
||||
if [ "$cversion" -lt "$min_cversion" ]; then
|
||||
echo >&2 "***"
|
||||
echo >&2 "*** Compiler is too old."
|
||||
echo >&2 "*** C compiler is too old."
|
||||
echo >&2 "*** Your $name version: $version"
|
||||
echo >&2 "*** Minimum $name version: $min_version"
|
||||
echo >&2 "***"
|
||||
|
||||
@@ -3616,7 +3616,7 @@ sub process {
|
||||
my $comment = "";
|
||||
if ($realfile =~ /\.(h|s|S)$/) {
|
||||
$comment = '/*';
|
||||
} elsif ($realfile =~ /\.(c|dts|dtsi)$/) {
|
||||
} elsif ($realfile =~ /\.(c|rs|dts|dtsi)$/) {
|
||||
$comment = '//';
|
||||
} elsif (($checklicenseline == 2) || $realfile =~ /\.(sh|pl|py|awk|tc|yaml)$/) {
|
||||
$comment = '#';
|
||||
@@ -3664,7 +3664,7 @@ sub process {
|
||||
}
|
||||
|
||||
# check we are in a valid source file if not then ignore this hunk
|
||||
next if ($realfile !~ /\.(h|c|s|S|sh|dtsi|dts)$/);
|
||||
next if ($realfile !~ /\.(h|c|rs|s|S|sh|dtsi|dts)$/);
|
||||
|
||||
# check for using SPDX-License-Identifier on the wrong line number
|
||||
if ($realline != $checklicenseline &&
|
||||
@@ -6783,15 +6783,19 @@ sub process {
|
||||
}
|
||||
if ($bad_specifier ne "") {
|
||||
my $stat_real = get_stat_real($linenr, $lc);
|
||||
my $msg_level = \&WARN;
|
||||
my $ext_type = "Invalid";
|
||||
my $use = "";
|
||||
if ($bad_specifier =~ /p[Ff]/) {
|
||||
$use = " - use %pS instead";
|
||||
$use =~ s/pS/ps/ if ($bad_specifier =~ /pf/);
|
||||
} elsif ($bad_specifier =~ /pA/) {
|
||||
$use = " - '%pA' is only intended to be used from Rust code";
|
||||
$msg_level = \&ERROR;
|
||||
}
|
||||
|
||||
WARN("VSPRINTF_POINTER_EXTENSION",
|
||||
"$ext_type vsprintf pointer extension '$bad_specifier'$use\n" . "$here\n$stat_real\n");
|
||||
&{$msg_level}("VSPRINTF_POINTER_EXTENSION",
|
||||
"$ext_type vsprintf pointer extension '$bad_specifier'$use\n" . "$here\n$stat_real\n");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -8,6 +8,14 @@ usage() {
|
||||
echo " $0 -r <release> | <vmlinux> [<base path>|auto] [<modules path>]"
|
||||
}
|
||||
|
||||
# Try to find a Rust demangler
|
||||
if type llvm-cxxfilt >/dev/null 2>&1 ; then
|
||||
cppfilt=llvm-cxxfilt
|
||||
elif type c++filt >/dev/null 2>&1 ; then
|
||||
cppfilt=c++filt
|
||||
cppfilt_opts=-i
|
||||
fi
|
||||
|
||||
if [[ $1 == "-r" ]] ; then
|
||||
vmlinux=""
|
||||
basepath="auto"
|
||||
@@ -180,6 +188,12 @@ parse_symbol() {
|
||||
# In the case of inlines, move everything to same line
|
||||
code=${code//$'\n'/' '}
|
||||
|
||||
# Demangle if the name looks like a Rust symbol and if
|
||||
# we got a Rust demangler
|
||||
if [[ $name =~ ^_R && $cppfilt != "" ]] ; then
|
||||
name=$("$cppfilt" "$cppfilt_opts" "$name")
|
||||
fi
|
||||
|
||||
# Replace old address with pretty line numbers
|
||||
symbol="$segment$name ($code)"
|
||||
}
|
||||
|
||||
135
scripts/generate_rust_analyzer.py
Executable file
135
scripts/generate_rust_analyzer.py
Executable file
@@ -0,0 +1,135 @@
|
||||
#!/usr/bin/env python3
|
||||
# SPDX-License-Identifier: GPL-2.0
|
||||
"""generate_rust_analyzer - Generates the `rust-project.json` file for `rust-analyzer`.
|
||||
"""
|
||||
|
||||
import argparse
|
||||
import json
|
||||
import logging
|
||||
import pathlib
|
||||
import sys
|
||||
|
||||
def generate_crates(srctree, objtree, sysroot_src):
|
||||
# Generate the configuration list.
|
||||
cfg = []
|
||||
with open(objtree / "include" / "generated" / "rustc_cfg") as fd:
|
||||
for line in fd:
|
||||
line = line.replace("--cfg=", "")
|
||||
line = line.replace("\n", "")
|
||||
cfg.append(line)
|
||||
|
||||
# Now fill the crates list -- dependencies need to come first.
|
||||
#
|
||||
# Avoid O(n^2) iterations by keeping a map of indexes.
|
||||
crates = []
|
||||
crates_indexes = {}
|
||||
|
||||
def append_crate(display_name, root_module, deps, cfg=[], is_workspace_member=True, is_proc_macro=False):
|
||||
crates_indexes[display_name] = len(crates)
|
||||
crates.append({
|
||||
"display_name": display_name,
|
||||
"root_module": str(root_module),
|
||||
"is_workspace_member": is_workspace_member,
|
||||
"is_proc_macro": is_proc_macro,
|
||||
"deps": [{"crate": crates_indexes[dep], "name": dep} for dep in deps],
|
||||
"cfg": cfg,
|
||||
"edition": "2021",
|
||||
"env": {
|
||||
"RUST_MODFILE": "This is only for rust-analyzer"
|
||||
}
|
||||
})
|
||||
|
||||
# First, the ones in `rust/` since they are a bit special.
|
||||
append_crate(
|
||||
"core",
|
||||
sysroot_src / "core" / "src" / "lib.rs",
|
||||
[],
|
||||
is_workspace_member=False,
|
||||
)
|
||||
|
||||
append_crate(
|
||||
"compiler_builtins",
|
||||
srctree / "rust" / "compiler_builtins.rs",
|
||||
[],
|
||||
)
|
||||
|
||||
append_crate(
|
||||
"alloc",
|
||||
srctree / "rust" / "alloc" / "lib.rs",
|
||||
["core", "compiler_builtins"],
|
||||
)
|
||||
|
||||
append_crate(
|
||||
"macros",
|
||||
srctree / "rust" / "macros" / "lib.rs",
|
||||
[],
|
||||
is_proc_macro=True,
|
||||
)
|
||||
crates[-1]["proc_macro_dylib_path"] = "rust/libmacros.so"
|
||||
|
||||
append_crate(
|
||||
"bindings",
|
||||
srctree / "rust"/ "bindings" / "lib.rs",
|
||||
["core"],
|
||||
cfg=cfg,
|
||||
)
|
||||
crates[-1]["env"]["OBJTREE"] = str(objtree.resolve(True))
|
||||
|
||||
append_crate(
|
||||
"kernel",
|
||||
srctree / "rust" / "kernel" / "lib.rs",
|
||||
["core", "alloc", "macros", "bindings"],
|
||||
cfg=cfg,
|
||||
)
|
||||
crates[-1]["source"] = {
|
||||
"include_dirs": [
|
||||
str(srctree / "rust" / "kernel"),
|
||||
str(objtree / "rust")
|
||||
],
|
||||
"exclude_dirs": [],
|
||||
}
|
||||
|
||||
# Then, the rest outside of `rust/`.
|
||||
#
|
||||
# We explicitly mention the top-level folders we want to cover.
|
||||
for folder in ("samples", "drivers"):
|
||||
for path in (srctree / folder).rglob("*.rs"):
|
||||
logging.info("Checking %s", path)
|
||||
name = path.name.replace(".rs", "")
|
||||
|
||||
# Skip those that are not crate roots.
|
||||
if f"{name}.o" not in open(path.parent / "Makefile").read():
|
||||
continue
|
||||
|
||||
logging.info("Adding %s", name)
|
||||
append_crate(
|
||||
name,
|
||||
path,
|
||||
["core", "alloc", "kernel"],
|
||||
cfg=cfg,
|
||||
)
|
||||
|
||||
return crates
|
||||
|
||||
def main():
|
||||
parser = argparse.ArgumentParser()
|
||||
parser.add_argument('--verbose', '-v', action='store_true')
|
||||
parser.add_argument("srctree", type=pathlib.Path)
|
||||
parser.add_argument("objtree", type=pathlib.Path)
|
||||
parser.add_argument("sysroot_src", type=pathlib.Path)
|
||||
args = parser.parse_args()
|
||||
|
||||
logging.basicConfig(
|
||||
format="[%(asctime)s] [%(levelname)s] %(message)s",
|
||||
level=logging.INFO if args.verbose else logging.WARNING
|
||||
)
|
||||
|
||||
rust_project = {
|
||||
"crates": generate_crates(args.srctree, args.objtree, args.sysroot_src),
|
||||
"sysroot_src": str(args.sysroot_src),
|
||||
}
|
||||
|
||||
json.dump(rust_project, sys.stdout, sort_keys=True, indent=4)
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
182
scripts/generate_rust_target.rs
Normal file
182
scripts/generate_rust_target.rs
Normal file
@@ -0,0 +1,182 @@
|
||||
// SPDX-License-Identifier: GPL-2.0
|
||||
|
||||
//! The custom target specification file generator for `rustc`.
|
||||
//!
|
||||
//! To configure a target from scratch, a JSON-encoded file has to be passed
|
||||
//! to `rustc` (introduced in [RFC 131]). These options and the file itself are
|
||||
//! unstable. Eventually, `rustc` should provide a way to do this in a stable
|
||||
//! manner. For instance, via command-line arguments. Therefore, this file
|
||||
//! should avoid using keys which can be set via `-C` or `-Z` options.
|
||||
//!
|
||||
//! [RFC 131]: https://rust-lang.github.io/rfcs/0131-target-specification.html
|
||||
|
||||
use std::{
|
||||
collections::HashMap,
|
||||
fmt::{Display, Formatter, Result},
|
||||
io::BufRead,
|
||||
};
|
||||
|
||||
enum Value {
|
||||
Boolean(bool),
|
||||
Number(i32),
|
||||
String(String),
|
||||
Object(Object),
|
||||
}
|
||||
|
||||
type Object = Vec<(String, Value)>;
|
||||
|
||||
/// Minimal "almost JSON" generator (e.g. no `null`s, no arrays, no escaping),
|
||||
/// enough for this purpose.
|
||||
impl Display for Value {
|
||||
fn fmt(&self, formatter: &mut Formatter<'_>) -> Result {
|
||||
match self {
|
||||
Value::Boolean(boolean) => write!(formatter, "{}", boolean),
|
||||
Value::Number(number) => write!(formatter, "{}", number),
|
||||
Value::String(string) => write!(formatter, "\"{}\"", string),
|
||||
Value::Object(object) => {
|
||||
formatter.write_str("{")?;
|
||||
if let [ref rest @ .., ref last] = object[..] {
|
||||
for (key, value) in rest {
|
||||
write!(formatter, "\"{}\": {},", key, value)?;
|
||||
}
|
||||
write!(formatter, "\"{}\": {}", last.0, last.1)?;
|
||||
}
|
||||
formatter.write_str("}")
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
struct TargetSpec(Object);
|
||||
|
||||
impl TargetSpec {
|
||||
fn new() -> TargetSpec {
|
||||
TargetSpec(Vec::new())
|
||||
}
|
||||
}
|
||||
|
||||
trait Push<T> {
|
||||
fn push(&mut self, key: &str, value: T);
|
||||
}
|
||||
|
||||
impl Push<bool> for TargetSpec {
|
||||
fn push(&mut self, key: &str, value: bool) {
|
||||
self.0.push((key.to_string(), Value::Boolean(value)));
|
||||
}
|
||||
}
|
||||
|
||||
impl Push<i32> for TargetSpec {
|
||||
fn push(&mut self, key: &str, value: i32) {
|
||||
self.0.push((key.to_string(), Value::Number(value)));
|
||||
}
|
||||
}
|
||||
|
||||
impl Push<String> for TargetSpec {
|
||||
fn push(&mut self, key: &str, value: String) {
|
||||
self.0.push((key.to_string(), Value::String(value)));
|
||||
}
|
||||
}
|
||||
|
||||
impl Push<&str> for TargetSpec {
|
||||
fn push(&mut self, key: &str, value: &str) {
|
||||
self.push(key, value.to_string());
|
||||
}
|
||||
}
|
||||
|
||||
impl Push<Object> for TargetSpec {
|
||||
fn push(&mut self, key: &str, value: Object) {
|
||||
self.0.push((key.to_string(), Value::Object(value)));
|
||||
}
|
||||
}
|
||||
|
||||
impl Display for TargetSpec {
|
||||
fn fmt(&self, formatter: &mut Formatter<'_>) -> Result {
|
||||
// We add some newlines for clarity.
|
||||
formatter.write_str("{\n")?;
|
||||
if let [ref rest @ .., ref last] = self.0[..] {
|
||||
for (key, value) in rest {
|
||||
write!(formatter, " \"{}\": {},\n", key, value)?;
|
||||
}
|
||||
write!(formatter, " \"{}\": {}\n", last.0, last.1)?;
|
||||
}
|
||||
formatter.write_str("}")
|
||||
}
|
||||
}
|
||||
|
||||
struct KernelConfig(HashMap<String, String>);
|
||||
|
||||
impl KernelConfig {
|
||||
/// Parses `include/config/auto.conf` from `stdin`.
|
||||
fn from_stdin() -> KernelConfig {
|
||||
let mut result = HashMap::new();
|
||||
|
||||
let stdin = std::io::stdin();
|
||||
let mut handle = stdin.lock();
|
||||
let mut line = String::new();
|
||||
|
||||
loop {
|
||||
line.clear();
|
||||
|
||||
if handle.read_line(&mut line).unwrap() == 0 {
|
||||
break;
|
||||
}
|
||||
|
||||
if line.starts_with('#') {
|
||||
continue;
|
||||
}
|
||||
|
||||
let (key, value) = line.split_once('=').expect("Missing `=` in line.");
|
||||
result.insert(key.to_string(), value.trim_end_matches('\n').to_string());
|
||||
}
|
||||
|
||||
KernelConfig(result)
|
||||
}
|
||||
|
||||
/// Does the option exist in the configuration (any value)?
|
||||
///
|
||||
/// The argument must be passed without the `CONFIG_` prefix.
|
||||
/// This avoids repetition and it also avoids `fixdep` making us
|
||||
/// depend on it.
|
||||
fn has(&self, option: &str) -> bool {
|
||||
let option = "CONFIG_".to_owned() + option;
|
||||
self.0.contains_key(&option)
|
||||
}
|
||||
}
|
||||
|
||||
fn main() {
|
||||
let cfg = KernelConfig::from_stdin();
|
||||
let mut ts = TargetSpec::new();
|
||||
|
||||
// `llvm-target`s are taken from `scripts/Makefile.clang`.
|
||||
if cfg.has("X86_64") {
|
||||
ts.push("arch", "x86_64");
|
||||
ts.push(
|
||||
"data-layout",
|
||||
"e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128",
|
||||
);
|
||||
let mut features = "-3dnow,-3dnowa,-mmx,+soft-float".to_string();
|
||||
if cfg.has("RETPOLINE") {
|
||||
features += ",+retpoline-external-thunk";
|
||||
}
|
||||
ts.push("features", features);
|
||||
ts.push("llvm-target", "x86_64-linux-gnu");
|
||||
ts.push("target-pointer-width", "64");
|
||||
} else {
|
||||
panic!("Unsupported architecture");
|
||||
}
|
||||
|
||||
ts.push("emit-debug-gdb-scripts", false);
|
||||
ts.push("frame-pointer", "may-omit");
|
||||
ts.push(
|
||||
"stack-probes",
|
||||
vec![("kind".to_string(), Value::String("none".to_string()))],
|
||||
);
|
||||
|
||||
// Everything else is LE, whether `CPU_LITTLE_ENDIAN` is declared or not
|
||||
// (e.g. x86). It is also `rustc`'s default.
|
||||
if cfg.has("CPU_BIG_ENDIAN") {
|
||||
ts.push("target-endian", "big");
|
||||
}
|
||||
|
||||
println!("{}", ts);
|
||||
}
|
||||
16
scripts/is_rust_module.sh
Executable file
16
scripts/is_rust_module.sh
Executable file
@@ -0,0 +1,16 @@
|
||||
#!/bin/sh
|
||||
# SPDX-License-Identifier: GPL-2.0
|
||||
#
|
||||
# is_rust_module.sh module.ko
|
||||
#
|
||||
# Returns `0` if `module.ko` is a Rust module, `1` otherwise.
|
||||
|
||||
set -e
|
||||
|
||||
# Using the `16_` prefix ensures other symbols with the same substring
|
||||
# are not picked up (even if it would be unlikely). The last part is
|
||||
# used just in case LLVM decides to use the `.` suffix.
|
||||
#
|
||||
# In the future, checking for the `.comment` section may be another
|
||||
# option, see https://github.com/rust-lang/rust/pull/97550.
|
||||
${NM} "$*" | grep -qE '^[0-9a-fA-F]+ r _R[^[:space:]]+16___IS_RUST_MODULE[^[:space:]]*$'
|
||||
@@ -27,7 +27,23 @@
|
||||
|
||||
#define ARRAY_SIZE(arr) (sizeof(arr) / sizeof(arr[0]))
|
||||
|
||||
#define KSYM_NAME_LEN 128
|
||||
#define _stringify_1(x) #x
|
||||
#define _stringify(x) _stringify_1(x)
|
||||
|
||||
#define KSYM_NAME_LEN 512
|
||||
|
||||
/*
|
||||
* A substantially bigger size than the current maximum.
|
||||
*
|
||||
* It cannot be defined as an expression because it gets stringified
|
||||
* for the fscanf() format string. Therefore, a _Static_assert() is
|
||||
* used instead to maintain the relationship with KSYM_NAME_LEN.
|
||||
*/
|
||||
#define KSYM_NAME_LEN_BUFFER 2048
|
||||
_Static_assert(
|
||||
KSYM_NAME_LEN_BUFFER == KSYM_NAME_LEN * 4,
|
||||
"Please keep KSYM_NAME_LEN_BUFFER in sync with KSYM_NAME_LEN"
|
||||
);
|
||||
|
||||
struct sym_entry {
|
||||
unsigned long long addr;
|
||||
@@ -198,15 +214,15 @@ static void check_symbol_range(const char *sym, unsigned long long addr,
|
||||
|
||||
static struct sym_entry *read_symbol(FILE *in)
|
||||
{
|
||||
char name[500], type;
|
||||
char name[KSYM_NAME_LEN_BUFFER+1], type;
|
||||
unsigned long long addr;
|
||||
unsigned int len;
|
||||
struct sym_entry *sym;
|
||||
int rc;
|
||||
|
||||
rc = fscanf(in, "%llx %c %499s\n", &addr, &type, name);
|
||||
rc = fscanf(in, "%llx %c %" _stringify(KSYM_NAME_LEN_BUFFER) "s\n", &addr, &type, name);
|
||||
if (rc != 3) {
|
||||
if (rc != EOF && fgets(name, 500, in) == NULL)
|
||||
if (rc != EOF && fgets(name, ARRAY_SIZE(name), in) == NULL)
|
||||
fprintf(stderr, "Read error or end of file.\n");
|
||||
return NULL;
|
||||
}
|
||||
@@ -471,12 +487,35 @@ static void write_src(void)
|
||||
if ((i & 0xFF) == 0)
|
||||
markers[i >> 8] = off;
|
||||
|
||||
printf("\t.byte 0x%02x", table[i]->len);
|
||||
/* There cannot be any symbol of length zero. */
|
||||
if (table[i]->len == 0) {
|
||||
fprintf(stderr, "kallsyms failure: "
|
||||
"unexpected zero symbol length\n");
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
/* Only lengths that fit in up-to-two-byte ULEB128 are supported. */
|
||||
if (table[i]->len > 0x3FFF) {
|
||||
fprintf(stderr, "kallsyms failure: "
|
||||
"unexpected huge symbol length\n");
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
/* Encode length with ULEB128. */
|
||||
if (table[i]->len <= 0x7F) {
|
||||
/* Most symbols use a single byte for the length. */
|
||||
printf("\t.byte 0x%02x", table[i]->len);
|
||||
off += table[i]->len + 1;
|
||||
} else {
|
||||
/* "Big" symbols use two bytes. */
|
||||
printf("\t.byte 0x%02x, 0x%02x",
|
||||
(table[i]->len & 0x7F) | 0x80,
|
||||
(table[i]->len >> 7) & 0x7F);
|
||||
off += table[i]->len + 2;
|
||||
}
|
||||
for (k = 0; k < table[i]->len; k++)
|
||||
printf(", 0x%02x", table[i]->sym[k]);
|
||||
printf("\n");
|
||||
|
||||
off += table[i]->len + 1;
|
||||
}
|
||||
printf("\n");
|
||||
|
||||
|
||||
@@ -216,6 +216,13 @@ static const char *conf_get_autoheader_name(void)
|
||||
return name ? name : "include/generated/autoconf.h";
|
||||
}
|
||||
|
||||
static const char *conf_get_rustccfg_name(void)
|
||||
{
|
||||
char *name = getenv("KCONFIG_RUSTCCFG");
|
||||
|
||||
return name ? name : "include/generated/rustc_cfg";
|
||||
}
|
||||
|
||||
static int conf_set_sym_val(struct symbol *sym, int def, int def_flags, char *p)
|
||||
{
|
||||
char *p2;
|
||||
@@ -605,6 +612,9 @@ static const struct comment_style comment_style_c = {
|
||||
|
||||
static void conf_write_heading(FILE *fp, const struct comment_style *cs)
|
||||
{
|
||||
if (!cs)
|
||||
return;
|
||||
|
||||
fprintf(fp, "%s\n", cs->prefix);
|
||||
|
||||
fprintf(fp, "%s Automatically generated file; DO NOT EDIT.\n",
|
||||
@@ -745,6 +755,65 @@ static void print_symbol_for_c(FILE *fp, struct symbol *sym)
|
||||
free(escaped);
|
||||
}
|
||||
|
||||
static void print_symbol_for_rustccfg(FILE *fp, struct symbol *sym)
|
||||
{
|
||||
const char *val;
|
||||
const char *val_prefix = "";
|
||||
char *val_prefixed = NULL;
|
||||
size_t val_prefixed_len;
|
||||
char *escaped = NULL;
|
||||
|
||||
if (sym->type == S_UNKNOWN)
|
||||
return;
|
||||
|
||||
val = sym_get_string_value(sym);
|
||||
|
||||
switch (sym->type) {
|
||||
case S_BOOLEAN:
|
||||
case S_TRISTATE:
|
||||
/*
|
||||
* We do not care about disabled ones, i.e. no need for
|
||||
* what otherwise are "comments" in other printers.
|
||||
*/
|
||||
if (*val == 'n')
|
||||
return;
|
||||
|
||||
/*
|
||||
* To have similar functionality to the C macro `IS_ENABLED()`
|
||||
* we provide an empty `--cfg CONFIG_X` here in both `y`
|
||||
* and `m` cases.
|
||||
*
|
||||
* Then, the common `fprintf()` below will also give us
|
||||
* a `--cfg CONFIG_X="y"` or `--cfg CONFIG_X="m"`, which can
|
||||
* be used as the equivalent of `IS_BUILTIN()`/`IS_MODULE()`.
|
||||
*/
|
||||
fprintf(fp, "--cfg=%s%s\n", CONFIG_, sym->name);
|
||||
break;
|
||||
case S_HEX:
|
||||
if (val[0] != '0' || (val[1] != 'x' && val[1] != 'X'))
|
||||
val_prefix = "0x";
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
if (strlen(val_prefix) > 0) {
|
||||
val_prefixed_len = strlen(val) + strlen(val_prefix) + 1;
|
||||
val_prefixed = xmalloc(val_prefixed_len);
|
||||
snprintf(val_prefixed, val_prefixed_len, "%s%s", val_prefix, val);
|
||||
val = val_prefixed;
|
||||
}
|
||||
|
||||
/* All values get escaped: the `--cfg` option only takes strings */
|
||||
escaped = escape_string_value(val);
|
||||
val = escaped;
|
||||
|
||||
fprintf(fp, "--cfg=%s%s=%s\n", CONFIG_, sym->name, val);
|
||||
|
||||
free(escaped);
|
||||
free(val_prefixed);
|
||||
}
|
||||
|
||||
/*
|
||||
* Write out a minimal config.
|
||||
* All values that has default values are skipped as this is redundant.
|
||||
@@ -1132,6 +1201,12 @@ int conf_write_autoconf(int overwrite)
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
ret = __conf_write_autoconf(conf_get_rustccfg_name(),
|
||||
print_symbol_for_rustccfg,
|
||||
NULL);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
/*
|
||||
* Create include/config/auto.conf. This must be the last step because
|
||||
* Kbuild has a dependency on auto.conf and this marks the successful
|
||||
|
||||
@@ -30,6 +30,12 @@ llvm)
|
||||
echo 11.0.0
|
||||
fi
|
||||
;;
|
||||
rustc)
|
||||
echo 1.62.0
|
||||
;;
|
||||
bindgen)
|
||||
echo 0.56.0
|
||||
;;
|
||||
*)
|
||||
echo "$1: unknown tool" >&2
|
||||
exit 1
|
||||
|
||||
160
scripts/rust_is_available.sh
Executable file
160
scripts/rust_is_available.sh
Executable file
@@ -0,0 +1,160 @@
|
||||
#!/bin/sh
|
||||
# SPDX-License-Identifier: GPL-2.0
|
||||
#
|
||||
# Tests whether a suitable Rust toolchain is available.
|
||||
#
|
||||
# Pass `-v` for human output and more checks (as warnings).
|
||||
|
||||
set -e
|
||||
|
||||
min_tool_version=$(dirname $0)/min-tool-version.sh
|
||||
|
||||
# Convert the version string x.y.z to a canonical up-to-7-digits form.
|
||||
#
|
||||
# Note that this function uses one more digit (compared to other
|
||||
# instances in other version scripts) to give a bit more space to
|
||||
# `rustc` since it will reach 1.100.0 in late 2026.
|
||||
get_canonical_version()
|
||||
{
|
||||
IFS=.
|
||||
set -- $1
|
||||
echo $((100000 * $1 + 100 * $2 + $3))
|
||||
}
|
||||
|
||||
# Check that the Rust compiler exists.
|
||||
if ! command -v "$RUSTC" >/dev/null; then
|
||||
if [ "$1" = -v ]; then
|
||||
echo >&2 "***"
|
||||
echo >&2 "*** Rust compiler '$RUSTC' could not be found."
|
||||
echo >&2 "***"
|
||||
fi
|
||||
exit 1
|
||||
fi
|
||||
|
||||
# Check that the Rust bindings generator exists.
|
||||
if ! command -v "$BINDGEN" >/dev/null; then
|
||||
if [ "$1" = -v ]; then
|
||||
echo >&2 "***"
|
||||
echo >&2 "*** Rust bindings generator '$BINDGEN' could not be found."
|
||||
echo >&2 "***"
|
||||
fi
|
||||
exit 1
|
||||
fi
|
||||
|
||||
# Check that the Rust compiler version is suitable.
|
||||
#
|
||||
# Non-stable and distributions' versions may have a version suffix, e.g. `-dev`.
|
||||
rust_compiler_version=$( \
|
||||
LC_ALL=C "$RUSTC" --version 2>/dev/null \
|
||||
| head -n 1 \
|
||||
| grep -oE '[0-9]+\.[0-9]+\.[0-9]+' \
|
||||
)
|
||||
rust_compiler_min_version=$($min_tool_version rustc)
|
||||
rust_compiler_cversion=$(get_canonical_version $rust_compiler_version)
|
||||
rust_compiler_min_cversion=$(get_canonical_version $rust_compiler_min_version)
|
||||
if [ "$rust_compiler_cversion" -lt "$rust_compiler_min_cversion" ]; then
|
||||
if [ "$1" = -v ]; then
|
||||
echo >&2 "***"
|
||||
echo >&2 "*** Rust compiler '$RUSTC' is too old."
|
||||
echo >&2 "*** Your version: $rust_compiler_version"
|
||||
echo >&2 "*** Minimum version: $rust_compiler_min_version"
|
||||
echo >&2 "***"
|
||||
fi
|
||||
exit 1
|
||||
fi
|
||||
if [ "$1" = -v ] && [ "$rust_compiler_cversion" -gt "$rust_compiler_min_cversion" ]; then
|
||||
echo >&2 "***"
|
||||
echo >&2 "*** Rust compiler '$RUSTC' is too new. This may or may not work."
|
||||
echo >&2 "*** Your version: $rust_compiler_version"
|
||||
echo >&2 "*** Expected version: $rust_compiler_min_version"
|
||||
echo >&2 "***"
|
||||
fi
|
||||
|
||||
# Check that the Rust bindings generator is suitable.
|
||||
#
|
||||
# Non-stable and distributions' versions may have a version suffix, e.g. `-dev`.
|
||||
rust_bindings_generator_version=$( \
|
||||
LC_ALL=C "$BINDGEN" --version 2>/dev/null \
|
||||
| head -n 1 \
|
||||
| grep -oE '[0-9]+\.[0-9]+\.[0-9]+' \
|
||||
)
|
||||
rust_bindings_generator_min_version=$($min_tool_version bindgen)
|
||||
rust_bindings_generator_cversion=$(get_canonical_version $rust_bindings_generator_version)
|
||||
rust_bindings_generator_min_cversion=$(get_canonical_version $rust_bindings_generator_min_version)
|
||||
if [ "$rust_bindings_generator_cversion" -lt "$rust_bindings_generator_min_cversion" ]; then
|
||||
if [ "$1" = -v ]; then
|
||||
echo >&2 "***"
|
||||
echo >&2 "*** Rust bindings generator '$BINDGEN' is too old."
|
||||
echo >&2 "*** Your version: $rust_bindings_generator_version"
|
||||
echo >&2 "*** Minimum version: $rust_bindings_generator_min_version"
|
||||
echo >&2 "***"
|
||||
fi
|
||||
exit 1
|
||||
fi
|
||||
if [ "$1" = -v ] && [ "$rust_bindings_generator_cversion" -gt "$rust_bindings_generator_min_cversion" ]; then
|
||||
echo >&2 "***"
|
||||
echo >&2 "*** Rust bindings generator '$BINDGEN' is too new. This may or may not work."
|
||||
echo >&2 "*** Your version: $rust_bindings_generator_version"
|
||||
echo >&2 "*** Expected version: $rust_bindings_generator_min_version"
|
||||
echo >&2 "***"
|
||||
fi
|
||||
|
||||
# Check that the `libclang` used by the Rust bindings generator is suitable.
|
||||
bindgen_libclang_version=$( \
|
||||
LC_ALL=C "$BINDGEN" $(dirname $0)/rust_is_available_bindgen_libclang.h 2>&1 >/dev/null \
|
||||
| grep -F 'clang version ' \
|
||||
| grep -oE '[0-9]+\.[0-9]+\.[0-9]+' \
|
||||
| head -n 1 \
|
||||
)
|
||||
bindgen_libclang_min_version=$($min_tool_version llvm)
|
||||
bindgen_libclang_cversion=$(get_canonical_version $bindgen_libclang_version)
|
||||
bindgen_libclang_min_cversion=$(get_canonical_version $bindgen_libclang_min_version)
|
||||
if [ "$bindgen_libclang_cversion" -lt "$bindgen_libclang_min_cversion" ]; then
|
||||
if [ "$1" = -v ]; then
|
||||
echo >&2 "***"
|
||||
echo >&2 "*** libclang (used by the Rust bindings generator '$BINDGEN') is too old."
|
||||
echo >&2 "*** Your version: $bindgen_libclang_version"
|
||||
echo >&2 "*** Minimum version: $bindgen_libclang_min_version"
|
||||
echo >&2 "***"
|
||||
fi
|
||||
exit 1
|
||||
fi
|
||||
|
||||
# If the C compiler is Clang, then we can also check whether its version
|
||||
# matches the `libclang` version used by the Rust bindings generator.
|
||||
#
|
||||
# In the future, we might be able to perform a full version check, see
|
||||
# https://github.com/rust-lang/rust-bindgen/issues/2138.
|
||||
if [ "$1" = -v ]; then
|
||||
cc_name=$($(dirname $0)/cc-version.sh "$CC" | cut -f1 -d' ')
|
||||
if [ "$cc_name" = Clang ]; then
|
||||
clang_version=$( \
|
||||
LC_ALL=C "$CC" --version 2>/dev/null \
|
||||
| sed -nE '1s:.*version ([0-9]+\.[0-9]+\.[0-9]+).*:\1:p'
|
||||
)
|
||||
if [ "$clang_version" != "$bindgen_libclang_version" ]; then
|
||||
echo >&2 "***"
|
||||
echo >&2 "*** libclang (used by the Rust bindings generator '$BINDGEN')"
|
||||
echo >&2 "*** version does not match Clang's. This may be a problem."
|
||||
echo >&2 "*** libclang version: $bindgen_libclang_version"
|
||||
echo >&2 "*** Clang version: $clang_version"
|
||||
echo >&2 "***"
|
||||
fi
|
||||
fi
|
||||
fi
|
||||
|
||||
# Check that the source code for the `core` standard library exists.
|
||||
#
|
||||
# `$KRUSTFLAGS` is passed in case the user added `--sysroot`.
|
||||
rustc_sysroot=$("$RUSTC" $KRUSTFLAGS --print sysroot)
|
||||
rustc_src=${RUST_LIB_SRC:-"$rustc_sysroot/lib/rustlib/src/rust/library"}
|
||||
rustc_src_core="$rustc_src/core/src/lib.rs"
|
||||
if [ ! -e "$rustc_src_core" ]; then
|
||||
if [ "$1" = -v ]; then
|
||||
echo >&2 "***"
|
||||
echo >&2 "*** Source code for the 'core' standard library could not be found"
|
||||
echo >&2 "*** at '$rustc_src_core'."
|
||||
echo >&2 "***"
|
||||
fi
|
||||
exit 1
|
||||
fi
|
||||
2
scripts/rust_is_available_bindgen_libclang.h
Normal file
2
scripts/rust_is_available_bindgen_libclang.h
Normal file
@@ -0,0 +1,2 @@
|
||||
/* SPDX-License-Identifier: GPL-2.0 */
|
||||
#pragma message("clang version " __clang_version__)
|
||||
Reference in New Issue
Block a user