bootloader: Add bootc loader-entries set-options-for-source support

On bootc systems with transient /etc, the state file
/etc/tuned/bootcmdline is lost after each reboot. This causes
TuneD to lose track of which kernel arguments it previously
set, leading to kargs stacking up on every reboot cycle.

bootc loader-entries set-options-for-source solves this by
recording kargs ownership directly in the BLS config on /boot,
which persists across reboots regardless of /etc transience.
With --source tuned, bootc automatically removes all previous
kargs from the "tuned" source and replaces them with the new
set, eliminating the need for TuneD to maintain its own state
for diffing.

This commit adds bootc source tracking to the bootloader plugin:

1. Detect set-options-for-source availability by checking
   "bootc loader-entries set-options-for-source --help" exit
   code during plugin init.

2. When available, use "bootc loader-entries
   set-options-for-source --source tuned --options ..." for
   applying kargs and the same command without --options for
   clearing all TuneD-owned kargs on profile removal.

3. The bootc path is a top-level dispatch branch, checked
   before rpm-ostree. Fallback chain: bootc -> rpm-ostree
   legacy --delete/--append -> GRUB2. All existing code paths
   are unchanged.

4. Continue writing to /etc/tuned/bootcmdline as best-effort
   for diagnostics and backward compatibility, but do not
   depend on it for correctness when bootc source tracking
   is available.

5. Add 15 unit tests for the bootloader plugin covering:
   bootc detection (3), apply (3), removal (2), init flag
   derivation (2), and top-level dispatch (5).

