From 195998592a00ace57a2fd154130bbd2d540659d7 Mon Sep 17 00:00:00 2001 From: Sasha Levin Date: Mon, 24 Jun 2024 23:25:01 -0400 Subject: [PATCH] Fixes for 6.9 Signed-off-by: Sasha Levin --- ...rm-xe-use-ordered-wq-for-g2h-handler.patch | 45 +++++ queue-6.9/nbd-fix-signal-handling.patch | 159 ++++++++++++++++ ...documentation-of-the-locking-assumpt.patch | 60 ++++++ queue-6.9/series | 6 + ...le_description-to-preemptirq_delay_t.patch | 39 ++++ ...match_cpu-to-match-just-x86_vendor_i.patch | 175 ++++++++++++++++++ ...new-macros-to-work-with-vendor-famil.patch | 146 +++++++++++++++ 7 files changed, 630 insertions(+) create mode 100644 queue-6.9/drm-xe-use-ordered-wq-for-g2h-handler.patch create mode 100644 queue-6.9/nbd-fix-signal-handling.patch create mode 100644 queue-6.9/nbd-improve-the-documentation-of-the-locking-assumpt.patch create mode 100644 queue-6.9/tracing-add-module_description-to-preemptirq_delay_t.patch create mode 100644 queue-6.9/x86-cpu-fix-x86_match_cpu-to-match-just-x86_vendor_i.patch create mode 100644 queue-6.9/x86-cpu-vfm-add-new-macros-to-work-with-vendor-famil.patch diff --git a/queue-6.9/drm-xe-use-ordered-wq-for-g2h-handler.patch b/queue-6.9/drm-xe-use-ordered-wq-for-g2h-handler.patch new file mode 100644 index 00000000000..aaabd72640f --- /dev/null +++ b/queue-6.9/drm-xe-use-ordered-wq-for-g2h-handler.patch @@ -0,0 +1,45 @@ +From 5a8a2b9e943b5275701a6e9643c6b3e4bbbff0a6 Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Sun, 5 May 2024 20:47:58 -0700 +Subject: drm/xe: Use ordered WQ for G2H handler +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +From: Matthew Brost + +[ Upstream commit 2d9c72f676e6f79a021b74c6c1c88235e7d5b722 ] + +System work queues are shared, use a dedicated work queue for G2H +processing to avoid G2H processing getting block behind system tasks. + +Fixes: dd08ebf6c352 ("drm/xe: Introduce a new DRM driver for Intel GPUs") +Cc: +Signed-off-by: Matthew Brost +Reviewed-by: Francois Dugast +Link: https://patchwork.freedesktop.org/patch/msgid/20240506034758.3697397-1-matthew.brost@intel.com +(cherry picked from commit 50aec9665e0babd62b9eee4e613d9a1ef8d2b7de) +Signed-off-by: Thomas Hellström +Signed-off-by: Sasha Levin +--- + drivers/gpu/drm/xe/xe_guc_ct.c | 4 ++++ + 1 file changed, 4 insertions(+) + +diff --git a/drivers/gpu/drm/xe/xe_guc_ct.c b/drivers/gpu/drm/xe/xe_guc_ct.c +index 8bbfa45798e2e..6ac86936faaf9 100644 +--- a/drivers/gpu/drm/xe/xe_guc_ct.c ++++ b/drivers/gpu/drm/xe/xe_guc_ct.c +@@ -146,6 +146,10 @@ int xe_guc_ct_init(struct xe_guc_ct *ct) + + xe_assert(xe, !(guc_ct_size() % PAGE_SIZE)); + ++ ct->g2h_wq = alloc_ordered_workqueue("xe-g2h-wq", 0); ++ if (!ct->g2h_wq) ++ return -ENOMEM; ++ + ct->g2h_wq = alloc_ordered_workqueue("xe-g2h-wq", 0); + if (!ct->g2h_wq) + return -ENOMEM; +-- +2.43.0 + diff --git a/queue-6.9/nbd-fix-signal-handling.patch b/queue-6.9/nbd-fix-signal-handling.patch new file mode 100644 index 00000000000..b002a732901 --- /dev/null +++ b/queue-6.9/nbd-fix-signal-handling.patch @@ -0,0 +1,159 @@ +From 58ac323330e658c0be5e1cf2e6c198d432e64d5e Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Fri, 10 May 2024 13:23:13 -0700 +Subject: nbd: Fix signal handling + +From: Bart Van Assche + +[ Upstream commit e56d4b633fffea9510db468085bed0799cba4ecd ] + +Both nbd_send_cmd() and nbd_handle_cmd() return either a negative error +number or a positive blk_status_t value. nbd_queue_rq() converts these +return values into a blk_status_t value. There is a bug in the conversion +code: if nbd_send_cmd() returns BLK_STS_RESOURCE, nbd_queue_rq() should +return BLK_STS_RESOURCE instead of BLK_STS_OK. Fix this, move the +conversion code into nbd_handle_cmd() and fix the remaining sparse warnings. + +This patch fixes the following sparse warnings: + +drivers/block/nbd.c:673:32: warning: incorrect type in return expression (different base types) +drivers/block/nbd.c:673:32: expected int +drivers/block/nbd.c:673:32: got restricted blk_status_t [usertype] +drivers/block/nbd.c:714:48: warning: incorrect type in return expression (different base types) +drivers/block/nbd.c:714:48: expected int +drivers/block/nbd.c:714:48: got restricted blk_status_t [usertype] +drivers/block/nbd.c:1120:21: warning: incorrect type in assignment (different base types) +drivers/block/nbd.c:1120:21: expected int [assigned] ret +drivers/block/nbd.c:1120:21: got restricted blk_status_t [usertype] +drivers/block/nbd.c:1125:16: warning: incorrect type in return expression (different base types) +drivers/block/nbd.c:1125:16: expected restricted blk_status_t +drivers/block/nbd.c:1125:16: got int [assigned] ret + +Cc: Christoph Hellwig +Cc: Josef Bacik +Cc: Yu Kuai +Cc: Markus Pargmann +Fixes: fc17b6534eb8 ("blk-mq: switch ->queue_rq return value to blk_status_t") +Cc: stable@vger.kernel.org +Signed-off-by: Bart Van Assche +Link: https://lore.kernel.org/r/20240510202313.25209-6-bvanassche@acm.org +Signed-off-by: Jens Axboe +Signed-off-by: Sasha Levin +--- + drivers/block/nbd.c | 28 ++++++++++++++-------------- + 1 file changed, 14 insertions(+), 14 deletions(-) + +diff --git a/drivers/block/nbd.c b/drivers/block/nbd.c +index 281df7bafc83c..1ddd3e5497896 100644 +--- a/drivers/block/nbd.c ++++ b/drivers/block/nbd.c +@@ -588,6 +588,10 @@ static inline int was_interrupted(int result) + return result == -ERESTARTSYS || result == -EINTR; + } + ++/* ++ * Returns BLK_STS_RESOURCE if the caller should retry after a delay. Returns ++ * -EAGAIN if the caller should requeue @cmd. Returns -EIO if sending failed. ++ */ + static int nbd_send_cmd(struct nbd_device *nbd, struct nbd_cmd *cmd, int index) + { + struct request *req = blk_mq_rq_from_pdu(cmd); +@@ -671,7 +675,7 @@ static int nbd_send_cmd(struct nbd_device *nbd, struct nbd_cmd *cmd, int index) + nsock->sent = sent; + } + set_bit(NBD_CMD_REQUEUED, &cmd->flags); +- return BLK_STS_RESOURCE; ++ return (__force int)BLK_STS_RESOURCE; + } + dev_err_ratelimited(disk_to_dev(nbd->disk), + "Send control failed (result %d)\n", result); +@@ -712,7 +716,7 @@ static int nbd_send_cmd(struct nbd_device *nbd, struct nbd_cmd *cmd, int index) + nsock->pending = req; + nsock->sent = sent; + set_bit(NBD_CMD_REQUEUED, &cmd->flags); +- return BLK_STS_RESOURCE; ++ return (__force int)BLK_STS_RESOURCE; + } + dev_err(disk_to_dev(nbd->disk), + "Send data failed (result %d)\n", +@@ -1009,7 +1013,7 @@ static int wait_for_reconnect(struct nbd_device *nbd) + return !test_bit(NBD_RT_DISCONNECTED, &config->runtime_flags); + } + +-static int nbd_handle_cmd(struct nbd_cmd *cmd, int index) ++static blk_status_t nbd_handle_cmd(struct nbd_cmd *cmd, int index) + { + struct request *req = blk_mq_rq_from_pdu(cmd); + struct nbd_device *nbd = cmd->nbd; +@@ -1023,14 +1027,14 @@ static int nbd_handle_cmd(struct nbd_cmd *cmd, int index) + if (!config) { + dev_err_ratelimited(disk_to_dev(nbd->disk), + "Socks array is empty\n"); +- return -EINVAL; ++ return BLK_STS_IOERR; + } + + if (index >= config->num_connections) { + dev_err_ratelimited(disk_to_dev(nbd->disk), + "Attempted send on invalid socket\n"); + nbd_config_put(nbd); +- return -EINVAL; ++ return BLK_STS_IOERR; + } + cmd->status = BLK_STS_OK; + again: +@@ -1053,7 +1057,7 @@ static int nbd_handle_cmd(struct nbd_cmd *cmd, int index) + */ + sock_shutdown(nbd); + nbd_config_put(nbd); +- return -EIO; ++ return BLK_STS_IOERR; + } + goto again; + } +@@ -1066,7 +1070,7 @@ static int nbd_handle_cmd(struct nbd_cmd *cmd, int index) + blk_mq_start_request(req); + if (unlikely(nsock->pending && nsock->pending != req)) { + nbd_requeue_cmd(cmd); +- ret = 0; ++ ret = BLK_STS_OK; + goto out; + } + /* +@@ -1085,19 +1089,19 @@ static int nbd_handle_cmd(struct nbd_cmd *cmd, int index) + "Request send failed, requeueing\n"); + nbd_mark_nsock_dead(nbd, nsock, 1); + nbd_requeue_cmd(cmd); +- ret = 0; ++ ret = BLK_STS_OK; + } + out: + mutex_unlock(&nsock->tx_lock); + nbd_config_put(nbd); +- return ret; ++ return ret < 0 ? BLK_STS_IOERR : (__force blk_status_t)ret; + } + + static blk_status_t nbd_queue_rq(struct blk_mq_hw_ctx *hctx, + const struct blk_mq_queue_data *bd) + { + struct nbd_cmd *cmd = blk_mq_rq_to_pdu(bd->rq); +- int ret; ++ blk_status_t ret; + + /* + * Since we look at the bio's to send the request over the network we +@@ -1117,10 +1121,6 @@ static blk_status_t nbd_queue_rq(struct blk_mq_hw_ctx *hctx, + * appropriate. + */ + ret = nbd_handle_cmd(cmd, hctx->queue_num); +- if (ret < 0) +- ret = BLK_STS_IOERR; +- else if (!ret) +- ret = BLK_STS_OK; + mutex_unlock(&cmd->lock); + + return ret; +-- +2.43.0 + diff --git a/queue-6.9/nbd-improve-the-documentation-of-the-locking-assumpt.patch b/queue-6.9/nbd-improve-the-documentation-of-the-locking-assumpt.patch new file mode 100644 index 00000000000..4f944b1ec08 --- /dev/null +++ b/queue-6.9/nbd-improve-the-documentation-of-the-locking-assumpt.patch @@ -0,0 +1,60 @@ +From 335601b7d0fcf9ecdf5f54a3eac5109c728641c4 Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Fri, 10 May 2024 13:23:11 -0700 +Subject: nbd: Improve the documentation of the locking assumptions + +From: Bart Van Assche + +[ Upstream commit 2a6751e052ab4789630bc889c814037068723bc1 ] + +Document locking assumptions with lockdep_assert_held() instead of source +code comments. The advantage of lockdep_assert_held() is that it is +verified at runtime if lockdep is enabled in the kernel config. + +Cc: Christoph Hellwig +Cc: Josef Bacik +Cc: Yu Kuai +Cc: Markus Pargmann +Signed-off-by: Bart Van Assche +Link: https://lore.kernel.org/r/20240510202313.25209-4-bvanassche@acm.org +Signed-off-by: Jens Axboe +Stable-dep-of: e56d4b633fff ("nbd: Fix signal handling") +Signed-off-by: Sasha Levin +--- + drivers/block/nbd.c | 6 +++++- + 1 file changed, 5 insertions(+), 1 deletion(-) + +diff --git a/drivers/block/nbd.c b/drivers/block/nbd.c +index 9d4ec9273bf95..281df7bafc83c 100644 +--- a/drivers/block/nbd.c ++++ b/drivers/block/nbd.c +@@ -588,7 +588,6 @@ static inline int was_interrupted(int result) + return result == -ERESTARTSYS || result == -EINTR; + } + +-/* always call with the tx_lock held */ + static int nbd_send_cmd(struct nbd_device *nbd, struct nbd_cmd *cmd, int index) + { + struct request *req = blk_mq_rq_from_pdu(cmd); +@@ -605,6 +604,9 @@ static int nbd_send_cmd(struct nbd_device *nbd, struct nbd_cmd *cmd, int index) + u32 nbd_cmd_flags = 0; + int sent = nsock->sent, skip = 0; + ++ lockdep_assert_held(&cmd->lock); ++ lockdep_assert_held(&nsock->tx_lock); ++ + iov_iter_kvec(&from, ITER_SOURCE, &iov, 1, sizeof(request)); + + type = req_to_nbd_cmd_type(req); +@@ -1015,6 +1017,8 @@ static int nbd_handle_cmd(struct nbd_cmd *cmd, int index) + struct nbd_sock *nsock; + int ret; + ++ lockdep_assert_held(&cmd->lock); ++ + config = nbd_get_config_unlocked(nbd); + if (!config) { + dev_err_ratelimited(disk_to_dev(nbd->disk), +-- +2.43.0 + diff --git a/queue-6.9/series b/queue-6.9/series index 1deb853c96e..c8edddb6649 100644 --- a/queue-6.9/series +++ b/queue-6.9/series @@ -238,3 +238,9 @@ spi-stm32-qspi-fix-dual-flash-mode-sanity-test-in-stm32_qspi_setup.patch arm64-dts-imx8qm-mek-fix-gpio-number-for-reg_usdhc2_vmmc.patch thermal-core-change-pm-notifier-priority-to-the-minimum.patch spi-stm32-qspi-clamp-stm32_qspi_get_mode-output-to-ccr_buswidth_4.patch +drm-xe-use-ordered-wq-for-g2h-handler.patch +nbd-improve-the-documentation-of-the-locking-assumpt.patch +nbd-fix-signal-handling.patch +tracing-add-module_description-to-preemptirq_delay_t.patch +x86-cpu-vfm-add-new-macros-to-work-with-vendor-famil.patch +x86-cpu-fix-x86_match_cpu-to-match-just-x86_vendor_i.patch diff --git a/queue-6.9/tracing-add-module_description-to-preemptirq_delay_t.patch b/queue-6.9/tracing-add-module_description-to-preemptirq_delay_t.patch new file mode 100644 index 00000000000..675e2112f15 --- /dev/null +++ b/queue-6.9/tracing-add-module_description-to-preemptirq_delay_t.patch @@ -0,0 +1,39 @@ +From 162097ae2b65b9907e904a54576dcd9cabf355ea Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Sat, 18 May 2024 15:54:49 -0700 +Subject: tracing: Add MODULE_DESCRIPTION() to preemptirq_delay_test + +From: Jeff Johnson + +[ Upstream commit 23748e3e0fbfe471eff5ce439921629f6a427828 ] + +Fix the 'make W=1' warning: + +WARNING: modpost: missing MODULE_DESCRIPTION() in kernel/trace/preemptirq_delay_test.o + +Link: https://lore.kernel.org/linux-trace-kernel/20240518-md-preemptirq_delay_test-v1-1-387d11b30d85@quicinc.com + +Cc: stable@vger.kernel.org +Cc: Mathieu Desnoyers +Fixes: f96e8577da10 ("lib: Add module for testing preemptoff/irqsoff latency tracers") +Acked-by: Masami Hiramatsu (Google) +Signed-off-by: Jeff Johnson +Signed-off-by: Steven Rostedt (Google) +Signed-off-by: Sasha Levin +--- + kernel/trace/preemptirq_delay_test.c | 1 + + 1 file changed, 1 insertion(+) + +diff --git a/kernel/trace/preemptirq_delay_test.c b/kernel/trace/preemptirq_delay_test.c +index 8c4ffd0761624..cb0871fbdb07f 100644 +--- a/kernel/trace/preemptirq_delay_test.c ++++ b/kernel/trace/preemptirq_delay_test.c +@@ -215,4 +215,5 @@ static void __exit preemptirq_delay_exit(void) + + module_init(preemptirq_delay_init) + module_exit(preemptirq_delay_exit) ++MODULE_DESCRIPTION("Preempt / IRQ disable delay thread to test latency tracers"); + MODULE_LICENSE("GPL v2"); +-- +2.43.0 + diff --git a/queue-6.9/x86-cpu-fix-x86_match_cpu-to-match-just-x86_vendor_i.patch b/queue-6.9/x86-cpu-fix-x86_match_cpu-to-match-just-x86_vendor_i.patch new file mode 100644 index 00000000000..cf978f6266b --- /dev/null +++ b/queue-6.9/x86-cpu-fix-x86_match_cpu-to-match-just-x86_vendor_i.patch @@ -0,0 +1,175 @@ +From 535fdf5c9c4e7284a249cc7eba1b59e089de99f4 Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Mon, 20 May 2024 15:45:33 -0700 +Subject: x86/cpu: Fix x86_match_cpu() to match just X86_VENDOR_INTEL + +From: Tony Luck + +[ Upstream commit 93022482b2948a9a7e9b5a2bb685f2e1cb4c3348 ] + +Code in v6.9 arch/x86/kernel/smpboot.c was changed by commit + + 4db64279bc2b ("x86/cpu: Switch to new Intel CPU model defines") from: + + static const struct x86_cpu_id intel_cod_cpu[] = { + X86_MATCH_INTEL_FAM6_MODEL(HASWELL_X, 0), /* COD */ + X86_MATCH_INTEL_FAM6_MODEL(BROADWELL_X, 0), /* COD */ + X86_MATCH_INTEL_FAM6_MODEL(ANY, 1), /* SNC */ <--- 443 + {} + }; + + static bool match_llc(struct cpuinfo_x86 *c, struct cpuinfo_x86 *o) + { + const struct x86_cpu_id *id = x86_match_cpu(intel_cod_cpu); + +to: + + static const struct x86_cpu_id intel_cod_cpu[] = { + X86_MATCH_VFM(INTEL_HASWELL_X, 0), /* COD */ + X86_MATCH_VFM(INTEL_BROADWELL_X, 0), /* COD */ + X86_MATCH_VFM(INTEL_ANY, 1), /* SNC */ + {} + }; + + static bool match_llc(struct cpuinfo_x86 *c, struct cpuinfo_x86 *o) + { + const struct x86_cpu_id *id = x86_match_cpu(intel_cod_cpu); + +On an Intel CPU with SNC enabled this code previously matched the rule on line +443 to avoid printing messages about insane cache configuration. The new code +did not match any rules. + +Expanding the macros for the intel_cod_cpu[] array shows that the old is +equivalent to: + + static const struct x86_cpu_id intel_cod_cpu[] = { + [0] = { .vendor = 0, .family = 6, .model = 0x3F, .steppings = 0, .feature = 0, .driver_data = 0 }, + [1] = { .vendor = 0, .family = 6, .model = 0x4F, .steppings = 0, .feature = 0, .driver_data = 0 }, + [2] = { .vendor = 0, .family = 6, .model = 0x00, .steppings = 0, .feature = 0, .driver_data = 1 }, + [3] = { .vendor = 0, .family = 0, .model = 0x00, .steppings = 0, .feature = 0, .driver_data = 0 } + } + +while the new code expands to: + + static const struct x86_cpu_id intel_cod_cpu[] = { + [0] = { .vendor = 0, .family = 6, .model = 0x3F, .steppings = 0, .feature = 0, .driver_data = 0 }, + [1] = { .vendor = 0, .family = 6, .model = 0x4F, .steppings = 0, .feature = 0, .driver_data = 0 }, + [2] = { .vendor = 0, .family = 0, .model = 0x00, .steppings = 0, .feature = 0, .driver_data = 1 }, + [3] = { .vendor = 0, .family = 0, .model = 0x00, .steppings = 0, .feature = 0, .driver_data = 0 } + } + +Looking at the code for x86_match_cpu(): + + const struct x86_cpu_id *x86_match_cpu(const struct x86_cpu_id *match) + { + const struct x86_cpu_id *m; + struct cpuinfo_x86 *c = &boot_cpu_data; + + for (m = match; + m->vendor | m->family | m->model | m->steppings | m->feature; + m++) { + ... + } + return NULL; + +it is clear that there was no match because the ANY entry in the table (array +index 2) is now the loop termination condition (all of vendor, family, model, +steppings, and feature are zero). + +So this code was working before because the "ANY" check was looking for any +Intel CPU in family 6. But fails now because the family is a wild card. So the +root cause is that x86_match_cpu() has never been able to match on a rule with +just X86_VENDOR_INTEL and all other fields set to wildcards. + +Add a new flags field to struct x86_cpu_id that has a bit set to indicate that +this entry in the array is valid. Update X86_MATCH*() macros to set that bit. +Change the end-marker check in x86_match_cpu() to just check the flags field +for this bit. + +Backporter notes: The commit in Fixes is really the one that is broken: +you can't have m->vendor as part of the loop termination conditional in +x86_match_cpu() because it can happen - as it has happened above +- that that whole conditional is 0 albeit vendor == 0 is a valid case +- X86_VENDOR_INTEL is 0. + +However, the only case where the above happens is the SNC check added by +4db64279bc2b1 so you only need this fix if you have backported that +other commit + + 4db64279bc2b ("x86/cpu: Switch to new Intel CPU model defines") + +Fixes: 644e9cbbe3fc ("Add driver auto probing for x86 features v4") +Suggested-by: Thomas Gleixner +Suggested-by: Borislav Petkov +Signed-off-by: Tony Luck +Signed-off-by: Borislav Petkov (AMD) +Cc: # see above +Link: https://lore.kernel.org/r/20240517144312.GBZkdtAOuJZCvxhFbJ@fat_crate.local +Signed-off-by: Sasha Levin +--- + arch/x86/include/asm/cpu_device_id.h | 5 +++++ + arch/x86/kernel/cpu/match.c | 4 +--- + include/linux/mod_devicetable.h | 2 ++ + 3 files changed, 8 insertions(+), 3 deletions(-) + +diff --git a/arch/x86/include/asm/cpu_device_id.h b/arch/x86/include/asm/cpu_device_id.h +index dd7b9463696f5..e8e3dbe7f1730 100644 +--- a/arch/x86/include/asm/cpu_device_id.h ++++ b/arch/x86/include/asm/cpu_device_id.h +@@ -53,6 +53,9 @@ + #define X86_CENTAUR_FAM6_C7_D 0xd + #define X86_CENTAUR_FAM6_NANO 0xf + ++/* x86_cpu_id::flags */ ++#define X86_CPU_ID_FLAG_ENTRY_VALID BIT(0) ++ + #define X86_STEPPINGS(mins, maxs) GENMASK(maxs, mins) + /** + * X86_MATCH_VENDOR_FAM_MODEL_STEPPINGS_FEATURE - Base macro for CPU matching +@@ -79,6 +82,7 @@ + .model = _model, \ + .steppings = _steppings, \ + .feature = _feature, \ ++ .flags = X86_CPU_ID_FLAG_ENTRY_VALID, \ + .driver_data = (unsigned long) _data \ + } + +@@ -89,6 +93,7 @@ + .model = _model, \ + .steppings = _steppings, \ + .feature = _feature, \ ++ .flags = X86_CPU_ID_FLAG_ENTRY_VALID, \ + .driver_data = (unsigned long) _data \ + } + +diff --git a/arch/x86/kernel/cpu/match.c b/arch/x86/kernel/cpu/match.c +index ad6776081e60d..ae71b8ef909c9 100644 +--- a/arch/x86/kernel/cpu/match.c ++++ b/arch/x86/kernel/cpu/match.c +@@ -39,9 +39,7 @@ const struct x86_cpu_id *x86_match_cpu(const struct x86_cpu_id *match) + const struct x86_cpu_id *m; + struct cpuinfo_x86 *c = &boot_cpu_data; + +- for (m = match; +- m->vendor | m->family | m->model | m->steppings | m->feature; +- m++) { ++ for (m = match; m->flags & X86_CPU_ID_FLAG_ENTRY_VALID; m++) { + if (m->vendor != X86_VENDOR_ANY && c->x86_vendor != m->vendor) + continue; + if (m->family != X86_FAMILY_ANY && c->x86 != m->family) +diff --git a/include/linux/mod_devicetable.h b/include/linux/mod_devicetable.h +index 7a9a07ea451bc..4338b1b4ac444 100644 +--- a/include/linux/mod_devicetable.h ++++ b/include/linux/mod_devicetable.h +@@ -690,6 +690,8 @@ struct x86_cpu_id { + __u16 model; + __u16 steppings; + __u16 feature; /* bit index */ ++ /* Solely for kernel-internal use: DO NOT EXPORT to userspace! */ ++ __u16 flags; + kernel_ulong_t driver_data; + }; + +-- +2.43.0 + diff --git a/queue-6.9/x86-cpu-vfm-add-new-macros-to-work-with-vendor-famil.patch b/queue-6.9/x86-cpu-vfm-add-new-macros-to-work-with-vendor-famil.patch new file mode 100644 index 00000000000..fa58d3ca2fd --- /dev/null +++ b/queue-6.9/x86-cpu-vfm-add-new-macros-to-work-with-vendor-famil.patch @@ -0,0 +1,146 @@ +From fb90b692172ea4988930bbb531a95380cbf6a229 Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Tue, 16 Apr 2024 14:19:04 -0700 +Subject: x86/cpu/vfm: Add new macros to work with (vendor/family/model) values + +From: Tony Luck + +[ Upstream commit e6dfdc2e89a0adedf455814c91b977d6a584cc88 ] + +To avoid adding a slew of new macros for each new Intel CPU family +switch over from providing CPU model number #defines to a new +scheme that encodes vendor, family, and model in a single number. + + [ bp: s/casted/cast/g ] + +Signed-off-by: Tony Luck +Signed-off-by: Borislav Petkov (AMD) +Reviewed-by: Thomas Gleixner +Link: https://lore.kernel.org/r/20240416211941.9369-3-tony.luck@intel.com +Stable-dep-of: 93022482b294 ("x86/cpu: Fix x86_match_cpu() to match just X86_VENDOR_INTEL") +Signed-off-by: Sasha Levin +--- + arch/x86/include/asm/cpu_device_id.h | 93 ++++++++++++++++++++++++++++ + 1 file changed, 93 insertions(+) + +diff --git a/arch/x86/include/asm/cpu_device_id.h b/arch/x86/include/asm/cpu_device_id.h +index eb8fcede9e3bf..dd7b9463696f5 100644 +--- a/arch/x86/include/asm/cpu_device_id.h ++++ b/arch/x86/include/asm/cpu_device_id.h +@@ -2,6 +2,39 @@ + #ifndef _ASM_X86_CPU_DEVICE_ID + #define _ASM_X86_CPU_DEVICE_ID + ++/* ++ * Can't use because it generates expressions that ++ * cannot be used in structure initializers. Bitfield construction ++ * here must match the union in struct cpuinfo_86: ++ * union { ++ * struct { ++ * __u8 x86_model; ++ * __u8 x86; ++ * __u8 x86_vendor; ++ * __u8 x86_reserved; ++ * }; ++ * __u32 x86_vfm; ++ * }; ++ */ ++#define VFM_MODEL_BIT 0 ++#define VFM_FAMILY_BIT 8 ++#define VFM_VENDOR_BIT 16 ++#define VFM_RSVD_BIT 24 ++ ++#define VFM_MODEL_MASK GENMASK(VFM_FAMILY_BIT - 1, VFM_MODEL_BIT) ++#define VFM_FAMILY_MASK GENMASK(VFM_VENDOR_BIT - 1, VFM_FAMILY_BIT) ++#define VFM_VENDOR_MASK GENMASK(VFM_RSVD_BIT - 1, VFM_VENDOR_BIT) ++ ++#define VFM_MODEL(vfm) (((vfm) & VFM_MODEL_MASK) >> VFM_MODEL_BIT) ++#define VFM_FAMILY(vfm) (((vfm) & VFM_FAMILY_MASK) >> VFM_FAMILY_BIT) ++#define VFM_VENDOR(vfm) (((vfm) & VFM_VENDOR_MASK) >> VFM_VENDOR_BIT) ++ ++#define VFM_MAKE(_vendor, _family, _model) ( \ ++ ((_model) << VFM_MODEL_BIT) | \ ++ ((_family) << VFM_FAMILY_BIT) | \ ++ ((_vendor) << VFM_VENDOR_BIT) \ ++) ++ + /* + * Declare drivers belonging to specific x86 CPUs + * Similar in spirit to pci_device_id and related PCI functions +@@ -49,6 +82,16 @@ + .driver_data = (unsigned long) _data \ + } + ++#define X86_MATCH_VENDORID_FAM_MODEL_STEPPINGS_FEATURE(_vendor, _family, _model, \ ++ _steppings, _feature, _data) { \ ++ .vendor = _vendor, \ ++ .family = _family, \ ++ .model = _model, \ ++ .steppings = _steppings, \ ++ .feature = _feature, \ ++ .driver_data = (unsigned long) _data \ ++} ++ + /** + * X86_MATCH_VENDOR_FAM_MODEL_FEATURE - Macro for CPU matching + * @_vendor: The vendor name, e.g. INTEL, AMD, HYGON, ..., ANY +@@ -164,6 +207,56 @@ + X86_MATCH_VENDOR_FAM_MODEL_STEPPINGS_FEATURE(INTEL, 6, INTEL_FAM6_##model, \ + steppings, X86_FEATURE_ANY, data) + ++/** ++ * X86_MATCH_VFM - Match encoded vendor/family/model ++ * @vfm: Encoded 8-bits each for vendor, family, model ++ * @data: Driver specific data or NULL. The internal storage ++ * format is unsigned long. The supplied value, pointer ++ * etc. is cast to unsigned long internally. ++ * ++ * Stepping and feature are set to wildcards ++ */ ++#define X86_MATCH_VFM(vfm, data) \ ++ X86_MATCH_VENDORID_FAM_MODEL_STEPPINGS_FEATURE( \ ++ VFM_VENDOR(vfm), \ ++ VFM_FAMILY(vfm), \ ++ VFM_MODEL(vfm), \ ++ X86_STEPPING_ANY, X86_FEATURE_ANY, data) ++ ++/** ++ * X86_MATCH_VFM_STEPPINGS - Match encoded vendor/family/model/stepping ++ * @vfm: Encoded 8-bits each for vendor, family, model ++ * @steppings: Bitmask of steppings to match ++ * @data: Driver specific data or NULL. The internal storage ++ * format is unsigned long. The supplied value, pointer ++ * etc. is cast to unsigned long internally. ++ * ++ * feature is set to wildcard ++ */ ++#define X86_MATCH_VFM_STEPPINGS(vfm, steppings, data) \ ++ X86_MATCH_VENDORID_FAM_MODEL_STEPPINGS_FEATURE( \ ++ VFM_VENDOR(vfm), \ ++ VFM_FAMILY(vfm), \ ++ VFM_MODEL(vfm), \ ++ steppings, X86_FEATURE_ANY, data) ++ ++/** ++ * X86_MATCH_VFM_FEATURE - Match encoded vendor/family/model/feature ++ * @vfm: Encoded 8-bits each for vendor, family, model ++ * @feature: A X86_FEATURE bit ++ * @data: Driver specific data or NULL. The internal storage ++ * format is unsigned long. The supplied value, pointer ++ * etc. is cast to unsigned long internally. ++ * ++ * Steppings is set to wildcard ++ */ ++#define X86_MATCH_VFM_FEATURE(vfm, feature, data) \ ++ X86_MATCH_VENDORID_FAM_MODEL_STEPPINGS_FEATURE( \ ++ VFM_VENDOR(vfm), \ ++ VFM_FAMILY(vfm), \ ++ VFM_MODEL(vfm), \ ++ X86_STEPPING_ANY, feature, data) ++ + /* + * Match specific microcode revisions. + * +-- +2.43.0 + -- 2.47.3