mirror of https://lore.kernel.org/lkml/
 help / color / mirror / Atom feed
From: "Chang S. Bae" <chang.seok.bae@intel.com>
To: linux-kernel@vger.kernel.org
Cc: x86@kernel.org, tglx@kernel.org, mingo@redhat.com, bp@alien8.de,
	dave.hansen@linux.intel.com, hpa@zytor.com,
	andrew.cooper3@citrix.com, arjan.van.de.ven@intel.com,
	chang.seok.bae@intel.com
Subject: [PATCH v2 0/7] x86/microcode: Incremental Loading and Early Minimum Revision Check
Date: Mon, 16 Nov 2026 16:45:41 +0000	[thread overview]
Message-ID: <20261116164548.900486-1-chang.seok.bae@intel.com> (raw)

Hi all,

This series came up with the microcode loading issues [1] previously. The
immediate fix, which prevents problematic blobs from being loaded, has
been merged to the mainline and backported to stable trees. This revision
follows up with two longer-term solutions addressing the underlying
issues.

First, let me summarize the changes since the previous posting [2] in
parts:

  Part 1, patch 1-3: Preparatory fixes
   * Only minor updates to changelogs and patch subjects.

  Part 2, patch 4-5: Late-loading - incremental Loading
   * Rename the approach to "incremental loading" to better describe
     the intention of advancing revisions through multiple updates.
   * Move this part ahead of the early minimum revision check, since
     the check now recommends incremental loading when fails.

  Part 3, patch 6-7: Early-loading - early minimum revision check
   * Keep this part in RFC status for now, as the resulting tainting
     behavior wants more reviews
   * Do not extend force_minrev to early loading, since doing so would
     reject all early loadings on AMD systems.

Below is more detail about the longer-term solutions, largely carried
from the previous posting [2].

1. Incremental Late Loading

  Looking at Intel microcode releases [3], the repository traditionally 
  provides the latest blob. When updating from an older revision, admins 
  may need to retrieve prerequisite older revisions from the git history. 
  This can be inefficient and error-prone.

  Intel will now concatenate prerequisite older blobs with the latest 
  blob together into a multi-blob image. The kernel, however, currently 
  selects the highest loadable revision, or at best one prerequisite when 
  the minimum revision check is enforced. Admins may need to trigger 
  multiple loads manually.

  Instead the kernel loader can facilitate iterative loading to apply the 
  available blobs incrementally. There are some possible ways to 
  implement this:

    (1) One is to rely on the minimum revision check and select the 
        highest revision whose prerequisite has been loaded already. 
    (2) Another is to load the blobs sequentially according to the order 
        in the image.

  Both approaches have drawbacks: (1) depends on the minimum revision 
  information being correct, while (2) is sensitive to blob ordering.

  The approach here selects the lowest loadable revision on each 
  iteration, so that the blobs to be applied incrementally (patch 4-5).

2. Early Minimum Revision Check

  The minimum revision information can serve as a more general revision
  dependency check, rather than being limited to runtime changes. This
  part extends the minimum revision check to early loading (patch 6-7).

  Although the implementation itself isn't complex, there are some 
  user-visible consequences:

    * For Intel, early loading of older patches without minimum revision
      information would result in kernel tainting. 

    * For AMD, the absence of the field could result in tainting _every_ 
      successful update unless explicitly treating AMD patches as safe. 
      To me, it is unclear whether the absence of this field reflects a 
      lack of such dependencies or simply a difference in the vendor's 
      microcode format.

    * Another consideration is force_minrev. Extending it to early 
      loading would reject all early loading on AMD systems, equivalent
      to disabling the loader entirely. Since the existing build-time and 
      command-line option descriptions are specific to late loading, I 
      have kept its semantics unchanged.

  For now, I'm keeping this part as RFC material. Depending on the
  feedback, the series could move forward with a smaller series, leaving 
  this part to follow after landing part1/2.

The patch set is available in this repository:
  git://github.com/intel-staging/microcode.git incr-loading-and-early-minrev-v2

Thanks,
Chang

[1] GNR98. MCE When Early OS Microcode Update to MCU 0x1000405 Release or Later
[2] https://lore.kernel.org/lkml/20260901231634.714144-1-chang.seok.bae@intel.com
[3] https://github.com/intel/Intel-Linux-Processor-Microcode-Data-Files.git

Chang S. Bae (7):
  x86/microcode: Avoid spurious base_rev= match
  x86/microcode: Accept a boolean for force_minrev parameter
  x86/microcode: Mark early_data __initdata
  x86/microcode: Introduce incremental late loading
  x86/microcode/intel: Select the lowest revision for incremental
    loading
  x86/microcode: Decouple minimum revision check from late loading
  x86/microcode/intel: Apply minimum revision check to early loading

 .../admin-guide/kernel-parameters.txt         | 11 ++-
 arch/x86/Kconfig                              | 13 +++
 arch/x86/kernel/cpu/microcode/core.c          | 91 ++++++++++++++++---
 arch/x86/kernel/cpu/microcode/intel.c         | 63 ++++++++-----
 arch/x86/kernel/cpu/microcode/internal.h      |  9 +-
 5 files changed, 147 insertions(+), 40 deletions(-)


base-commit: aebb7274476403040d582c61478df8f4a7bf9cd3
-- 
2.53.0


             reply	other threads:[~2026-11-16 17:13 UTC|newest]

Thread overview: 8+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2026-11-16 16:45 Chang S. Bae [this message]
2026-11-16 16:45 ` [PATCH v2 1/7] x86/microcode: Avoid spurious base_rev= match Chang S. Bae
2026-11-16 16:45 ` [PATCH v2 2/7] x86/microcode: Accept a boolean for force_minrev parameter Chang S. Bae
2026-11-16 16:45 ` [PATCH v2 3/7] x86/microcode: Mark early_data __initdata Chang S. Bae
2026-11-16 16:45 ` [PATCH v2 4/7] x86/microcode: Introduce incremental late loading Chang S. Bae
2026-11-16 16:45 ` [PATCH v2 5/7] x86/microcode/intel: Select the lowest revision for incremental loading Chang S. Bae
2026-11-16 16:45 ` [PATCH RFC v2 6/7] x86/microcode: Decouple minimum revision check from late loading Chang S. Bae
2026-11-16 16:45 ` [PATCH RFC v2 7/7] x86/microcode/intel: Apply minimum revision check to early loading Chang S. Bae

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=20261116164548.900486-1-chang.seok.bae@intel.com \
    --to=chang.seok.bae@intel.com \
    --cc=andrew.cooper3@citrix.com \
    --cc=arjan.van.de.ven@intel.com \
    --cc=bp@alien8.de \
    --cc=dave.hansen@linux.intel.com \
    --cc=hpa@zytor.com \
    --cc=linux-kernel@vger.kernel.org \
    --cc=mingo@redhat.com \
    --cc=tglx@kernel.org \
    --cc=x86@kernel.org \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox

all inboxes | Powered by JetHome®