Requires: bootc with loader-entries set-options-for-source
          (bootc PR #2114) and ostree >= 2026.1
See: bootc-dev/bootc#899
See: bootc-dev/bootc#2114

Assisted-by: OpenCode (Claude Opus 4.6)

Author: jmarrero

tests/unit/plugins/test_bootloader.py

@@ -0,0 +1,277 @@
+import unittest
+
+try:
+	from unittest.mock import Mock, patch, call
+except ImportError:
+	from mock import Mock, patch, call
+
+import tuned.consts as consts
+
+
+class BootloaderPluginBootcTestCase(unittest.TestCase):
+	"""Tests for the bootc loader-entries set-options-for-source integration
+	in the bootloader plugin.
+
+	These tests exercise the bootc detection, source-based kargs apply,
+	source-based kargs removal, and the dispatch logic that falls back to
+	the rpm-ostree or GRUB2 code paths when bootc is not available.
+
+	The BootloaderPlugin constructor requires /etc/grub.d/00_tuned to exist,
+	so we test the methods directly on a minimal mock rather than
+	instantiating the full plugin.
+	"""
+
+	def _make_plugin_mock(self, bootc_has_source=True):
+		"""Create a mock that has the real methods under test patched onto it.
+
+		This avoids instantiating BootloaderPlugin (which requires GRUB2
+		template files on disk) while still testing the actual method logic.
+
+		Args:
+			bootc_has_source: Whether bootc set-options-for-source is available
+		"""
+		from tuned.plugins.plugin_bootloader import BootloaderPlugin
+
+		mock_plugin = Mock(spec=BootloaderPlugin)
+		mock_plugin._bootc_has_source = bootc_has_source
+		mock_plugin._cmdline_val = ""
+		mock_plugin._cmd = Mock()
+		mock_plugin._cmd.add_modify_option_in_file = Mock(return_value=True)
+
+		# Bind real methods to the mock so we test actual logic
+		mock_plugin._bootc_has_set_options_for_source = \
+			lambda: BootloaderPlugin._bootc_has_set_options_for_source(mock_plugin)
+		mock_plugin._bootc_source_update = \
+			lambda: BootloaderPlugin._bootc_source_update(mock_plugin)
+		mock_plugin._remove_bootc_source_tuning = \
+			lambda: BootloaderPlugin._remove_bootc_source_tuning(mock_plugin)
+		mock_plugin._patch_bootcmdline = \
+			lambda d: BootloaderPlugin._patch_bootcmdline(mock_plugin, d)
+
+		return mock_plugin
+
+	# ------------------------------------------------------------------
+	# _bootc_has_set_options_for_source() detection
+	# ------------------------------------------------------------------
+
+	def test_bootc_has_source_present(self):
+		"""bootc set-options-for-source is detected when --help succeeds."""
+		plugin = self._make_plugin_mock()
+		plugin._cmd.execute = Mock(return_value=(0, "Usage: bootc loader-entries...", ""))
+		self.assertTrue(plugin._bootc_has_set_options_for_source())
+		plugin._cmd.execute.assert_called_once_with(
+			['bootc', 'loader-entries', 'set-options-for-source', '--help'],
+			return_err=True)
+
+	def test_bootc_has_source_absent(self):
+		"""bootc set-options-for-source is not detected when --help fails."""
+		plugin = self._make_plugin_mock()
+		plugin._cmd.execute = Mock(return_value=(1, "", "error: unrecognized subcommand"))
+		self.assertFalse(plugin._bootc_has_set_options_for_source())
+
+	def test_bootc_has_source_not_installed(self):
+		"""bootc set-options-for-source is not detected when bootc is not installed."""
+		plugin = self._make_plugin_mock()
+		plugin._cmd.execute = Mock(return_value=(127, "", "command not found"))
+		self.assertFalse(plugin._bootc_has_set_options_for_source())
+
+	# ------------------------------------------------------------------
+	# _bootc_source_update()
+	# ------------------------------------------------------------------
+
+	def test_bootc_source_update_basic(self):
+		"""bootc set-options-for-source is called with correct --options."""
+		plugin = self._make_plugin_mock()
+		plugin._cmdline_val = "nohz=full isolcpus=1-3"
+		plugin._cmd.execute = Mock(return_value=(0, "", ""))
+
+		plugin._bootc_source_update()
+
+		plugin._cmd.execute.assert_called_once_with(
+			["bootc", "loader-entries", "set-options-for-source",
+			 "--source", "tuned", "--options", "nohz=full isolcpus=1-3"],
+			return_err=True)
+		# Verify bootcmdline state file is updated
+		plugin._cmd.add_modify_option_in_file.assert_called_once_with(
+			consts.BOOT_CMDLINE_FILE,
+			{consts.BOOT_CMDLINE_TUNED_VAR: "nohz=full isolcpus=1-3"})
+
+	def test_bootc_source_update_empty_cmdline(self):
+		"""When cmdline is empty, --options is not passed (clears kargs)."""
+		plugin = self._make_plugin_mock()
+		plugin._cmdline_val = ""
+		plugin._cmd.execute = Mock(return_value=(0, "", ""))
+
+		plugin._bootc_source_update()
+
+		plugin._cmd.execute.assert_called_once_with(
+			["bootc", "loader-entries", "set-options-for-source",
+			 "--source", "tuned"],
+			return_err=True)
+		plugin._cmd.add_modify_option_in_file.assert_called_once_with(
+			consts.BOOT_CMDLINE_FILE,
+			{consts.BOOT_CMDLINE_TUNED_VAR: ""})
+
+	def test_bootc_source_update_command_fails(self):
+		"""When bootc fails, bootcmdline is not updated."""
+		plugin = self._make_plugin_mock()
+		plugin._cmdline_val = "nohz=full"
+		plugin._cmd.execute = Mock(return_value=(1, "", "error: ostree too old"))
+
+		plugin._bootc_source_update()
+
+		plugin._cmd.execute.assert_called_once()
+		plugin._cmd.add_modify_option_in_file.assert_not_called()
+
+	# ------------------------------------------------------------------
+	# _remove_bootc_source_tuning()
+	# ------------------------------------------------------------------
+
+	def test_remove_bootc_source_tuning(self):
+		"""Removal calls set-options-for-source with no --options (clears all)."""
+		plugin = self._make_plugin_mock()
+		plugin._cmd.execute = Mock(return_value=(0, "", ""))
+
+		plugin._remove_bootc_source_tuning()
+
+		plugin._cmd.execute.assert_called_once_with(
+			["bootc", "loader-entries", "set-options-for-source",
+			 "--source", "tuned"],
+			return_err=True)
+		plugin._cmd.add_modify_option_in_file.assert_called_once_with(
+			consts.BOOT_CMDLINE_FILE,
+			{consts.BOOT_CMDLINE_TUNED_VAR: ""})
+
+	def test_remove_bootc_source_tuning_command_fails(self):
+		"""When bootc removal fails, bootcmdline is still cleared."""
+		plugin = self._make_plugin_mock()
+		plugin._cmd.execute = Mock(return_value=(1, "", "error"))
+
+		plugin._remove_bootc_source_tuning()
+
+		plugin._cmd.add_modify_option_in_file.assert_called_once_with(
+			consts.BOOT_CMDLINE_FILE,
+			{consts.BOOT_CMDLINE_TUNED_VAR: ""})
+
+	# ------------------------------------------------------------------
+	# Init flag derivation logic
+	# ------------------------------------------------------------------
+
+	def test_init_bootc_available(self):
+		"""When bootc is available, _bootc_has_source is True."""
+		plugin = Mock()
+		plugin._cmd = Mock()
+		plugin._bootc_has_set_options_for_source = Mock(return_value=True)
+		plugin._rpm_ostree_status = Mock(return_value="idle")
+
+		plugin._rpm_ostree = plugin._rpm_ostree_status() is not None
+		plugin._bootc_has_source = plugin._bootc_has_set_options_for_source()
+
+		self.assertTrue(plugin._bootc_has_source)
+
+	def test_init_no_bootc_no_rpm_ostree(self):
+		"""When neither bootc nor rpm-ostree is available, both flags are False."""
+		plugin = Mock()
+		plugin._cmd = Mock()
+		plugin._bootc_has_set_options_for_source = Mock(return_value=False)
+		plugin._rpm_ostree_status = Mock(return_value=None)
+
+		plugin._rpm_ostree = plugin._rpm_ostree_status() is not None
+		plugin._bootc_has_source = plugin._bootc_has_set_options_for_source()
+
+		self.assertFalse(plugin._bootc_has_source)
+		self.assertFalse(plugin._rpm_ostree)
+
+	# ------------------------------------------------------------------
+	# Top-level dispatch
+	# ------------------------------------------------------------------
+
+	def test_dispatch_bootc_independent_of_rpm_ostree(self):
+		"""bootc path works even when _rpm_ostree is False (bootc-only system)."""
+		plugin = self._make_plugin_mock(bootc_has_source=True)
+		plugin._rpm_ostree = False
+		plugin._cmdline_val = "nohz=full"
+		plugin._cmd.execute = Mock(return_value=(0, "", ""))
+
+		# Simulate _instance_post_static dispatch
+		if plugin._bootc_has_source:
+			plugin._bootc_source_update()
+		elif plugin._rpm_ostree:
+			pass  # would call _rpm_ostree_update
+
+		plugin._cmd.execute.assert_called_once_with(
+			["bootc", "loader-entries", "set-options-for-source",
+			 "--source", "tuned", "--options", "nohz=full"],
+			return_err=True)
+
+	def test_dispatch_falls_through_to_rpm_ostree(self):
+		"""When bootc is not available, dispatch falls through to rpm-ostree."""
+		plugin = self._make_plugin_mock(bootc_has_source=False)
+		plugin._rpm_ostree = True
+
+		# Simulate _instance_post_static dispatch
+		bootc_called = False
+		rpm_ostree_called = False
+		if plugin._bootc_has_source:
+			bootc_called = True
+		elif plugin._rpm_ostree:
+			rpm_ostree_called = True
+
+		self.assertFalse(bootc_called)
+		self.assertTrue(rpm_ostree_called)
+
+	def test_instance_post_static_dispatches_to_bootc(self):
+		"""_instance_post_static calls bootc when _bootc_has_source is True."""
+		from tuned.plugins.plugin_bootloader import BootloaderPlugin
+
+		plugin = self._make_plugin_mock(bootc_has_source=True)
+		plugin._rpm_ostree = False
+		plugin._cmdline_val = "nohz=full"
+		plugin._cmd.execute = Mock(return_value=(0, "", ""))
+		plugin.update_grub2_cfg = True
+		plugin._skip_grub_config_val = False
+
+		instance = Mock()
+		BootloaderPlugin._instance_post_static(plugin, instance, enabling=True)
+
+		plugin._cmd.execute.assert_called_once_with(
+			["bootc", "loader-entries", "set-options-for-source",
+			 "--source", "tuned", "--options", "nohz=full"],
+			return_err=True)
+
+	def test_instance_unapply_dispatches_to_bootc(self):
+		"""_instance_unapply_static calls bootc removal when _bootc_has_source."""
+		from tuned.plugins.plugin_bootloader import BootloaderPlugin
+		import tuned.consts as c
+
+		plugin = self._make_plugin_mock(bootc_has_source=True)
+		plugin._rpm_ostree = False
+		plugin._cmd.execute = Mock(return_value=(0, "", ""))
+		plugin._skip_grub_config_val = False
+
+		instance = Mock()
+		BootloaderPlugin._instance_unapply_static(plugin, instance, rollback=c.ROLLBACK_FULL)
+
+		plugin._cmd.execute.assert_called_once_with(
+			["bootc", "loader-entries", "set-options-for-source",
+			 "--source", "tuned"],
+			return_err=True)
+
+	def test_instance_unapply_falls_through_to_rpm_ostree(self):
+		"""_instance_unapply_static falls through to rpm-ostree when no bootc."""
+		from tuned.plugins.plugin_bootloader import BootloaderPlugin
+		import tuned.consts as c
+
+		plugin = self._make_plugin_mock(bootc_has_source=False)
+		plugin._rpm_ostree = True
+		plugin._skip_grub_config_val = False
+		plugin._remove_rpm_ostree_tuning = Mock()
+
+		instance = Mock()
+		BootloaderPlugin._instance_unapply_static(plugin, instance, rollback=c.ROLLBACK_FULL)
+
+		plugin._remove_rpm_ostree_tuning.assert_called_once()
+
+
+if __name__ == '__main__':
+	unittest.main()

tuned/plugins/plugin_bootloader.py

@@ -194,6 +194,7 @@ def _instance_init(self, instance):
 		self._bls = self._bls_enabled()
 
 		self._rpm_ostree = self._rpm_ostree_status() is not None
+		self._bootc_has_source = self._bootc_has_set_options_for_source()
 
 	def _instance_cleanup(self, instance):
 		pass
@@ -224,6 +225,48 @@ def _rpm_ostree_status(self):
 			return None
 		return splited[1]
 
+	def _bootc_has_set_options_for_source(self):
+		"""Check if bootc loader-entries set-options-for-source is available."""
+		(rc, out, err) = self._cmd.execute(
+			['bootc', 'loader-entries', 'set-options-for-source', '--help'],
+			return_err=True)
+		return rc == 0
+
+	def _bootc_source_update(self):
+		"""Apply kernel parameter tuning using bootc source tracking.
+
+		With bootc loader-entries set-options-for-source, bootc automatically
+		removes all previous kargs from the 'tuned' source and replaces them
+		with the new set. This eliminates the need to track state in
+		/etc/tuned/bootcmdline, which is critical for bootc systems with
+		transient /etc.
+		"""
+		cmd = ["bootc", "loader-entries", "set-options-for-source",
+			"--source", "tuned"]
+		if self._cmdline_val:
+			cmd.extend(["--options", self._cmdline_val])
+		(rc, _, err) = self._cmd.execute(cmd, return_err=True)
+		if rc != 0:
+			log.error("Error applying bootc kargs with set-options-for-source: %s" % err)
+			# Do not update state file — the kargs were not applied
+			return
+		# Best-effort state file write for diagnostics and backward compat
+		self._patch_bootcmdline({consts.BOOT_CMDLINE_TUNED_VAR: self._cmdline_val})
+
+	def _remove_bootc_source_tuning(self):
+		"""Remove kernel parameter tuning using bootc source tracking.
+
+		Calling set-options-for-source with --source tuned and no --options
+		clears all kargs owned by the 'tuned' source.
+		"""
+		(rc, _, err) = self._cmd.execute(
+			["bootc", "loader-entries", "set-options-for-source",
+			 "--source", "tuned"], return_err=True)
+		if rc != 0:
+			log.error("Error clearing bootc kargs source: %s" % err)
+		# Clear the state file even on failure to prevent stale state
+		self._patch_bootcmdline({consts.BOOT_CMDLINE_TUNED_VAR: ""})
+
 	def _wait_till_rpm_ostree_idle(self):
 		"""Check that rpm-ostree is idle, allowing some waiting time."""
 		sleep_cycles = 10
@@ -341,7 +384,10 @@ def _remove_rpm_ostree_tuning(self):
 
 	def _instance_unapply_static(self, instance, rollback = consts.ROLLBACK_SOFT):
 		if rollback == consts.ROLLBACK_FULL and not self._skip_grub_config_val:
-			if self._rpm_ostree:
+			if self._bootc_has_source:
+				log.info("removing bootc tuning previously added by Tuned")
+				self._remove_bootc_source_tuning()
+			elif self._rpm_ostree:
 				log.info("removing rpm-ostree tuning previously added by Tuned")
 				self._remove_rpm_ostree_tuning()
 			else:
@@ -678,7 +724,9 @@ def _instance_post_static(self, instance, enabling):
 			# ensure that the desired cmdline is always written to BOOT_CMDLINE_FILE (/etc/tuned/bootcmdline)
 			self._patch_bootcmdline({consts.BOOT_CMDLINE_TUNED_VAR : self._cmdline_val, consts.BOOT_CMDLINE_INITRD_ADD_VAR : self._initrd_val})
 		elif enabling and self.update_grub2_cfg:
-			if self._rpm_ostree:
+			if self._bootc_has_source:
+				self._bootc_source_update()
+			elif self._rpm_ostree:
 				self._rpm_ostree_update()
 			else:
 				self._grub2_update()