FAILED: patch "[PATCH] tracing/kprobes: Return EADDRNOTAVAIL when func matches" failed to apply to 4.19-stable tree
Subsystems (2)
[email protected]
maintainerThe patch below does not apply to the 4.19-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-4.19.y
git checkout FETCH_HEAD
git cherry-pick -x b022f0c7e404887a7c5229788fc99eff9f9a80d5
# <resolve conflicts, build, test, etc.>
git commit -s
git send-email --to '<[email protected]>' --in-reply-to '2023102138-riverbed-senator-e356@gregkh' --subject-prefix 'PATCH 4.19.y' HEAD^..
Possible dependencies:
thanks,
greg k-h
------------------ original commit in Linus's tree ------------------
From b022f0c7e404887a7c5229788fc99eff9f9a80d5 Mon Sep 17 00:00:00 2001
From: Francis Laniel <[email protected]>
Date: Fri, 20 Oct 2023 13:42:49 +0300
Subject: [PATCH] tracing/kprobes: Return EADDRNOTAVAIL when func matches
several symbols
When a kprobe is attached to a function that's name is not unique (is static and shares the name with other functions in the kernel), the kprobe is attached to the first function it finds. This is a bug as the function that it is attaching to is not necessarily the one that the user wants to attach to.
Instead of blindly picking a function to attach to what is ambiguous, error with EADDRNOTAVAIL to let the user know that this function is not unique, and that the user must use another unique function with an address offset to get to the function they want to attach to.
kernel/trace/trace_kprobe.c +63 -0
@@ -705,6 +705,25 @@ static struct notifier_block trace_kprobe_module_nb = { .priority = 1 /* Invoked after kprobe module callback */ }; +static int count_symbols (void *data,unsigned long unused) +{ +unsigned int *count = data; + + (*count)++; + +return 0 ; +} + +static unsigned int number_of_same_symbols (char *func_name) +{ +unsigned int count; + + count =0 ; +kallsyms_on_each_match_symbol (count_symbols, func_name, &count); + +return count; +} +static int __trace_kprobe_create (int argc,const char *argv[]) {/*
@@ -836,6 +855,31 @@ static int __trace_kprobe_create(int argc, const char *argv[]) } } +if (symbol && !strchr (symbol,':' )) { +unsigned int count; + + count =number_of_same_symbols (symbol); +if (count >1 ) { +/* +* Users should use ADDR to remove the ambiguity of +* using KSYM only. +*/ +trace_probe_log_err (0 ,NON_UNIQ_SYMBOL ); + ret = -EADDRNOTAVAIL ; + + goto error; + }else if (count ==0 ) { +/* +* We can return ENOENT earlier than when register the +* kprobe. +*/ +trace_probe_log_err (0 ,BAD_PROBE_ADDR ); + ret = -ENOENT ; + + goto error; + } + } +trace_probe_log_set_index (0 );if (event) { ret = traceprobe_parse_event_name(&event, &group, gbuf,
@@ -1695,6 +1739,7 @@ static int unregister_kprobe_event(struct trace_kprobe *tk) }#ifdef CONFIG_PERF_EVENTS +/* create a trace_kprobe, but don't add it to global lists */ struct trace_event_call * create_local_trace_kprobe(char *func, void *addr, unsigned long offs,
@@ -1705,6 +1750,24 @@ create_local_trace_kprobe(char *func, void *addr, unsigned long offs,int ret;char *event; +if (func) { +unsigned int count; + + count =number_of_same_symbols (func); +if (count >1 ) +/* +* Users should use addr to remove the ambiguity of +* using func only. +*/ +return ERR_PTR (-EADDRNOTAVAIL ); +else if (count ==0 ) +/* +* We can return ENOENT earlier than when register the +* kprobe. +*/ +return ERR_PTR (-ENOENT ); + } +/* * local trace_kprobes are not added to dyn_event, so they are never * searched in find_trace_kprobe(). Therefore, there is no concern of
kernel/trace/trace_probe.h +1 -0
@@ -450,6 +450,7 @@ extern int traceprobe_define_arg_fields(struct trace_event_call *event_call,C (BAD_MAXACT ,"Invalid maxactive number" ), \C (MAXACT_TOO_BIG ,"Maxactive is too big" ), \C (BAD_PROBE_ADDR ,"Invalid probed address or symbol" ), \ +C (NON_UNIQ_SYMBOL ,"The symbol is not unique" ), \C (BAD_RETPROBE ,"Retprobe address must be an function entry" ), \C (NO_TRACEPOINT ,"Tracepoint is not found" ), \ C(BAD_ADDR_SUFFIX, "Invalid probed address suffix"), \
PATCH 1/1 tracing/kprobes: Return EADDRNOTAVAIL when func matches several symbols
When a kprobe is attached to a function that's name is not unique (is static and shares the name with other functions in the kernel), the kprobe is attached to the first function it finds. This is a bug as the function that it is attaching to is not necessarily the one that the user wants to attach to.
Instead of blindly picking a function to attach to what is ambiguous, error with EADDRNOTAVAIL to let the user know that this function is not unique, and that the user must use another unique function with an address offset to get to the function they want to attach to.
--- kernel/trace/trace_kprobe.c | 48 +++++++++++++++++++++++++++++++++++++ 1 file changed, 48 insertions(+)
kernel/trace/trace_kprobe.c +48 -0
@@ -715,6 +715,36 @@ static inline void sanitize_event_name(char *name) *name ='_' ; } +struct count_symbols_struct { +const char *func_name; +unsigned int count; +}; + +static int count_symbols (void *data,const char *name,struct module *unused0, +unsigned long unused1) +{ +struct count_symbols_struct *args = data; + +if (strcmp (args->func_name, name)) +return 0 ; + + args->count++; + +return 0 ; +} + +static unsigned int number_of_same_symbols (char *func_name) +{ +struct count_symbols_struct args = { + .func_name = func_name, + .count =0 , + }; + +kallsyms_on_each_symbol (count_symbols, &args); + +return args.count; +} +static int create_trace_kprobe (int argc,char **argv) {/*
@@ -845,6 +875,24 @@ static int create_trace_kprobe(int argc, char **argv) } argc -=2 ; argv +=2 ; +if (symbol && !strchr (symbol,':' )) { +unsigned int count; + + count =number_of_same_symbols (symbol); +if (count >1 ) +/* +* Users should use ADDR to remove the ambiguity of +* using KSYM only. +*/ +return -EADDRNOTAVAIL ; +else if (count ==0 ) +/* +* We can return ENOENT earlier than when register the +* kprobe. +*/ +return -ENOENT ; + } +/* setup a probe */ if (!event) {/* Make a new event name */
Signature · 1 line
2.34.1
Greg KH
maintainerRe: [PATCH 4.19.y] tracing/kprobes: Return EADDRNOTAVAIL when func matches several symbols
Quoted 21 lines · Francis Laniel
When a kprobe is attached to a function that's name is not unique (is static and shares the name with other functions in the kernel), the kprobe is attached to the first function it finds. This is a bug as the function that it is attaching to is not necessarily the one that the user wants to attach to.
Instead of blindly picking a function to attach to what is ambiguous, error with EADDRNOTAVAIL to let the user know that this function is not unique, and that the user must use another unique function with an address offset to get to the function they want to attach to.
Fixes 413d37d1eb69 ("tracing: Add kprobe-based event tracer")Suggested-by Masami Hiramatsu <[email protected]>Signed-off-by Francis Laniel <[email protected]>Signed-off-by Masami Hiramatsu (Google) <[email protected]>(cherry picked from commit b022f0c7e404887a7c5229788fc99eff9f9a80d5)
Quoted 3 lines
--- kernel/trace/trace_kprobe.c | 48 +++++++++++++++++++++++++++++++++++++ 1 file changed, 48 insertions(+)
Again, we need a version for 5.4.y as well before we can take this version.
thanks,
greg k-h
Re: [PATCH 4.19.y] tracing/kprobes: Return EADDRNOTAVAIL when func matches several symbols
Hi!
Quoted 27 lines · Le vendredi 24 novembre 2023, 17:17:04 CET Greg KH a écrit :
Quoted 26 lines · Francis Laniel
When a kprobe is attached to a function that's name is not unique (is static and shares the name with other functions in the kernel), the kprobe is attached to the first function it finds. This is a bug as the function that it is attaching to is not necessarily the one that the user wants to attach to.
Instead of blindly picking a function to attach to what is ambiguous, error with EADDRNOTAVAIL to let the user know that this function is not unique, and that the user must use another unique function with an address offset to get to the function they want to attach to.
Link:
https://lore.kernel.org/all/[email protected]
.com/Fixes 413d37d1eb69 ("tracing: Add kprobe-based event tracer")Suggested-by Masami Hiramatsu <[email protected]>Signed-off-by Francis Laniel <[email protected]>Link:
https://lore.kernel.org/lkml/20230819101105.b0c104ae4494a7d1f2eea742@kern
el.org/ Acked-by: Masami Hiramatsu (Google) <[email protected]>Signed-off-by Masami Hiramatsu (Google) <[email protected]>(cherry picked from commit b022f0c7e404887a7c5229788fc99eff9f9a80d5)---
Quoted 5 lines
Quoted 2 lines
kernel/trace/trace_kprobe.c | 48 +++++++++++++++++++++++++++++++++++++ 1 file changed, 48 insertions(+)Again, we need a version for 5.4.y as well before we can take this version.
I sent the 5.4.y patch some times ago, you can find it here:
https://lore.kernel.org/stable/[email protected]/
With the recent batch I sent, I should have cover all the stable kernels. In case I miss one, please indicate it to me so I can fix this problem and ensure all stable kernels have a corresponding patch.
Quoted 3 lines
thanks,
greg k-h
Best regards.
Greg KH
maintainerRe: [PATCH 4.19.y] tracing/kprobes: Return EADDRNOTAVAIL when func matches several symbols
Quoted 37 lines · Francis Laniel
Hi!
Quoted 27 lines · Le vendredi 24 novembre 2023, 17:17:04 CET Greg KH a écrit :
Quoted 26 lines · Francis Laniel
When a kprobe is attached to a function that's name is not unique (is static and shares the name with other functions in the kernel), the kprobe is attached to the first function it finds. This is a bug as the function that it is attaching to is not necessarily the one that the user wants to attach to.
Instead of blindly picking a function to attach to what is ambiguous, error with EADDRNOTAVAIL to let the user know that this function is not unique, and that the user must use another unique function with an address offset to get to the function they want to attach to.
Link:
https://lore.kernel.org/all/[email protected]
.com/Fixes 413d37d1eb69 ("tracing: Add kprobe-based event tracer")Suggested-by Masami Hiramatsu <[email protected]>Signed-off-by Francis Laniel <[email protected]>Link:
https://lore.kernel.org/lkml/20230819101105.b0c104ae4494a7d1f2eea742@kern
el.org/ Acked-by: Masami Hiramatsu (Google) <[email protected]>Signed-off-by Masami Hiramatsu (Google) <[email protected]>(cherry picked from commit b022f0c7e404887a7c5229788fc99eff9f9a80d5)---
Quoted 5 lines
Quoted 2 lines
kernel/trace/trace_kprobe.c | 48 +++++++++++++++++++++++++++++++++++++ 1 file changed, 48 insertions(+)Again, we need a version for 5.4.y as well before we can take this version.
Quoted 6 lines
I sent the 5.4.y patch some times ago, you can find it here:
https://lore.kernel.org/stable/[email protected]/With the recent batch I sent, I should have cover all the stable kernels. In case I miss one, please indicate it to me so I can fix this problem and ensure all stable kernels have a corresponding patch.
I only see the following in my stable mbox right now:
1 C Nov 27 Francis Laniel (4.4K) ┬─>[PATCH 5.10.y] tracing/kprobes: Return EADDRNOTAVAIL when func matches several symbols 2 r C Nov 24 Francis Laniel (4.4K) └─>[PATCH 5.10.y] tracing/kprobes: Return EADDRNOTAVAIL when func matches several symbols 3 F Nov 24 To Francis Lani (1.5K) └─> 4 r T Nov 27 Francis Laniel (1.9K) └─> 5 F Nov 27 To Francis Lani (2.0K) └─> 23 r C Nov 24 Francis Laniel (2.7K) [PATCH 4.19.y] tracing/kprobes: Return EADDRNOTAVAIL when func matches several symbols 24 r + Nov 27 Francis Laniel (2.0K) └─>
So could you resend them all just to be sure I have all of the latest versions that you wish to have applied?
thanks,
greg "drowning in patches" k-h
PATCH 1/1 tracing/kprobes: Return EADDRNOTAVAIL when func matches several symbols
In reply to [email protected]When a kprobe is attached to a function that's name is not unique (is static and shares the name with other functions in the kernel), the kprobe is attached to the first function it finds. This is a bug as the function that it is attaching to is not necessarily the one that the user wants to attach to.
Instead of blindly picking a function to attach to what is ambiguous, error with EADDRNOTAVAIL to let the user know that this function is not unique, and that the user must use another unique function with an address offset to get to the function they want to attach to.
--- kernel/trace/trace_kprobe.c | 48 +++++++++++++++++++++++++++++++++++++ 1 file changed, 48 insertions(+)
kernel/trace/trace_kprobe.c +48 -0
@@ -715,6 +715,36 @@ static inline void sanitize_event_name(char *name) *name ='_' ; } +struct count_symbols_struct { +const char *func_name; +unsigned int count; +}; + +static int count_symbols (void *data,const char *name,struct module *unused0, +unsigned long unused1) +{ +struct count_symbols_struct *args = data; + +if (strcmp (args->func_name, name)) +return 0 ; + + args->count++; + +return 0 ; +} + +static unsigned int number_of_same_symbols (char *func_name) +{ +struct count_symbols_struct args = { + .func_name = func_name, + .count =0 , + }; + +kallsyms_on_each_symbol (count_symbols, &args); + +return args.count; +} +static int create_trace_kprobe (int argc,char **argv) {/*
@@ -845,6 +875,24 @@ static int create_trace_kprobe(int argc, char **argv) } argc -=2 ; argv +=2 ; +if (symbol && !strchr (symbol,':' )) { +unsigned int count; + + count =number_of_same_symbols (symbol); +if (count >1 ) +/* +* Users should use ADDR to remove the ambiguity of +* using KSYM only. +*/ +return -EADDRNOTAVAIL ; +else if (count ==0 ) +/* +* We can return ENOENT earlier than when register the +* kprobe. +*/ +return -ENOENT ; + } +/* setup a probe */ if (!event) {/* Make a new event name */
Signature · 1 line
2.34.1
Re: [PATCH 4.19.y] tracing/kprobes: Return EADDRNOTAVAIL when func matches several symbols
In reply to Greg KHHi!
Quoted 59 lines · Le lundi 27 novembre 2023, 16:44:22 CET Greg KH a écrit :
Quoted 41 lines · Francis Laniel
Hi!
Quoted 31 lines · Le vendredi 24 novembre 2023, 17:17:04 CET Greg KH a écrit :
Quoted 30 lines · Francis Laniel
When a kprobe is attached to a function that's name is not unique (is static and shares the name with other functions in the kernel), the kprobe is attached to the first function it finds. This is a bug as the
function that it is attaching to is not necessarily the one that the user wants to attach to.Instead of blindly picking a function to attach to what is ambiguous, error with EADDRNOTAVAIL to let the user know that this function is not
unique, and that the user must use another unique function with an address offset to get to the function they want to attach to.Link:
https://lore.kernel.org/all/[email protected]
oft
.com/Fixes 413d37d1eb69 ("tracing: Add kprobe-based event tracer")Suggested-by Masami Hiramatsu <[email protected]>Signed-off-by Francis Laniel <[email protected]>Link:
https://lore.kernel.org/lkml/20230819101105.b0c104ae4494a7d1f2eea742@k
ern
el.org/ Acked-by: Masami Hiramatsu (Google) <[email protected]>Signed-off-by Masami Hiramatsu (Google) <[email protected]>(cherry picked from commit b022f0c7e404887a7c5229788fc99eff9f9a80d5)---
Quoted 6 lines
Quoted 3 lines
kernel/trace/trace_kprobe.c | 48 +++++++++++++++++++++++++++++++++++++ 1 file changed, 48 insertions(+)Again, we need a version for 5.4.y as well before we can take this version.
Quoted 7 lines
I sent the 5.4.y patch some times ago, you can find it here:
https://lore.kernel.org/stable/[email protected]
oft.com/With the recent batch I sent, I should have cover all the stable kernels. In case I miss one, please indicate it to me so I can fix this problem and ensure all stable kernels have a corresponding patch.
I only see the following in my stable mbox right now:
1 C Nov 27 Francis Laniel (4.4K) ┬─>[PATCH 5.10.y] tracing/kprobes:
Return EADDRNOTAVAIL when func matches several symbols 2 r C Nov 24 FrancisLaniel (4.4K) └─>[PATCH 5.10.y] tracing/kprobes: Return EADDRNOTAVAIL when func matches several symbols 3 F Nov 24 To Francis Lani (1.5K) └─> 4 r T Nov 27 Francis Laniel (1.9K) └─> 5 F Nov 27 To Francis Lani (2.0K) └─> 23 r C Nov 24 Francis Laniel (2.7K) [PATCH 4.19.y] tracing/kprobes:
Quoted 5 lines
Return EADDRNOTAVAIL when func matches several symbols 24 r + Nov 27 Francis Laniel (2.0K) └─>
So could you resend them all just to be sure I have all of the latest versions that you wish to have applied?
I normally sent again the patch for version 4.14 to 5.15 (it was already present in 6.1 and 6.6).
I tested all of them by building the corresponding kernel with the patch applied before sending, so they should not break compilation or testing.
Can you please confirm me you received them?
Quoted 3 lines
thanks,
greg "drowning in patches" k-h
*throws a buoy at greg k-h*
Best regards.
Greg KH
maintainerRe: [PATCH 4.19.y] tracing/kprobes: Return EADDRNOTAVAIL when func matches several symbols
Quoted 69 lines · Francis Laniel
Hi!
Quoted 59 lines · Le lundi 27 novembre 2023, 16:44:22 CET Greg KH a écrit :
Quoted 41 lines · Francis Laniel
Hi!
Quoted 31 lines · Le vendredi 24 novembre 2023, 17:17:04 CET Greg KH a écrit :
Quoted 30 lines · Francis Laniel
When a kprobe is attached to a function that's name is not unique (is static and shares the name with other functions in the kernel), the kprobe is attached to the first function it finds. This is a bug as the
function that it is attaching to is not necessarily the one that the user wants to attach to.Instead of blindly picking a function to attach to what is ambiguous, error with EADDRNOTAVAIL to let the user know that this function is not
unique, and that the user must use another unique function with an address offset to get to the function they want to attach to.Link:
https://lore.kernel.org/all/[email protected]
oft
.com/Fixes 413d37d1eb69 ("tracing: Add kprobe-based event tracer")Suggested-by Masami Hiramatsu <[email protected]>Signed-off-by Francis Laniel <[email protected]>Link:
https://lore.kernel.org/lkml/20230819101105.b0c104ae4494a7d1f2eea742@k
ern
el.org/ Acked-by: Masami Hiramatsu (Google) <[email protected]>Signed-off-by Masami Hiramatsu (Google) <[email protected]>(cherry picked from commit b022f0c7e404887a7c5229788fc99eff9f9a80d5)---
Quoted 6 lines
Quoted 3 lines
kernel/trace/trace_kprobe.c | 48 +++++++++++++++++++++++++++++++++++++ 1 file changed, 48 insertions(+)Again, we need a version for 5.4.y as well before we can take this version.
Quoted 7 lines
I sent the 5.4.y patch some times ago, you can find it here:
https://lore.kernel.org/stable/[email protected]
oft.com/With the recent batch I sent, I should have cover all the stable kernels. In case I miss one, please indicate it to me so I can fix this problem and ensure all stable kernels have a corresponding patch.
I only see the following in my stable mbox right now:
1 C Nov 27 Francis Laniel (4.4K) ┬─>[PATCH 5.10.y] tracing/kprobes:
Return EADDRNOTAVAIL when func matches several symbols 2 r C Nov 24 FrancisLaniel (4.4K) └─>[PATCH 5.10.y] tracing/kprobes: Return EADDRNOTAVAIL when func matches several symbols 3 F Nov 24 To Francis Lani (1.5K) └─> 4 r T Nov 27 Francis Laniel (1.9K) └─> 5 F Nov 27 To Francis Lani (2.0K) └─> 23 r C Nov 24 Francis Laniel (2.7K) [PATCH 4.19.y] tracing/kprobes:Quoted 5 lines
Return EADDRNOTAVAIL when func matches several symbols 24 r + Nov 27 Francis Laniel (2.0K) └─>
So could you resend them all just to be sure I have all of the latest versions that you wish to have applied?
Quoted 6 lines
I normally sent again the patch for version 4.14 to 5.15 (it was already present in 6.1 and 6.6).
I tested all of them by building the corresponding kernel with the patch applied before sending, so they should not break compilation or testing.Can you please confirm me you received them?
Got them now, thanks, I'll dig through them after this latest round of stable kernels gets released.
thanks,
greg k-h
Re: [PATCH 4.19.y] tracing/kprobes: Return EADDRNOTAVAIL when func matches several symbols
Hi!
Quoted 60 lines · Le lundi 27 novembre 2023, 18:58:10 CET Greg KH a écrit :
Quoted 59 lines · Francis Laniel
Hi!
Quoted 56 lines · Le lundi 27 novembre 2023, 16:44:22 CET Greg KH a écrit :
Quoted 55 lines · Francis Laniel
Hi!
Quoted 40 lines · Le vendredi 24 novembre 2023, 17:17:04 CET Greg KH a écrit :
Quoted 39 lines · Francis Laniel
When a kprobe is attached to a function that's name is not unique (is
static and shares the name with other functions in the kernel), the
kprobe is attached to the first function it finds. This is a bug as
the
function that it is attaching to is not necessarily the one that the
user wants to attach to.Instead of blindly picking a function to attach to what is ambiguous,
error with EADDRNOTAVAIL to let the user know that this function is
not
unique, and that the user must use another unique function with an address offset to get to the function they want to attach to.Link:
https://lore.kernel.org/all/[email protected]
cros
oft
.com/Fixes 413d37d1eb69 ("tracing: Add kprobe-based event tracer")Suggested-by Masami Hiramatsu <[email protected]>Signed-off-by Francis Laniel <[email protected]>Link:
https://lore.kernel.org/lkml/20230819101105.b0c104ae4494a7d1f2eea7
42@k
ern
el.org/ Acked-by: Masami Hiramatsu (Google) <[email protected]>Signed-off-by Masami Hiramatsu (Google) <[email protected]>(cherry picked from commit
b022f0c7e404887a7c5229788fc99eff9f9a80d5)
---Quoted 6 lines
Quoted 3 lines
kernel/trace/trace_kprobe.c | 48 +++++++++++++++++++++++++++++++++++++ 1 file changed, 48 insertions(+)Again, we need a version for 5.4.y as well before we can take this version.
I sent the 5.4.y patch some times ago, you can find it here:
https://lore.kernel.org/stable/[email protected]
cros
oft.com/
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 5 lines
With the recent batch I sent, I should have cover all the stable kernels.
In case I miss one, please indicate it to me so I can fix this problem and
ensure all stable kernels have a corresponding patch.I only see the following in my stable mbox right now:
1 C Nov 27 Francis Laniel (4.4K) ┬─>[PATCH 5.10.y] tracing/
kprobes:
Quoted 21 lines
Quoted 21 lines
Quoted 9 lines
Return EADDRNOTAVAIL when func matches several symbols 2 r C Nov 24 Francis
Laniel (4.4K) └─>[PATCH 5.10.y] tracing/kprobes: Return EADDRNOTAVAIL when
func matches several symbols 3 F Nov 24 To Francis Lani (1.5K) └─>4 r T Nov 27 Francis Laniel (1.9K) └─> 5 F Nov 27 To Francis Lani (2.0K) └─>Quoted 6 lines
23 r C Nov 24 Francis Laniel (2.7K) [PATCH 4.19.y] tracing/kprobes:
Return EADDRNOTAVAIL when func matches several symbols 24 r + Nov 27 Francis Laniel (2.0K) └─>So could you resend them all just to be sure I have all of the latest versions that you wish to have applied?
I normally sent again the patch for version 4.14 to 5.15 (it was already present in 6.1 and 6.6).
I tested all of them by building the corresponding kernel with the patch applied before sending, so they should not break compilation or testing.
Quoted 4 lines
Quoted 1 line
Can you please confirm me you received them?
Got them now, thanks, I'll dig through them after this latest round of stable kernels gets released.
You are welcome!
Take your time, this is indeed a bug fix but not a major one (I am doubtful plenty of people met this).
If you find anything wrong with one of the patch, send a message and I will for sure polish it.
Quoted 3 lines
thanks,
greg k-h
Best regards.