mirror of
https://github.com/JakeHillion/scx.git
synced 2024-11-29 20:50:22 +00:00
4a18e9c7f7
In my dev enviroment, bpf_clang_ver is coming as NULL, since I am using upstream Clang. Fails graceful in this case. # /usr/local/bin/clang --version clang version 18.0.0git (https://github.com/llvm/llvm-project.git c458f928fad7bbcf08ab1da9949eb2969fc9f89c) Target: x86_64-unknown-linux-gnu Thread model: posix InstalledDir: /usr/local/bin But the command below returns nothing /home/leit/Devel/scx/meson-scripts/get_clang_ver /usr/local/bin/clang Signed-off-by: Breno Leitao <leitao@debian.org>
300 lines
9.6 KiB
Meson
300 lines
9.6 KiB
Meson
project('sched_ext schedulers', 'c',
|
|
version: '0.1.7',
|
|
license: 'GPL-2.0')
|
|
|
|
if meson.version().version_compare('<1.2')
|
|
error('meson >= 1.2 required')
|
|
endif
|
|
|
|
fs = import('fs')
|
|
|
|
cc = meson.get_compiler('c')
|
|
|
|
enable_rust = get_option('enable_rust')
|
|
|
|
bpf_clang = find_program(get_option('bpf_clang'))
|
|
|
|
if enable_rust
|
|
cargo = find_program(get_option('cargo'))
|
|
endif
|
|
|
|
|
|
get_clang_ver = find_program(join_paths(meson.current_source_dir(),
|
|
'meson-scripts/get_clang_ver'))
|
|
bpftool_build_skel = find_program(join_paths(meson.current_source_dir(),
|
|
'meson-scripts/bpftool_build_skel'))
|
|
get_sys_incls = find_program(join_paths(meson.current_source_dir(),
|
|
'meson-scripts/get_sys_incls'))
|
|
test_sched = find_program(join_paths(meson.current_source_dir(),
|
|
'meson-scripts/test_sched'))
|
|
fetch_libbpf = find_program(join_paths(meson.current_source_dir(),
|
|
'meson-scripts/fetch_libbpf'))
|
|
build_libbpf = find_program(join_paths(meson.current_source_dir(),
|
|
'meson-scripts/build_libbpf'))
|
|
fetch_bpftool = find_program(join_paths(meson.current_source_dir(),
|
|
'meson-scripts/fetch_bpftool'))
|
|
build_bpftool = find_program(join_paths(meson.current_source_dir(),
|
|
'meson-scripts/build_bpftool'))
|
|
if enable_rust
|
|
cargo_fetch = find_program(join_paths(meson.current_source_dir(),
|
|
'meson-scripts/cargo_fetch'))
|
|
endif
|
|
|
|
bpf_clang_ver = run_command(get_clang_ver, bpf_clang, check: true).stdout().strip()
|
|
if bpf_clang_ver == ''
|
|
error('Unable to find clang version')
|
|
endif
|
|
|
|
bpf_clang_maj = bpf_clang_ver.split('.')[0].to_int()
|
|
|
|
if bpf_clang_maj < 16
|
|
error('clang < 16 loses high 32 bits of 64 bit enums when compiling BPF (@0@ ver=@1@)'
|
|
.format(bpf_clang.full_path(), bpf_clang_ver))
|
|
elif bpf_clang_maj < 17
|
|
warning('clang >= 17 recommended (@0@ ver=@1@)'
|
|
.format(bpf_clang.full_path(), bpf_clang_ver))
|
|
endif
|
|
|
|
# These are for building libbpf and/or bpftool
|
|
|
|
if meson.get_compiler('c').get_id() == 'gcc'
|
|
extra_args = ['-Wno-sign-compare']
|
|
else
|
|
extra_args = []
|
|
endif
|
|
|
|
executable('cc_cflags_probe', 'meson-scripts/cc_cflags_probe.c', install: false, pie: true, c_args : extra_args)
|
|
|
|
jq = find_program('jq')
|
|
make = find_program('make')
|
|
nproc = find_program('nproc')
|
|
|
|
make_jobs = 1
|
|
if nproc.found()
|
|
make_jobs = run_command(nproc, check: true).stdout().to_int()
|
|
endif
|
|
|
|
libbpf_path = '@0@/libbpf/src'.format(meson.current_build_dir())
|
|
libbpf_a = '@0@/libbpf.a'.format(libbpf_path)
|
|
should_build_libbpf = true
|
|
libbpf_h = get_option('libbpf_h')
|
|
libbpf_local_h = get_option('libbpf_h')
|
|
|
|
if get_option('libbpf_a') == 'disabled'
|
|
libbpf_a = ''
|
|
should_build_libbpf = false
|
|
elif get_option('libbpf_a') != ''
|
|
libbpf_a = get_option('libbpf_a')
|
|
if not fs.exists(libbpf_a)
|
|
error('@0@ does not exist.'.format(libbpf_a))
|
|
endif
|
|
should_build_libbpf = false
|
|
endif
|
|
|
|
# WARNING! To build libbpf with the same compiler(CC) and CFLAGS
|
|
# as the schedulers we need to do this hack whereby we create a dummy exe
|
|
# then read the compiler and args from meson's compile_commands.json
|
|
# and re-set them when we build libbpf with make
|
|
if should_build_libbpf
|
|
if not jq.found() or not make.found()
|
|
error('To build the libbpf library "make" and "jq" are required')
|
|
endif
|
|
|
|
libbpf_h = ['@0@/usr/include'.format(libbpf_path)]
|
|
libbpf_local_h = ['.@0@/libbpf/src/usr/include'.format(meson.current_build_dir().replace(meson.current_source_dir(), ''))]
|
|
|
|
message('Fetching libbpf repo')
|
|
libbpf_commit = '4f875865b772c4f534bc0a665bbd988193825bd4'
|
|
run_command(fetch_libbpf, meson.current_build_dir(), libbpf_commit, check: true)
|
|
|
|
make_jobs = 1
|
|
if nproc.found()
|
|
make_jobs = run_command(nproc, check: true).stdout().to_int()
|
|
endif
|
|
|
|
libbpf = custom_target('libbpf',
|
|
output: '@PLAINNAME@.__PHONY__',
|
|
input: 'meson-scripts/cc_cflags_probe.c',
|
|
command: [build_libbpf, jq, make, libbpf_path, '@0@'.format(make_jobs)],
|
|
build_by_default: true)
|
|
else
|
|
# this is a noop when we're not building libbpf ourselves
|
|
libbpf = custom_target('libbpf',
|
|
output: '@PLAINNAME@.__PHONY__',
|
|
input: 'meson-scripts/cc_cflags_probe.c',
|
|
command: ['echo'],
|
|
build_by_default: true)
|
|
endif
|
|
|
|
if libbpf_a != ''
|
|
libbpf_dep = [declare_dependency(
|
|
link_args: libbpf_a,
|
|
include_directories: libbpf_local_h),
|
|
cc.find_library('elf'),
|
|
cc.find_library('z'),
|
|
cc.find_library('zstd')]
|
|
else
|
|
libbpf_dep = dependency('libbpf', version: '>=1.2.2')
|
|
if libbpf_dep.version().version_compare('<1.3')
|
|
warning('libbpf <1.3 does not support RESIZE_ARRAY(), expect breakages in schedulers that use them')
|
|
endif
|
|
endif
|
|
|
|
bpftool_path = '@0@/bpftool/src'.format(meson.current_build_dir())
|
|
should_build_bpftool = true
|
|
bpftool_exe_path = '@0@/bpftool'.format(bpftool_path)
|
|
|
|
if get_option('bpftool') == 'disabled'
|
|
bpftool = find_program('bpftool')
|
|
should_build_bpftool = false
|
|
bpftool_exe_path = bpftool.full_path()
|
|
elif get_option('bpftool') != ''
|
|
bpftool = find_program(get_option('bpftool'))
|
|
should_build_bpftool = false
|
|
bpftool_exe_path = bpftool.full_path()
|
|
endif
|
|
|
|
if should_build_bpftool
|
|
message('Fetching bpftool repo')
|
|
bpftool_commit = '8328f373c0ef27fda14f12e67f1d6ed882dd2e81'
|
|
run_command(fetch_bpftool, meson.current_build_dir(), bpftool_commit, check: true)
|
|
|
|
bpftool_target = custom_target('bpftool_target',
|
|
output: '@PLAINNAME@.__PHONY__',
|
|
input: 'meson-scripts/bpftool_dummy.c',
|
|
command: [build_bpftool, jq, make, bpftool_path, '@0@'.format(make_jobs)],
|
|
build_by_default: true)
|
|
else
|
|
# this is a noop when we're not building bpftool ourselves
|
|
bpftool_target = custom_target('bpftool_target',
|
|
output: '@PLAINNAME@.__PHONY__',
|
|
input: 'meson-scripts/bpftool_dummy.c',
|
|
command: ['echo'],
|
|
build_by_default: true)
|
|
endif
|
|
# end libbpf/bpftool stuff
|
|
|
|
#
|
|
# Determine bpf_base_cflags which will be used to compile all .bpf.o files.
|
|
# Note that "-target bpf" is not included to accommodate
|
|
# libbpf_cargo::SkeletonBuilder.
|
|
#
|
|
# Map https://mesonbuild.com/Reference-tables.html#cpu-families to the
|
|
# __TARGET_ARCH list in tools/lib/bpf/bpf_tracing.h in the kernel tree.
|
|
#
|
|
arch_dict = {
|
|
'x86': 'x86',
|
|
'x86_64': 'x86',
|
|
's390x': 's390',
|
|
'arm': 'arm',
|
|
'aarch64': 'arm64',
|
|
'mips': 'mips',
|
|
'mips64': 'mips',
|
|
'ppc': 'powerpc',
|
|
'ppc64': 'powerpc',
|
|
'sparc': 'sparc',
|
|
'sparc64': 'sparc',
|
|
'riscv32': 'riscv',
|
|
'riscv64': 'riscv',
|
|
'arc': 'arc',
|
|
'loongarch64': 'loongarch'
|
|
}
|
|
|
|
cpu = host_machine.cpu_family()
|
|
if cpu not in arch_dict
|
|
error('CPU family "@0@" is not in known arch dict'.format(cpu))
|
|
endif
|
|
|
|
sys_incls = run_command(get_sys_incls, bpf_clang, check: true).stdout().splitlines()
|
|
bpf_base_cflags = ['-g', '-O2', '-Wall', '-Wno-compare-distinct-pointer-types',
|
|
'-D__TARGET_ARCH_' + arch_dict[cpu], '-mcpu=v3',
|
|
'-m@0@-endian'.format(host_machine.endian())] + sys_incls
|
|
|
|
message('cpu=@0@ bpf_base_cflags=@1@'.format(cpu, bpf_base_cflags))
|
|
|
|
libbpf_c_headers = []
|
|
|
|
if libbpf_a != ''
|
|
foreach header: libbpf_h
|
|
libbpf_c_headers += ['-I', header]
|
|
endforeach
|
|
endif
|
|
|
|
#
|
|
# Generators to build BPF skel file for C schedulers.
|
|
#
|
|
gen_bpf_o = generator(bpf_clang,
|
|
output: '@BASENAME@.o',
|
|
depends: [libbpf],
|
|
arguments: [bpf_base_cflags, '-target', 'bpf', libbpf_c_headers, '@EXTRA_ARGS@',
|
|
'-c', '@INPUT@', '-o', '@OUTPUT@'])
|
|
gen_bpf_skel = generator(bpftool_build_skel,
|
|
output: ['@BASENAME@.skel.h','@BASENAME@.subskel.h' ],
|
|
depends: [libbpf, bpftool_target],
|
|
arguments: [bpftool_exe_path, '@INPUT@', '@OUTPUT0@', '@OUTPUT1@'])
|
|
|
|
#
|
|
# For rust sub-projects.
|
|
#
|
|
cargo_build_args = ['--quiet']
|
|
if get_option('buildtype') == 'release'
|
|
cargo_build_args += '--release'
|
|
endif
|
|
|
|
if get_option('offline')
|
|
cargo_build_args += '--offline'
|
|
endif
|
|
|
|
cargo_env = environment()
|
|
cargo_env.set('BPF_CLANG', bpf_clang.full_path())
|
|
|
|
foreach flag: bpf_base_cflags
|
|
cargo_env.append('BPF_BASE_CFLAGS', flag, separator: ' ')
|
|
endforeach
|
|
|
|
if libbpf_a != ''
|
|
foreach header: libbpf_h
|
|
cargo_env.append('BPF_EXTRA_CFLAGS_PRE_INCL', '-I' + header, separator: ' ')
|
|
endforeach
|
|
|
|
cargo_env.append('RUSTFLAGS',
|
|
'-C relocation-model=pic -C link-args=-lelf -C link-args=-lz -C link-args=-lzstd -L '
|
|
+ fs.parent(libbpf_a))
|
|
|
|
#
|
|
# XXX - scx_rusty's original Cargo.toml contained a dependency matching
|
|
# the following. However, it doesn't seem necessary to enable linking to
|
|
# libbpf.a. Ask Dan Schatzberg about the role the dependency line plays.
|
|
#
|
|
#cargo_build_args += ['--config',
|
|
# 'dependencies.libbpf-sys.version="1.2"',
|
|
# '--config',
|
|
# 'dependencies.libbpf-sys.features=["novendor", "static"]']
|
|
endif
|
|
|
|
if get_option('cargo_home') != ''
|
|
cargo_env.set('CARGO_HOME', get_option('cargo_home'))
|
|
endif
|
|
|
|
if enable_rust
|
|
meson.add_install_script('meson-scripts/install_rust_user_scheds')
|
|
run_target('fetch', command: [cargo_fetch, cargo], env: cargo_env)
|
|
endif
|
|
|
|
if get_option('kernel') != ''
|
|
kernel = get_option('kernel')
|
|
endif
|
|
|
|
run_target('test_sched', command: [test_sched, kernel])
|
|
|
|
if enable_rust
|
|
subdir('rust')
|
|
endif
|
|
subdir('scheds')
|
|
|
|
systemd = dependency('systemd', required: get_option('systemd'))
|
|
|
|
if systemd.found()
|
|
subdir('services')
|
|
endif
|