kbuild: Use tuxmake native fragment support with --kconfig-add

Switch to tuxmake's native --kconfig-add parameter for applying
configuration fragments instead of manually merging them.

Add --output-dir to specify where tuxmake places build artifacts.
Build the dtbs target for architectures that support it. Handle
multiple defconfigs by passing the first to --kconfig and the rest
as --kconfig-add. Handle ChromeOS defconfig by pre-creating the
.config file.

Reviewed-by: Ben Copeland <ben.copeland@linaro.org>
Signed-off-by: Anders Roxell <anders.roxell@linaro.org>

Author: roxell

kernelci/kbuild.py

@@ -593,10 +593,17 @@ def _parse_fragments(self, firmware=False):
                 # Use fragment configs passed from scheduler
                 content = self.add_fragment(fragment)
 
+            if not content:
+                print(f"[_parse_fragments] WARNING: Fragment {fragment} has no content")
+                continue
+
             fragfile = os.path.join(self._fragments_dir, f"{idx}.config")
             with open(fragfile, 'w') as f:
                 f.write(content)
 
+            config_count = len([line for line in content.split('\n') if line.strip()])
+            print(f"[_parse_fragments] Created {fragfile} ({config_count} configs)")
+
             fragment_files.append(fragfile)
 
             # add fragment to artifacts but relative to artifacts dir
@@ -610,12 +617,14 @@ def _parse_fragments(self, firmware=False):
             with open(fragfile, 'w') as f:
                 f.write(content)
 
-            fragment_files.append(fragfile)
-
-            # add fragment to artifacts but relative to artifacts dir
-            frag_rel = os.path.relpath(fragfile, self._af_dir)
-            self._artifacts.append(frag_rel)
+            if os.path.exists(fragfile):
+                fragment_files.append(fragfile)
+                frag_rel = os.path.relpath(fragfile, self._af_dir)
+                self._artifacts.append(frag_rel)
+            else:
+                print("[_parse_fragments] ERROR: Failed to create firmware fragment")
 
+        print(f"[_parse_fragments] Created {len(fragment_files)} fragment files")
         return fragment_files
 
     def _merge_frags(self, fragment_files):
@@ -727,18 +736,78 @@ def _build_with_make(self):
             self._build_dtbs_check()
 
     def _build_with_tuxmake(self):
-        """ Build kernel using tuxmake """
+        """ Build kernel using tuxmake with native fragment support """
+        print("[_build_with_tuxmake] Starting tuxmake build")
+
+        if not hasattr(self, '_fragment_files'):
+            print("[_build_with_tuxmake] ERROR: No fragment files available")
+            self._fragment_files = []
+
+        print(f"[_build_with_tuxmake] Using {len(self._fragment_files)} fragment files")
+
+        # Handle defconfigs - first goes to --kconfig, rest to --kconfig-add
+        extra_defconfigs = []
+        if isinstance(self._defconfig, list):
+            defconfig = self._defconfig[0]
+            extra_defconfigs = self._defconfig[1:]
+            self._config_full = '+'.join(self._defconfig) + self._config_full
+        elif isinstance(self._defconfig, str):
+            defconfig = self._defconfig
+            self._config_full = self._defconfig + self._config_full
+        else:
+            defconfig = 'defconfig'
+            print("[_build_with_tuxmake] WARNING: No defconfig specified, using 'defconfig'")
+
+        # Fetch firmware for builds that need it
+        self._fetch_firmware()
+
         self.startjob("build_tuxmake")
         self.addcmd("cd " + self._srcdir)
 
-        tuxmake_cmd = (
-            f"tuxmake --runtime=null "
-            f"--target-arch={self._arch} "
-            f"--toolchain={self._compiler} "
-            f"kernel modules"
-        )
+        use_kconfig_flag = True
 
-        print(f"Building with tuxmake: {tuxmake_cmd}")
+        # Handle ChromeOS defconfig
+        if defconfig.startswith('cros://'):
+            print(f"[_build_with_tuxmake] Handling ChromeOS defconfig: {defconfig}")
+            dotconfig = os.path.join(self._srcdir, ".config")
+            content, defconfig_name = self._getcrosfragment(defconfig)
+            with open(dotconfig, 'w') as f:
+                f.write(content)
+            self.addcmd("make olddefconfig")
+            use_kconfig_flag = False
+
+        cmd_parts = [
+            "tuxmake --runtime=null",
+            f"--target-arch={self._arch}",
+            f"--toolchain={self._compiler}",
+            f"--output-dir={self._af_dir}",
+        ]
+
+        if use_kconfig_flag:
+            cmd_parts.append(f"--kconfig={defconfig}")
+            for extra in extra_defconfigs:
+                cmd_parts.append(f"--kconfig-add={extra}")
+                print(f"[_build_with_tuxmake] Adding extra defconfig: {extra}")
+
+        for fragfile in self._fragment_files:
+            if os.path.exists(fragfile):
+                cmd_parts.append(f"--kconfig-add={fragfile}")
+                print(f"[_build_with_tuxmake] Adding fragment: {os.path.basename(fragfile)}")
+            else:
+                print(f"[_build_with_tuxmake] WARNING: Fragment file not found: {fragfile}")
+
+        # Build targets: kernel modules, plus dtbs if arch supports it
+        targets = ["kernel", "modules"]
+        if self._arch not in DTBS_DISABLED:
+            targets.append("dtbs")
+            if self._kfselftest:
+                targets.append("kselftest")
+        cmd_parts.append(" ".join(targets))
+        print(f"[_build_with_tuxmake] Building targets: {' '.join(targets)}")
+
+        tuxmake_cmd = " ".join(cmd_parts)
+        print(f"[_build_with_tuxmake] Command: {tuxmake_cmd}")
+        print(f"[_build_with_tuxmake] Output directory: {self._af_dir}")
         self.addcmd(tuxmake_cmd)
 
         # tuxmake outputs 'config' (no dot), rename to '.config' for consistency
@@ -996,9 +1065,19 @@ def upload_artifacts(self):
 
         # Prepare all artifacts for upload
         upload_tasks = []
-        for artifact in self._artifacts:
-            artifact_path = os.path.join(self._af_dir, artifact)
-            upload_tasks.append((artifact, artifact_path))
+        if self._backend == 'tuxmake':
+            # For TuxMake, upload everything in artifacts directory
+            print("[_upload_artifacts] TuxMake backend: discovering files in artifacts dir")
+            for root, dirs, files in os.walk(self._af_dir):
+                for file in files:
+                    file_rel = os.path.relpath(os.path.join(root, file), self._af_dir)
+                    artifact_path = os.path.join(self._af_dir, file_rel)
+                    upload_tasks.append((file_rel, artifact_path))
+        else:
+            # For make backend, upload only listed artifacts
+            for artifact in self._artifacts:
+                artifact_path = os.path.join(self._af_dir, artifact)
+                upload_tasks.append((artifact, artifact_path))
 
         # Function to handle a single artifact upload
         # args: (artifact, artifact_path)