refactor: make linux kbuild tree recipe-only
This commit is contained in:
parent
94811349b0
commit
41f4de40e5
|
|
@ -9,200 +9,87 @@ from conan.tools.build import cross_building
|
|||
from conan.tools.files import copy, get, save
|
||||
|
||||
|
||||
class LinuxKbuildTreeConan(ConanFile):
|
||||
name = "linux-kbuild-tree"
|
||||
package_type = "application"
|
||||
|
||||
settings = "os", "arch", "compiler", "build_type"
|
||||
|
||||
options = {
|
||||
"url": ["ANY"],
|
||||
"defconfig": ["ANY"],
|
||||
"make_modules": [True, False],
|
||||
}
|
||||
|
||||
default_options = {
|
||||
"url": "",
|
||||
"defconfig": "defconfig",
|
||||
"make_modules": False,
|
||||
}
|
||||
|
||||
exports_sources = "configs/*"
|
||||
|
||||
def layout(self):
|
||||
self.folders.build = "build"
|
||||
self.folders.generators = os.path.join(self.folders.build, "generators")
|
||||
|
||||
def package_id(self):
|
||||
c_compiler = self._compiler_executable("c")
|
||||
if c_compiler is not None:
|
||||
self.info.conf.define("tools.build:compiler_executables", {"c": str(c_compiler)})
|
||||
|
||||
def validate(self):
|
||||
if self.settings.os != "Linux":
|
||||
def prepare(conanfile, output=None, defconfig=None, make_modules=None, url=None):
|
||||
if conanfile.settings.os != "Linux":
|
||||
raise ConanInvalidConfiguration("linux-kbuild-tree requires a Linux target")
|
||||
|
||||
if not self.version:
|
||||
raise ConanInvalidConfiguration(
|
||||
"linux-kbuild-tree requires a package version, e.g. "
|
||||
"conan create recipes/linux-kbuild-tree --version=6.5.9"
|
||||
)
|
||||
|
||||
self._kernel_arch
|
||||
|
||||
if cross_building(self) and self._cross_compile is None:
|
||||
pyreq = conanfile.python_requires["linux-kbuild-tree"]
|
||||
version = str(pyreq.ref.version)
|
||||
arch = kernel_arch(conanfile)
|
||||
cross_compile = _cross_compile(conanfile)
|
||||
if cross_compile is None:
|
||||
raise ConanInvalidConfiguration(
|
||||
"Cross-building a kernel tree requires "
|
||||
"tools.build:compiler_executables with a GCC-like C compiler"
|
||||
)
|
||||
|
||||
def source(self):
|
||||
source_url, sha256 = self._linux_source()
|
||||
get(
|
||||
self,
|
||||
source_url,
|
||||
sha256=sha256,
|
||||
destination=os.path.join(self.source_folder, "linux"),
|
||||
strip_root=True,
|
||||
if defconfig is None:
|
||||
defconfig = conanfile.conf.get("user.linux-kbuild-tree:defconfig", default="defconfig")
|
||||
if make_modules is None:
|
||||
make_modules = conanfile.conf.get(
|
||||
"user.linux-kbuild-tree:make_modules",
|
||||
default=False,
|
||||
)
|
||||
make_modules = _as_bool(make_modules)
|
||||
if url is None:
|
||||
url = conanfile.conf.get("user.linux-kbuild-tree:url", default=None)
|
||||
|
||||
def build(self):
|
||||
linux = os.path.join(self.source_folder, "linux")
|
||||
arch = self._kernel_arch
|
||||
cross_compile = self._cross_compile or ""
|
||||
jobs = self.conf.get("tools.build:jobs", default=None)
|
||||
linux = output or os.path.join(conanfile.build_folder, "linux-kbuild-tree")
|
||||
source_url, sha256 = _linux_source(pyreq.path, version, url=url)
|
||||
|
||||
if not os.path.exists(os.path.join(linux, "Makefile")):
|
||||
get(conanfile, source_url, sha256=sha256, destination=linux, strip_root=True)
|
||||
|
||||
jobs = conanfile.conf.get("tools.build:jobs", default=None)
|
||||
make_jobs = f" -j{jobs}" if jobs else ""
|
||||
|
||||
make_base = (
|
||||
f"make --no-print-directory -C {shlex.quote(linux)}{make_jobs} "
|
||||
f"ARCH={shlex.quote(str(arch))} "
|
||||
f"CROSS_COMPILE={shlex.quote(str(cross_compile))} "
|
||||
f"{self._host_warning_flags_args}"
|
||||
f"CROSS_COMPILE={shlex.quote(str(cross_compile or ''))} "
|
||||
f"{_host_warning_flags_args(version)}"
|
||||
)
|
||||
|
||||
self._install_config(linux, make_base)
|
||||
_install_config(conanfile, pyreq.path, linux, make_base, defconfig)
|
||||
conanfile.run(f"{make_base} olddefconfig prepare modules_prepare")
|
||||
|
||||
self.run(f"{make_base} olddefconfig prepare modules_prepare")
|
||||
|
||||
if self.options.make_modules:
|
||||
if make_modules:
|
||||
# Required when CONFIG_MODVERSIONS=y and the target kernel exports
|
||||
# symbols that are not available from a vendor-provided Module.symvers.
|
||||
self.run(f"{make_base} modules")
|
||||
conanfile.run(f"{make_base} modules")
|
||||
|
||||
kernelrelease = self._capture(f"{make_base} kernelrelease")
|
||||
compiler = self._capture(f"{self._cross_gcc} --version").splitlines()[0]
|
||||
source_url, sha256 = self._linux_source()
|
||||
kernelrelease = _capture(f"{make_base} kernelrelease")
|
||||
compiler = _capture(f"{_cross_gcc(cross_compile)} --version").splitlines()[0]
|
||||
info_path = os.path.join(linux, "kbuild-tree-info.txt")
|
||||
|
||||
save(
|
||||
self,
|
||||
os.path.join(self.build_folder, "kbuild-tree-info.txt"),
|
||||
conanfile,
|
||||
info_path,
|
||||
"\n".join(
|
||||
[
|
||||
f"url={source_url}",
|
||||
f"ref={self._linux_ref_from_version()}",
|
||||
f"ref={_linux_ref_from_version(version)}",
|
||||
f"sha256={sha256 or ''}",
|
||||
f"kernelrelease={kernelrelease}",
|
||||
f"arch={arch}",
|
||||
f"cross_compile={cross_compile}",
|
||||
f"cross_compile={cross_compile or ''}",
|
||||
f"compiler={compiler}",
|
||||
f"make_modules={self.options.make_modules}",
|
||||
f"make_modules={make_modules}",
|
||||
"",
|
||||
]
|
||||
),
|
||||
)
|
||||
|
||||
def package(self):
|
||||
linux = os.path.join(self.source_folder, "linux")
|
||||
return {
|
||||
"path": linux,
|
||||
"info_path": info_path,
|
||||
"kernelrelease": kernelrelease,
|
||||
"arch": arch,
|
||||
"cross_compile": cross_compile or "",
|
||||
}
|
||||
|
||||
# External module builds need source files, generated headers, scripts,
|
||||
# .config, and often Module.symvers. Packaging the whole prepared tree is
|
||||
# intentionally conservative and can be optimized after the flow is stable.
|
||||
copy(self, "*", src=linux, dst=self.package_folder, excludes=(".git", ".git/*"))
|
||||
copy(self, ".config", src=linux, dst=self.package_folder, keep_path=False)
|
||||
copy(
|
||||
self,
|
||||
"kbuild-tree-info.txt",
|
||||
src=self.build_folder,
|
||||
dst=self.package_folder,
|
||||
keep_path=False,
|
||||
)
|
||||
|
||||
def _linux_ref_from_version(self):
|
||||
# Upstream Linux tags base releases as v6.8, while the kernel release
|
||||
# and Conan package version are commonly represented as 6.8.0.
|
||||
version_parts = str(self.version).split(".")
|
||||
if len(version_parts) == 3 and version_parts[2] == "0":
|
||||
return f"v{version_parts[0]}.{version_parts[1]}"
|
||||
return f"v{self.version}"
|
||||
|
||||
def _linux_archive_version(self):
|
||||
version_parts = str(self.version).split(".")
|
||||
if len(version_parts) == 3 and version_parts[2] == "0":
|
||||
return f"{version_parts[0]}.{version_parts[1]}"
|
||||
return str(self.version)
|
||||
|
||||
def _linux_source(self):
|
||||
source = self.conan_data.get("sources", {}).get(str(self.version)) or {}
|
||||
source_url = source.get("url") or self._kernel_cdn_url()
|
||||
return source_url, source.get("sha256")
|
||||
|
||||
def _kernel_cdn_url(self):
|
||||
archive_version = self._linux_archive_version()
|
||||
major = archive_version.split(".", 1)[0]
|
||||
return (
|
||||
f"https://cdn.kernel.org/pub/linux/kernel/v{major}.x/"
|
||||
f"linux-{archive_version}.tar.gz"
|
||||
)
|
||||
|
||||
@property
|
||||
def _host_warning_flags_args(self):
|
||||
hostcflags = []
|
||||
|
||||
if self._version_lt("5.16.0") and self._host_compiler_accepts(
|
||||
"-Wno-error=use-after-free"
|
||||
):
|
||||
# Older objtool builds use -Werror and trip GCC 14's realloc(ptr)
|
||||
# use-after-free diagnostic in tools/lib/subcmd/subcmd-util.h.
|
||||
hostcflags.append("-Wno-error=use-after-free")
|
||||
|
||||
if not hostcflags:
|
||||
return ""
|
||||
|
||||
flags = shlex.quote(" ".join(hostcflags))
|
||||
return f"HOSTCFLAGS={flags} EXTRA_CFLAGS={flags}"
|
||||
|
||||
def _host_compiler_accepts(self, flag):
|
||||
try:
|
||||
subprocess.run(
|
||||
[
|
||||
"gcc",
|
||||
flag,
|
||||
"-x",
|
||||
"c",
|
||||
"-c",
|
||||
"-o",
|
||||
os.devnull,
|
||||
"-",
|
||||
],
|
||||
input="int main(void) { return 0; }\n",
|
||||
text=True,
|
||||
stdout=subprocess.DEVNULL,
|
||||
stderr=subprocess.DEVNULL,
|
||||
check=True,
|
||||
)
|
||||
except (OSError, subprocess.CalledProcessError):
|
||||
return False
|
||||
return True
|
||||
|
||||
def _version_lt(self, other):
|
||||
return self._version_tuple(str(self.version)) < self._version_tuple(other)
|
||||
|
||||
def _version_tuple(self, version):
|
||||
return tuple(int(part) for part in version.split("."))
|
||||
|
||||
@property
|
||||
def _kernel_arch(self):
|
||||
arch = str(self.settings.arch)
|
||||
def kernel_arch(conanfile):
|
||||
arch = str(conanfile.settings.arch)
|
||||
arch_map = {
|
||||
"x86": "x86",
|
||||
"x86_64": "x86",
|
||||
|
|
@ -238,57 +125,169 @@ class LinuxKbuildTreeConan(ConanFile):
|
|||
)
|
||||
return arch_map[arch]
|
||||
|
||||
@property
|
||||
def _cross_compile(self):
|
||||
if not cross_building(self):
|
||||
|
||||
def _linux_ref_from_version(version):
|
||||
# Upstream Linux tags base releases as v6.8, while the kernel release
|
||||
# and Conan package version are commonly represented as 6.8.0.
|
||||
version_parts = str(version).split(".")
|
||||
if len(version_parts) == 3 and version_parts[2] == "0":
|
||||
return f"v{version_parts[0]}.{version_parts[1]}"
|
||||
return f"v{version}"
|
||||
|
||||
|
||||
def _linux_archive_version(version):
|
||||
version_parts = str(version).split(".")
|
||||
if len(version_parts) == 3 and version_parts[2] == "0":
|
||||
return f"{version_parts[0]}.{version_parts[1]}"
|
||||
return str(version)
|
||||
|
||||
|
||||
def _linux_source(recipe_path, version, url=None):
|
||||
source = _conandata_sources(recipe_path).get(str(version), {})
|
||||
source_url = url or source.get("url") or _kernel_cdn_url(version)
|
||||
return source_url, source.get("sha256")
|
||||
|
||||
|
||||
def _kernel_cdn_url(version):
|
||||
archive_version = _linux_archive_version(version)
|
||||
major = archive_version.split(".", 1)[0]
|
||||
return (
|
||||
f"https://cdn.kernel.org/pub/linux/kernel/v{major}.x/"
|
||||
f"linux-{archive_version}.tar.gz"
|
||||
)
|
||||
|
||||
|
||||
def _conandata_sources(recipe_path):
|
||||
path = os.path.join(recipe_path, "conandata.yml")
|
||||
if not os.path.isfile(path):
|
||||
return {}
|
||||
|
||||
sources = {}
|
||||
current = None
|
||||
in_sources = False
|
||||
with open(path, encoding="utf-8") as conandata:
|
||||
for raw_line in conandata:
|
||||
line = raw_line.rstrip()
|
||||
stripped = line.strip()
|
||||
if not stripped or stripped.startswith("#"):
|
||||
continue
|
||||
if stripped == "sources:":
|
||||
in_sources = True
|
||||
continue
|
||||
if not in_sources:
|
||||
continue
|
||||
if not line.startswith(" "):
|
||||
break
|
||||
version_match = re.match(r'^\s{2}"?([^":]+)"?:\s*$', line)
|
||||
if version_match:
|
||||
current = version_match.group(1)
|
||||
sources[current] = {}
|
||||
continue
|
||||
field_match = re.match(r'^\s{4}([A-Za-z0-9_-]+):\s*"?([^"]*)"?\s*$', line)
|
||||
if current and field_match:
|
||||
key, value = field_match.groups()
|
||||
sources[current][key] = value
|
||||
return sources
|
||||
|
||||
|
||||
def _host_warning_flags_args(version):
|
||||
hostcflags = []
|
||||
|
||||
if _version_lt(version, "5.16.0") and _host_compiler_accepts("-Wno-error=use-after-free"):
|
||||
# Older objtool builds use -Werror and trip GCC 14's realloc(ptr)
|
||||
# use-after-free diagnostic in tools/lib/subcmd/subcmd-util.h.
|
||||
hostcflags.append("-Wno-error=use-after-free")
|
||||
|
||||
if not hostcflags:
|
||||
return ""
|
||||
|
||||
c_compiler = self._compiler_executable("c")
|
||||
flags = shlex.quote(" ".join(hostcflags))
|
||||
return f"HOSTCFLAGS={flags} EXTRA_CFLAGS={flags}"
|
||||
|
||||
|
||||
def _as_bool(value):
|
||||
if isinstance(value, str):
|
||||
return value.lower() in ("1", "true", "yes", "on")
|
||||
return bool(value)
|
||||
|
||||
|
||||
def _host_compiler_accepts(flag):
|
||||
try:
|
||||
subprocess.run(
|
||||
[
|
||||
"gcc",
|
||||
flag,
|
||||
"-x",
|
||||
"c",
|
||||
"-c",
|
||||
"-o",
|
||||
os.devnull,
|
||||
"-",
|
||||
],
|
||||
input="int main(void) { return 0; }\n",
|
||||
text=True,
|
||||
stdout=subprocess.DEVNULL,
|
||||
stderr=subprocess.DEVNULL,
|
||||
check=True,
|
||||
)
|
||||
except (OSError, subprocess.CalledProcessError):
|
||||
return False
|
||||
return True
|
||||
|
||||
|
||||
def _version_lt(version, other):
|
||||
return _version_tuple(str(version)) < _version_tuple(other)
|
||||
|
||||
|
||||
def _version_tuple(version):
|
||||
return tuple(int(part) for part in version.split("."))
|
||||
|
||||
|
||||
def _cross_compile(conanfile):
|
||||
if not cross_building(conanfile):
|
||||
return ""
|
||||
|
||||
c_compiler = _compiler_executable(conanfile, "c")
|
||||
if not c_compiler:
|
||||
return None
|
||||
|
||||
return self._cross_compile_from_executable(c_compiler)
|
||||
return _cross_compile_from_executable(c_compiler)
|
||||
|
||||
def _cross_compile_from_compiler_executables(self):
|
||||
c_compiler = self._compiler_executable("c")
|
||||
if not c_compiler:
|
||||
return None
|
||||
return self._cross_compile_from_executable(c_compiler)
|
||||
|
||||
def _cross_compile_from_executable(self, c_compiler):
|
||||
def _cross_compile_from_executable(c_compiler):
|
||||
executable = os.path.basename(c_compiler)
|
||||
match = re.match(r"^(.+?)(?:gcc|cc)(?:-\d+(?:\.\d+)*)?$", executable)
|
||||
if not match:
|
||||
return None
|
||||
return match.group(1)
|
||||
|
||||
@property
|
||||
def _cross_gcc(self):
|
||||
cross_compile = self._cross_compile or ""
|
||||
return shlex.quote(f"{cross_compile}gcc")
|
||||
|
||||
def _compiler_executable(self, language):
|
||||
executables = self.conf.get("tools.build:compiler_executables", default={})
|
||||
def _cross_gcc(cross_compile):
|
||||
return shlex.quote(f"{cross_compile or ''}gcc")
|
||||
|
||||
|
||||
def _compiler_executable(conanfile, language):
|
||||
executables = conanfile.conf.get("tools.build:compiler_executables", default={})
|
||||
if not executables:
|
||||
return None
|
||||
if hasattr(executables, "get"):
|
||||
return executables.get(language)
|
||||
return None
|
||||
|
||||
def _install_config(self, linux, make_base):
|
||||
defconfig = str(self.options.defconfig)
|
||||
|
||||
def _install_config(conanfile, recipe_path, linux, make_base, defconfig):
|
||||
defconfig = "" if defconfig is None else str(defconfig)
|
||||
if not defconfig:
|
||||
if not os.path.exists(os.path.join(linux, ".config")):
|
||||
raise ConanInvalidConfiguration(
|
||||
"Missing kernel config: set linux-kbuild-tree/*:defconfig "
|
||||
"or provide a source tree with .config"
|
||||
"Missing kernel config: pass defconfig or provide a source tree with .config"
|
||||
)
|
||||
return
|
||||
|
||||
exported_config = os.path.join(self.source_folder, "configs", defconfig)
|
||||
exported_config = os.path.join(recipe_path, "configs", defconfig)
|
||||
if os.path.isfile(exported_config):
|
||||
copy(
|
||||
self,
|
||||
conanfile,
|
||||
defconfig,
|
||||
src=os.path.dirname(exported_config),
|
||||
dst=linux,
|
||||
|
|
@ -297,9 +296,10 @@ class LinuxKbuildTreeConan(ConanFile):
|
|||
os.replace(os.path.join(linux, defconfig), os.path.join(linux, ".config"))
|
||||
return
|
||||
|
||||
self.run(f"{make_base} {shlex.quote(defconfig)}")
|
||||
conanfile.run(f"{make_base} {shlex.quote(defconfig)}")
|
||||
|
||||
def _capture(self, command):
|
||||
|
||||
def _capture(command):
|
||||
output = subprocess.check_output(
|
||||
command,
|
||||
shell=True,
|
||||
|
|
@ -309,3 +309,11 @@ class LinuxKbuildTreeConan(ConanFile):
|
|||
if not output:
|
||||
raise ConanInvalidConfiguration(f"Command produced no output: {command}")
|
||||
return output
|
||||
|
||||
|
||||
class LinuxKbuildTreeConan(ConanFile):
|
||||
name = "linux-kbuild-tree"
|
||||
package_type = "python-require"
|
||||
upload_policy = "skip"
|
||||
|
||||
exports = "configs/*"
|
||||
|
|
|
|||
|
|
@ -8,23 +8,26 @@ from conan.tools.files import copy
|
|||
|
||||
class TestPackageConan(ConanFile):
|
||||
test_type = "explicit"
|
||||
python_requires = "tested_reference_str"
|
||||
|
||||
settings = "os", "compiler", "build_type", "arch"
|
||||
exports_sources = "Makefile", "test_kbuild_module.c"
|
||||
|
||||
def requirements(self):
|
||||
self.requires(self.tested_reference_str)
|
||||
|
||||
def layout(self):
|
||||
self.folders.build = "build"
|
||||
self.folders.generators = os.path.join(self.folders.build, "generators")
|
||||
|
||||
def build(self):
|
||||
kernel_tree = self.dependencies["linux-kbuild-tree"].package_folder
|
||||
linux_kbuild_tree = self.python_requires["linux-kbuild-tree"].module
|
||||
tree_info = linux_kbuild_tree.prepare(
|
||||
self,
|
||||
output=os.path.join(self.build_folder, "linux-kbuild-tree"),
|
||||
)
|
||||
|
||||
kernel_tree = tree_info["path"]
|
||||
module_dir = os.path.join(self.build_folder, "module")
|
||||
copy(self, "*", src=self.source_folder, dst=module_dir)
|
||||
|
||||
tree_info = self._read_tree_info(kernel_tree)
|
||||
arch = tree_info.get("arch", "")
|
||||
cross_compile = tree_info.get("cross_compile", "")
|
||||
jobs = self.conf.get("tools.build:jobs", default=None)
|
||||
|
|
@ -44,18 +47,3 @@ class TestPackageConan(ConanFile):
|
|||
module_path = os.path.join(self.build_folder, "module", "test_kbuild_module.ko")
|
||||
if not os.path.isfile(module_path):
|
||||
raise ConanException(f"Kernel module was not built: {module_path}")
|
||||
|
||||
def _read_tree_info(self, kernel_tree):
|
||||
path = os.path.join(kernel_tree, "kbuild-tree-info.txt")
|
||||
if not os.path.isfile(path):
|
||||
raise ConanException(f"Missing linux-kbuild-tree metadata: {path}")
|
||||
|
||||
result = {}
|
||||
with open(path, encoding="utf-8") as tree_info:
|
||||
for line in tree_info:
|
||||
line = line.strip()
|
||||
if not line or "=" not in line:
|
||||
continue
|
||||
key, value = line.split("=", 1)
|
||||
result[key] = value
|
||||
return result
|
||||
|
|
|
|||
Loading…
Reference in New Issue