FAILED: patch "[PATCH] ACPI: processor_idle: Fix invalid comparison with insertion" failed to apply to 5.15-stable tree
Subsystems (2)
[email protected]
maintainerThe patch below does not apply to the 5.15-stable tree.
If someone wants it applied there, or to any other stable or longterm tree, then please email the backport, including the original git commit id to <[email protected]>.
To reproduce the conflict and resubmit, you may use the following commands:
git fetch https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git/ linux-5.15.y
git checkout FETCH_HEAD
git cherry-pick -x 233323f9b9f828cd7cd5145ad811c1990b692542
# <resolve conflicts, build, test, etc.>
git commit -s
git send-email --to '<[email protected]>' --in-reply-to '2024071528-foothill-overdraft-d69a@gregkh' --subject-prefix 'PATCH 5.15.y' HEAD^..
Possible dependencies:
233323f9b9f8 ("ACPI: processor_idle: Fix invalid comparison with insertion sort for latency") 0e6078c3c673 ("ACPI: processor idle: Use swap() instead of open coding it")
thanks,
greg k-h
------------------ original commit in Linus's tree ------------------
From 233323f9b9f828cd7cd5145ad811c1990b692542 Mon Sep 17 00:00:00 2001
From: Kuan-Wei Chiu <[email protected]>
Date: Tue, 2 Jul 2024 04:56:39 +0800
Subject: [PATCH] ACPI: processor_idle: Fix invalid comparison with insertion
sort for latency
The acpi_cst_latency_cmp() comparison function currently used for sorting C-state latencies does not satisfy transitivity, causing incorrect sorting results.
Specifically, if there are two valid acpi_processor_cx elements A and B and one invalid element C, it may occur that A < B, A = C, and B = C. Sorting algorithms assume that if A < B and A = C, then C < B, leading to incorrect ordering.
Given the small size of the array (<=8), we replace the library sort function with a simple insertion sort that properly ignores invalid elements and sorts valid ones based on latency. This change ensures correct ordering of the C-state latencies.
drivers/acpi/processor_idle.c +16 -21
@@ -16,7 +16,6 @@#include <linux/acpi.h> #include <linux/dmi.h> #include <linux/sched.h> /* need_resched() */ -#include <linux/sort.h> #include <linux/tick.h> #include <linux/cpuidle.h> #include <linux/cpu.h>
@@ -386,25 +385,24 @@ static void acpi_processor_power_verify_c3(struct acpi_processor *pr,acpi_write_bit_register (ACPI_BITREG_BUS_MASTER_RLD ,1 ); } -static int acpi_cst_latency_cmp (const void *a,const void *b) +static void acpi_cst_latency_sort (struct acpi_processor_cx *states,size_t length) { -const struct acpi_processor_cx *x = a, *y = b; +int i, j, k; -if (!(x->valid && y->valid)) -return 0 ; -if (x->latency > y->latency) -return 1 ; -if (x->latency < y->latency) -return -1 ; -return 0 ; -} -static void acpi_cst_latency_swap (void *a,void *b,int n) -{ -struct acpi_processor_cx *x = a, *y = b; +for (i =1 ; i < length; i++) { +if (!states[i].valid) +continue ; -if (!(x->valid && y->valid)) -return ; -swap (x->latency, y->latency); +for (j = i -1 , k = i; j >=0 ; j--) { +if (!states[j].valid) +continue ; + +if (states[j].latency > states[k].latency) +swap (states[j].latency, states[k].latency); + + k = j; + } + } }static int acpi_processor_power_verify (struct acpi_processor *pr)
@@ -449,10 +447,7 @@ static int acpi_processor_power_verify(struct acpi_processor *pr)if (buggy_latency) {pr_notice ("FW issue: working around C-state latencies out of order\n" ); -sort (&pr->power.states[1 ], max_cstate, -sizeof (struct acpi_processor_cx ), - acpi_cst_latency_cmp, - acpi_cst_latency_swap); +acpi_cst_latency_sort (&pr->power.states[1 ], max_cstate); }lapic_timer_propagate_broadcast (pr);
PATCH 1/1 ACPI: processor_idle: Fix invalid comparison with insertion sort for latency
The acpi_cst_latency_cmp() comparison function currently used for sorting C-state latencies does not satisfy transitivity, causing incorrect sorting results.
Specifically, if there are two valid acpi_processor_cx elements A and B and one invalid element C, it may occur that A < B, A = C, and B = C. Sorting algorithms assume that if A < B and A = C, then C < B, leading to incorrect ordering.
Given the small size of the array (<=8), we replace the library sort function with a simple insertion sort that properly ignores invalid elements and sorts valid ones based on latency. This change ensures correct ordering of the C-state latencies.
--- drivers/acpi/processor_idle.c | 40 ++++++++++++++--------------------- 1 file changed, 16 insertions(+), 24 deletions(-)
drivers/acpi/processor_idle.c +16 -24
@@ -16,7 +16,6 @@#include <linux/acpi.h> #include <linux/dmi.h> #include <linux/sched.h> /* need_resched() */ -#include <linux/sort.h> #include <linux/tick.h> #include <linux/cpuidle.h> #include <linux/cpu.h>
@@ -385,28 +384,24 @@ static void acpi_processor_power_verify_c3(struct acpi_processor *pr,return ; } -static int acpi_cst_latency_cmp (const void *a,const void *b) +static void acpi_cst_latency_sort (struct acpi_processor_cx *states,size_t length) { -const struct acpi_processor_cx *x = a, *y = b; +int i, j, k; -if (!(x->valid && y->valid)) -return 0 ; -if (x->latency > y->latency) -return 1 ; -if (x->latency < y->latency) -return -1 ; -return 0 ; -} -static void acpi_cst_latency_swap (void *a,void *b,int n) -{ -struct acpi_processor_cx *x = a, *y = b; -u32 tmp; +for (i =1 ; i < length; i++) { +if (!states[i].valid) +continue ; -if (!(x->valid && y->valid)) -return ; - tmp = x->latency; - x->latency = y->latency; - y->latency = tmp; +for (j = i -1 , k = i; j >=0 ; j--) { +if (!states[j].valid) +continue ; + +if (states[j].latency > states[k].latency) +swap (states[j].latency, states[k].latency); + + k = j; + } + } }static int acpi_processor_power_verify (struct acpi_processor *pr)
@@ -451,10 +446,7 @@ static int acpi_processor_power_verify(struct acpi_processor *pr)if (buggy_latency) {pr_notice ("FW issue: working around C-state latencies out of order\n" ); -sort (&pr->power.states[1 ], max_cstate, -sizeof (struct acpi_processor_cx ), - acpi_cst_latency_cmp, - acpi_cst_latency_swap); +acpi_cst_latency_sort (&pr->power.states[1 ], max_cstate); }lapic_timer_propagate_broadcast (pr);
Signature · 1 line
2.34.1
Re: [PATCH 5.15.y] ACPI: processor_idle: Fix invalid comparison with insertion sort for latency
Quoted 24 lines · Kuan-Wei Chiu
The
acpi_cst_latency_cmp()comparison function currently used for sorting C-state latencies does not satisfy transitivity, causing incorrect sorting results.Specifically, if there are two valid
acpi_processor_cxelements A and B and one invalid element C, it may occur that A < B, A = C, and B = C. Sorting algorithms assume that if A < B and A = C, then C < B, leading to incorrect ordering.Given the small size of the array (<=8), we replace the library sort function with a simple insertion sort that properly ignores invalid elements and sorts valid ones based on latency. This change ensures correct ordering of the C-state latencies.
Fixes 65ea8f2c6e23 ("ACPI: processor idle: Fix up C-state latency if not ordered")Reported-by Julian Sikorski <[email protected]>Signed-off-by Kuan-Wei Chiu <[email protected]>Tested-by Julian Sikorski <[email protected]>Cc All applicable <[email protected]>Signed-off-by Rafael J. Wysocki <[email protected]>(cherry picked from commit 233323f9b9f828cd7cd5145ad811c1990b692542)Signed-off-by Kuan-Wei Chiu <[email protected]>
Quoted 3 lines
--- drivers/acpi/processor_idle.c | 40 ++++++++++++++--------------------- 1 file changed, 16 insertions(+), 24 deletions(-)
ALl now queued up, thanks.
greg k-h