syscalls/inotify06: Terminate child process on test error
PATCH 1/2 syscalls/inotify06: Terminate child process on test error
If the main test process exits early, the child would keep running and interfere with tmpdir cleanup.
--- testcases/kernel/syscalls/inotify/inotify06.c | 14 ++++++++++++-- 1 file changed, 12 insertions(+), 2 deletions(-)
testcases/kernel/syscalls/inotify/inotify06.c +12 -2
@@ -38,7 +38,8 @@/* Number of files to test (must be > 1) */ #define FILES 5 -char names[FILES ][PATH_MAX ]; +static char names[FILES ][PATH_MAX ]; +static pid_t pid;static void setup (void ) {
@@ -51,7 +52,6 @@ static void setup(void)static void verify_inotify (void ) {int inotify_fd, fd; -pid_t pid;int i, tests; pid =SAFE_FORK ();
@@ -85,14 +85,24 @@ static void verify_inotify(void)/* Kill the child creating / deleting files and wait for it */ SAFE_KILL (pid,SIGKILL ); + pid =0 ;SAFE_WAIT (NULL ); } +static void cleanup (void ) +{ +if (pid) { +SAFE_KILL (pid,SIGKILL ); +SAFE_WAIT (NULL ); + } +} +static struct tst_test test = { .timeout =600 , .needs_tmpdir =1 , .forks_child =1 , .setup = setup, + .cleanup = cleanup, .test_all = verify_inotify, };
Signature · 1 line
2.31.1
PATCH 2/2 syscalls/inotify06: Raise inotify instance limit in /proc
inotify_init() sometimes fails with EMFILE because there are too many partially closed instances waiting for garbage collection. Bump the limit in /proc/sys/fs/inotify/max_user_instances for the duration of the test.
---
I thought about only reading the procfile and calling yield() after every proc_limit/2 iterations to wait for garbage collection but I'm afraid that it might reduce the likelihood of triggering the bug. Since I currently have no system where I could reproduce the race, I've decided to play it safe and bump the /proc limit.
testcases/kernel/syscalls/inotify/inotify06.c | 11 +++++++++++ 1 file changed, 11 insertions(+)
testcases/kernel/syscalls/inotify/inotify06.c +11 -0
@@ -38,8 +38,11 @@/* Number of files to test (must be > 1) */ #define FILES 5 +#define PROCFILE "/proc/sys/fs/inotify/max_user_instances" +static char names[FILES ][PATH_MAX ];static pid_t pid; +static int old_proc_limit;static void setup (void ) {
@@ -47,6 +50,11 @@ static void setup(void)for (i =0 ; i <FILES ; i++)sprintf (names[i],"fname_%d" , i); + +SAFE_FILE_SCANF (PROCFILE ,"%d" , &old_proc_limit); + +if (old_proc_limit >=0 && old_proc_limit <TEARDOWNS ) +SAFE_FILE_PRINTF (PROCFILE ,"%d" ,TEARDOWNS +128 ); }static void verify_inotify (void )
@@ -95,10 +103,13 @@ static void cleanup(void)SAFE_KILL (pid,SIGKILL );SAFE_WAIT (NULL ); } + +SAFE_FILE_PRINTF (PROCFILE ,"%d" , old_proc_limit); }static struct tst_test test = { .timeout =600 , + .needs_root =1 , .needs_tmpdir =1 , .forks_child =1 , .setup = setup,
Signature · 1 line
2.31.1
PATCH 2/2 syscalls/inotify06: Raise inotify instance limit in /proc
Quoted 4 lines · Martin Doucha
inotify_init()sometimes fails with EMFILE because there are too many partially closed instances waiting for garbage collection. Bump the limit in/proc/sys/fs/inotify/max_user_instancesfor the duration of the test.
Quoted 8 lines
Signed-off-by Martin Doucha <[email protected]>---
I thought about only reading the procfile and calling
yield()after every proc_limit/2 iterations to wait for garbage collection but I'm afraid that it might reduce the likelihood of triggering the bug. Since I currently have no system where I could reproduce the race, I've decided to play it safe and bump the /proc limit.
So waiting would be fine as well. One process simply creates & deletes files in a loop until the other performs TEARDOWNS teardowns. It doesn't really matter how fast teardowns happen for the race to trigger. But I have no problem with this solution either.
Honza
Quoted 49 lines
testcases/kernel/syscalls/inotify/inotify06.c | 11 +++++++++++ 1 file changed, 11 insertions(+)testcases/kernel/syscalls/inotify/inotify06.c +11
-0@@ -38,8 +38,11 @@/* Number of files to test (must be > 1) */ #define FILES 5 +#define PROCFILE "/proc/sys/fs/inotify/max_user_instances" +static char names[FILES ][PATH_MAX ];static pid_t pid; +static int old_proc_limit;static void setup (void ) {@@ -47,6 +50,11 @@ static void setup(void)for (i =0 ; i <FILES ; i++)sprintf (names[i],"fname_%d" , i); + +SAFE_FILE_SCANF (PROCFILE ,"%d" , &old_proc_limit); + +if (old_proc_limit >=0 && old_proc_limit <TEARDOWNS ) +SAFE_FILE_PRINTF (PROCFILE ,"%d" ,TEARDOWNS +128 ); }static void verify_inotify (void )@@ -95,10 +103,13 @@ static void cleanup(void)SAFE_KILL (pid,SIGKILL );SAFE_WAIT (NULL ); } + +SAFE_FILE_PRINTF (PROCFILE ,"%d" , old_proc_limit); }static struct tst_test test = { .timeout =600 , + .needs_root =1 , .needs_tmpdir =1 , .forks_child =1 , .setup = setup,Signature · 1 line
2.31.1
Signature · 2 lines
Jan Kara <[email protected]> SUSE Labs, CR
PATCH 2/2 syscalls/inotify06: Raise inotify instance limit in /proc
Quoted 14 lines · Jan Kara
Quoted 4 lines · Martin Doucha
inotify_init()sometimes fails with EMFILE because there are too many partially closed instances waiting for garbage collection. Bump the limit in/proc/sys/fs/inotify/max_user_instancesfor the duration of the test.Quoted 8 lines
Signed-off-by Martin Doucha <[email protected]>---
I thought about only reading the procfile and calling
yield()after every proc_limit/2 iterations to wait for garbage collection but I'm afraid that it might reduce the likelihood of triggering the bug. Since I currently have no system where I could reproduce the race, I've decided to play it safe and bump the /proc limit.
Quoted 4 lines
So waiting would be fine as well. One process simply creates & deletes files in a loop until the other performs TEARDOWNS teardowns. It doesn't really matter how fast teardowns happen for the race to trigger. But I have no problem with this solution either.
Let's go with the patch as is then. Like I said, when I don't have a system where the issue is reproducible, I prefer to play it safe.
Signature · 7 lines
Martin Doucha [email protected] QA Engineer for Software Maintenance SUSE LINUX, s.r.o. CORSO IIa Krizikova 148/34 186 00 Prague 8 Czech Republic
PATCH 2/2 syscalls/inotify06: Raise inotify instance limit in /proc
Hi Martin, Jan,
Quoted 15 lines · Jan Kara
Quoted 13 lines · Martin Doucha
Quoted 12 lines
inotify_init()sometimes fails with EMFILE because there are too many partially closed instances waiting for garbage collection. Bump the limit in/proc/sys/fs/inotify/max_user_instancesfor the duration of the test.Signed-off-by Martin Doucha <[email protected]>---
I thought about only reading the procfile and calling
yield()after every proc_limit/2 iterations to wait for garbage collection but I'm afraid that it might reduce the likelihood of triggering the bug. Since I currently have no system where I could reproduce the race, I've decided to play it safe and bump the /proc limit.
Quoted 7 lines
Quoted 4 lines
So waiting would be fine as well. One process simply creates & deletes files in a loop until the other performs TEARDOWNS teardowns. It doesn't really matter how fast teardowns happen for the race to trigger. But I have no problem with this solution either.
Let's go with the patch as is then. Like I said, when I don't have a system where the issue is reproducible, I prefer to play it safe.
Make sense, merged. Thank you both for fixing and review!
Kind regards,
Petr
PATCH 1/2 syscalls/inotify06: Terminate child process on test error
In reply to Martin DouchaQuoted 7 lines · Martin Doucha
If the main test process exits early, the child would keep running and interfere with tmpdir cleanup.
Signed-off-by Martin Doucha <[email protected]>--- testcases/kernel/syscalls/inotify/inotify06.c | 14 ++++++++++++-- 1 file changed, 12 insertions(+), 2 deletions(-)
Thanks for the patch. It looks good to me. You can add:
Honza
Quoted 51 lines
testcases/kernel/syscalls/inotify/inotify06.c +12
-2@@ -38,7 +38,8 @@/* Number of files to test (must be > 1) */ #define FILES 5 -char names[FILES ][PATH_MAX ]; +static char names[FILES ][PATH_MAX ]; +static pid_t pid;static void setup (void ) {@@ -51,7 +52,6 @@ static void setup(void)static void verify_inotify (void ) {int inotify_fd, fd; -pid_t pid;int i, tests; pid =SAFE_FORK ();@@ -85,14 +85,24 @@ static void verify_inotify(void)/* Kill the child creating / deleting files and wait for it */ SAFE_KILL (pid,SIGKILL ); + pid =0 ;SAFE_WAIT (NULL ); } +static void cleanup (void ) +{ +if (pid) { +SAFE_KILL (pid,SIGKILL ); +SAFE_WAIT (NULL ); + } +} +static struct tst_test test = { .timeout =600 , .needs_tmpdir =1 , .forks_child =1 , .setup = setup, + .cleanup = cleanup, .test_all = verify_inotify, };Signature · 1 line
2.31.1
Signature · 2 lines
Jan Kara <[email protected]> SUSE Labs, CR
Petr Vorel
AppliedPATCH 1/2 syscalls/inotify06: Terminate child process on test error
Hi Martin, Jan,
Quoted 12 lines · Martin Doucha
Quoted 7 lines
If the main test process exits early, the child would keep running and interfere with tmpdir cleanup.
Signed-off-by Martin Doucha <[email protected]>--- testcases/kernel/syscalls/inotify/inotify06.c | 14 ++++++++++++-- 1 file changed, 12 insertions(+), 2 deletions(-)Thanks for the patch. It looks good to me. You can add:
Reviewed-by Jan Kara <[email protected]>
Merged, thanks!
Kind regards,
Petr