fs/coredump: Enable dynamic configuration of max file note size
Subsystems (3)
PATCH v3 1/1 fs/coredump: Enable dynamic configuration of max file note size
Introduce the capability to dynamically configure the maximum file note size for ELF core dumps via sysctl. This enhancement removes the previous static limit of 4MB, allowing system administrators to adjust the size based on system-specific requirements or constraints.
- Remove hardcoded MAX_FILE_NOTE_SIZE from fs/binfmt_elf.c.
- Define max_file_note_size in fs/coredump.c with an initial value set to 4MB.
- Declare max_file_note_size as an external variable in include/linux/coredump.h.
- Add a new sysctl entry in kernel/sysctl.c to manage this setting at runtime.
$ sysctl -a | grep core_file_note_size_max kernel.core_file_note_size_max = 4194304
$ sysctl -n kernel.core_file_note_size_max 4194304
$echo 519304 > /proc/sys/kernel/core_file_note_size_max
$sysctl -n kernel.core_file_note_size_max
519304
Attempting to write beyond the ceiling value of 16MB $echo 17194304 > /proc/sys/kernel/core_file_note_size_max
bash: echo: write error: Invalid argument
Why is this being done?
We have observed that during a crash when there are more than 65k mmaps in memory, the existing fixed limit on the size of the ELF notes section becomes a bottleneck. The notes section quickly reaches its capacity, leading to incomplete memory segment information in the resulting coredump. This truncation compromises the utility of the coredumps, as crucial information about the memory state at the time of the crash might be omitted.
---
Chagnes in v3:
- Fix commit message to reflect the correct sysctl knob [Kees]
- Add a ceiling for maximum pssible note size(16M) [Allen]
- Add a pr_warn_once() [Kees]
Changes in v2:
- Move new sysctl to fs/coredump.c [Luis & Kees]
- rename max_file_note_size to core_file_note_size_max [kees]
- Capture "why this is being done?" int he commit message [Luis & Kees]
--- fs/binfmt_elf.c | 8 ++++++-- fs/coredump.c | 15 +++++++++++++++ include/linux/coredump.h | 1 + 3 files changed, 22 insertions(+), 2 deletions(-)
fs/binfmt_elf.c +6 -2
@@ -1564,7 +1564,6 @@ static void fill_siginfo_note(struct memelfnote *note, user_siginfo_t *csigdata,fill_note (note,"CORE" ,NT_SIGINFO ,sizeof (*csigdata), csigdata); } -#define MAX_FILE_NOTE_SIZE (4*1024*1024)/* * Format of NT_FILE note: *
@@ -1592,8 +1591,13 @@ static int fill_files_note(struct memelfnote *note, struct coredump_params *cprm names_ofs = (2 +3 * count) *sizeof (data[0 ]); alloc: -if (size >=MAX_FILE_NOTE_SIZE )/* paranoia check */ +/* paranoia check */ +if (size >= core_file_note_size_max) { +pr_warn_once ("coredump Note size too large: %u " +"(does kernel.core_file_note_size_max sysctl need adjustment?)\n" , + size);return -EINVAL ; + } size =round_up (size,PAGE_SIZE );/* * "size" can be 0 here legitimately.
fs/coredump.c +15 -0
@@ -56,10 +56,16 @@static bool dump_vma_snapshot (struct coredump_params *cprm);static void free_vma_snapshot (struct coredump_params *cprm); +#define MAX_FILE_NOTE_SIZE (4*1024*1024) +/* Define a reasonable max cap */ +#define MAX_ALLOWED_NOTE_SIZE (16*1024*1024) +static int core_uses_pid;static unsigned int core_pipe_limit;static char core_pattern[CORENAME_MAX_SIZE ] ="core" ;static int core_name_size =CORENAME_MAX_SIZE ; +unsigned int core_file_note_size_max =MAX_FILE_NOTE_SIZE ; +unsigned int core_file_note_size_allowed =MAX_ALLOWED_NOTE_SIZE ;struct core_name {char *corename;
@@ -1020,6 +1026,15 @@ static struct ctl_table coredump_sysctls[] = { .mode = 0644, .proc_handler = proc_dointvec, }, + { + .procname = "core_file_note_size_max", + .data = &core_file_note_size_max, + .maxlen = sizeof(unsigned int), + .mode = 0644, + .proc_handler = proc_douintvec_minmax, + .extra1 = &core_file_note_size_max, + .extra2 = &core_file_note_size_allowed, + }, };static int __init init_fs_coredump_sysctls (void )
include/linux/coredump.h +1 -0
@@ -46,6 +46,7 @@ static inline void do_coredump(const kernel_siginfo_t *siginfo) {}#endif #if defined(CONFIG_COREDUMP ) && defined(CONFIG_SYSCTL ) +extern unsigned int core_file_note_size_max;extern void validate_coredump_safety (void );#else static inline void validate_coredump_safety (void ) {}
Signature · 1 line
2.17.1
Quoted 5 lines · Allen Pais
Introduce the capability to dynamically configure the maximum file note size for ELF core dumps via sysctl. This enhancement removes the previous static limit of 4MB, allowing system administrators to adjust the size based on system-specific requirements or constraints.
Quoted 7 lines
- Remove hardcoded
MAX_FILE_NOTE_SIZEfromfs/binfmt_elf.c.
- Definemax_file_note_sizeinfs/coredump.cwith an initial value set to 4MB.
- Declaremax_file_note_sizeas an external variable ininclude/linux/coredump.h.
- Add a new sysctl entry inkernel/sysctl.cto manage this setting at runtime.
The above bullet points should be clear from the patch itself. The commit is really more about rationale and examples (which you have below). I'd remove the bullets.
Quoted 16 lines
$ sysctl -a | grep core_file_note_size_max kernel.core_file_note_size_max = 4194304$ sysctl -n kernel.core_file_note_size_max 4194304$echo 519304 >
/proc/sys/kernel/core_file_note_size_max$sysctl -n kernel.core_file_note_size_max
519304Attempting to write beyond the ceiling value of 16MB $echo 17194304 >
/proc/sys/kernel/core_file_note_size_max
bash: echo: write error: Invalid argument
Quoted 8 lines
Why is this being done?
We have observed that during a crash when there are more than 65k mmaps in memory, the existing fixed limit on the size of the ELF notes section becomes a bottleneck. The notes section quickly reaches its capacity, leading to incomplete memory segment information in the resulting coredump. This truncation compromises the utility of the coredumps, as crucial information about the memory state at the time of the crash might be omitted.
I'd make this the first paragraph of the commit log. "We have this problem" goes first, then "Here's what we did to deal with it", then you examples. :)
Quoted 32 lines
Signed-off-by Vijay Nag <[email protected]>Signed-off-by Allen Pais <[email protected]>---
Chagnes in v3:
- Fix commit message to reflect the correct sysctl knob [Kees]
- Add a ceiling for maximum pssible note size(16M) [Allen]
- Add apr_warn_once()[Kees]
Changes in v2:
- Move new sysctl tofs/coredump.c[Luis & Kees]
- renamemax_file_note_sizetocore_file_note_size_max[kees]
- Capture "why this is being done?" int he commit message [Luis & Kees]--- fs/binfmt_elf.c | 8 ++++++-- fs/coredump.c | 15 +++++++++++++++ include/linux/coredump.h | 1 + 3 files changed, 22 insertions(+), 2 deletions(-)fs/binfmt_elf.c +0
-1@@ -1564,7 +1564,6 @@ static void fill_siginfo_note(struct memelfnote *note, user_siginfo_t *csigdata,fill_note (note,"CORE" ,NT_SIGINFO ,sizeof (*csigdata), csigdata); } -#define MAX_FILE_NOTE_SIZE (4*1024*1024)/* * Format of NT_FILE note: *
fs/binfmt_elf.c static int fill_files_note(struct memelfnote *note, struct coredump_params *cprm · line 1597
Quoted 8 lines
fs/binfmt_elf.c +4
-1@@ -1592,8 +1591,13 @@ static int fill_files_note(struct memelfnote *note, struct coredump_params *cprm names_ofs = (2 +3 * count) *sizeof (data[0 ]); alloc: -if (size >=MAX_FILE_NOTE_SIZE )/* paranoia check */ +/* paranoia check */ +if (size >= core_file_note_size_max) { + pr_warn_once("coredump Note size too large: %u " + "(does kernel.core_file_note_size_max sysctl need adjustment?)\n",
The string can be on a single line (I think scripts/check_patch.pl will warn about this, as well as the indentation of "size" below...
Quoted 11 lines
fs/binfmt_elf.c +2
-0+ size);return -EINVAL ; + } size =round_up (size,PAGE_SIZE );/* * "size" can be 0 here legitimately. fs/coredump.c +0
-0
fs/coredump.c line 61
Quoted 6 lines
fs/coredump.c +3
-0@@ -56,10 +56,16 @@static bool dump_vma_snapshot (struct coredump_params *cprm);static void free_vma_snapshot (struct coredump_params *cprm); +#define MAX_FILE_NOTE_SIZE (4*1024*1024) +/* Define a reasonable max cap */ +#define MAX_ALLOWED_NOTE_SIZE (16*1024*1024)
Let's call this CORE_FILE_NOTE_SIZE_DEFAULT andCORE_FILE_NOTE_SIZE_MAX to match the sysctl.
fs/coredump.c line 68
Quoted 7 lines
fs/coredump.c +3
-0+static int core_uses_pid;static unsigned int core_pipe_limit;static char core_pattern[CORENAME_MAX_SIZE ] ="core" ;static int core_name_size =CORENAME_MAX_SIZE ; +unsigned int core_file_note_size_max =MAX_FILE_NOTE_SIZE ; +unsigned int core_file_note_size_allowed =MAX_ALLOWED_NOTE_SIZE ;
The latter can be static and const.
For the note below, perhaps add:
static const unsigned int core_file_note_size_min = CORE_FILE_NOTE_SIZE_DEFAULT;
Quoted 4 lines
fs/coredump.c +0
-0struct core_name {char *corename;
fs/coredump.c static struct ctl_table coredump_sysctls[] = { · line 1035
Quoted 10 lines
fs/coredump.c +7
-0@@ -1020,6 +1026,15 @@ static struct ctl_table coredump_sysctls[] = { .mode = 0644, .proc_handler = proc_dointvec, }, + { + .procname = "core_file_note_size_max", + .data = &core_file_note_size_max, + .maxlen = sizeof(unsigned int), + .mode = 0644, + .proc_handler = proc_douintvec_minmax, + .extra1 = &core_file_note_size_max,
This means you can never shrink it if you raise it from the default. Let's use the core_file_note_size_min above.
Quoted 20 lines
fs/coredump.c +2
-0+ .extra2 = &core_file_note_size_allowed, + }, };static int __init init_fs_coredump_sysctls (void )include/linux/coredump.h +1
-0@@ -46,6 +46,7 @@ static inline void do_coredump(const kernel_siginfo_t *siginfo) {}#endif #if defined(CONFIG_COREDUMP ) && defined(CONFIG_SYSCTL ) +extern unsigned int core_file_note_size_max;extern void validate_coredump_safety (void );#else static inline void validate_coredump_safety (void ) {}Signature · 1 line
2.17.1
I think v4 will be all good to go, assuming no one else pops up. :) Thanks for the changes!
-Kees
Signature · 1 line
Kees Cook
Quoted 13 lines
Quoted 5 lines
Introduce the capability to dynamically configure the maximum file note size for ELF core dumps via sysctl. This enhancement removes the previous static limit of 4MB, allowing system administrators to adjust the size based on system-specific requirements or constraints.
Quoted 7 lines
- Remove hardcoded
MAX_FILE_NOTE_SIZEfromfs/binfmt_elf.c.
- Definemax_file_note_sizeinfs/coredump.cwith an initial value set to 4MB.
- Declaremax_file_note_sizeas an external variable ininclude/linux/coredump.h.
- Add a new sysctl entry inkernel/sysctl.cto manage this setting at runtime.
Quoted 3 lines
The above bullet points should be clear from the patch itself. The commit is really more about rationale and examples (which you have below). I'd remove the bullets.
Sure, I have it modified to:
fs/coredump: Enable dynamic configuration of max file note size
Introduce the capability to dynamically configure the maximum file note size for ELF core dumps via sysctl.
Why is this being done?
We have observed that during a crash when there are more than 65k mmaps in memory, the existing fixed limit on the size of the ELF notes section becomes a bottleneck. The notes section quickly reaches its capacity, leading to incomplete memory segment information in the resulting coredump. This truncation compromises the utility of the coredumps, as crucial information about the memory state at the time of the crash might be omitted.
This enhancement removes the previous static limit of 4MB, allowing system administrators to adjust the size based on system-specific requirements or constraints.
Eg:
$ sysctl -a | grep core_file_note_size_max
kernel.core_file_note_size_max = 4194304
.......
Quoted 26 lines
Quoted 17 lines
$ sysctl -a | grep core_file_note_size_max kernel.core_file_note_size_max = 4194304$ sysctl -n kernel.core_file_note_size_max 4194304$echo 519304 >
/proc/sys/kernel/core_file_note_size_max$sysctl -n kernel.core_file_note_size_max
519304Attempting to write beyond the ceiling value of 16MB $echo 17194304 >
/proc/sys/kernel/core_file_note_size_max
bash: echo: write error: Invalid argumentQuoted 8 lines
Why is this being done?
We have observed that during a crash when there are more than 65k mmaps in memory, the existing fixed limit on the size of the ELF notes section becomes a bottleneck. The notes section quickly reaches its capacity, leading to incomplete memory segment information in the resulting coredump. This truncation compromises the utility of the coredumps, as crucial information about the memory state at the time of the crash might be omitted.
Quoted 4 lines
I'd make this the first paragraph of the commit log. "We have this problem" goes first, then "Here's what we did to deal with it", then you examples. :)
Done.
Quoted 33 lines
Quoted 33 lines
Signed-off-by Vijay Nag <[email protected]>Signed-off-by Allen Pais <[email protected]>---
Chagnes in v3:
- Fix commit message to reflect the correct sysctl knob [Kees]
- Add a ceiling for maximum pssible note size(16M) [Allen]
- Add apr_warn_once()[Kees]
Changes in v2:
- Move new sysctl tofs/coredump.c[Luis & Kees]
- renamemax_file_note_sizetocore_file_note_size_max[kees]
- Capture "why this is being done?" int he commit message [Luis & Kees]--- fs/binfmt_elf.c | 8 ++++++-- fs/coredump.c | 15 +++++++++++++++ include/linux/coredump.h | 1 + 3 files changed, 22 insertions(+), 2 deletions(-)fs/binfmt_elf.c +0
-1@@ -1564,7 +1564,6 @@ static void fill_siginfo_note(struct memelfnote *note, user_siginfo_t *csigdata,fill_note (note,"CORE" ,NT_SIGINFO ,sizeof (*csigdata), csigdata); } -#define MAX_FILE_NOTE_SIZE (4*1024*1024)/* * Format of NT_FILE note: * @@ -1592,8 +1591,13 @@ static int fill_files_note(struct memelfnote *note, struct coredump_params *cprm
Quoted 10 lines
fs/binfmt_elf.c static int fill_files_note(struct memelfnote *note, struct coredump_params *cprm · line 1597
Quoted 7 lines
fs/binfmt_elf.c +4
-1names_ofs = (2 +3 * count) *sizeof (data[0 ]); alloc: -if (size >=MAX_FILE_NOTE_SIZE )/* paranoia check */ +/* paranoia check */ +if (size >= core_file_note_size_max) { + pr_warn_once("coredump Note size too large: %u " + "(does kernel.core_file_note_size_max sysctl need adjustment?)\n",The string can be on a single line (I think
scripts/check_patch.plwill warn about this, as well as the indentation of "size" below...
It does warn, but if I leave it as a single line, there's still a warning:
WARNING: line length of 135 exceeds 100 columns, which is why I split it into multiple lines.
Quoted 15 lines
Quoted 15 lines
fs/binfmt_elf.c +2
-0+ size);return -EINVAL ; + } size =round_up (size,PAGE_SIZE );/* * "size" can be 0 here legitimately. fs/coredump.c +0
-0@@ -56,10 +56,16 @@static bool dump_vma_snapshot (struct coredump_params *cprm);static void free_vma_snapshot (struct coredump_params *cprm);
Quoted 7 lines
fs/coredump.c line 61
Quoted 3 lines
fs/coredump.c +3
-0+#define MAX_FILE_NOTE_SIZE (4*1024*1024) +/* Define a reasonable max cap */ +#define MAX_ALLOWED_NOTE_SIZE (16*1024*1024)Let's call this
CORE_FILE_NOTE_SIZE_DEFAULTandCORE_FILE_NOTE_SIZE_MAXto match the sysctl.
Sure, will update it in v4.
Quoted 10 lines
fs/coredump.c line 68
Quoted 7 lines
fs/coredump.c +3
-0+static int core_uses_pid;static unsigned int core_pipe_limit;static char core_pattern[CORENAME_MAX_SIZE ] ="core" ;static int core_name_size =CORENAME_MAX_SIZE ; +unsigned int core_file_note_size_max =MAX_FILE_NOTE_SIZE ; +unsigned int core_file_note_size_allowed =MAX_ALLOWED_NOTE_SIZE ;The latter can be static and const.
Quoted 4 lines
For the note below, perhaps add:
static const unsigned int
core_file_note_size_min=CORE_FILE_NOTE_SIZE_DEFAULT;
core_file_note_size_min will be used in fs/binfmt_elf.c at:
if (size >= core_file_note_size_min) ,
did you mean
static const unsigned int core_file_note_size_allowed = CORE_FILE_NOTE_SIZE_MAX;??
Quoted 17 lines
Quoted 4 lines
fs/coredump.c +0
-0struct core_name {char *corename;fs/coredump.c static struct ctl_table coredump_sysctls[] = { · line 1035
Quoted 10 lines
fs/coredump.c +7
-0@@ -1020,6 +1026,15 @@ static struct ctl_table coredump_sysctls[] = { .mode = 0644, .proc_handler = proc_dointvec, }, + { + .procname = "core_file_note_size_max", + .data = &core_file_note_size_max, + .maxlen = sizeof(unsigned int), + .mode = 0644, + .proc_handler = proc_douintvec_minmax, + .extra1 = &core_file_note_size_max,This means you can never shrink it if you raise it from the default. Let's use the
core_file_note_size_minabove.
Sure, will fix it in v4.
Quoted 13 lines
Quoted 13 lines
fs/coredump.c +2
-0+ .extra2 = &core_file_note_size_allowed, + }, };static int __init init_fs_coredump_sysctls (void )include/linux/coredump.h +0
-0@@ -46,6 +46,7 @@ static inline void do_coredump(const kernel_siginfo_t *siginfo) {}#endif
Quoted 11 lines
Quoted 8 lines
include/linux/coredump.h +1
-1#if defined(CONFIG_COREDUMP ) && defined(CONFIG_SYSCTL ) +extern unsigned int core_file_note_size_max;extern void validate_coredump_safety (void );#else static inline void validate_coredump_safety (void ) {} --2.17.1
I think v4 will be all good to go, assuming no one else pops up. :) Thanks for the changes!
Thank you for the reviews. Will send out v4 soon.
Signature · 1 line
- Allen
Quoted 161 lines
Quoted 13 lines
Quoted 5 lines
Introduce the capability to dynamically configure the maximum file note size for ELF core dumps via sysctl. This enhancement removes the previous static limit of 4MB, allowing system administrators to adjust the size based on system-specific requirements or constraints.
Quoted 7 lines
- Remove hardcoded
MAX_FILE_NOTE_SIZEfromfs/binfmt_elf.c.
- Definemax_file_note_sizeinfs/coredump.cwith an initial value set to 4MB.
- Declaremax_file_note_sizeas an external variable ininclude/linux/coredump.h.
- Add a new sysctl entry inkernel/sysctl.cto manage this setting at runtime.Quoted 3 lines
The above bullet points should be clear from the patch itself. The commit is really more about rationale and examples (which you have below). I'd remove the bullets.
Sure, I have it modified to:
fs/coredump: Enable dynamic configuration of max file note size
Introduce the capability to dynamically configure the maximum file note size for ELF core dumps via sysctl.
Why is this being done?
We have observed that during a crash when there are more than 65k mmaps in memory, the existing fixed limit on the size of the ELF notes section becomes a bottleneck. The notes section quickly reaches its capacity, leading to incomplete memory segment information in the resulting coredump. This truncation compromises the utility of the coredumps, as crucial information about the memory state at the time of the crash might be omitted.This enhancement removes the previous static limit of 4MB, allowing system administrators to adjust the size based on system-specific requirements or constraints.
Eg:
$ sysctl -a | grepcore_file_note_size_max
kernel.core_file_note_size_max = 4194304
.......Quoted 26 lines
Quoted 17 lines
$ sysctl -a | grep core_file_note_size_max kernel.core_file_note_size_max = 4194304$ sysctl -n kernel.core_file_note_size_max 4194304$echo 519304 >
/proc/sys/kernel/core_file_note_size_max$sysctl -n kernel.core_file_note_size_max
519304Attempting to write beyond the ceiling value of 16MB $echo 17194304 >
/proc/sys/kernel/core_file_note_size_max
bash: echo: write error: Invalid argumentQuoted 8 lines
Why is this being done?
We have observed that during a crash when there are more than 65k mmaps in memory, the existing fixed limit on the size of the ELF notes section becomes a bottleneck. The notes section quickly reaches its capacity, leading to incomplete memory segment information in the resulting coredump. This truncation compromises the utility of the coredumps, as crucial information about the memory state at the time of the crash might be omitted.Quoted 4 lines
I'd make this the first paragraph of the commit log. "We have this problem" goes first, then "Here's what we did to deal with it", then you examples. :)
Done.
Quoted 33 lines
Quoted 33 lines
Signed-off-by Vijay Nag <[email protected]>Signed-off-by Allen Pais <[email protected]>---
Chagnes in v3:
- Fix commit message to reflect the correct sysctl knob [Kees]
- Add a ceiling for maximum pssible note size(16M) [Allen]
- Add apr_warn_once()[Kees]
Changes in v2:
- Move new sysctl tofs/coredump.c[Luis & Kees]
- renamemax_file_note_sizetocore_file_note_size_max[kees]
- Capture "why this is being done?" int he commit message [Luis & Kees]--- fs/binfmt_elf.c | 8 ++++++-- fs/coredump.c | 15 +++++++++++++++ include/linux/coredump.h | 1 + 3 files changed, 22 insertions(+), 2 deletions(-)fs/binfmt_elf.c +0
-1@@ -1564,7 +1564,6 @@ static void fill_siginfo_note(struct memelfnote *note, user_siginfo_t *csigdata,fill_note (note,"CORE" ,NT_SIGINFO ,sizeof (*csigdata), csigdata); } -#define MAX_FILE_NOTE_SIZE (4*1024*1024)/* * Format of NT_FILE note: * @@ -1592,8 +1591,13 @@ static int fill_files_note(struct memelfnote *note, struct coredump_params *cprmQuoted 10 lines
fs/binfmt_elf.c static int fill_files_note(struct memelfnote *note, struct coredump_params *cprm · line 1597
Quoted 7 lines
fs/binfmt_elf.c +4
-1names_ofs = (2 +3 * count) *sizeof (data[0 ]); alloc: -if (size >=MAX_FILE_NOTE_SIZE )/* paranoia check */ +/* paranoia check */ +if (size >= core_file_note_size_max) { + pr_warn_once("coredump Note size too large: %u " + "(does kernel.core_file_note_size_max sysctl need adjustment?)\n",The string can be on a single line (I think
scripts/check_patch.plwill warn about this, as well as the indentation of "size" below...It does warn, but if I leave it as a single line, there's still a warning:
WARNING: line length of 135 exceeds 100 columns, which is why I split it into multiple lines.Quoted 15 lines
Quoted 15 lines
fs/binfmt_elf.c +2
-0+ size);return -EINVAL ; + } size =round_up (size,PAGE_SIZE );/* * "size" can be 0 here legitimately. fs/coredump.c +0
-0@@ -56,10 +56,16 @@static bool dump_vma_snapshot (struct coredump_params *cprm);static void free_vma_snapshot (struct coredump_params *cprm);Quoted 7 lines
fs/coredump.c line 61
Quoted 3 lines
fs/coredump.c +3
-0+#define MAX_FILE_NOTE_SIZE (4*1024*1024) +/* Define a reasonable max cap */ +#define MAX_ALLOWED_NOTE_SIZE (16*1024*1024)Let's call this
CORE_FILE_NOTE_SIZE_DEFAULTandCORE_FILE_NOTE_SIZE_MAXto match the sysctl.Sure, will update it in v4.
Quoted 10 lines
fs/coredump.c line 68
Quoted 7 lines
fs/coredump.c +3
-0+static int core_uses_pid;static unsigned int core_pipe_limit;static char core_pattern[CORENAME_MAX_SIZE ] ="core" ;static int core_name_size =CORENAME_MAX_SIZE ; +unsigned int core_file_note_size_max =MAX_FILE_NOTE_SIZE ; +unsigned int core_file_note_size_allowed =MAX_ALLOWED_NOTE_SIZE ;The latter can be static and const.
Quoted 4 lines
For the note below, perhaps add:
static const unsigned int
core_file_note_size_min=CORE_FILE_NOTE_SIZE_DEFAULT;
Quoted 7 lines
core_file_note_size_minwill be used infs/binfmt_elf.cat:if (size >=
core_file_note_size_min) ,
did you mean
static const unsigned intcore_file_note_size_allowed=CORE_FILE_NOTE_SIZE_MAX;??Quoted 1 line
Quoted 1 line
Kees,
My bad, I misunderstood what you asked for. Here is the final diff,
if it looks fine,
i can send out a v4.
Note, there is a warning issued by checkpatch.pl (WARNING: line length of 134 exceeds 100 columns)
for the pr_warn_once() and adding const trigger a build warning(warning: initialization discards
'const' qualifier from pointer target type), which is why i dropped it.
fs/binfmt_elf.c +0 -0
@@ -1564,7 +1564,6 @@ static void fill_siginfo_note(struct memelfnote
*note, user_siginfo_t *csigdata,
fill_note(note, "CORE", NT_SIGINFO, sizeof(*csigdata), csigdata);
}
-#define MAX_FILE_NOTE_SIZE (4*1024*1024)
/*
* Format of NT_FILE note:
*
@@ -1592,8 +1591,11 @@ static int fill_files_note(struct memelfnote *note, struct coredump_params *cprm
names_ofs = (2 + 3 * count) * sizeof(data[0]);
alloc:
- if (size >= MAX_FILE_NOTE_SIZE) /* paranoia check */
+ /* paranoia check */
+ if (size >= core_file_note_size_allowed) {
+ pr_warn_once("coredump Note size too large: %u (does
kernel.core_file_note_size_min sysctl need adjustment?\n", size);
return -EINVAL;
+ }
size = round_up(size, PAGE_SIZE);
/*
* "size" can be 0 here legitimately.fs/coredump.c +15 -0
@@ -56,10 +56,16 @@static bool dump_vma_snapshot (struct coredump_params *cprm);static void free_vma_snapshot (struct coredump_params *cprm); +#define CORE_FILE_NOTE_SIZE_DEFAULT (4*1024*1024) +/* Define a reasonable max cap */ +#define CORE_FILE_NOTE_SIZE_MAX (16*1024*1024) +static int core_uses_pid;static unsigned int core_pipe_limit;static char core_pattern[CORENAME_MAX_SIZE ] ="core" ;static int core_name_size =CORENAME_MAX_SIZE ; +static unsigned int core_file_note_size_min =CORE_FILE_NOTE_SIZE_DEFAULT ; +unsigned int core_file_note_size_allowed =CORE_FILE_NOTE_SIZE_MAX ;struct core_name {char *corename;
@@ -1020,6 +1026,15 @@ static struct ctl_table coredump_sysctls[] = { .mode = 0644, .proc_handler = proc_dointvec, }, + { + .procname = "core_file_note_size_min", + .data = &core_file_note_size_min, + .maxlen = sizeof(unsigned int), + .mode = 0644, + .proc_handler = proc_douintvec_minmax, + .extra1 = &core_file_note_size_min, + .extra2 = &core_file_note_size_allowed, + }, };static int __init init_fs_coredump_sysctls (void )
include/linux/coredump.h +0 -0
@@ -46,6 +46,7 @@ static inline void do_coredump(const
kernel_siginfo_t *siginfo) {}
#endif
#if defined(CONFIG_COREDUMP) && defined(CONFIG_SYSCTL)
+extern unsigned int core_file_note_size_allowed;
extern void validate_coredump_safety(void); #else
static inline void validate_coredump_safety(void) {}
Thanks,
Allen
Quoted 47 lines
Quoted 8 lines
Quoted 8 lines
struct core_name { char *corename;fs/coredump.c +2
-0@@ -1020,6 +1026,15 @@ static struct ctl_table coredump_sysctls[] = { .mode = 0644, .proc_handler = proc_dointvec, }, + { + .procname = "core_file_note_size_max",Quoted 8 lines
fs/coredump.c static struct ctl_table coredump_sysctls[] = { · line 1035
Quoted 5 lines
fs/coredump.c +5
-0+ .data = &core_file_note_size_max, + .maxlen = sizeof(unsigned int), + .mode = 0644, + .proc_handler = proc_douintvec_minmax, + .extra1 = &core_file_note_size_max,This means you can never shrink it if you raise it from the default. Let's use the
core_file_note_size_minabove.Sure, will fix it in v4.
Quoted 13 lines
Quoted 13 lines
fs/coredump.c +2
-0+ .extra2 = &core_file_note_size_allowed, + }, };static int __init init_fs_coredump_sysctls (void )include/linux/coredump.h +0
-0@@ -46,6 +46,7 @@ static inline void do_coredump(const kernel_siginfo_t *siginfo) {}#endif Quoted 11 lines
Quoted 8 lines
include/linux/coredump.h +1
-1#if defined(CONFIG_COREDUMP ) && defined(CONFIG_SYSCTL ) +extern unsigned int core_file_note_size_max;extern void validate_coredump_safety (void );#else static inline void validate_coredump_safety (void ) {} --2.17.1
I think v4 will be all good to go, assuming no one else pops up. :) Thanks for the changes!
Thank you for the reviews. Will send out v4 soon.
--
- Allen
Signature · 1 line
- Allen
Quoted 169 lines · Allen
Quoted 161 lines
Quoted 13 lines
Quoted 5 lines
Introduce the capability to dynamically configure the maximum file note size for ELF core dumps via sysctl. This enhancement removes the previous static limit of 4MB, allowing system administrators to adjust the size based on system-specific requirements or constraints.
Quoted 7 lines
- Remove hardcoded
MAX_FILE_NOTE_SIZEfromfs/binfmt_elf.c.
- Definemax_file_note_sizeinfs/coredump.cwith an initial value set to 4MB.
- Declaremax_file_note_sizeas an external variable ininclude/linux/coredump.h.
- Add a new sysctl entry inkernel/sysctl.cto manage this setting at runtime.Quoted 3 lines
The above bullet points should be clear from the patch itself. The commit is really more about rationale and examples (which you have below). I'd remove the bullets.
Sure, I have it modified to:
fs/coredump: Enable dynamic configuration of max file note size
Introduce the capability to dynamically configure the maximum file note size for ELF core dumps via sysctl.
Why is this being done?
We have observed that during a crash when there are more than 65k mmaps in memory, the existing fixed limit on the size of the ELF notes section becomes a bottleneck. The notes section quickly reaches its capacity, leading to incomplete memory segment information in the resulting coredump. This truncation compromises the utility of the coredumps, as crucial information about the memory state at the time of the crash might be omitted.This enhancement removes the previous static limit of 4MB, allowing system administrators to adjust the size based on system-specific requirements or constraints.
Eg:
$ sysctl -a | grepcore_file_note_size_max
kernel.core_file_note_size_max = 4194304
.......Quoted 26 lines
Quoted 17 lines
$ sysctl -a | grep core_file_note_size_max kernel.core_file_note_size_max = 4194304$ sysctl -n kernel.core_file_note_size_max 4194304$echo 519304 >
/proc/sys/kernel/core_file_note_size_max$sysctl -n kernel.core_file_note_size_max
519304Attempting to write beyond the ceiling value of 16MB $echo 17194304 >
/proc/sys/kernel/core_file_note_size_max
bash: echo: write error: Invalid argumentQuoted 8 lines
Why is this being done?
We have observed that during a crash when there are more than 65k mmaps in memory, the existing fixed limit on the size of the ELF notes section becomes a bottleneck. The notes section quickly reaches its capacity, leading to incomplete memory segment information in the resulting coredump. This truncation compromises the utility of the coredumps, as crucial information about the memory state at the time of the crash might be omitted.Quoted 4 lines
I'd make this the first paragraph of the commit log. "We have this problem" goes first, then "Here's what we did to deal with it", then you examples. :)
Done.
Quoted 33 lines
Quoted 33 lines
Signed-off-by Vijay Nag <[email protected]>Signed-off-by Allen Pais <[email protected]>---
Chagnes in v3:
- Fix commit message to reflect the correct sysctl knob [Kees]
- Add a ceiling for maximum pssible note size(16M) [Allen]
- Add apr_warn_once()[Kees]
Changes in v2:
- Move new sysctl tofs/coredump.c[Luis & Kees]
- renamemax_file_note_sizetocore_file_note_size_max[kees]
- Capture "why this is being done?" int he commit message [Luis & Kees]--- fs/binfmt_elf.c | 8 ++++++-- fs/coredump.c | 15 +++++++++++++++ include/linux/coredump.h | 1 + 3 files changed, 22 insertions(+), 2 deletions(-)fs/binfmt_elf.c +0
-1@@ -1564,7 +1564,6 @@ static void fill_siginfo_note(struct memelfnote *note, user_siginfo_t *csigdata,fill_note (note,"CORE" ,NT_SIGINFO ,sizeof (*csigdata), csigdata); } -#define MAX_FILE_NOTE_SIZE (4*1024*1024)/* * Format of NT_FILE note: * @@ -1592,8 +1591,13 @@ static int fill_files_note(struct memelfnote *note, struct coredump_params *cprmQuoted 10 lines
fs/binfmt_elf.c static int fill_files_note(struct memelfnote *note, struct coredump_params *cprm · line 1597
Quoted 7 lines
fs/binfmt_elf.c +4
-1names_ofs = (2 +3 * count) *sizeof (data[0 ]); alloc: -if (size >=MAX_FILE_NOTE_SIZE )/* paranoia check */ +/* paranoia check */ +if (size >= core_file_note_size_max) { + pr_warn_once("coredump Note size too large: %u " + "(does kernel.core_file_note_size_max sysctl need adjustment?)\n",The string can be on a single line (I think
scripts/check_patch.plwill warn about this, as well as the indentation of "size" below...It does warn, but if I leave it as a single line, there's still a warning:
WARNING: line length of 135 exceeds 100 columns, which is why I split it into multiple lines.Quoted 15 lines
Quoted 15 lines
fs/binfmt_elf.c +2
-0+ size);return -EINVAL ; + } size =round_up (size,PAGE_SIZE );/* * "size" can be 0 here legitimately. fs/coredump.c +0
-0@@ -56,10 +56,16 @@static bool dump_vma_snapshot (struct coredump_params *cprm);static void free_vma_snapshot (struct coredump_params *cprm);Quoted 7 lines
fs/coredump.c line 61
Quoted 3 lines
fs/coredump.c +3
-0+#define MAX_FILE_NOTE_SIZE (4*1024*1024) +/* Define a reasonable max cap */ +#define MAX_ALLOWED_NOTE_SIZE (16*1024*1024)Let's call this
CORE_FILE_NOTE_SIZE_DEFAULTandCORE_FILE_NOTE_SIZE_MAXto match the sysctl.Sure, will update it in v4.
Quoted 10 lines
fs/coredump.c
Quoted 7 lines
fs/coredump.c +3
-0+static int core_uses_pid;static unsigned int core_pipe_limit;static char core_pattern[CORENAME_MAX_SIZE ] ="core" ;static int core_name_size =CORENAME_MAX_SIZE ; +unsigned int core_file_note_size_max =MAX_FILE_NOTE_SIZE ; +unsigned int core_file_note_size_allowed =MAX_ALLOWED_NOTE_SIZE ;The latter can be static and const.
Quoted 4 lines
For the note below, perhaps add:
static const unsigned int
core_file_note_size_min=CORE_FILE_NOTE_SIZE_DEFAULT;Quoted 7 lines
core_file_note_size_minwill be used infs/binfmt_elf.cat:if (size >=
core_file_note_size_min) ,
did you mean
static const unsigned intcore_file_note_size_allowed=CORE_FILE_NOTE_SIZE_MAX;??Quoted 1 line
Quoted 1 line
Quoted 8 lines
Kees,
My bad, I misunderstood what you asked for. Here is the final diff,
if it looks fine,
i can send out a v4.Note, there is a warning issued by checkpatch.pl (WARNING: line length of 134 exceeds 100 columns)
For strings that should be fine. You'll want the ", size);" part on the next line though.
Quoted 3 lines
for the
pr_warn_once()and adding const trigger a build warning(warning: initialization discards
'const' qualifier from pointer target type), which is why i dropped it.
Yeah, that's a common pattern for sysctl. You can fix it with a cast. For example:
static const unsigned long nlm_grace_period_min = 0;
static const unsigned long nlm_grace_period_max = 240;
...
.proc_handler = proc_doulongvec_minmax,
.extra1 = (unsigned long *) &nlm_grace_period_min,
.extra2 = (unsigned long *) &nlm_grace_period_max,But yeah, looks good.
Signature · 1 line
Kees Cook
Thanks for the cleanups, this is certainly now in the right direction. Generic long term growth questions below.
Quoted 4 lines · Allen Pais
Why is this being done?
We have observed that during a crash when there are more than 65k mmaps in memory, the existing fixed limit on the size of the ELF notes section becomes a bottleneck. The notes section quickly reaches its capacity,
I'm not well versed here on how core dumps associate mmaps to ELF notes section, can you elaborate? Does each new mmap potentially peg information on ELF notes section? Where do we standardize on this? Does it also change depending on any criteria of the mmap?
Depending on the above, we might want to be proactive to get a sense of when we want to go beyond the new 16 MiB max cap on new mmaps for instance. How many mmaps can we have anyway too?
Quoted 4 lines
leading to incomplete memory segment information in the resulting coredump. This truncation compromises the utility of the coredumps, as crucial information about the memory state at the time of the crash might be omitted.
Luis
Quoted 9 lines · Luis Chamberlain
Thanks for the cleanups, this is certainly now in the right direction. Generic long term growth questions below.
Quoted 4 lines · Allen Pais
Why is this being done?
We have observed that during a crash when there are more than 65k mmaps in memory, the existing fixed limit on the size of the ELF notes section becomes a bottleneck. The notes section quickly reaches its capacity,
Quoted 4 lines
I'm not well versed here on how core dumps associate mmaps to ELF notes section, can you elaborate? Does each new mmap potentially peg information on ELF notes section? Where do we standardize on this? Does it also change depending on any criteria of the mmap?
This is all in fs/binfmt_elf.c, fill_note_info(). There's a dump for each thread's info, and then fill_files_note() (which is what this code is adjusting) which writes out every filename for any file-map VMAs. The format of NT_FILE record is documented above fill_files_note(). So, it all depends on the count of VMAs and length of filenames.
Quoted 3 lines
Depending on the above, we might want to be proactive to get a sense of when we want to go beyond the new 16 MiB max cap on new mmaps for instance. How many mmaps can we have anyway too?
INT_MAX :)
I'm fine with the new 16MiB max for the coredump. If we really need to go beyond this, we might need to avoid building the entire thing in memory, and instead move it all into write_note_info() directly, but I'm not interested in that refactor unless we have an overwhelmingly good reason to do so.
Signature · 1 line
Kees Cook
kernel test robot
build botkernel test robot noticed the following build errors:
Hi Allen,
kernel test robot noticed the following build errors:
[auto build test ERROR on kees/for-next/execve]
[also build test ERROR on brauner-vfs/vfs.all linus/master v6.9-rc6 next-20240503] [If your patch is applied to the wrong git tree, kindly drop us a note. And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch#_base_tree_information]
url: https://github.com/intel-lab-lkp/linux/commits/Allen-Pais/fs-coredump-Enable-dynamic-configuration-of-max-file-note-size/20240503-075758 base: https://git.kernel.org/pub/scm/linux/kernel/git/kees/linux.git for-next/execve patch link: https://lore.kernel.org/r/20240502235603.19290-1-apais%40linux.microsoft.com patch subject: [PATCH v3] fs/coredump: Enable dynamic configuration of max file note size config: powerpc64-randconfig-001-20240504 (https://download.01.org/0day-ci/archive/20240504/[email protected]/config) compiler: clang version 19.0.0git (https://github.com/llvm/llvm-project 37ae4ad0eef338776c7e2cffb3896153d43dcd90) reproduce (this is a W=1 build): (https://download.01.org/0day-ci/archive/20240504/[email protected]/reproduce)
If you fix the issue in a separate patch/commit (i.e. not just a new version of the same patch/commit), kindly add following tags
| Reported-by: kernel test robot <[email protected]>
| Closes: https://lore.kernel.org/oe-kbuild-all/[email protected]/
All errors (new ones prefixed by >>):
In file included from fs/compat_binfmt_elf.c:17:
In file included from include/linux/elfcore-compat.h:6:
In file included from include/linux/elfcore.h:11:
In file included from include/linux/ptrace.h:10:
In file included from include/linux/pid_namespace.h:7:
In file included from include/linux/mm.h:2208:
include/linux/vmstat.h:522:36: warning: arithmetic between different enumeration types ('enum node_stat_item' and 'enum lru_list') [-Wenum-enum-conversion]
522 | return node_stat_name(NR_LRU_BASE + lru) + 3; // skip "nr_"
| ~~~~~~~~~~~ ^ ~~~
In file included from fs/compat_binfmt_elf.c:144:
>> fs/binfmt_elf.c:1598:14: error: use of undeclared identifier 'core_file_note_size_max'
1598 | if (size >= core_file_note_size_max) {
| ^1 warning and 1 error generated.
vim +/core_file_note_size_max +1598 fs/binfmt_elf.c
1569
1570 /*
1571 * Format of NT_FILE note:
1572 *
1573 * long count -- how many files are mapped
1574 * long page_size -- units for file_ofs
1575 * array of [COUNT] elements of
1576 * long start
1577 * long end
1578 * long file_ofs
1579 * followed by COUNT filenames in ASCII: "FILE1" NUL "FILE2" NUL...
1580 */
1581 static int fill_files_note(struct memelfnote *note, struct coredump_params *cprm)
1582 {
1583 unsigned count, size, names_ofs, remaining, n;
1584 user_long_t *data;
1585 user_long_t *start_end_ofs;
1586 char *name_base, *name_curpos;
1587 int i;
1588
1589 /* *Estimated* file count and total data size needed */
1590 count = cprm->vma_count;
1591 if (count > UINT_MAX / 64)
1592 return -EINVAL;
1593 size = count * 64;
1594
1595 names_ofs = (2 + 3 * count) * sizeof(data[0]);
1596 alloc:
1597 /* paranoia check */
> 1598 if (size >= core_file_note_size_max) { 1599 pr_warn_once("coredump Note size too large: %u "
1600 "(does kernel.core_file_note_size_max sysctl need adjustment?)\n",
1601 size);
1602 return -EINVAL;
1603 }
1604 size = round_up(size, PAGE_SIZE);
1605 /*
1606 * "size" can be 0 here legitimately.
1607 * Let it ENOMEM and omit NT_FILE section which will be empty anyway.
1608 */
1609 data = kvmalloc(size, GFP_KERNEL);
1610 if (ZERO_OR_NULL_PTR(data))
1611 return -ENOMEM;
1612
1613 start_end_ofs = data + 2;
1614 name_base = name_curpos = ((char *)data) + names_ofs;
1615 remaining = size - names_ofs;
1616 count = 0;
1617 for (i = 0; i < cprm->vma_count; i++) {
1618 struct core_vma_metadata *m = &cprm->vma_meta[i];
1619 struct file *file;
1620 const char *filename;
1621
1622 file = m->file;
1623 if (!file)
1624 continue;
1625 filename = file_path(file, name_curpos, remaining);
1626 if (IS_ERR(filename)) {
1627 if (PTR_ERR(filename) == -ENAMETOOLONG) {
1628 kvfree(data);
1629 size = size * 5 / 4;
1630 goto alloc;
1631 }
1632 continue;
1633 }
1634
1635 /* file_path() fills at the end, move name down */
1636 /* n = strlen(filename) + 1: */
1637 n = (name_curpos + remaining) - filename;
1638 remaining = filename - name_curpos;
1639 memmove(name_curpos, filename, n);
1640 name_curpos += n;
1641
1642 *start_end_ofs++ = m->start;
1643 *start_end_ofs++ = m->end;
1644 *start_end_ofs++ = m->pgoff;
1645 count++;
1646 }
1647
1648 /* Now we know exact count of files, can store it */
1649 data[0] = count;
1650 data[1] = PAGE_SIZE;
1651 /*
1652 * Count usually is less than mm->map_count,
1653 * we need to move filenames down.
1654 */
1655 n = cprm->vma_count - count;
1656 if (n != 0) {
1657 unsigned shift_bytes = n * 3 * sizeof(data[0]);
1658 memmove(name_base - shift_bytes, name_base,
1659 name_curpos - name_base);
1660 name_curpos -= shift_bytes;
1661 }
1662
1663 size = name_curpos - (char *)data;
1664 fill_note(note, "CORE", NT_FILE, size, data);
1665 return 0;
1666 }
1667
Signature · 2 lines
0-DAY CI Kernel Test Service https://github.com/intel/lkp-tests/wiki