updated ptrace/core-dump patches for supporting xstate - V2
Subsystems (3)
v2 cover updated ptrace/core-dump patches for supporting xstate - V2
Patches are on top of the -tip/master tree.
First patch in the series reverts the first version of the patch that went into the -tip tree.
Changes from v1:
a. Split the patch into multiple patches.
b. Fix some bugs and coding style changes based on Roland's feedback. c. Add generic PTRACE_GETREGSET/PTRACE_SETREGSET commands through which we can
export the architecture specific regsets using the corresponding NT_* codes that userland is already aware of. The "xstate" regset is exported only using this interface.
thanks,
suresh
PATCH v2 1/4 revert "x86: ptrace and core-dump extensions for xstate"
Revert commit c741196df8a42602965f781e0f09462de81742e2. Updated patches based on Roland's feedback follow.
--- arch/x86/include/asm/i387.h | 8 +-- arch/x86/include/asm/ptrace-abi.h | 38 ------------------ arch/x86/include/asm/xsave.h | 2 arch/x86/kernel/i387.c | 79 -------------------------------------- arch/x86/kernel/ptrace.c | 53 ------------------------- arch/x86/kernel/xsave.c | 1 include/linux/elf.h | 1 7 files changed, 5 insertions(+), 177 deletions(-)
arch/x86/include/asm/i387.h +3 -5
@@ -32,11 +32,9 @@ extern void __math_state_restore(void);extern void init_thread_xstate (void );extern int dump_fpu (struct pt_regs *,struct user_i387_struct *); -extern user_regset_active_fn fpregs_active, xfpregs_active, xstateregs_active; -extern user_regset_get_fn fpregs_get, xfpregs_get, fpregs_soft_get, - xstateregs_get; -extern user_regset_set_fn fpregs_set, xfpregs_set, fpregs_soft_set, - xstateregs_set; +extern user_regset_active_fn fpregs_active, xfpregs_active; +extern user_regset_get_fn fpregs_get, xfpregs_get, fpregs_soft_get; +extern user_regset_set_fn fpregs_set, xfpregs_set, fpregs_soft_set;extern struct _fpx_sw_bytes fx_sw_reserved;#ifdef CONFIG_IA32_EMULATION
arch/x86/include/asm/ptrace-abi.h +0 -38
@@ -80,44 +80,6 @@#define PTRACE_SINGLEBLOCK 33/* resume execution until next branch */ -/* -* Structure layout used in PTRACE_GETXSTATEREGS/PTRACE_SETXSTATEREGS is same -* as the memory layout of xsave used by the processor (except for the bytes -* 464..511 which can be used by the software). Size of the structure that users -* need to use for these two interfaces can be obtained by doing: -* cpuid_count(0xd, 0, &eax, &ptrace_xstateregs_struct_size, &ecx, &edx); -* i.e., cpuid.(eax=0xd,ecx=0).ebx will be the size that user (debuggers etc) -* need to use. -* -* And format of this structure will be like: -* struct { -* fxsave_bytes[0..463] -* sw_usable_bytes[464..511] -* xsave_hdr_bytes[512..575] -* avx_bytes[576..831] -* future_state etc -* } -* -* Same memory layout will be used for the coredump NT_X86_XSTATE representing -* the xstate registers. -* -* For now, only first 8 bytes of the sw_usable_bytes[464..467] will be used and -* will be set to OS enabled xstate mask(which is same as the 64bit mask -* returned by the xgetbv's xCR0). Users (analyzing core dump remotely etc) -* can use this mask aswell as the mask saved in the xstate_hdr bytes and -* interpret what states the processor/OS supports and what states are in -* modified/initialized conditions for the particular process/thread. -* -* Also when the user modifies certain state FP/SSE/etc through this -* PTRACE_SETXSTATEREGS, they must ensure that the xsave_hdr.xstate_bv -* bytes[512..519] of the above memory layout are updated correspondingly. -* i.e., for example when FP state is modified to a non-init state, -* xsave_hdr.xstate_bv's bit 0 must be set to '1', when SSE is modified to -* non-init state, xsave_hdr.xstate_bv's bit 1 must to be set to '1' etc.. -*/ -#define PTRACE_GETXSTATEREGS 34 -#define PTRACE_SETXSTATEREGS 35 -#ifndef __ASSEMBLY__#include <linux/types.h>
arch/x86/include/asm/xsave.h +0 -2
@@ -27,11 +27,9 @@extern unsigned int xstate_size;extern u64 pcntxt_mask;extern struct xsave_struct *init_xstate_buf; -extern u64 xstate_fx_sw_bytes[6 ];extern void xsave_cntxt_init (void );extern void xsave_init (void ); -extern void update_regset_xstate_info (unsigned int size,u64 xstate_mask);extern int init_fpu (struct task_struct *child); extern int check_for_xstate(struct i387_fxsave_struct __user *buf, void __user *fpstate,
arch/x86/kernel/i387.c +0 -79
85 lines not on this page · raw message
arch/x86/kernel/ptrace.c +2 -51
101 lines not on this page · raw message
arch/x86/kernel/xsave.c +0 -1
@@ -337,7 +337,6 @@ void __ref xsave_cntxt_init(void)cpuid_count (0xd ,0 , &eax, &ebx, &ecx, &edx); xstate_size = ebx; -update_regset_xstate_info (xstate_size, pcntxt_mask);prepare_fx_sw_frame ();setup_xstate_init ();
include/linux/elf.h +0 -1
@@ -361,7 +361,6 @@ typedef struct elf64_shdr {#define NT_PPC_VSX 0x102/* PowerPC VSX registers */ #define NT_386_TLS 0x200/* i386 TLS slots (struct user_desc) */ #define NT_386_IOPERM 0x201/* x86 io permission bitmap (1=deny) */ -#define NT_X86_XSTATE 0x202/* x86 extended state using xsave */ #define NT_S390_HIGH_GPRS 0x300/* s390 upper register halves */
[tip:x86/ptrace] Revert "x86: ptrace and core-dump extensions for xstate"
Commit-ID: bea19fc4b32ec1974edaa999290e23b6375b0768 Gitweb: http://git.kernel.org/tip/bea19fc4b32ec1974edaa999290e23b6375b0768 Author: Suresh Siddha <[email protected]> AuthorDate: Tue, 9 Feb 2010 12:13:10 -0800 Committer: H. Peter Anvin <[email protected]> CommitDate: Tue, 9 Feb 2010 14:09:41 -0800
Revert "x86: ptrace and core-dump extensions for xstate"
Revert commit c741196df8a42602965f781e0f09462de81742e2. Updated patches based on Roland's feedback follow.
LKML-Reference: <[email protected]>
--- arch/x86/include/asm/i387.h | 8 +-- arch/x86/include/asm/ptrace-abi.h | 38 ------------------ arch/x86/include/asm/xsave.h | 2 - arch/x86/kernel/i387.c | 79 ------------------------------------- arch/x86/kernel/ptrace.c | 53 +------------------------ arch/x86/kernel/xsave.c | 1 - include/linux/elf.h | 1 - 7 files changed, 5 insertions(+), 177 deletions(-)
arch/x86/include/asm/i387.h +3 -5
@@ -32,11 +32,9 @@ extern void __math_state_restore(void);extern void init_thread_xstate (void );extern int dump_fpu (struct pt_regs *,struct user_i387_struct *); -extern user_regset_active_fn fpregs_active, xfpregs_active, xstateregs_active; -extern user_regset_get_fn fpregs_get, xfpregs_get, fpregs_soft_get, - xstateregs_get; -extern user_regset_set_fn fpregs_set, xfpregs_set, fpregs_soft_set, - xstateregs_set; +extern user_regset_active_fn fpregs_active, xfpregs_active; +extern user_regset_get_fn fpregs_get, xfpregs_get, fpregs_soft_get; +extern user_regset_set_fn fpregs_set, xfpregs_set, fpregs_soft_set;extern struct _fpx_sw_bytes fx_sw_reserved;#ifdef CONFIG_IA32_EMULATION
arch/x86/include/asm/ptrace-abi.h +0 -38
@@ -80,44 +80,6 @@#define PTRACE_SINGLEBLOCK 33/* resume execution until next branch */ -/* -* Structure layout used in PTRACE_GETXSTATEREGS/PTRACE_SETXSTATEREGS is same -* as the memory layout of xsave used by the processor (except for the bytes -* 464..511 which can be used by the software). Size of the structure that users -* need to use for these two interfaces can be obtained by doing: -* cpuid_count(0xd, 0, &eax, &ptrace_xstateregs_struct_size, &ecx, &edx); -* i.e., cpuid.(eax=0xd,ecx=0).ebx will be the size that user (debuggers etc) -* need to use. -* -* And format of this structure will be like: -* struct { -* fxsave_bytes[0..463] -* sw_usable_bytes[464..511] -* xsave_hdr_bytes[512..575] -* avx_bytes[576..831] -* future_state etc -* } -* -* Same memory layout will be used for the coredump NT_X86_XSTATE representing -* the xstate registers. -* -* For now, only first 8 bytes of the sw_usable_bytes[464..467] will be used and -* will be set to OS enabled xstate mask(which is same as the 64bit mask -* returned by the xgetbv's xCR0). Users (analyzing core dump remotely etc) -* can use this mask aswell as the mask saved in the xstate_hdr bytes and -* interpret what states the processor/OS supports and what states are in -* modified/initialized conditions for the particular process/thread. -* -* Also when the user modifies certain state FP/SSE/etc through this -* PTRACE_SETXSTATEREGS, they must ensure that the xsave_hdr.xstate_bv -* bytes[512..519] of the above memory layout are updated correspondingly. -* i.e., for example when FP state is modified to a non-init state, -* xsave_hdr.xstate_bv's bit 0 must be set to '1', when SSE is modified to -* non-init state, xsave_hdr.xstate_bv's bit 1 must to be set to '1' etc.. -*/ -#define PTRACE_GETXSTATEREGS 34 -#define PTRACE_SETXSTATEREGS 35 -#ifndef __ASSEMBLY__#include <linux/types.h>
arch/x86/include/asm/xsave.h +0 -2
@@ -27,11 +27,9 @@extern unsigned int xstate_size;extern u64 pcntxt_mask;extern struct xsave_struct *init_xstate_buf; -extern u64 xstate_fx_sw_bytes[6 ];extern void xsave_cntxt_init (void );extern void xsave_init (void ); -extern void update_regset_xstate_info (unsigned int size,u64 xstate_mask);extern int init_fpu (struct task_struct *child); extern int check_for_xstate(struct i387_fxsave_struct __user *buf, void __user *fpstate,
arch/x86/kernel/i387.c +0 -79
85 lines not on this page · raw message
arch/x86/kernel/ptrace.c +2 -51
101 lines not on this page · raw message
arch/x86/kernel/xsave.c +0 -1
@@ -337,7 +337,6 @@ void __ref xsave_cntxt_init(void)cpuid_count (0xd ,0 , &eax, &ebx, &ecx, &edx); xstate_size = ebx; -update_regset_xstate_info (xstate_size, pcntxt_mask);prepare_fx_sw_frame ();setup_xstate_init ();
include/linux/elf.h +0 -1
@@ -361,7 +361,6 @@ typedef struct elf64_shdr {#define NT_PPC_VSX 0x102/* PowerPC VSX registers */ #define NT_386_TLS 0x200/* i386 TLS slots (struct user_desc) */ #define NT_386_IOPERM 0x201/* x86 io permission bitmap (1=deny) */ -#define NT_X86_XSTATE 0x202/* x86 extended state using xsave */ #define NT_S390_HIGH_GPRS 0x300/* s390 upper register halves */
PATCH v2 2/4 x86, ptrace: regset extensions to support xstate
In reply to Suresh SiddhaAdd the xstate regset support which helps extend the kernel ptrace and the core-dump interfaces to support AVX state etc.
This regset interface is designed to support all the future state that gets supported using xsave/xrstor infrastructure.
Looking at the memory layout saved by "xsave", one can't say which state is represented in the memory layout. This is because if a particular state is in init state, in the xsave hdr it can be represented by bit '0'. And hence we can't really say by the xsave header wether a state is in init state or the state is not saved in the memory layout.
And hence the xsave memory layout available through this regset interface uses SW usable bytes [464..511] to convey what state is represented in the memory layout.
First 8 bytes of the sw_usable_bytes[464..467] will be set to OS enabled xstate mask(which is same as the 64bit mask returned by the xgetbv's xCR0).
The note NT_X86_XSTATE represents the extended state information in the core file, using the above mentioned memory layout.
--- arch/x86/include/asm/i387.h | 12 ++++- arch/x86/include/asm/xsave.h | 2 arch/x86/kernel/i387.c | 88 ++++++++++++++++++++++++++++++++++++++++++- arch/x86/kernel/ptrace.c | 29 +++++++++++++- arch/x86/kernel/xsave.c | 1 include/linux/elf.h | 1 6 files changed, 127 insertions(+), 6 deletions(-)
arch/x86/include/asm/i387.h +10 -2
@@ -33,8 +33,16 @@ extern void init_thread_xstate(void);extern int dump_fpu (struct pt_regs *,struct user_i387_struct *);extern user_regset_active_fn fpregs_active, xfpregs_active; -extern user_regset_get_fn fpregs_get, xfpregs_get, fpregs_soft_get; -extern user_regset_set_fn fpregs_set, xfpregs_set, fpregs_soft_set; +extern user_regset_get_fn fpregs_get, xfpregs_get, fpregs_soft_get, + xstateregs_get; +extern user_regset_set_fn fpregs_set, xfpregs_set, fpregs_soft_set, + xstateregs_set; + +/* +* xstateregs_active == fpregs_active. Please refer to the comment +* at the definition of fpregs_active. +*/ +#define xstateregs_active fpregs_activeextern struct _fpx_sw_bytes fx_sw_reserved;#ifdef CONFIG_IA32_EMULATION
arch/x86/include/asm/xsave.h +2 -0
@@ -27,9 +27,11 @@extern unsigned int xstate_size;extern u64 pcntxt_mask;extern struct xsave_struct *init_xstate_buf; +extern u64 xstate_fx_sw_bytes[6 ];extern void xsave_cntxt_init (void );extern void xsave_init (void ); +extern void update_regset_xstate_info (unsigned int size,u64 xstate_mask);extern int init_fpu (struct task_struct *child); extern int check_for_xstate(struct i387_fxsave_struct __user *buf, void __user *fpstate,
arch/x86/kernel/i387.c +86 -2
106 lines not on this page · raw message
arch/x86/kernel/ptrace.c +27 -2
@@ -48,6 +48,7 @@ enum x86_regset {REGSET_FP ,REGSET_XFP ,REGSET_IOPERM64 =REGSET_XFP , +REGSET_XSTATE ,REGSET_TLS , REGSET_IOPERM32, };
@@ -1560,7 +1561,7 @@ long compat_arch_ptrace(struct task_stru #ifdef CONFIG_X86_64 -static const struct user_regset x86_64_regsets[] = { +static struct user_regset x86_64_regsets[] __read_mostly = { [REGSET_GENERAL] = { .core_note_type = NT_PRSTATUS, .n = sizeof(struct user_regs_struct) / sizeof(long),
@@ -1573,6 +1574,12 @@ static const struct user_regset x86_64_r .size = sizeof(long), .align = sizeof(long), .active = xfpregs_active, .get = xfpregs_get, .set = xfpregs_set }, + [REGSET_XSTATE] = { + .core_note_type = NT_X86_XSTATE, + .size = sizeof(long), .align = sizeof(long), + .active = xstateregs_active, .get = xstateregs_get, + .set = xstateregs_set + }, [REGSET_IOPERM64] = { .core_note_type = NT_386_IOPERM, .n = IO_BITMAP_LONGS,
@@ -1598,7 +1605,7 @@ static const struct user_regset_view use#endif /* CONFIG_X86_64 */ #if defined CONFIG_X86_32 || defined CONFIG_IA32_EMULATION -static const struct user_regset x86_32_regsets[] = { +static struct user_regset x86_32_regsets[] __read_mostly = { [REGSET_GENERAL] = { .core_note_type = NT_PRSTATUS, .n = sizeof(struct user_regs_struct32) / sizeof(u32),
@@ -1617,6 +1624,12 @@ static const struct user_regset x86_32_r .size = sizeof(u32), .align = sizeof(u32), .active = xfpregs_active, .get = xfpregs_get, .set = xfpregs_set }, + [REGSET_XSTATE] = { + .core_note_type = NT_X86_XSTATE, + .size = sizeof(u32), .align = sizeof(u32), + .active = xstateregs_active, .get = xstateregs_get, + .set = xstateregs_set + }, [REGSET_TLS] = { .core_note_type = NT_386_TLS, .n = GDT_ENTRY_TLS_ENTRIES, .bias = GDT_ENTRY_TLS_MIN,
@@ -1639,6 +1652,18 @@ static const struct user_regset_view use };#endif +u64 xstate_fx_sw_bytes[6 ]; +void update_regset_xstate_info (unsigned int size,u64 xstate_mask) +{ +#ifdef CONFIG_X86_64 + x86_64_regsets[REGSET_XSTATE ].n = size /sizeof (long ); +#endif +#if definedCONFIG_X86_32 || definedCONFIG_IA32_EMULATION + x86_32_regsets[REGSET_XSTATE ].n = size /sizeof (u32); +#endif + xstate_fx_sw_bytes[0 ] = xstate_mask; +} +const struct user_regset_view *task_user_regset_view (struct task_struct *task) {#ifdef CONFIG_IA32_EMULATION
arch/x86/kernel/xsave.c +1 -0
@@ -337,6 +337,7 @@ void __ref xsave_cntxt_init(void)cpuid_count (0xd ,0 , &eax, &ebx, &ecx, &edx); xstate_size = ebx; +update_regset_xstate_info (xstate_size, pcntxt_mask);prepare_fx_sw_frame ();setup_xstate_init ();
include/linux/elf.h +1 -0
@@ -361,6 +361,7 @@ typedef struct elf64_shdr {#define NT_PPC_VSX 0x102/* PowerPC VSX registers */ #define NT_386_TLS 0x200/* i386 TLS slots (struct user_desc) */ #define NT_386_IOPERM 0x201/* x86 io permission bitmap (1=deny) */ +#define NT_X86_XSTATE 0x202/* x86 extended state using xsave */ #define NT_S390_HIGH_GPRS 0x300/* s390 upper register halves */
[tip:x86/ptrace] x86, ptrace: Regset extensions to support xstate
Commit-ID: c19ff02dbfbb926913f78556a2be51ce5daddcd5 Gitweb: http://git.kernel.org/tip/c19ff02dbfbb926913f78556a2be51ce5daddcd5 Author: Suresh Siddha <[email protected]> AuthorDate: Tue, 9 Feb 2010 12:13:11 -0800 Committer: H. Peter Anvin <[email protected]> CommitDate: Tue, 9 Feb 2010 14:09:53 -0800
x86, ptrace: Regset extensions to support xstate
Add the xstate regset support which helps extend the kernel ptrace and the core-dump interfaces to support AVX state etc.
This regset interface is designed to support all the future state that gets supported using xsave/xrstor infrastructure.
Looking at the memory layout saved by "xsave", one can't say which state is represented in the memory layout. This is because if a particular state is in init state, in the xsave hdr it can be represented by bit '0'. And hence we can't really say by the xsave header wether a state is in init state or the state is not saved in the memory layout.
And hence the xsave memory layout available through this regset interface uses SW usable bytes [464..511] to convey what state is represented in the memory layout.
First 8 bytes of the sw_usable_bytes[464..467] will be set to OS enabled xstate mask(which is same as the 64bit mask returned by the xgetbv's xCR0).
The note NT_X86_XSTATE represents the extended state information in the core file, using the above mentioned memory layout.
LKML-Reference: <[email protected]>
--- arch/x86/include/asm/i387.h | 12 +++++- arch/x86/include/asm/xsave.h | 2 + arch/x86/kernel/i387.c | 88 +++++++++++++++++++++++++++++++++++++++++- arch/x86/kernel/ptrace.c | 29 +++++++++++++- arch/x86/kernel/xsave.c | 1 + include/linux/elf.h | 1 + 6 files changed, 127 insertions(+), 6 deletions(-)
arch/x86/include/asm/i387.h +10 -2
@@ -33,8 +33,16 @@ extern void init_thread_xstate(void);extern int dump_fpu (struct pt_regs *,struct user_i387_struct *);extern user_regset_active_fn fpregs_active, xfpregs_active; -extern user_regset_get_fn fpregs_get, xfpregs_get, fpregs_soft_get; -extern user_regset_set_fn fpregs_set, xfpregs_set, fpregs_soft_set; +extern user_regset_get_fn fpregs_get, xfpregs_get, fpregs_soft_get, + xstateregs_get; +extern user_regset_set_fn fpregs_set, xfpregs_set, fpregs_soft_set, + xstateregs_set; + +/* +* xstateregs_active == fpregs_active. Please refer to the comment +* at the definition of fpregs_active. +*/ +#define xstateregs_active fpregs_activeextern struct _fpx_sw_bytes fx_sw_reserved;#ifdef CONFIG_IA32_EMULATION
arch/x86/include/asm/xsave.h +2 -0
@@ -27,9 +27,11 @@extern unsigned int xstate_size;extern u64 pcntxt_mask;extern struct xsave_struct *init_xstate_buf; +extern u64 xstate_fx_sw_bytes[6 ];extern void xsave_cntxt_init (void );extern void xsave_init (void ); +extern void update_regset_xstate_info (unsigned int size,u64 xstate_mask);extern int init_fpu (struct task_struct *child); extern int check_for_xstate(struct i387_fxsave_struct __user *buf, void __user *fpstate,
arch/x86/kernel/i387.c +86 -2
106 lines not on this page · raw message
arch/x86/kernel/ptrace.c +27 -2
@@ -48,6 +48,7 @@ enum x86_regset {REGSET_FP ,REGSET_XFP ,REGSET_IOPERM64 =REGSET_XFP , +REGSET_XSTATE ,REGSET_TLS , REGSET_IOPERM32, };
@@ -1584,7 +1585,7 @@ long compat_arch_ptrace(struct task_struct *child, compat_long_t request, #ifdef CONFIG_X86_64 -static const struct user_regset x86_64_regsets[] = { +static struct user_regset x86_64_regsets[] __read_mostly = { [REGSET_GENERAL] = { .core_note_type = NT_PRSTATUS, .n = sizeof(struct user_regs_struct) / sizeof(long),
@@ -1597,6 +1598,12 @@ static const struct user_regset x86_64_regsets[] = { .size = sizeof(long), .align = sizeof(long), .active = xfpregs_active, .get = xfpregs_get, .set = xfpregs_set }, + [REGSET_XSTATE] = { + .core_note_type = NT_X86_XSTATE, + .size = sizeof(long), .align = sizeof(long), + .active = xstateregs_active, .get = xstateregs_get, + .set = xstateregs_set + }, [REGSET_IOPERM64] = { .core_note_type = NT_386_IOPERM, .n = IO_BITMAP_LONGS,
@@ -1622,7 +1629,7 @@ static const struct user_regset_view user_x86_64_view = {#endif /* CONFIG_X86_64 */ #if defined CONFIG_X86_32 || defined CONFIG_IA32_EMULATION -static const struct user_regset x86_32_regsets[] = { +static struct user_regset x86_32_regsets[] __read_mostly = { [REGSET_GENERAL] = { .core_note_type = NT_PRSTATUS, .n = sizeof(struct user_regs_struct32) / sizeof(u32),
@@ -1641,6 +1648,12 @@ static const struct user_regset x86_32_regsets[] = { .size = sizeof(u32), .align = sizeof(u32), .active = xfpregs_active, .get = xfpregs_get, .set = xfpregs_set }, + [REGSET_XSTATE] = { + .core_note_type = NT_X86_XSTATE, + .size = sizeof(u32), .align = sizeof(u32), + .active = xstateregs_active, .get = xstateregs_get, + .set = xstateregs_set + }, [REGSET_TLS] = { .core_note_type = NT_386_TLS, .n = GDT_ENTRY_TLS_ENTRIES, .bias = GDT_ENTRY_TLS_MIN,
@@ -1663,6 +1676,18 @@ static const struct user_regset_view user_x86_32_view = { };#endif +u64 xstate_fx_sw_bytes[6 ]; +void update_regset_xstate_info (unsigned int size,u64 xstate_mask) +{ +#ifdef CONFIG_X86_64 + x86_64_regsets[REGSET_XSTATE ].n = size /sizeof (long ); +#endif +#if definedCONFIG_X86_32 || definedCONFIG_IA32_EMULATION + x86_32_regsets[REGSET_XSTATE ].n = size /sizeof (u32); +#endif + xstate_fx_sw_bytes[0 ] = xstate_mask; +} +const struct user_regset_view *task_user_regset_view (struct task_struct *task) {#ifdef CONFIG_IA32_EMULATION
arch/x86/kernel/xsave.c +1 -0
@@ -337,6 +337,7 @@ void __ref xsave_cntxt_init(void)cpuid_count (0xd ,0 , &eax, &ebx, &ecx, &edx); xstate_size = ebx; +update_regset_xstate_info (xstate_size, pcntxt_mask);prepare_fx_sw_frame ();setup_xstate_init ();
include/linux/elf.h +1 -0
@@ -361,6 +361,7 @@ typedef struct elf64_shdr {#define NT_PPC_VSX 0x102/* PowerPC VSX registers */ #define NT_386_TLS 0x200/* i386 TLS slots (struct user_desc) */ #define NT_386_IOPERM 0x201/* x86 io permission bitmap (1=deny) */ +#define NT_X86_XSTATE 0x202/* x86 extended state using xsave */ #define NT_S390_HIGH_GPRS 0x300/* s390 upper register halves */
Re: [patch v2 2/4] x86, ptrace: regset extensions to support xstate
In reply to Suresh SiddhaQuoted 5 lines
Add the xstate regset support which helps extend the kernel ptrace and the core-dump interfaces to support AVX state etc.
This regset interface is designed to support all the future state that gets supported using xsave/xrstor infrastructure.
Looks good modulo cosmetic nits below.
Quoted 6 lines
And hence the xsave memory layout available through this regset interface uses SW usable bytes [464..511] to convey what state is represented in the memory layout.
First 8 bytes of the sw_usable_bytes[464..467] will be set to OS enabled xstate mask(which is same as the 64bit mask returned by the xgetbv's xCR0).
I'd like to see some macros or struct or something in some user-visible header (ptrace-abi.h I guess?) that instruct userland where to find this software-defined word. The rest of the layout and meaning is specified by the chip manuals and it's only a question of convenience if we want to help userland out with those bits. But the use of the reserved-for-software area to store a bitmask (or whatever else Linux might put there in the future) is entirely a Linux invention that needs to be a clear and explicit part of this userland ABI format.
Quoted 2 lines
+/*
+ * Thexfpregs_active()routine is same as thefpregs_active()routine,
s/xfpregs_active/xstateregs_active/
s/is same/is the same/
arch/x86/kernel/i387.c int xfpregs_set(struct task_struct *targ · line 208
Quoted 6 lines
arch/x86/kernel/i387.c +0
-2@@ -204,8 +209,6 @@ int xfpregs_set(struct task_struct *targif (ret)return ret; -set_stopped_child_used_math (target); -
You didn't mention this change in a comment or log entry. It looks like it's superfluous after init_fpu. So this change is right, but AFAICT it belongs in an entirely separate patch and has nothing to do with xsave support.
Quoted 6 lines
arch/x86/kernel/i387.c +6
-0+int xstateregs_get (struct task_struct *target,const struct user_regset *regset, +unsigned int pos,unsigned int count, +void *kbuf,void __user *ubuf) +{ +int ret; +int size = regset->n * regset->size;
[...]
arch/x86/kernel/i387.c int xfpregs_set(struct task_struct *targ · line 270
Quoted 7 lines
arch/x86/kernel/i387.c +7
-0+/* +* Copy the rest of xstate memory layout +*/ + ret =user_regset_copyout (&pos, &count, &kbuf, &ubuf, + xsave_hdr, + offsetof(struct xsave_struct , + xsave_hdr), size);
This calculation is unnecessary (though it doesn't hurt); you can just use -1 here. The arch user_regset.get and user_regset.set functions are not required to worry about bogus arguments. Their callers are required to pass values that don't violate the .n, .size, and .align constraints in the user_regset.
Quoted 6 lines
arch/x86/kernel/i387.c +6
-0+int xstateregs_set (struct task_struct *target,const struct user_regset *regset, +unsigned int pos,unsigned int count, +const void *kbuf,const void __user *ubuf) +{ +int ret; +int size = regset->n * regset->size;
[...]
arch/x86/kernel/i387.c int xfpregs_set(struct task_struct *targ · line 294
Quoted 2 lines
arch/x86/kernel/i387.c +2
-0+ ret =user_regset_copyin (&pos, &count, &kbuf, &ubuf, + &target->thread.xstate->xsave,0 , size);
Same here.
Quoted 3 lines
arch/x86/kernel/ptrace.c +3
-0+ [REGSET_XSTATE] = { + .core_note_type = NT_X86_XSTATE, + .size = sizeof(long), .align = sizeof(long),
[...]
arch/x86/kernel/ptrace.c static const struct user_regset x86_32_r · line 1629
Quoted 3 lines
arch/x86/kernel/ptrace.c +3
-0+ [REGSET_XSTATE] = { + .core_note_type = NT_X86_XSTATE, + .size = sizeof(u32), .align = sizeof(u32),
Isn't the xsave format is really the same for 32-bit and 64-bit? All its components are naturally 64 bits or larger, right?
If that's correct, I think it would be better to make the 32 and 64 version of the regset uniform with .size and .align being sizeof(u64).
arch/x86/kernel/ptrace.c static const struct user_regset_view use · line 1663
Quoted 9 lines
arch/x86/kernel/ptrace.c +9
-0+u64 xstate_fx_sw_bytes[6 ]; +void update_regset_xstate_info (unsigned int size,u64 xstate_mask) +{ +#ifdef CONFIG_X86_64 + x86_64_regsets[REGSET_XSTATE ].n = size /sizeof (long ); +#endif +#if definedCONFIG_X86_32 || definedCONFIG_IA32_EMULATION + x86_32_regsets[REGSET_XSTATE ].n = size /sizeof (u32); +#endif
Just change these to / sizeof(u64) accordingly.
Thanks,
Roland
Oleg Nesterov
maintainerRe: [patch v2 2/4] x86, ptrace: regset extensions to support xstate
Quoted 5 lines · Roland McGrath
Quoted 5 lines
arch/x86/kernel/i387.c +0
-0@@ -204,8 +209,6 @@ int xfpregs_set(struct task_struct *targif (ret)return ret;
Quoted 7 lines
arch/x86/kernel/i387.c int xfpregs_set(struct task_struct *targ · line 208
Quoted 2 lines
arch/x86/kernel/i387.c +0
-2-set_stopped_child_used_math (target); -You didn't mention this change in a comment or log entry. It looks like it's superfluous after
init_fpu. So this change is right, but AFAICT it belongs in an entirely separate patch and has nothing to do with xsave support.
I guess Suresh was going to change xstateregs_set() added by this patch, it also sets USED_MATH after init_fpu().
Oleg.
Oleg Nesterov
maintainerRe: [patch v2 2/4] x86, ptrace: regset extensions to support xstate
In reply to Suresh SiddhaQuoted 24 lines · Suresh Siddha
arch/x86/kernel/i387.c +23
-0+int xstateregs_get (struct task_struct *target,const struct user_regset *regset, +unsigned int pos,unsigned int count, +void *kbuf,void __user *ubuf) +{ +int ret; +int size = regset->n * regset->size; +struct xsave_hdr_struct *xsave_hdr = + &target->thread.xstate->xsave.xsave_hdr; + +if (!cpu_has_xsave) +return -ENODEV ; + + ret =init_fpu (target); +if (ret) +return ret; + +/* +* First copy the fxsave bytes 0..463 +*/ + ret =user_regset_copyout (&pos, &count, &kbuf, &ubuf, + &target->thread.xstate->xsave,0 , + offsetof(struct i387_fxsave_struct , + sw_reserved));
arch/x86/kernel/i387.c int xfpregs_set(struct task_struct *targ · line 262
Quoted 10 lines
arch/x86/kernel/i387.c +10
-0+if (!ret) +/* +* Copy the 48bytes defined by software +*/ + ret =user_regset_copyout (&pos, &count, &kbuf, &ubuf, + xstate_fx_sw_bytes, + offsetof(struct i387_fxsave_struct , + sw_reserved), + offsetof(struct xsave_struct , + xsave_hdr));
Hmm. Suresh, could you confirm these offsetof's are correct?
We are copying xstate_fx_sw_bytes array which is u64[6], but start_pos == sizeof(i387_fxsave_struct) - padding ?
While we are here. Perhaps it would be more symmetrical to do
ret = user_regset_copyout(); if (ret) return ret;
instead of "if (!ret)" which needs a tab, but this is up to you.
arch/x86/kernel/i387.c int xfpregs_set(struct task_struct *targ · line 268
Quoted 6 lines
arch/x86/kernel/i387.c +6
-0+if (!ret) +/* +* Copy the rest of xstate memory layout +*/ + ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf, + xsave_hdr,
Another very minor nit, this is the only user of xsave_hdr, but this var was defined at the top. Perhaps it would be a bit more clean to have
struct xsave_struct *xsave = target->thread.xstate->xsave;
and use it in 1st and 3rd copyout?
Speaking about the first user_regset_copyout(), perhaps xsave->i387 would be more clear than xsave?
Oleg.
Oleg Nesterov
maintainerRe: [patch v2 2/4] x86, ptrace: regset extensions to support xstate
Quoted 39 lines · Oleg Nesterov
Quoted 24 lines · Suresh Siddha
arch/x86/kernel/i387.c +23
-0+int xstateregs_get (struct task_struct *target,const struct user_regset *regset, +unsigned int pos,unsigned int count, +void *kbuf,void __user *ubuf) +{ +int ret; +int size = regset->n * regset->size; +struct xsave_hdr_struct *xsave_hdr = + &target->thread.xstate->xsave.xsave_hdr; + +if (!cpu_has_xsave) +return -ENODEV ; + + ret =init_fpu (target); +if (ret) +return ret; + +/* +* First copy the fxsave bytes 0..463 +*/ + ret =user_regset_copyout (&pos, &count, &kbuf, &ubuf, + &target->thread.xstate->xsave,0 , + offsetof(struct i387_fxsave_struct , + sw_reserved));arch/x86/kernel/i387.c int xfpregs_set(struct task_struct *targ · line 262
Quoted 10 lines
arch/x86/kernel/i387.c +10
-0+if (!ret) +/* +* Copy the 48bytes defined by software +*/ + ret =user_regset_copyout (&pos, &count, &kbuf, &ubuf, + xstate_fx_sw_bytes, + offsetof(struct i387_fxsave_struct , + sw_reserved), + offsetof(struct xsave_struct , + xsave_hdr));Hmm. Suresh, could you confirm these offsetof's are correct?
Quoted 2 lines
We are copying
xstate_fx_sw_bytesarray which is u64[6], butstart_pos==sizeof(i387_fxsave_struct)- padding ?
Sorry for noise. Now I see this should be correct, see another email I sent.
In fact, unless I missed something again, the 2nd and 3rd _copyout's could use pos as start_pos instead of offsetof(what_we_already_copied).
Oleg.
Re: [patch v2 2/4] x86, ptrace: regset extensions to support xstate
Quoted 2 lines
In fact, unless I missed something again, the 2nd and 3rd _copyout's could use pos as
start_posinstead ofoffsetof(what_we_already_copied).
No, you should never do that. start_pos and end_pos should be constants.
Thanks,
Roland
Oleg Nesterov
maintainerRe: [patch v2 2/4] x86, ptrace: regset extensions to support xstate
In reply to Suresh Siddhastatic inline int user_regset_copyout(unsigned int *pos, unsigned int *count,
void **kbuf,
void __user **ubuf, const void *data, const int start_pos, const int end_pos)
{
if (*count == 0)
return 0;
BUG_ON(*pos < start_pos);
if (end_pos < 0 || *pos < end_pos) {
unsigned int copy = (end_pos < 0 ? *count
: min(*count, end_pos - *pos));
data += *pos - start_pos;
^^^Is it correct? Shouldn't it be
data += *pos + start_pos;
?
Currently this doesn't matter, start_pos == 0 always. In fact I don't understand why do we need this arg. In unlikely case the caller wants to copy the part of *data, it can adjust data/end_pos itself.
Oleg.
Oleg Nesterov
maintainerRe: [patch v2 2/4] x86, ptrace: regset extensions to support xstate
Quoted 14 lines · Oleg Nesterov
static inline int user_regset_copyout(unsigned int *pos, unsigned int *count,
void **kbuf,
void__user**ubuf, const void *data, const intstart_pos, const intend_pos){ if (*count == 0) return 0; BUG_ON(*pos < start_pos); if (end_pos < 0 || *pos < end_pos) { unsigned int copy = (end_pos < 0 ? *count : min(*count, end_pos - *pos)); data += *pos - start_pos; ^^^
Quoted 5 lines
Is it correct? Shouldn't it be
data += *pos + start_pos;?
Ah, I seem to understand. start_pos is not the offset inside *data as I thought. It is needed to compensate the "*pos += copy" addition which was done by the previous user_regset_copyout().
This means that xstateregs_get() is right, it copies xstate_fx_sw_bytes but uses sizeof(i387_fxsave_struct) as start_pos.
So tricky... I must admit, I don't understand the point.
Oleg.
PATCH v2 3/4 x86, ptrace: prepare regset get/set routines for user specified lengths
In reply to Suresh SiddhaPrepare the x86 regset routines for the upcoming generic PTRACE_GETREGSET/PTRACE_SETREGSET commands. These commands allow the user to specify how much to read and hence the kernel needs to ensure that the get/set routines of the regset don't allow the user to access more kernel buffers than needed.
--- arch/x86/kernel/i387.c | 15 ++++++++++----- 1 file changed, 10 insertions(+), 5 deletions(-)
arch/x86/kernel/i387.c +10 -5
@@ -184,6 +184,7 @@ int xfpregs_get(struct task_struct *targ void *kbuf, void __user *ubuf) { int ret; +int size = regset->n * regset->size;if (!cpu_has_fxsr)return -ENODEV ;
@@ -193,7 +194,7 @@ int xfpregs_get(struct task_struct *targreturn ret;return user_regset_copyout (&pos, &count, &kbuf, &ubuf, - &target->thread.xstate->fxsave,0 ,-1 ); + &target->thread.xstate->fxsave,0 , size); } int xfpregs_set(struct task_struct *target, const struct user_regset *regset,
@@ -201,6 +202,7 @@ int xfpregs_set(struct task_struct *targ const void *kbuf, const void __user *ubuf) { int ret; +int size = regset->n * regset->size;if (!cpu_has_fxsr)return -ENODEV ;
@@ -210,7 +212,7 @@ int xfpregs_set(struct task_struct *targreturn ret; ret =user_regset_copyin (&pos, &count, &kbuf, &ubuf, - &target->thread.xstate->fxsave,0 ,-1 ); + &target->thread.xstate->fxsave,0 , size);/* * mxcsr reserved bits must be masked to zero for security reasons.
@@ -452,6 +454,7 @@ int fpregs_get(struct task_struct *targe void *kbuf, void __user *ubuf) { struct user_i387_ia32_struct env; +int size = regset->n * regset->size;int ret; ret =init_fpu (target);
@@ -464,7 +467,7 @@ int fpregs_get(struct task_struct *targeif (!cpu_has_fxsr) {return user_regset_copyout (&pos, &count, &kbuf, &ubuf, &target->thread.xstate->fsave,0 , --1 ); + size); }if (kbuf && pos ==0 && count ==sizeof (env)) {
@@ -482,6 +485,7 @@ int fpregs_set(struct task_struct *targe const void *kbuf, const void __user *ubuf) { struct user_i387_ia32_struct env; +int size = regset->n * regset->size;int ret; ret =init_fpu (target);
@@ -495,13 +499,14 @@ int fpregs_set(struct task_struct *targeif (!cpu_has_fxsr) {return user_regset_copyin (&pos, &count, &kbuf, &ubuf, - &target->thread.xstate->fsave,0 ,-1 ); + &target->thread.xstate->fsave,0 , + size); }if (pos >0 || count <sizeof (env))convert_from_fxsr (&env, target); - ret =user_regset_copyin (&pos, &count, &kbuf, &ubuf, &env,0 ,-1 ); + ret =user_regset_copyin (&pos, &count, &kbuf, &ubuf, &env,0 , size);if (!ret)convert_to_fxsr (target, &env);
[tip:x86/ptrace] x86, ptrace: Prepare regset get/set routines for user specified lengths
Commit-ID: a6bf9383255e088f5a78d93e2f8cd871aa028060 Gitweb: http://git.kernel.org/tip/a6bf9383255e088f5a78d93e2f8cd871aa028060 Author: Suresh Siddha <[email protected]> AuthorDate: Tue, 9 Feb 2010 12:13:12 -0800 Committer: H. Peter Anvin <[email protected]> CommitDate: Tue, 9 Feb 2010 14:09:58 -0800
x86, ptrace: Prepare regset get/set routines for user specified lengths
Prepare the x86 regset routines for the upcoming generic PTRACE_GETREGSET/PTRACE_SETREGSET commands. These commands allow the user to specify how much to read and hence the kernel needs to ensure that the get/set routines of the regset don't allow the user to access more kernel buffers than needed.
LKML-Reference: <[email protected]>
--- arch/x86/kernel/i387.c | 15 ++++++++++----- 1 files changed, 10 insertions(+), 5 deletions(-)
arch/x86/kernel/i387.c +10 -5
@@ -184,6 +184,7 @@ int xfpregs_get(struct task_struct *target, const struct user_regset *regset, void *kbuf, void __user *ubuf) { int ret; +int size = regset->n * regset->size;if (!cpu_has_fxsr)return -ENODEV ;
@@ -193,7 +194,7 @@ int xfpregs_get(struct task_struct *target, const struct user_regset *regset,return ret;return user_regset_copyout (&pos, &count, &kbuf, &ubuf, - &target->thread.xstate->fxsave,0 ,-1 ); + &target->thread.xstate->fxsave,0 , size); } int xfpregs_set(struct task_struct *target, const struct user_regset *regset,
@@ -201,6 +202,7 @@ int xfpregs_set(struct task_struct *target, const struct user_regset *regset, const void *kbuf, const void __user *ubuf) { int ret; +int size = regset->n * regset->size;if (!cpu_has_fxsr)return -ENODEV ;
@@ -210,7 +212,7 @@ int xfpregs_set(struct task_struct *target, const struct user_regset *regset,return ret; ret =user_regset_copyin (&pos, &count, &kbuf, &ubuf, - &target->thread.xstate->fxsave,0 ,-1 ); + &target->thread.xstate->fxsave,0 , size);/* * mxcsr reserved bits must be masked to zero for security reasons.
@@ -452,6 +454,7 @@ int fpregs_get(struct task_struct *target, const struct user_regset *regset, void *kbuf, void __user *ubuf) { struct user_i387_ia32_struct env; +int size = regset->n * regset->size;int ret; ret =init_fpu (target);
@@ -464,7 +467,7 @@ int fpregs_get(struct task_struct *target, const struct user_regset *regset,if (!cpu_has_fxsr) {return user_regset_copyout (&pos, &count, &kbuf, &ubuf, &target->thread.xstate->fsave,0 , --1 ); + size); }if (kbuf && pos ==0 && count ==sizeof (env)) {
@@ -482,6 +485,7 @@ int fpregs_set(struct task_struct *target, const struct user_regset *regset, const void *kbuf, const void __user *ubuf) { struct user_i387_ia32_struct env; +int size = regset->n * regset->size;int ret; ret =init_fpu (target);
@@ -495,13 +499,14 @@ int fpregs_set(struct task_struct *target, const struct user_regset *regset,if (!cpu_has_fxsr) {return user_regset_copyin (&pos, &count, &kbuf, &ubuf, - &target->thread.xstate->fsave,0 ,-1 ); + &target->thread.xstate->fsave,0 , + size); }if (pos >0 || count <sizeof (env))convert_from_fxsr (&env, target); - ret =user_regset_copyin (&pos, &count, &kbuf, &ubuf, &env,0 ,-1 ); + ret =user_regset_copyin (&pos, &count, &kbuf, &ubuf, &env,0 , size);if (!ret)convert_to_fxsr (target, &env);
Re: [patch v2 3/4] x86, ptrace: prepare regset get/set routines for user specified lengths
In reply to Suresh SiddhaThis change is unnecessary and IMHO misguided. The arch user_regset.get and user_regset.set functions are not required to worry about bogus arguments. Their callers are required to pass values that don't violate the .n, .size, and .align constraints in the user_regset. The right place to enforce these constraints on parameters coming from userland is in the arch-independent code that calls the arch user_regset functions.
Thanks,
Roland
PATCH v2 4/4 ptrace: Add support for generic PTRACE_GETREGSET/PTRACE_SETREGSET
In reply to Suresh SiddhaGeneric support for PTRACE_GETREGSET/PTRACE_SETREGSET commands which export the regsets supported by each architecture using the correponding NT_* types.
'addr' parameter for the ptrace system call encode the REGSET type and the buffer length. 'data' parameter points to the user buffer.
ptrace(PTRACE_GETREGSET/PTRACE_SETREGSET, pid, (NT_TYPE << 20) | buf_length, buf);
For more information on how to use this API by users like debuggers and core dump for accessing xstate registers, etc., please refer to comments in arch/x86/include/asm/ptrace-abi.h
--- arch/x86/include/asm/ptrace-abi.h | 51 ++++++++++++++++++++++++++++++++++++++ include/linux/elf.h | 25 +++++++++++++++++- include/linux/ptrace.h | 14 ++++++++++ kernel/ptrace.c | 34 +++++++++++++++++++++++++ 4 files changed, 122 insertions(+), 2 deletions(-)
include/linux/ptrace.h +14 -0
@@ -26,6 +26,18 @@#define PTRACE_GETEVENTMSG 0x4201#define PTRACE_GETSIGINFO 0x4202#define PTRACE_SETSIGINFO 0x4203 +#define PTRACE_GETREGSET 0x4204 +#define PTRACE_SETREGSET 0x4205 + +/* +* First 20 bits of the addr in the PTRACE_GETREGSET/PTRACE_SETREGSET requests +* are reserved for communicating the user buffer size and the remaining 12 bits +* are reserved for the NT_* types (defined in include/linux/elf.h) which +* indicate the regset that the ptrace user is interested in. +*/ +#define PTRACE_REGSET_BUF_SIZE (addr) (addr & 0xfffff) +#define PTRACE_REGSET_TYPE (addr) ((addr >> 20) & 0xfff) +#define NOTE_TO_REGSET_TYPE (note) (note & 0xfff)/* options set using PTRACE_SETOPTIONS */ #define PTRACE_O_TRACESYSGOOD 0x00000001
@@ -114,6 +126,8 @@ static inline void ptrace_unlink(structint generic_ptrace_peekdata (struct task_struct *tsk,long addr,long data);int generic_ptrace_pokedata (struct task_struct *tsk,long addr,long data); +int generic_ptrace_regset (struct task_struct *child,long request,long addr, +long data);/** * task_ptrace - return %PT_* flags that apply to a task
kernel/ptrace.c +34 -0
@@ -22,6 +22,7 @@#include <linux/pid_namespace.h> #include <linux/syscalls.h> #include <linux/uaccess.h> +#include <linux/regset.h> /*
@@ -573,6 +574,11 @@ int ptrace_request(struct task_struct *creturn 0 ;return ptrace_resume (child, request,SIGKILL ); +#ifdef PTRACE_EXPORT_REGSET +case PTRACE_GETREGSET : +case PTRACE_SETREGSET : +return generic_ptrace_regset (child, request, addr, data); +#endif default :break ; }
@@ -664,6 +670,34 @@ int generic_ptrace_pokedata(struct task_return (copied ==sizeof (data)) ?0 : -EIO ; } +#ifdef PTRACE_EXPORT_REGSET +int generic_ptrace_regset (struct task_struct *child,long request,long addr, +long data) +{ +const struct user_regset_view *view =task_user_regset_view (child); +unsigned int buf_size =PTRACE_REGSET_BUF_SIZE (addr); +int setno; + +for (setno =0 ; setno < view->n; setno++) { +const struct user_regset *regset = &view->regsets[setno]; +if (NOTE_TO_REGSET_TYPE (regset->core_note_type) != +PTRACE_REGSET_TYPE (addr)) +continue ; + +if (request ==PTRACE_GETREGSET ) +return copy_regset_to_user (child, view, setno,0 , + buf_size, + (void __user *) data); +else if (request ==PTRACE_SETREGSET ) +return copy_regset_from_user (child, view, setno,0 , + buf_size, + (void __user *) data); + } + +return -EIO ; +} +#endif +#if definedCONFIG_COMPAT #include <linux/compat.h>
arch/x86/include/asm/ptrace-abi.h +50 -0
54 lines not on this page · raw message
include/linux/elf.h +23 -2
@@ -349,7 +349,29 @@ typedef struct elf64_shdr {#define ELF_OSABI ELFOSABI_NONE#endif -/* Notes used in ET_CORE */ +/* +* Notes used in ET_CORE. Architectures export some of the arch register sets +* using the corresponding note types via ptrace +* PTRACE_GETREGSET/PTRACE_SETREGSET requests. +* +* For example, +* long addr = (NT_X86_XSTATE << 20 | buf_length); +* ptrace(PTRACE_GETREGSET, pid, addr, buf); +* +* will obtain the x86 extended register state of the pid. +* +* On 32bit architectures, addr argument is 32bits wide and encodes the length +* of the buffer in the first 20 bits, followed by NT_* type encoded in the +* remaining 12 bits, representing an unique regset. +* +* Hence on 32bit architectures, NT_PRXFPREG (0x46e62b7f) will be seen as 0xb7f +* and we can't allocate 0xb7f to any other note. +* +* All the other existing NT_* types fall with in the 12 bits and we have +* plenty of room for more NT_* types. For now, on all architectures +* we use first 20 bits of the addr for the buffer size and the next 12 bits for +* the NT_* type representing the corresponding regset. +*/ #define NT_PRSTATUS 1#define NT_PRFPREG 2#define NT_PRPSINFO 3
@@ -364,7 +386,6 @@ typedef struct elf64_shdr {#define NT_X86_XSTATE 0x202/* x86 extended state using xsave */ #define NT_S390_HIGH_GPRS 0x300/* s390 upper register halves */ -/* Note header in a PT_NOTE section */ typedef struct elf32_note { Elf32_Word n_namesz; /* Name size */
[tip:x86/ptrace] ptrace: Add support for generic PTRACE_GETREGSET/PTRACE_SETREGSET
Commit-ID: b26d3b32b860e4667df88dc2407f8823e2aa7cc6 Gitweb: http://git.kernel.org/tip/b26d3b32b860e4667df88dc2407f8823e2aa7cc6 Author: Suresh Siddha <[email protected]> AuthorDate: Tue, 9 Feb 2010 12:13:13 -0800 Committer: H. Peter Anvin <[email protected]> CommitDate: Tue, 9 Feb 2010 14:10:07 -0800
ptrace: Add support for generic PTRACE_GETREGSET/PTRACE_SETREGSET
Generic support for PTRACE_GETREGSET/PTRACE_SETREGSET commands which export the regsets supported by each architecture using the correponding NT_* types.
'addr' parameter for the ptrace system call encode the REGSET type and the buffer length. 'data' parameter points to the user buffer.
ptrace(PTRACE_GETREGSET/PTRACE_SETREGSET, pid, (NT_TYPE << 20) | buf_length, buf);
For more information on how to use this API by users like debuggers and core dump for accessing xstate registers, etc., please refer to comments in arch/x86/include/asm/ptrace-abi.h
LKML-Reference: <[email protected]>
--- arch/x86/include/asm/ptrace-abi.h | 50 +++++++++++++++++++++++++++++++++++++ include/linux/elf.h | 25 +++++++++++++++++- include/linux/ptrace.h | 14 ++++++++++ kernel/ptrace.c | 34 +++++++++++++++++++++++++ 4 files changed, 121 insertions(+), 2 deletions(-)
arch/x86/include/asm/ptrace-abi.h +50 -0
@@ -139,4 +139,54 @@ struct ptrace_bts_config {Returns number of BTS records drained. */ +/* +* The extended register state using xsave/xrstor infrastructure can be +* be read and set by the user using the following ptrace command. +* +* ptrace(PTRACE_GETREGSET/PTRACE_SETREGSET, pid, +* (NT_X86_XSTATE << 20) | xstate_buf_length, xstate_buf); +* +* The structure layout used for the xstate_buf is same as +* the memory layout of xsave used by the processor (except for the bytes +* 464..511, which can be used by the software) and hence the size +* of this structure varies depending on the features supported by the processor +* and OS. The size of the structure that users need to use can be obtained by +* doing: +* cpuid_count(0xd, 0, &eax, &ptrace_xstateregs_struct_size, &ecx, &edx); +* i.e., cpuid.(eax=0xd,ecx=0).ebx will be the size that user (debuggers, etc.) +* need to use. +* +* The format of this structure will be like: +* struct { +* fxsave_bytes[0..463] +* sw_usable_bytes[464..511] +* xsave_hdr_bytes[512..575] +* avx_bytes[576..831] +* future_state etc +* } +* +* The same memory layout will be used for the core-dump NT_X86_XSTATE +* note representing the xstate registers. +* +* For now, only the first 8 bytes of the sw_usable_bytes[464..471] will +* be used and will be set to OS enabled xstate mask (which is same as the +* 64bit mask returned by the xgetbv's xCR0). Users (analyzing core dump +* remotely, etc.) can use this mask as well as the mask saved in the +* xstate_hdr bytes and interpret what states the processor/OS supports +* and what states are in modified/initialized conditions for the +* particular process/thread. +* +* Also when the user modifies certain state FP/SSE/etc through this +* PTRACE_SETXSTATEREGS, they must ensure that the xsave_hdr.xstate_bv +* bytes[512..519] of the above memory layout are updated correspondingly. +* i.e., for example when FP state is modified to a non-init state, +* xsave_hdr.xstate_bv's bit 0 must be set to '1', when SSE is modified to +* non-init state, xsave_hdr.xstate_bv's bit 1 must to be set to '1', etc. +*/ + +/* +* Enable PTRACE_GETREGSET/PTRACE_SETREGSET interface +*/ +#define PTRACE_EXPORT_REGSET +#endif /* _ASM_X86_PTRACE_ABI_H */
include/linux/elf.h +23 -2
@@ -349,7 +349,29 @@ typedef struct elf64_shdr {#define ELF_OSABI ELFOSABI_NONE#endif -/* Notes used in ET_CORE */ +/* +* Notes used in ET_CORE. Architectures export some of the arch register sets +* using the corresponding note types via ptrace +* PTRACE_GETREGSET/PTRACE_SETREGSET requests. +* +* For example, +* long addr = (NT_X86_XSTATE << 20 | buf_length); +* ptrace(PTRACE_GETREGSET, pid, addr, buf); +* +* will obtain the x86 extended register state of the pid. +* +* On 32bit architectures, addr argument is 32bits wide and encodes the length +* of the buffer in the first 20 bits, followed by NT_* type encoded in the +* remaining 12 bits, representing an unique regset. +* +* Hence on 32bit architectures, NT_PRXFPREG (0x46e62b7f) will be seen as 0xb7f +* and we can't allocate 0xb7f to any other note. +* +* All the other existing NT_* types fall with in the 12 bits and we have +* plenty of room for more NT_* types. For now, on all architectures +* we use first 20 bits of the addr for the buffer size and the next 12 bits for +* the NT_* type representing the corresponding regset. +*/ #define NT_PRSTATUS 1#define NT_PRFPREG 2#define NT_PRPSINFO 3
@@ -364,7 +386,6 @@ typedef struct elf64_shdr {#define NT_X86_XSTATE 0x202/* x86 extended state using xsave */ #define NT_S390_HIGH_GPRS 0x300/* s390 upper register halves */ -/* Note header in a PT_NOTE section */ typedef struct elf32_note { Elf32_Word n_namesz; /* Name size */
include/linux/ptrace.h +14 -0
@@ -26,6 +26,18 @@#define PTRACE_GETEVENTMSG 0x4201#define PTRACE_GETSIGINFO 0x4202#define PTRACE_SETSIGINFO 0x4203 +#define PTRACE_GETREGSET 0x4204 +#define PTRACE_SETREGSET 0x4205 + +/* +* First 20 bits of the addr in the PTRACE_GETREGSET/PTRACE_SETREGSET requests +* are reserved for communicating the user buffer size and the remaining 12 bits +* are reserved for the NT_* types (defined in include/linux/elf.h) which +* indicate the regset that the ptrace user is interested in. +*/ +#define PTRACE_REGSET_BUF_SIZE (addr) (addr & 0xfffff) +#define PTRACE_REGSET_TYPE (addr) ((addr >> 20) & 0xfff) +#define NOTE_TO_REGSET_TYPE (note) (note & 0xfff)/* options set using PTRACE_SETOPTIONS */ #define PTRACE_O_TRACESYSGOOD 0x00000001
@@ -114,6 +126,8 @@ static inline void ptrace_unlink(struct task_struct *child)int generic_ptrace_peekdata (struct task_struct *tsk,long addr,long data);int generic_ptrace_pokedata (struct task_struct *tsk,long addr,long data); +int generic_ptrace_regset (struct task_struct *child,long request,long addr, +long data);/** * task_ptrace - return %PT_* flags that apply to a task
kernel/ptrace.c +34 -0
@@ -22,6 +22,7 @@#include <linux/pid_namespace.h> #include <linux/syscalls.h> #include <linux/uaccess.h> +#include <linux/regset.h> /*
@@ -573,6 +574,11 @@ int ptrace_request(struct task_struct *child, long request,return 0 ;return ptrace_resume (child, request,SIGKILL ); +#ifdef PTRACE_EXPORT_REGSET +case PTRACE_GETREGSET : +case PTRACE_SETREGSET : +return generic_ptrace_regset (child, request, addr, data); +#endif default :break ; }
@@ -664,6 +670,34 @@ int generic_ptrace_pokedata(struct task_struct *tsk, long addr, long data)return (copied ==sizeof (data)) ?0 : -EIO ; } +#ifdef PTRACE_EXPORT_REGSET +int generic_ptrace_regset (struct task_struct *child,long request,long addr, +long data) +{ +const struct user_regset_view *view =task_user_regset_view (child); +unsigned int buf_size =PTRACE_REGSET_BUF_SIZE (addr); +int setno; + +for (setno =0 ; setno < view->n; setno++) { +const struct user_regset *regset = &view->regsets[setno]; +if (NOTE_TO_REGSET_TYPE (regset->core_note_type) != +PTRACE_REGSET_TYPE (addr)) +continue ; + +if (request ==PTRACE_GETREGSET ) +return copy_regset_to_user (child, view, setno,0 , + buf_size, + (void __user *) data); +else if (request ==PTRACE_SETREGSET ) +return copy_regset_from_user (child, view, setno,0 , + buf_size, + (void __user *) data); + } + +return -EIO ; +} +#endif +#if definedCONFIG_COMPAT #include <linux/compat.h>
Re: [patch v2 4/4] ptrace: Add support for generic PTRACE_GETREGSET/PTRACE_SETREGSET
In reply to Suresh SiddhaQuoted 5 lines
'addr' parameter for the ptrace system call encode the REGSET type and the buffer length. 'data' parameter points to the user buffer.
ptrace(PTRACE_GETREGSET/PTRACE_SETREGSET, pid, (NT_TYPE << 20) | buf_length, buf);
IMHO this bit swizzling is a non-starter. The NT_* codes can use a full 32 bits. NT_PRXFPREG uses 31 bits. The comments about ignoring the high bits for this as a special case just seem insane to me. Pass a full 32 bit word for NT_* and a full word for the buffer size. What's so terrible about just having an obvious and comprehensible API?
IMHO if you insist on an insane bit swizzling approach, you should mix the buffer size bits into the request code, leaving the "addr" argument free for the unmolested NT_* code. There is just no earthly reason that we should suddenly impose a new and arcane constraint on what NT_* values can be, even if there is no particular reason for future values not to be small.
include/linux/ptrace.h static inline void ptrace_unlink(struct · line 130
Quoted 2 lines
include/linux/ptrace.h +2
-0+int generic_ptrace_regset (struct task_struct *child,long request,long addr, +long data);
There is no need for a global function for this. It should all be static in kernel/ptrace.c, called only by ptrace_request()/compat_ptrace_request().
kernel/ptrace.c int ptrace_request(struct task_struct *c · line 581
Quoted 5 lines
kernel/ptrace.c +5
-0+#ifdef PTRACE_EXPORT_REGSET +case PTRACE_GETREGSET : +case PTRACE_SETREGSET : +return generic_ptrace_regset (child, request, addr, data); +#endif
Just use CONFIG_HAVE_ARCH_TRACEHOOK. That means the arch supplies task_user_regset_view(). Any additional per-arch conditionalization defeats the essential purpose of having fully generic ptrace requests.
kernel/ptrace.c int generic_ptrace_pokedata(struct task_ · line 685
Quoted 3 lines
kernel/ptrace.c +3
-0+if (NOTE_TO_REGSET_TYPE (regset->core_note_type) != +PTRACE_REGSET_TYPE (addr)) +continue ;
Here is where you should validate the buf_size value. You must not pass a size that is > regset.size * regset.n or has % regset.size != 0. The arch user_regset.get and .set functions are not required to check for bogus offsets or sizes.
You could either just use:
buf_size = MIN(buf_size, regset->n * regset->size);
or you could diagnose it with:
if (buf_size > regset->n * regset->size) return -EINVAL;
Possibly we might want to allow a PTRACE_GETREGSET with a buffer that is larger than necessary. Then it would probably make sense to zero-fill the rest of the buffer. Or else, use an API that can pass back to userland how much we're actually filling in.
include/linux/elf.h typedef struct elf64_shdr { · line 353
Quoted 9 lines
include/linux/elf.h +2
-1@@ -349,7 +349,29 @@ typedef struct elf64_shdr {#define ELF_OSABI ELFOSABI_NONE#endif -/* Notes used in ET_CORE */ +/* +* Notes used in ET_CORE. Architectures export some of the arch register sets
[...]
These comments don't really belong in linux/elf.h IMHO. They don't add anything, except documenting the insanity about truncating NT_* values. I don't think that nutty idea should survive. But regardless, everything about it belongs alongside the macros used to construct and deconstruct the argument word. No example should recommend using the bit-twiddling rather than using some such macros that are made public in linux/ptrace.h.
Thanks,
Roland
Re: [patch v2 4/4] ptrace: Add support for generic PTRACE_GETREGSET/PTRACE_SETREGSET
Quoted 18 lines · Roland McGrath
Quoted 5 lines
'addr' parameter for the ptrace system call encode the REGSET type and the buffer length. 'data' parameter points to the user buffer.
ptrace(PTRACE_GETREGSET/PTRACE_SETREGSET, pid, (NT_TYPE << 20) | buf_length, buf);IMHO this bit swizzling is a non-starter. The NT_* codes can use a full 32 bits. NT_PRXFPREG uses 31 bits. The comments about ignoring the high bits for this as a special case just seem insane to me. Pass a full 32 bit word for NT_* and a full word for the buffer size. What's so terrible about just having an obvious and comprehensible API?
IMHO if you insist on an insane bit swizzling approach, you should mix the buffer size bits into the request code, leaving the "addr" argument free for the unmolested NT_* code. There is just no earthly reason that we should suddenly impose a new and arcane constraint on what NT_* values can be, even if there is no particular reason for future values not to be small.
Quoted 6 lines
Quoted 2 lines
+int generic_ptrace_regset(struct
task_struct*child, long request, long addr,
+ long data);There is no need for a global function for this. It should all be static in
kernel/ptrace.c, called only by ptrace_request()/compat_ptrace_request().
Won't it be called by ptrace emulation in utrace?
Signature · 1 line
H.J.
Re: [patch v2 4/4] ptrace: Add support for generic PTRACE_GETREGSET/PTRACE_SETREGSET
Quoted 5 lines
Quoted 3 lines
There is no need for a global function for this. It should all be static in
kernel/ptrace.c, called only by ptrace_request()/compat_ptrace_request().Won't it be called by ptrace emulation in utrace?
I guess I don't really understand the question. I'm not aware of any patches where any such things are done anywhere except the existing ptrace_request and compat_ptrace_request functions in kernel/ptrace.c.
Thanks,
Roland
Re: [patch v2 4/4] ptrace: Add support for generic PTRACE_GETREGSET/PTRACE_SETREGSET
Quoted 10 lines · Roland McGrath
Quoted 5 lines
Quoted 3 lines
There is no need for a global function for this. It should all be static in
kernel/ptrace.c, called only by ptrace_request()/compat_ptrace_request().Won't it be called by ptrace emulation in utrace?
I guess I don't really understand the question. I'm not aware of any patches where any such things are done anywhere except the existing
ptrace_requestandcompat_ptrace_requestfunctions inkernel/ptrace.c.
I guess it isn't needed to be global then.
Signature · 1 line
H.J.
Oleg Nesterov
maintainerRe: [patch v2 4/4] ptrace: Add support for generic PTRACE_GETREGSET/PTRACE_SETREGSET
In reply to Suresh SiddhaReview static inline void ptrace_unlink(struct
Quoted 8 lines · Suresh Siddha
(quoted diff) +3
-0+#define PTRACE_REGSET_BUF_SIZE(addr) (addr & 0xfffff) +#define PTRACE_REGSET_TYPE(addr) ((addr >> 20) & 0xfff) +#define NOTE_TO_REGSET_TYPE(note) (note & 0xfff) /* options set using PTRACE_SETOPTIONS */ #define PTRACE_O_TRACESYSGOOD 0x00000001@@ -114,6 +126,8 @@ static inline void ptrace_unlink(struct
Well. Personally, I like Roland's suggestion more.
How about something like the patch below?
I am not sure how should we check the size, see the comment in ptrace_regset().
What do you think?
And, I don't understand NOTE_TO_REGSET_TYPE() logic. I mean, I don't know why we should use "->core_note_type & 0xfff".
Oleg.
include/linux/ptrace.h renamed from include/linux/ptrace.h~REGSET +3 -0
@@ -27,6 +27,9 @@#define PTRACE_GETSIGINFO 0x4202#define PTRACE_SETSIGINFO 0x4203 +#define PTRACE_GETREGSET 0x4204 +#define PTRACE_SETREGSET 0x4205 +/* options set using PTRACE_SETOPTIONS */ #define PTRACE_O_TRACESYSGOOD 0x00000001#define PTRACE_O_TRACEFORK 0x00000002
kernel/ptrace.c renamed from kernel/ptrace.c~REGSET +49 -1
68 lines not on this page · raw message
Re: [patch v2 4/4] ptrace: Add support for generic PTRACE_GETREGSET/PTRACE_SETREGSET
kernel/ptrace.c int ptrace_writedata(struct task_struct · line 416
Quoted 2 lines
kernel/ptrace.c renamed from kernel/ptrace.c~REGSET +2
-0+static int ptrace_regset (struct task_struct *task,int req,unsigned int type, +struct iovec *uiov)
^__user
kernel/ptrace.c int ptrace_writedata(struct task_struct · line 426
Quoted 10 lines
kernel/ptrace.c renamed from kernel/ptrace.c~REGSET +10
-0+{ +const struct user_regset_view *view =task_user_regset_view (task); +const struct user_regset *regset =find_regset (view, type); +struct iovec kiov; + +if (!regset) +return -EIO ; + +if (copy_from_user (&kiov, uiov,sizeof kiov)) +return -EFAULT ;
Since it's just two words, most places handling struct iovec seem to just use two get_user() calls, which is probably more efficient.
Also, here is where this function would need to be split in half for compat_ptrace_request() calls where it has to use struct compat_iovec.
kernel/ptrace.c int ptrace_writedata(struct task_struct · line 431
Quoted 4 lines
kernel/ptrace.c renamed from kernel/ptrace.c~REGSET +4
-0+// I am not sure. Afaics it is OK to pass the +// size which is less than n * size. If iov_len +// is bigger, we can silently truncate it, or +// even write the correct value back.
Modifying iov_len to report how much we accessed seems good to me. If we do that, we should certainly allow a larger size for get, so userland can just use a generic large buffer before even knowing the real size. I'm not sure whether we should allow a smaller size, especially for set. I could go either way.
Thanks,
Roland
H. Peter Anvin
reviewerRe: [patch v2 4/4] ptrace: Add support for generic PTRACE_GETREGSET/PTRACE_SETREGSET
Quoted 7 lines · Roland McGrath
Since it's just two words, most places handling struct iovec seem to just use two
get_user()calls, which is probably more efficient.Also, here is where this function would need to be split in half for
compat_ptrace_request()calls where it has to use structcompat_iovec.
Quoted 11 lines
kernel/ptrace.c int ptrace_writedata(struct task_struct · line 431
Quoted 4 lines
kernel/ptrace.c renamed from kernel/ptrace.c~REGSET +4
-0+// I am not sure. Afaics it is OK to pass the +// size which is less than n * size. If iov_len +// is bigger, we can silently truncate it, or +// even write the correct value back. Modifying
iov_lento report how much we accessed seems good to me. If we do that, we should certainly allow a larger size for get, so userland can just use a generic large buffer before even knowing the real size. I'm not sure whether we should allow a smaller size, especially for set. I could go either way.
Allowing a larger size for get seems very sane. Allowing a smaller size would be ok iff we make sure we handle corner cases right (i.e. a partially overwritten subregister.)
-hpa
Re: [patch v2 4/4] ptrace: Add support for generic PTRACE_GETREGSET/PTRACE_SETREGSET
Quoted 3 lines
Allowing a larger size for get seems very sane. Allowing a smaller size would be ok iff we make sure we handle corner cases right (i.e. a partially overwritten subregister.)
It should enforce the static constraints of the user_regset, which include a starting position that's 0 % .align (if we had non-zero starting position in the request) and a size that's 0 % .size. The arch code sets those and then is not obliged to handle requests outside those constraints. It's already documented that the arch code is obliged to handle any partial regset access that meets them.
The usual thing is to set .size and .align to the size of a register. This is exactly so that the arch code does not need to add gratuitous corner case complications such as "partially overwritten subregister".
Thanks,
Roland
Quoted 3 lines
Patches are on top of the -tip/master tree.
First patch in the series reverts the first version of the patch that went into the -tip tree.
AFAIK tip/x86/ptrace is just a temporary branch containing nothing but your patch. So I imagine you don't need a reversion, Ingo et al will just put the new patches on a fresh replacement branch.
I'll reply to each patch individually.
Thanks,
Roland
Quoted 7 lines · Roland McGrath
Quoted 3 lines
Patches are on top of the -tip/master tree.
First patch in the series reverts the first version of the patch that went into the -tip tree.AFAIK tip/x86/ptrace is just a temporary branch containing nothing but your patch. So I imagine you don't need a reversion, Ingo et al will just put the new patches on a fresh replacement branch.
That is my understanding too but was not sure. Wanted to mention that they should either replace the branch or apply the reverted patch (incase if they have issues with replacing the branch). Peter, you seem to have applied the revert. Can you instead start with a fresh branch so that we can just ignore the first version (and hence skip first revert patch in this series)?
Quoted 1 line
I'll reply to each patch individually.
Thanks Roland.
Quoted 6 lines · Roland McGrath
Quoted 2 lines
Patches are on top of the -tip/master tree. First patch in the series reverts the first version of the patch that went into the -tip tree.
AFAIK tip/x86/ptrace is just a temporary branch containing nothing but your patch. So I imagine you don't need a reversion, Ingo et al will just put the new patches on a fresh replacement branch.
Yeah - and the patches your review strikes we'll remove/fix as well. And you can pick up the patches yourself as well into your tree, if you wish to. (or pull it from us if we are done) We can push it too with your acks - your call.
Quoted 1 line
I'll reply to each patch individually.
Thanks!
Ingo
Quoted 4 lines
Yeah - and the patches your review strikes we'll remove/fix as well. And you can pick up the patches yourself as well into your tree, if you wish to. (or pull it from us if we are done) We can push it too with your acks - your call.
AFAIK there is no tree of mine that anyone habitually pulls from as part of a regular merge procedure. Since the x86 patches have to go through your approval, and these ones are coming from someone else's postings (Suresh), I'm not sure how I would or should fit into the chain. If you would like me to use a git branch for x86 things (ptrace things? x86 ptrace things?) that have my ACK and I think should be merged, I'm glad to do that.
Thanks,
Roland
H. Peter Anvin
reviewerQuoted 5 lines · Roland McGrath
Quoted 4 lines
Yeah - and the patches your review strikes we'll remove/fix as well. And you can pick up the patches yourself as well into your tree, if you wish to. (or pull it from us if we are done) We can push it too with your acks - your call.
Quoted 7 lines
AFAIK there is no tree of mine that anyone habitually pulls from as part of a regular merge procedure. Since the x86 patches have to go through your approval, and these ones are coming from someone else's postings (Suresh), I'm not sure how I would or should fit into the chain. If you would like me to use a git branch for x86 things (ptrace things? x86 ptrace things?) that have my ACK and I think should be merged, I'm glad to do that.
We're happy to carry the patches as long as it's okay with you. We were mostly wondering if you preferred any other kind of workflow.
-hpa
Quoted 2 lines
We're happy to carry the patches as long as it's okay with you. We were mostly wondering if you preferred any other kind of workflow.
When I write patches myself, I always use git, so it is always easy and most convenient for me to have my own branches pulled directly just to save on 'git rebase' churn later.
As to a regular workflow of using a well-known branch of mine, I think it makes sense for me to maintain a branch if there is an area where things are presumptively merged just on my approval and I'm the one who has to be lobbied to revert them. I have not heretofore acquired the sensation that this was the case with any given area of code.
Thanks,
Roland
H. Peter Anvin
reviewerQuoted 7 lines · Roland McGrath
Quoted 2 lines
We're happy to carry the patches as long as it's okay with you. We were mostly wondering if you preferred any other kind of workflow.
When I write patches myself, I always use git, so it is always easy and most convenient for me to have my own branches pulled directly just to save on 'git rebase' churn later.
Quoted 5 lines
As to a regular workflow of using a well-known branch of mine, I think it makes sense for me to maintain a branch if there is an area where things are presumptively merged just on my approval and I'm the one who has to be lobbied to revert them. I have not heretofore acquired the sensation that this was the case with any given area of code.
LOL, okay :)
-hpa
Signature · 2 lines
H. Peter Anvin, Intel Open Source Technology Center I work for Intel. I don't speak on their behalf.