From: Greg Kroah-Hartman Date: Mon, 18 Jul 2022 15:50:38 +0000 (+0200) Subject: 5.10-stable patches X-Git-Tag: v4.9.324~12 X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=e7c11725164293646c435b74922160f5850e3c05;p=thirdparty%2Fkernel%2Fstable-queue.git 5.10-stable patches added patches: drm-amd-display-ensure-valid-event-timestamp-for-cursor-only-commits.patch serial-8250-fix-pm-usage_count-for-console-handover.patch serial-8250-fix-return-error-code-in-serial8250_request_std_resource.patch serial-pl011-upstat_autorts-requires-.throttle-unthrottle.patch serial-stm32-clear-prev-values-before-setting-rts-delays.patch vt-fix-memory-overlapping-when-deleting-chars-in-the-buffer.patch x86-pat-fix-x86_has_pat_wp.patch --- diff --git a/queue-5.10/drm-amd-display-ensure-valid-event-timestamp-for-cursor-only-commits.patch b/queue-5.10/drm-amd-display-ensure-valid-event-timestamp-for-cursor-only-commits.patch new file mode 100644 index 00000000000..f4bf2e8d054 --- /dev/null +++ b/queue-5.10/drm-amd-display-ensure-valid-event-timestamp-for-cursor-only-commits.patch @@ -0,0 +1,111 @@ +From 3283c83eb6fcfbda8ea03d7149d8e42e71c5d45e Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?Michel=20D=C3=A4nzer?= +Date: Mon, 11 Jul 2022 16:51:31 +0200 +Subject: drm/amd/display: Ensure valid event timestamp for cursor-only commits +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +From: Michel Dänzer + +commit 3283c83eb6fcfbda8ea03d7149d8e42e71c5d45e upstream. + +Requires enabling the vblank machinery for them. + +Bug: https://gitlab.freedesktop.org/drm/amd/-/issues/2030 +Signed-off-by: Michel Dänzer +Signed-off-by: Alex Deucher +Cc: stable@vger.kernel.org +Signed-off-by: Greg Kroah-Hartman +--- + drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c | 43 ++++++++++++++++++++-- + 1 file changed, 40 insertions(+), 3 deletions(-) + +--- a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c ++++ b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c +@@ -439,6 +439,26 @@ static void dm_pflip_high_irq(void *inte + vrr_active, (int) !e); + } + ++static void dm_crtc_handle_vblank(struct amdgpu_crtc *acrtc) ++{ ++ struct drm_crtc *crtc = &acrtc->base; ++ struct drm_device *dev = crtc->dev; ++ unsigned long flags; ++ ++ drm_crtc_handle_vblank(crtc); ++ ++ spin_lock_irqsave(&dev->event_lock, flags); ++ ++ /* Send completion event for cursor-only commits */ ++ if (acrtc->event && acrtc->pflip_status != AMDGPU_FLIP_SUBMITTED) { ++ drm_crtc_send_vblank_event(crtc, acrtc->event); ++ drm_crtc_vblank_put(crtc); ++ acrtc->event = NULL; ++ } ++ ++ spin_unlock_irqrestore(&dev->event_lock, flags); ++} ++ + static void dm_vupdate_high_irq(void *interrupt_params) + { + struct common_irq_params *irq_params = interrupt_params; +@@ -463,7 +483,7 @@ static void dm_vupdate_high_irq(void *in + * if a pageflip happened inside front-porch. + */ + if (vrr_active) { +- drm_crtc_handle_vblank(&acrtc->base); ++ dm_crtc_handle_vblank(acrtc); + + /* BTR processing for pre-DCE12 ASICs */ + if (acrtc->dm_irq_params.stream && +@@ -515,7 +535,7 @@ static void dm_crtc_high_irq(void *inter + * to dm_vupdate_high_irq after end of front-porch. + */ + if (!vrr_active) +- drm_crtc_handle_vblank(&acrtc->base); ++ dm_crtc_handle_vblank(acrtc); + + /** + * Following stuff must happen at start of vblank, for crc +@@ -7169,6 +7189,7 @@ static void amdgpu_dm_commit_planes(stru + struct amdgpu_bo *abo; + uint32_t target_vblank, last_flip_vblank; + bool vrr_active = amdgpu_dm_vrr_active(acrtc_state); ++ bool cursor_update = false; + bool pflip_present = false; + struct { + struct dc_surface_update surface_updates[MAX_SURFACES]; +@@ -7203,8 +7224,13 @@ static void amdgpu_dm_commit_planes(stru + struct dm_plane_state *dm_new_plane_state = to_dm_plane_state(new_plane_state); + + /* Cursor plane is handled after stream updates */ +- if (plane->type == DRM_PLANE_TYPE_CURSOR) ++ if (plane->type == DRM_PLANE_TYPE_CURSOR) { ++ if ((fb && crtc == pcrtc) || ++ (old_plane_state->fb && old_plane_state->crtc == pcrtc)) ++ cursor_update = true; ++ + continue; ++ } + + if (!fb || !crtc || pcrtc != crtc) + continue; +@@ -7366,6 +7392,17 @@ static void amdgpu_dm_commit_planes(stru + bundle->stream_update.vrr_infopacket = + &acrtc_state->stream->vrr_infopacket; + } ++ } else if (cursor_update && acrtc_state->active_planes > 0 && ++ !acrtc_state->force_dpms_off && ++ acrtc_attach->base.state->event) { ++ drm_crtc_vblank_get(pcrtc); ++ ++ spin_lock_irqsave(&pcrtc->dev->event_lock, flags); ++ ++ acrtc_attach->event = acrtc_attach->base.state->event; ++ acrtc_attach->base.state->event = NULL; ++ ++ spin_unlock_irqrestore(&pcrtc->dev->event_lock, flags); + } + + /* Update the planes if changed or disable if we don't have any. */ diff --git a/queue-5.10/serial-8250-fix-pm-usage_count-for-console-handover.patch b/queue-5.10/serial-8250-fix-pm-usage_count-for-console-handover.patch new file mode 100644 index 00000000000..be569c5191c --- /dev/null +++ b/queue-5.10/serial-8250-fix-pm-usage_count-for-console-handover.patch @@ -0,0 +1,105 @@ +From f9b11229b79c0fb2100b5bb4628a101b1d37fbf6 Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?Ilpo=20J=C3=A4rvinen?= +Date: Wed, 29 Jun 2022 12:48:41 +0300 +Subject: serial: 8250: Fix PM usage_count for console handover +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +From: Ilpo Järvinen + +commit f9b11229b79c0fb2100b5bb4628a101b1d37fbf6 upstream. + +When console is enabled, univ8250_console_setup() calls +serial8250_console_setup() before .dev is set to uart_port. Therefore, +it will not call pm_runtime_get_sync(). Later, when the actual driver +is going to take over univ8250_console_exit() is called. As .dev is +already set, serial8250_console_exit() makes pm_runtime_put_sync() call +with usage count being zero triggering PM usage count warning +(extra debug for univ8250_console_setup(), univ8250_console_exit(), and +serial8250_register_ports()): + +[ 0.068987] univ8250_console_setup ttyS0 nodev +[ 0.499670] printk: console [ttyS0] enabled +[ 0.717955] printk: console [ttyS0] printing thread started +[ 1.960163] serial8250_register_ports assigned dev for ttyS0 +[ 1.976830] printk: console [ttyS0] disabled +[ 1.976888] printk: console [ttyS0] printing thread stopped +[ 1.977073] univ8250_console_exit ttyS0 usage:0 +[ 1.977075] serial8250 serial8250: Runtime PM usage count underflow! +[ 1.977429] dw-apb-uart.6: ttyS0 at MMIO 0x4010006000 (irq = 33, base_baud = 115200) is a 16550A +[ 1.977812] univ8250_console_setup ttyS0 usage:2 +[ 1.978167] printk: console [ttyS0] printing thread started +[ 1.978203] printk: console [ttyS0] enabled + +To fix the issue, call pm_runtime_get_sync() in +serial8250_register_ports() as soon as .dev is set for an uart_port +if it has console enabled. + +This problem became apparent only recently because 82586a721595 ("PM: +runtime: Avoid device usage count underflows") added the warning +printout. I confirmed this problem also occurs with v5.18 (w/o the +warning printout, obviously). + +Fixes: bedb404e91bb ("serial: 8250_port: Don't use power management for kernel console") +Cc: stable +Tested-by: Tony Lindgren +Reviewed-by: Andy Shevchenko +Reviewed-by: Tony Lindgren +Signed-off-by: Ilpo Järvinen +Link: https://lore.kernel.org/r/b4f428e9-491f-daf2-2232-819928dc276e@linux.intel.com +Signed-off-by: Greg Kroah-Hartman +--- + drivers/tty/serial/8250/8250_core.c | 4 ++++ + drivers/tty/serial/serial_core.c | 5 ----- + include/linux/serial_core.h | 5 +++++ + 3 files changed, 9 insertions(+), 5 deletions(-) + +--- a/drivers/tty/serial/8250/8250_core.c ++++ b/drivers/tty/serial/8250/8250_core.c +@@ -23,6 +23,7 @@ + #include + #include + #include ++#include + #include + #include + #include +@@ -571,6 +572,9 @@ serial8250_register_ports(struct uart_dr + + up->port.dev = dev; + ++ if (uart_console_enabled(&up->port)) ++ pm_runtime_get_sync(up->port.dev); ++ + serial8250_apply_quirks(up); + uart_add_one_port(drv, &up->port); + } +--- a/drivers/tty/serial/serial_core.c ++++ b/drivers/tty/serial/serial_core.c +@@ -1941,11 +1941,6 @@ static int uart_proc_show(struct seq_fil + } + #endif + +-static inline bool uart_console_enabled(struct uart_port *port) +-{ +- return uart_console(port) && (port->cons->flags & CON_ENABLED); +-} +- + static void uart_port_spin_lock_init(struct uart_port *port) + { + spin_lock_init(&port->lock); +--- a/include/linux/serial_core.h ++++ b/include/linux/serial_core.h +@@ -394,6 +394,11 @@ static const bool earlycon_acpi_spcr_ena + static inline int setup_earlycon(char *buf) { return 0; } + #endif + ++static inline bool uart_console_enabled(struct uart_port *port) ++{ ++ return uart_console(port) && (port->cons->flags & CON_ENABLED); ++} ++ + struct uart_port *uart_get_console(struct uart_port *ports, int nr, + struct console *c); + int uart_parse_earlycon(char *p, unsigned char *iotype, resource_size_t *addr, diff --git a/queue-5.10/serial-8250-fix-return-error-code-in-serial8250_request_std_resource.patch b/queue-5.10/serial-8250-fix-return-error-code-in-serial8250_request_std_resource.patch new file mode 100644 index 00000000000..c93a3a1b814 --- /dev/null +++ b/queue-5.10/serial-8250-fix-return-error-code-in-serial8250_request_std_resource.patch @@ -0,0 +1,39 @@ +From 6e690d54cfa802f939cefbd2fa2c91bd0b8bd1b6 Mon Sep 17 00:00:00 2001 +From: Yi Yang +Date: Tue, 28 Jun 2022 16:35:15 +0800 +Subject: serial: 8250: fix return error code in serial8250_request_std_resource() + +From: Yi Yang + +commit 6e690d54cfa802f939cefbd2fa2c91bd0b8bd1b6 upstream. + +If port->mapbase = NULL in serial8250_request_std_resource() , it need +return a error code instead of 0. If uart_set_info() fail to request new +regions by serial8250_request_std_resource() but the return value of +serial8250_request_std_resource() is 0, The system incorrectly considers +that the resource application is successful and does not attempt to +restore the old setting. A null pointer reference is triggered when the +port resource is later invoked. + +Signed-off-by: Yi Yang +Cc: stable +Link: https://lore.kernel.org/r/20220628083515.64138-1-yiyang13@huawei.com +Signed-off-by: Greg Kroah-Hartman +--- + drivers/tty/serial/8250/8250_port.c | 4 +++- + 1 file changed, 3 insertions(+), 1 deletion(-) + +--- a/drivers/tty/serial/8250/8250_port.c ++++ b/drivers/tty/serial/8250/8250_port.c +@@ -2953,8 +2953,10 @@ static int serial8250_request_std_resour + case UPIO_MEM32BE: + case UPIO_MEM16: + case UPIO_MEM: +- if (!port->mapbase) ++ if (!port->mapbase) { ++ ret = -EINVAL; + break; ++ } + + if (!request_mem_region(port->mapbase, size, "serial")) { + ret = -EBUSY; diff --git a/queue-5.10/serial-pl011-upstat_autorts-requires-.throttle-unthrottle.patch b/queue-5.10/serial-pl011-upstat_autorts-requires-.throttle-unthrottle.patch new file mode 100644 index 00000000000..e4be0a48340 --- /dev/null +++ b/queue-5.10/serial-pl011-upstat_autorts-requires-.throttle-unthrottle.patch @@ -0,0 +1,83 @@ +From 211565b100993c90b53bf40851eacaefc830cfe0 Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?Ilpo=20J=C3=A4rvinen?= +Date: Tue, 14 Jun 2022 10:56:37 +0300 +Subject: serial: pl011: UPSTAT_AUTORTS requires .throttle/unthrottle +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +From: Ilpo Järvinen + +commit 211565b100993c90b53bf40851eacaefc830cfe0 upstream. + +The driver must provide throttle and unthrottle in uart_ops when it +sets UPSTAT_AUTORTS. Add them using existing stop_rx & +enable_interrupts functions. + +Fixes: 2a76fa283098 (serial: pl011: Adopt generic flag to store auto RTS status) +Cc: stable +Cc: Lukas Wunner +Reported-by: Nuno Gonçalves +Tested-by: Nuno Gonçalves +Signed-off-by: Ilpo Järvinen +Link: https://lore.kernel.org/r/20220614075637.8558-1-ilpo.jarvinen@linux.intel.com +Signed-off-by: Greg Kroah-Hartman +--- + drivers/tty/serial/amba-pl011.c | 23 +++++++++++++++++++++-- + 1 file changed, 21 insertions(+), 2 deletions(-) + +--- a/drivers/tty/serial/amba-pl011.c ++++ b/drivers/tty/serial/amba-pl011.c +@@ -1326,6 +1326,15 @@ static void pl011_stop_rx(struct uart_po + pl011_dma_rx_stop(uap); + } + ++static void pl011_throttle_rx(struct uart_port *port) ++{ ++ unsigned long flags; ++ ++ spin_lock_irqsave(&port->lock, flags); ++ pl011_stop_rx(port); ++ spin_unlock_irqrestore(&port->lock, flags); ++} ++ + static void pl011_enable_ms(struct uart_port *port) + { + struct uart_amba_port *uap = +@@ -1717,9 +1726,10 @@ static int pl011_allocate_irq(struct uar + */ + static void pl011_enable_interrupts(struct uart_amba_port *uap) + { ++ unsigned long flags; + unsigned int i; + +- spin_lock_irq(&uap->port.lock); ++ spin_lock_irqsave(&uap->port.lock, flags); + + /* Clear out any spuriously appearing RX interrupts */ + pl011_write(UART011_RTIS | UART011_RXIS, uap, REG_ICR); +@@ -1741,7 +1751,14 @@ static void pl011_enable_interrupts(stru + if (!pl011_dma_rx_running(uap)) + uap->im |= UART011_RXIM; + pl011_write(uap->im, uap, REG_IMSC); +- spin_unlock_irq(&uap->port.lock); ++ spin_unlock_irqrestore(&uap->port.lock, flags); ++} ++ ++static void pl011_unthrottle_rx(struct uart_port *port) ++{ ++ struct uart_amba_port *uap = container_of(port, struct uart_amba_port, port); ++ ++ pl011_enable_interrupts(uap); + } + + static int pl011_startup(struct uart_port *port) +@@ -2116,6 +2133,8 @@ static const struct uart_ops amba_pl011_ + .stop_tx = pl011_stop_tx, + .start_tx = pl011_start_tx, + .stop_rx = pl011_stop_rx, ++ .throttle = pl011_throttle_rx, ++ .unthrottle = pl011_unthrottle_rx, + .enable_ms = pl011_enable_ms, + .break_ctl = pl011_break_ctl, + .startup = pl011_startup, diff --git a/queue-5.10/serial-stm32-clear-prev-values-before-setting-rts-delays.patch b/queue-5.10/serial-stm32-clear-prev-values-before-setting-rts-delays.patch new file mode 100644 index 00000000000..bbd5bcbdb5b --- /dev/null +++ b/queue-5.10/serial-stm32-clear-prev-values-before-setting-rts-delays.patch @@ -0,0 +1,37 @@ +From 5c5f44e36217de5ead789ff25da71c31c2331c96 Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?Ilpo=20J=C3=A4rvinen?= +Date: Mon, 27 Jun 2022 18:07:52 +0300 +Subject: serial: stm32: Clear prev values before setting RTS delays +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +From: Ilpo Järvinen + +commit 5c5f44e36217de5ead789ff25da71c31c2331c96 upstream. + +The code lacks clearing of previous DEAT/DEDT values. Thus, changing +values on the fly results in garbage delays tending towards the maximum +value as more and more bits are ORed together. (Leaving RS485 mode +would have cleared the old values though). + +Fixes: 1bcda09d2910 ("serial: stm32: add support for RS485 hardware control mode") +Cc: stable +Signed-off-by: Ilpo Järvinen +Link: https://lore.kernel.org/r/20220627150753.34510-1-ilpo.jarvinen@linux.intel.com +Signed-off-by: Greg Kroah-Hartman +--- + drivers/tty/serial/stm32-usart.c | 2 ++ + 1 file changed, 2 insertions(+) + +--- a/drivers/tty/serial/stm32-usart.c ++++ b/drivers/tty/serial/stm32-usart.c +@@ -70,6 +70,8 @@ static void stm32_usart_config_reg_rs485 + *cr3 |= USART_CR3_DEM; + over8 = *cr1 & USART_CR1_OVER8; + ++ *cr1 &= ~(USART_CR1_DEDT_MASK | USART_CR1_DEAT_MASK); ++ + if (over8) + rs485_deat_dedt = delay_ADE * baud * 8; + else diff --git a/queue-5.10/series b/queue-5.10/series index e122a6027b1..7a19a765b07 100644 --- a/queue-5.10/series +++ b/queue-5.10/series @@ -104,3 +104,10 @@ usb-serial-ftdi_sio-add-belimo-device-ids.patch usb-typec-add-missing-uevent-when-partner-support-pd.patch usb-dwc3-gadget-fix-event-pending-check.patch tty-serial-samsung_tty-set-dma-burst_size-to-1.patch +vt-fix-memory-overlapping-when-deleting-chars-in-the-buffer.patch +drm-amd-display-ensure-valid-event-timestamp-for-cursor-only-commits.patch +serial-8250-fix-return-error-code-in-serial8250_request_std_resource.patch +serial-stm32-clear-prev-values-before-setting-rts-delays.patch +serial-pl011-upstat_autorts-requires-.throttle-unthrottle.patch +serial-8250-fix-pm-usage_count-for-console-handover.patch +x86-pat-fix-x86_has_pat_wp.patch diff --git a/queue-5.10/vt-fix-memory-overlapping-when-deleting-chars-in-the-buffer.patch b/queue-5.10/vt-fix-memory-overlapping-when-deleting-chars-in-the-buffer.patch new file mode 100644 index 00000000000..970465e7d3f --- /dev/null +++ b/queue-5.10/vt-fix-memory-overlapping-when-deleting-chars-in-the-buffer.patch @@ -0,0 +1,38 @@ +From 39cdb68c64d84e71a4a717000b6e5de208ee60cc Mon Sep 17 00:00:00 2001 +From: Yangxi Xiang +Date: Tue, 28 Jun 2022 17:33:22 +0800 +Subject: vt: fix memory overlapping when deleting chars in the buffer + +From: Yangxi Xiang + +commit 39cdb68c64d84e71a4a717000b6e5de208ee60cc upstream. + +A memory overlapping copy occurs when deleting a long line. This memory +overlapping copy can cause data corruption when scr_memcpyw is optimized +to memcpy because memcpy does not ensure its behavior if the destination +buffer overlaps with the source buffer. The line buffer is not always +broken, because the memcpy utilizes the hardware acceleration, whose +result is not deterministic. + +Fix this problem by using replacing the scr_memcpyw with scr_memmovew. + +Fixes: 81732c3b2fed ("tty vt: Fix line garbage in virtual console on command line edition") +Cc: stable +Signed-off-by: Yangxi Xiang +Link: https://lore.kernel.org/r/20220628093322.5688-1-xyangxi5@gmail.com +Signed-off-by: Greg Kroah-Hartman +--- + drivers/tty/vt/vt.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +--- a/drivers/tty/vt/vt.c ++++ b/drivers/tty/vt/vt.c +@@ -855,7 +855,7 @@ static void delete_char(struct vc_data * + unsigned short *p = (unsigned short *) vc->vc_pos; + + vc_uniscr_delete(vc, nr); +- scr_memcpyw(p, p + nr, (vc->vc_cols - vc->state.x - nr) * 2); ++ scr_memmovew(p, p + nr, (vc->vc_cols - vc->state.x - nr) * 2); + scr_memsetw(p + vc->vc_cols - vc->state.x - nr, vc->vc_video_erase_char, + nr * 2); + vc->vc_need_wrap = 0; diff --git a/queue-5.10/x86-pat-fix-x86_has_pat_wp.patch b/queue-5.10/x86-pat-fix-x86_has_pat_wp.patch new file mode 100644 index 00000000000..7ffe2f2d403 --- /dev/null +++ b/queue-5.10/x86-pat-fix-x86_has_pat_wp.patch @@ -0,0 +1,63 @@ +From 230ec83d4299b30c51a1c133b4f2a669972cc08a Mon Sep 17 00:00:00 2001 +From: Juergen Gross +Date: Fri, 8 Jul 2022 15:14:56 +0200 +Subject: x86/pat: Fix x86_has_pat_wp() + +From: Juergen Gross + +commit 230ec83d4299b30c51a1c133b4f2a669972cc08a upstream. + +x86_has_pat_wp() is using a wrong test, as it relies on the normal +PAT configuration used by the kernel. In case the PAT MSR has been +setup by another entity (e.g. Xen hypervisor) it might return false +even if the PAT configuration is allowing WP mappings. This due to the +fact that when running as Xen PV guest the PAT MSR is setup by the +hypervisor and cannot be changed by the guest. This results in the WP +related entry to be at a different position when running as Xen PV +guest compared to the bare metal or fully virtualized case. + +The correct way to test for WP support is: + +1. Get the PTE protection bits needed to select WP mode by reading + __cachemode2pte_tbl[_PAGE_CACHE_MODE_WP] (depending on the PAT MSR + setting this might return protection bits for a stronger mode, e.g. + UC-) +2. Translate those bits back into the real cache mode selected by those + PTE bits by reading __pte2cachemode_tbl[__pte2cm_idx(prot)] +3. Test for the cache mode to be _PAGE_CACHE_MODE_WP + +Fixes: f88a68facd9a ("x86/mm: Extend early_memremap() support with additional attrs") +Signed-off-by: Juergen Gross +Signed-off-by: Borislav Petkov +Cc: # 4.14 +Link: https://lore.kernel.org/r/20220503132207.17234-1-jgross@suse.com +Signed-off-by: Greg Kroah-Hartman +--- + arch/x86/mm/init.c | 14 ++++++++++++-- + 1 file changed, 12 insertions(+), 2 deletions(-) + +--- a/arch/x86/mm/init.c ++++ b/arch/x86/mm/init.c +@@ -78,10 +78,20 @@ static uint8_t __pte2cachemode_tbl[8] = + [__pte2cm_idx(_PAGE_PWT | _PAGE_PCD | _PAGE_PAT)] = _PAGE_CACHE_MODE_UC, + }; + +-/* Check that the write-protect PAT entry is set for write-protect */ ++/* ++ * Check that the write-protect PAT entry is set for write-protect. ++ * To do this without making assumptions how PAT has been set up (Xen has ++ * another layout than the kernel), translate the _PAGE_CACHE_MODE_WP cache ++ * mode via the __cachemode2pte_tbl[] into protection bits (those protection ++ * bits will select a cache mode of WP or better), and then translate the ++ * protection bits back into the cache mode using __pte2cm_idx() and the ++ * __pte2cachemode_tbl[] array. This will return the really used cache mode. ++ */ + bool x86_has_pat_wp(void) + { +- return __pte2cachemode_tbl[_PAGE_CACHE_MODE_WP] == _PAGE_CACHE_MODE_WP; ++ uint16_t prot = __cachemode2pte_tbl[_PAGE_CACHE_MODE_WP]; ++ ++ return __pte2cachemode_tbl[__pte2cm_idx(prot)] == _PAGE_CACHE_MODE_WP; + } + + enum page_cache_mode pgprot2cachemode(pgprot_t pgprot)