Regset cleanups
Subsystems (4)
v2 cover Regset cleanups
Hi,
I’m looking for ack’s on the first two patches from Intel reviewer’s before this is ready for official submission to x86 maintainers. Patch 3 is in core code, and Kees has offered to take it separately or ack it with the feedback on the previous version. The first posting of this already got some nice community feedback. Changes from v1 are in the patches. If you are not an Intel reviewer, feel free to ignore this until it has had more review.
While working on CET ptrace support, I found some suggested cleanups [0] [1] on past postings of that patch. So this small series is doing those cleanups and some related changes.
Way back then, it was noticed that CET ptrace patches were aliasing names in the enum that indexes the regsets. It turns out this was partly because of a limitation in core dump code that reads the registers for dumping. But excluding gaps in the regset array also allows them to be smaller, so just fixing the core dump code doesn’t remove all need for the specially crafted enum. So series changes the way the enums are defined such that enum has to be less carefully crafted, and also fixes the core dump code.
Patch 1 is improving the enums in x86 ptrace code.
Patch 2 is some x86 ptrace code formatting changes suggested by Ingo. [0]
Patch 3 is the fix to the core dump code. Just to be clear, there is no actual bug fixed. It would only overflow an array if the regset views were not laid out just so. But the regsets appear to be laid out so that the brittle code is not broken, from a quick scan of the archs.
Testing consisted of doing some core dumps and seeing that notes were in the same position, and verifying that the enum’s generated the same ints using printks.
Thanks,
Rick
[0] https://lore.kernel.org/lkml/[email protected]/
[1] https://lore.kernel.org/lkml/[email protected]/
Rick Edgecombe (3):
x86: Separate out x86_regset for 32 and 64 bit
x86: Improve formatting of user_regset arrays
elf: Don't write past end of notes for regset gap
arch/x86/kernel/ptrace.c | 171 ++++++++++++++++++++++++--------------- fs/binfmt_elf.c | 24 +++--- 2 files changed, 120 insertions(+), 75 deletions(-)
base-commit: 09688c0166e76ce2fb85e86b9d99be8b0084cdf9
Signature · 1 line
2.17.1
PATCH v2 2/3 x86: Improve formatting of user_regset arrays
Back in 2018, Ingo Molnar suggested[0] to improve the formatting of the struct user_regset arrays. They have multiple member initializations per line and some lines exceed 100 chars. Reformat them like he suggested.
[0] https://lore.kernel.org/lkml/[email protected]/
--- arch/x86/kernel/ptrace.c | 105 ++++++++++++++++++++++++--------------- 1 file changed, 64 insertions(+), 41 deletions(-)
arch/x86/kernel/ptrace.c +64 -41
@@ -1235,28 +1235,37 @@ long compat_arch_ptrace(struct task_struct *child, compat_long_t request,static struct user_regset x86_64_regsets[]__ro_after_init = { [REGSET64_GENERAL ] = { - .core_note_type =NT_PRSTATUS , - .n =sizeof (struct user_regs_struct ) /sizeof (long ), - .size =sizeof (long ), .align =sizeof (long ), - .regset_get = genregs_get, .set = genregs_set + .core_note_type =NT_PRSTATUS , + .n =sizeof (struct user_regs_struct ) /sizeof (long ), + .size =sizeof (long ), + .align =sizeof (long ), + .regset_get = genregs_get, + .set = genregs_set }, [REGSET64_FP ] = { .core_note_type =NT_PRFPREG , - .n =sizeof (struct fxregs_state ) /sizeof (long ), - .size =sizeof (long ), .align =sizeof (long ), - .active = regset_xregset_fpregs_active, .regset_get = xfpregs_get, .set = xfpregs_set + .n =sizeof (struct fxregs_state ) /sizeof (long ), + .size =sizeof (long ), + .align =sizeof (long ), + .active = regset_xregset_fpregs_active, + .regset_get = xfpregs_get, + .set = xfpregs_set }, [REGSET64_XSTATE ] = { - .core_note_type =NT_X86_XSTATE , - .size =sizeof (u64), .align =sizeof (u64), - .active = xstateregs_active, .regset_get = xstateregs_get, - .set = xstateregs_set + .core_note_type =NT_X86_XSTATE , + .size =sizeof (u64), + .align =sizeof (u64), + .active = xstateregs_active, + .regset_get = xstateregs_get, + .set = xstateregs_set }, [REGSET64_IOPERM ] = { - .core_note_type =NT_386_IOPERM , - .n =IO_BITMAP_LONGS , - .size =sizeof (long ), .align =sizeof (long ), - .active = ioperm_active, .regset_get = ioperm_get + .core_note_type =NT_386_IOPERM , + .n =IO_BITMAP_LONGS , + .size =sizeof (long ), + .align =sizeof (long ), + .active = ioperm_active, + .regset_get = ioperm_get }, };
@@ -1276,42 +1285,56 @@ static const struct user_regset_view user_x86_64_view = {#if definedCONFIG_X86_32 || definedCONFIG_IA32_EMULATION static struct user_regset x86_32_regsets[]__ro_after_init = { [REGSET32_GENERAL ] = { - .core_note_type =NT_PRSTATUS , - .n =sizeof (struct user_regs_struct32 ) /sizeof (u32), - .size =sizeof (u32), .align =sizeof (u32), - .regset_get = genregs32_get, .set = genregs32_set + .core_note_type =NT_PRSTATUS , + .n =sizeof (struct user_regs_struct32 ) /sizeof (u32), + .size =sizeof (u32), + .align =sizeof (u32), + .regset_get = genregs32_get, + .set = genregs32_set }, [REGSET32_FP ] = { - .core_note_type =NT_PRFPREG , - .n =sizeof (struct user_i387_ia32_struct ) /sizeof (u32), - .size =sizeof (u32), .align =sizeof (u32), - .active = regset_fpregs_active, .regset_get = fpregs_get, .set = fpregs_set + .core_note_type =NT_PRFPREG , + .n =sizeof (struct user_i387_ia32_struct ) /sizeof (u32), + .size =sizeof (u32), + .align =sizeof (u32), + .active = regset_fpregs_active, + .regset_get = fpregs_get, + .set = fpregs_set }, [REGSET32_XFP ] = { - .core_note_type =NT_PRXFPREG , - .n =sizeof (struct fxregs_state ) /sizeof (u32), - .size =sizeof (u32), .align =sizeof (u32), - .active = regset_xregset_fpregs_active, .regset_get = xfpregs_get, .set = xfpregs_set + .core_note_type =NT_PRXFPREG , + .n =sizeof (struct fxregs_state ) /sizeof (u32), + .size =sizeof (u32), + .align =sizeof (u32), + .active = regset_xregset_fpregs_active, + .regset_get = xfpregs_get, + .set = xfpregs_set }, [REGSET32_XSTATE ] = { - .core_note_type =NT_X86_XSTATE , - .size =sizeof (u64), .align =sizeof (u64), - .active = xstateregs_active, .regset_get = xstateregs_get, - .set = xstateregs_set + .core_note_type =NT_X86_XSTATE , + .size =sizeof (u64), + .align =sizeof (u64), + .active = xstateregs_active, + .regset_get = xstateregs_get, + .set = xstateregs_set }, [REGSET32_TLS ] = { - .core_note_type =NT_386_TLS , - .n =GDT_ENTRY_TLS_ENTRIES , .bias =GDT_ENTRY_TLS_MIN , - .size =sizeof (struct user_desc ), - .align =sizeof (struct user_desc ), - .active = regset_tls_active, - .regset_get = regset_tls_get, .set = regset_tls_set + .core_note_type =NT_386_TLS , + .n =GDT_ENTRY_TLS_ENTRIES , + .bias =GDT_ENTRY_TLS_MIN , + .size =sizeof (struct user_desc ), + .align =sizeof (struct user_desc ), + .active = regset_tls_active, + .regset_get = regset_tls_get, + .set = regset_tls_set }, [REGSET32_IOPERM ] = { - .core_note_type =NT_386_IOPERM , - .n =IO_BITMAP_BYTES /sizeof (u32), - .size =sizeof (u32), .align =sizeof (u32), - .active = ioperm_active, .regset_get = ioperm_get + .core_note_type =NT_386_IOPERM , + .n =IO_BITMAP_BYTES /sizeof (u32), + .size =sizeof (u32), + .align =sizeof (u32), + .active = ioperm_active, + .regset_get = ioperm_get }, };
Signature · 1 line
2.17.1
PATCH v2 1/3 x86: Separate out x86_regset for 32 and 64 bit
In reply to Rick EdgecombeIn ptrace, the x86_32_regsets and x86_64_regsets are constructed such that there are no gaps in the arrays. This appears to be for two reasons. One, the code in fill_thread_core_info() can't handle the gaps. This will be addressed in a future patch. And two, not having gaps shrinks the size of the array in memory.
Both regset arrays draw their indices from a shared enum x86_regset, but 32 bit and 64 bit don't all support the same regsets. In the case of IA32_EMULATION they can be compiled in at the same time. So this enum has to be laid out in a special way such that there are no gaps for both x86_32_regsets and x86_64_regsets. This involves creating aliases for enum’s that are only in one view or the other, or creating multiple versions like in the case of REGSET_IOPERM32/REGSET_IOPERM64.
Simplify the construction of these arrays by just fully separating out the enums for 32 bit and 64 bit. Add some bitsize-free defines for REGSET_GENERAL and REGSET_FP since they are the only two referred to in bitsize generic code. Also, change the name pattern to be like REGSET32_FOO, instead of REGSET_FOO32, to better emphasize that the bit size is the bitsize of the architecture, not the register itself.
This should have no functional change and is only changing how constants are generated and named. The enum is local to this file, so it does not introduce any burden on code calling from other places in the kernel now having to worry about whether to use a 32 bit or 64 bit enum name.
[1] https://lore.kernel.org/lkml/[email protected]/
---
v2:
- Rename REGSET_FOO32 to REGSET32_FOO (Eric Biederman)
- Drop Kees' Reviewed-by to Acked-by, due to changing enum value names
arch/x86/kernel/ptrace.c | 66 +++++++++++++++++++++++++--------------- 1 file changed, 42 insertions(+), 24 deletions(-)
arch/x86/kernel/ptrace.c +42 -24
@@ -45,16 +45,34 @@#include "tls.h" -enum x86_regset { -REGSET_GENERAL , -REGSET_FP , -REGSET_XFP , -REGSET_IOPERM64 =REGSET_XFP , -REGSET_XSTATE , -REGSET_TLS , -REGSET_IOPERM32 , +enum x86_regset_32 { +REGSET32_GENERAL , +REGSET32_FP , +REGSET32_XFP , +REGSET32_XSTATE , +REGSET32_TLS , +REGSET32_IOPERM , }; +enum x86_regset_64 { +REGSET64_GENERAL , +REGSET64_FP , +REGSET64_IOPERM , +REGSET64_XSTATE , +}; + +#define REGSET_GENERAL \ +({ \ + BUILD_BUG_ON((int)REGSET32_GENERAL != (int)REGSET64_GENERAL); \ + REGSET32_GENERAL; \ +}) + +#define REGSET_FP \ +({ \ + BUILD_BUG_ON((int)REGSET32_FP != (int)REGSET64_FP); \ + REGSET32_FP; \ +}) +struct pt_regs_offset {const char *name;int offset;
@@ -789,13 +807,13 @@ long arch_ptrace(struct task_struct *child, long request,#ifdef CONFIG_X86_32 case PTRACE_GETFPXREGS :/* Get the child extended FPU state. */ return copy_regset_to_user (child, &user_x86_32_view, -REGSET_XFP , +REGSET32_XFP ,0 ,sizeof (struct user_fxsr_struct ), datap) ? -EIO :0 ;case PTRACE_SETFPXREGS :/* Set the child extended FPU state. */ return copy_regset_from_user (child, &user_x86_32_view, -REGSET_XFP , +REGSET32_XFP ,0 ,sizeof (struct user_fxsr_struct ), datap) ? -EIO :0 ;#endif
@@ -1087,13 +1105,13 @@ static long ia32_arch_ptrace(struct task_struct *child, compat_long_t request,case PTRACE_GETFPXREGS :/* Get the child extended FPU state. */ return copy_regset_to_user (child, &user_x86_32_view, -REGSET_XFP ,0 , +REGSET32_XFP ,0 ,sizeof (struct user32_fxsr_struct ), datap);case PTRACE_SETFPXREGS :/* Set the child extended FPU state. */ return copy_regset_from_user (child, &user_x86_32_view, -REGSET_XFP ,0 , +REGSET32_XFP ,0 ,sizeof (struct user32_fxsr_struct ), datap);
@@ -1216,25 +1234,25 @@ long compat_arch_ptrace(struct task_struct *child, compat_long_t request, #ifdef CONFIG_X86_64 static struct user_regset x86_64_regsets[] __ro_after_init = { - [REGSET_GENERAL] = { + [REGSET64_GENERAL] = { .core_note_type = NT_PRSTATUS, .n = sizeof(struct user_regs_struct) / sizeof(long), .size = sizeof(long), .align = sizeof(long), .regset_get = genregs_get, .set = genregs_set }, - [REGSET_FP] = { + [REGSET64_FP] = { .core_note_type = NT_PRFPREG, .n = sizeof(struct fxregs_state) / sizeof(long), .size = sizeof(long), .align = sizeof(long), .active = regset_xregset_fpregs_active, .regset_get = xfpregs_get, .set = xfpregs_set }, - [REGSET_XSTATE] = { + [REGSET64_XSTATE] = { .core_note_type = NT_X86_XSTATE, .size = sizeof(u64), .align = sizeof(u64), .active = xstateregs_active, .regset_get = xstateregs_get, .set = xstateregs_set }, - [REGSET_IOPERM64] = { + [REGSET64_IOPERM] = { .core_note_type = NT_386_IOPERM, .n = IO_BITMAP_LONGS, .size = sizeof(long), .align = sizeof(long),
@@ -1257,31 +1275,31 @@ static const struct user_regset_view user_x86_64_view = { #if defined CONFIG_X86_32 || defined CONFIG_IA32_EMULATION static struct user_regset x86_32_regsets[] __ro_after_init = { - [REGSET_GENERAL] = { + [REGSET32_GENERAL] = { .core_note_type = NT_PRSTATUS, .n = sizeof(struct user_regs_struct32) / sizeof(u32), .size = sizeof(u32), .align = sizeof(u32), .regset_get = genregs32_get, .set = genregs32_set }, - [REGSET_FP] = { + [REGSET32_FP] = { .core_note_type = NT_PRFPREG, .n = sizeof(struct user_i387_ia32_struct) / sizeof(u32), .size = sizeof(u32), .align = sizeof(u32), .active = regset_fpregs_active, .regset_get = fpregs_get, .set = fpregs_set }, - [REGSET_XFP] = { + [REGSET32_XFP] = { .core_note_type = NT_PRXFPREG, .n = sizeof(struct fxregs_state) / sizeof(u32), .size = sizeof(u32), .align = sizeof(u32), .active = regset_xregset_fpregs_active, .regset_get = xfpregs_get, .set = xfpregs_set }, - [REGSET_XSTATE] = { + [REGSET32_XSTATE] = { .core_note_type = NT_X86_XSTATE, .size = sizeof(u64), .align = sizeof(u64), .active = xstateregs_active, .regset_get = xstateregs_get, .set = xstateregs_set }, - [REGSET_TLS] = { + [REGSET32_TLS] = { .core_note_type = NT_386_TLS, .n = GDT_ENTRY_TLS_ENTRIES, .bias = GDT_ENTRY_TLS_MIN, .size = sizeof(struct user_desc),
@@ -1289,7 +1307,7 @@ static struct user_regset x86_32_regsets[] __ro_after_init = { .active = regset_tls_active, .regset_get = regset_tls_get, .set = regset_tls_set }, - [REGSET_IOPERM32] = { + [REGSET32_IOPERM] = { .core_note_type = NT_386_IOPERM, .n = IO_BITMAP_BYTES / sizeof(u32), .size = sizeof(u32), .align = sizeof(u32),
@@ -1312,10 +1330,10 @@ u64 xstate_fx_sw_bytes[USER_XSTATE_FX_SW_WORDS];void __init update_regset_xstate_info (unsigned int size,u64 xstate_mask) {#ifdef CONFIG_X86_64 - x86_64_regsets[REGSET_XSTATE ].n = size /sizeof (u64); + x86_64_regsets[REGSET64_XSTATE ].n = size /sizeof (u64);#endif #if definedCONFIG_X86_32 || definedCONFIG_IA32_EMULATION - x86_32_regsets[REGSET_XSTATE ].n = size /sizeof (u64); + x86_32_regsets[REGSET32_XSTATE ].n = size /sizeof (u64);#endif xstate_fx_sw_bytes[USER_XSTATE_XCR0_WORD ] = xstate_mask; }
Signature · 1 line
2.17.1
PATCH v2 3/3 elf: Don't write past end of notes for regset gap
In reply to Rick EdgecombeIn fill_thread_core_info() the ptrace accessible registers are collected to be written out as notes in a core file. The note array is allocated from a size calculated by iterating the user regset view, and counting the regsets that have a non-zero core_note_type. However, this only allows for there to be non-zero core_note_type at the end of the regset view. If there are any gaps in the middle, fill_thread_core_info() will overflow the note allocation, as it iterates over the size of the view and the allocation would be smaller than that.
There doesn't appear to be any arch that has gaps such that they exceed the notes allocation, but the code is brittle and tries to support something it doesn't. It could be fixed by increasing the allocation size, but instead just have the note collecting code utilize the array better. This way the allocation can stay smaller.
Even in the case of no arch's that have gaps in their regset views, this introduces a change in the resulting indicies of t->notes. It does not introduce any changes to the core file itself, because any blank notes are skipped in write_note_info().
In case, the allocation logic between fill_note_info() and fill_thread_core_info() ever diverges from the usage logic, warn and skip writing any notes that would overflow the array.
This fix is derrived from an earlier one[0] by Yu-cheng Yu.
[0] https://lore.kernel.org/lkml/[email protected]/
---
v2:
- Warn and break out of the note collecting loop if the allocation would overflow. Note: I tweaked it slightly to do break instead of continue and to do it before SET_PR_FPVALID(). (Kees)
fs/binfmt_elf.c | 24 ++++++++++++++---------- 1 file changed, 14 insertions(+), 10 deletions(-)
fs/binfmt_elf.c +14 -10
@@ -1755,9 +1755,9 @@ static void do_thread_regset_writeback(struct task_struct *task,static int fill_thread_core_info (struct elf_thread_core_info *t,const struct user_regset_view *view, -long signr,size_t *total) +long signr,struct elf_note_info *info) { -unsigned int i; +unsigned int note_iter, view_iter;/* * NT_PRSTATUS is the one special case, because the regset data
@@ -1771,17 +1771,17 @@ static int fill_thread_core_info(struct elf_thread_core_info *t,fill_note (&t->notes[0 ],"CORE" ,NT_PRSTATUS ,PRSTATUS_SIZE , &t->prstatus); - *total +=notesize (&t->notes[0 ]); + info->size +=notesize (&t->notes[0 ]);do_thread_regset_writeback (t->task, &view->regsets[0 ]);/* * Each other regset might generate a note too. For each regset -* that has no core_note_type or is inactive, we leave t->notes[i] -* all zero and we'll know to skip writing it later. +* that has no core_note_type or is inactive, skip it. */ -for (i =1 ; i < view->n; ++i) { -const struct user_regset *regset = &view->regsets[i]; + note_iter =1 ; +for (view_iter =1 ; view_iter < view->n; ++view_iter) { +const struct user_regset *regset = &view->regsets[view_iter];int note_type = regset->core_note_type;bool is_fpreg = note_type ==NT_PRFPREG ;void *data;
@@ -1797,13 +1797,17 @@ static int fill_thread_core_info(struct elf_thread_core_info *t,if (ret <0 )continue ; +if (WARN_ON_ONCE (note_iter >= info->thread_notes)) +break ; +if (is_fpreg)SET_PR_FPVALID (&t->prstatus); -fill_note (&t->notes[i], is_fpreg ?"CORE" :"LINUX" , +fill_note (&t->notes[note_iter], is_fpreg ?"CORE" :"LINUX" , note_type, ret, data); - *total +=notesize (&t->notes[i]); + info->size +=notesize (&t->notes[note_iter]); + note_iter++; }return 1 ;
@@ -1883,7 +1887,7 @@ static int fill_note_info(struct elfhdr *elf, int phdrs,* Now fill in each thread's information. */ for (t = info->thread; t !=NULL ; t = t->next) -if (!fill_thread_core_info (t, view, siginfo->si_signo, &info->size)) +if (!fill_thread_core_info (t, view, siginfo->si_signo, info))return 0 ;/*
Signature · 1 line
2.17.1
Re: [PATCH v2 3/3] elf: Don't write past end of notes for regset gap
Quoted 32 lines · Rick Edgecombe
In
fill_thread_core_info()the ptrace accessible registers are collected to be written out as notes in a core file. The note array is allocated from a size calculated by iterating the user regset view, and counting the regsets that have a non-zerocore_note_type. However, this only allows for there to be non-zerocore_note_typeat the end of the regset view. If there are any gaps in the middle,fill_thread_core_info()will overflow the note allocation, as it iterates over the size of the view and the allocation would be smaller than that.There doesn't appear to be any arch that has gaps such that they exceed the notes allocation, but the code is brittle and tries to support something it doesn't. It could be fixed by increasing the allocation size, but instead just have the note collecting code utilize the array better. This way the allocation can stay smaller.
Even in the case of no arch's that have gaps in their regset views, this introduces a change in the resulting indicies of
t->notes. It does not introduce any changes to the core file itself, because any blank notes are skipped inwrite_note_info().In case, the allocation logic between
fill_note_info()andfill_thread_core_info()ever diverges from the usage logic, warn and skip writing any notes that would overflow the array.This fix is derrived from an earlier one[0] by Yu-cheng Yu.
[0] https://lore.kernel.org/lkml/[email protected]/
Co-developed-by Yu-cheng Yu <[email protected]>Signed-off-by Yu-cheng Yu <[email protected]>Signed-off-by Rick Edgecombe <[email protected]>
Quoted 6 lines
---
v2:
- Warn and break out of the note collecting loop if the allocation would overflow. Note: I tweaked it slightly to do break instead of continue and to do it beforeSET_PR_FPVALID(). (Kees)
This looks great; thank you for the tweak. :)
Shall I take this separately into the for-next/execve tree, or would you rather is stay in this series?
-Kees
Signature · 1 line
Kees Cook
Re: [PATCH v2 1/3] x86: Separate out x86_regset for 32 and 64 bit
In reply to Rick EdgecombeQuoted 28 lines · Rick Edgecombe
In ptrace, the
x86_32_regsetsandx86_64_regsetsare constructed such that there are no gaps in the arrays. This appears to be for two reasons. One, the code infill_thread_core_info()can't handle the gaps. This will be addressed in a future patch. And two, not having gaps shrinks the size of the array in memory.Both regset arrays draw their indices from a shared enum
x86_regset, but 32 bit and 64 bit don't all support the same regsets. In the case ofIA32_EMULATIONthey can be compiled in at the same time. So this enum has to be laid out in a special way such that there are no gaps for bothx86_32_regsetsandx86_64_regsets. This involves creating aliases for enum’s that are only in one view or the other, or creating multiple versions like in the case of REGSET_IOPERM32/REGSET_IOPERM64.Simplify the construction of these arrays by just fully separating out the enums for 32 bit and 64 bit. Add some bitsize-free defines for
REGSET_GENERALandREGSET_FPsince they are the only two referred to in bitsize generic code. Also, change the name pattern to be likeREGSET32_FOO, instead ofREGSET_FOO32, to better emphasize that the bit size is the bitsize of the architecture, not the register itself.This should have no functional change and is only changing how constants are generated and named. The enum is local to this file, so it does not introduce any burden on code calling from other places in the kernel now having to worry about whether to use a 32 bit or 64 bit enum name.
Quoted 8 lines
Signed-off-by Rick Edgecombe <[email protected]>Acked-by Kees Cook <[email protected]>---
v2:
- RenameREGSET_FOO32toREGSET32_FOO(Eric Biederman)
- Drop Kees' Reviewed-by to Acked-by, due to changing enum value names
I think of "Ack" to mean "I am a maintainer of this area and someone can carry this instead of it going via my tree". While I certainly poke and ptrace and x86 a lot, I probably wouldn't Ack in this part of the kernel. But it does seem "Reviewed-by" is a stronger signal[1].
Regardless, v2 looks good to me still. :)
-Kees
Signature · 1 line
Kees Cook
Re: [PATCH v2 3/3] elf: Don't write past end of notes for regset gap
In reply to Kees CookQuoted 9 lines · Kees Cook
This looks great; thank you for the tweak. :)
Acked-by Kees Cook <[email protected]>Shall I take this separately into the for-next/execve tree, or would you
rather is stay in this series?-Kees
Great thanks. Yea that would probably be the best I think, unless anyone speaks up.
Re: [PATCH v2 1/3] x86: Separate out x86_regset for 32 and 64 bit
In reply to Kees CookQuoted 6 lines · Kees Cook
I think of "Ack" to mean "I am a maintainer of this area and someone can
carry this instead of it going via my tree". While I certainly poke and
ptrace and x86 a lot, I probably wouldn't Ack in this part of the kernel. But it does seem "Reviewed-by" is a stronger signal[1].
I thought I remembered reading in some kernel docs somewhere to demote reviewed-by's to acks if anything changed, so some credit goes in for the past work on it. Cannot find anything now, thanks for the clarification.
Kees Cook
AppliedRe: (subset) [PATCH v2 3/3] elf: Don't write past end of notes for regset gap
In reply to Rick EdgecombeQuoted 10 lines · Rick Edgecombe
In
fill_thread_core_info()the ptrace accessible registers are collected to be written out as notes in a core file. The note array is allocated from a size calculated by iterating the user regset view, and counting the regsets that have a non-zerocore_note_type. However, this only allows for there to be non-zerocore_note_typeat the end of the regset view. If there are any gaps in the middle,fill_thread_core_info()will overflow the note allocation, as it iterates over the size of the view and the allocation would be smaller than that.[...]
Applied to for-next/execve, thanks!
[3/3] elf: Don't write past end of notes for regset gap
https://git.kernel.org/kees/c/dd664099002d
Signature · 1 line
Kees Cook