| Message ID | 519A40DE.2060409@redhat.com |
|---|---|
| State | Not Applicable, archived |
| Headers | show |
On Mon, May 20, 2013 at 10:27:26AM -0500, Eric Sandeen wrote: > Dave, I had suggested earlier in the thread that an option to specify a seed and a nr. of syscalls > to skip would help narrow down what triggers a bug. > i.e. in this case, we could find the last seed (for this child?) and then run with: The seed is 'global', ie, child 1 uses seed+1, child 2 uses seed+2 etc etc. We only log the seed value without the child number, so as long as you run with the same number of child processes, the children will all get the correct seed values. > * that seed > * max syscalls 421 > * skip the first 400 syscalls > > and see if it reproduces. Keep narrowing the window until we get the smallest set that reproduces. fsx has something similar to this. Setting the seed with -N should have the same net result as skipping the syscalls up until that point. There are however two gotchas with the code to use prior seeds. 1. imagine this scenario. a. initial seed b. N syscalls done c. reseed d. N syscalls done. If we get an oops after D, you might think "great, I can ignore everything before (c)" but that may not necessarily be the case, if something at (b) created/corrupted some kernel state that (d) ends up falling over. 2. We gather a list of filenames at startup from /proc, /sys and /dev, and these change at each run. This has undesirable results when you're trying to recreate something based on 'fd 243' etc, when that ends up mapping to a different file. However, in Toralf's case, if he's using -V, we'll only gather fd's from there, and as long as the files/dirs at that path are static across runs, all should be good. > (heh, now I want an option to emit C code to recreate the last N syscalls it's made, for permanent testcases. I suppose that'd be tough) ;) Not tough, just yet another idea to add to the already mile-long TODO :-) > Here's a really hacky, untested patch that might implement the skipping I'm talking about. Caveat; I've never actually used trinity. :) I think if we wanted to skip a few million syscalls this would involve quite a wait, and you're not really going to be saving much time over just doing the syscalls ;) > So if I'm missing something obvious about how to narrow down a failure to the call that caused it, I'm all ears. :) I really hope that -N is enough here. The only real gotcha is the 2nd case above, which we could solve by using a filename cache in the same way there's a network socket cache. Dave -- To unsubscribe from this list: send the line "unsubscribe linux-ext4" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
===== trinity: Add option to skip first X syscalls To narrow down what set of operations triggers a bug, it may be useful to rerun w/ the same seed, but skip the first X syscalls, to get the minimum set of calls which causes a problem. Add an "-X" option to do this. This is per-child, in the same way that the -N option is per-child. (I think!) Signed-off-by: Eric Sandeen <sandeen@redhat.com> --- diff --git a/include/syscall.h b/include/syscall.h index ccbe436..6dc00ec 100644 --- a/include/syscall.h +++ b/include/syscall.h @@ -99,6 +99,7 @@ extern const struct syscalltable *syscalls_32bit; extern const struct syscalltable *syscalls_64bit; extern unsigned long syscalls_todo; +extern unsigned long syscalls_skip; extern unsigned int max_nr_syscalls; extern unsigned int max_nr_32bit_syscalls; extern unsigned int max_nr_64bit_syscalls; diff --git a/params.c b/params.c index c2c3f70..d09c032 100644 --- a/params.c +++ b/params.c @@ -64,6 +64,7 @@ static void usage(void) fprintf(stderr, " -N#: do # syscalls then exit.\n"); fprintf(stderr, " -p: pause after syscall.\n"); fprintf(stderr, " -s#: use # as random seed.\n"); + fprintf(stderr, " -X#: skip first # syscalls.\n"); exit(EXIT_SUCCESS); } @@ -92,7 +93,7 @@ void parse_args(int argc, char *argv[]) { int opt; - while ((opt = getopt_long(argc, argv, "c:C:dDg:hIl:LN:mnP:pqr:s:SV:vx:", longopts, NULL)) != -1) { + while ((opt = getopt_long(argc, argv, "c:C:dDg:hIl:LN:mnP:pqr:s:SV:vx:X", longopts, NULL)) != -1) { switch (opt) { default: if (opt == '?') @@ -189,7 +190,9 @@ void parse_args(int argc, char *argv[]) seed = strtol(optarg, NULL, 10); user_set_seed = TRUE; break; - + case 'X': + syscalls_skip = strtol(optarg, NULL, 10); + break; case 'S': do_syslog = TRUE; diff --git a/syscall.c b/syscall.c index 42ac75e..cc33c52 100644 --- a/syscall.c +++ b/syscall.c @@ -83,10 +83,12 @@ static unsigned long do_syscall(int childno, int *errno_saved) errno = 0; - if (shm->do32bit[childno] == FALSE) - ret = syscall(nr, a1, a2, a3, a4, a5, a6); - else - ret = syscall32(num_args, nr, a1, a2, a3, a4, a5, a6); + if (shm->total_syscalls_done > syscalls_skip) { + if (shm->do32bit[childno] == FALSE) + ret = syscall(nr, a1, a2, a3, a4, a5, a6); + else + ret = syscall32(num_args, nr, a1, a2, a3, a4, a5, a6); + } *errno_saved = errno; @@ -221,7 +223,8 @@ args_done: sptr += sprintf(sptr, ") "); *sptr = '\0'; - output(2, "%s", string); + if (shm->total_syscalls_done >= syscalls_skip) + output(2, "%s", string); if (dopause == TRUE) { synclogs(); @@ -243,6 +246,7 @@ args_done: */ call += SYSCALL_OFFSET; + /* do_syscall will skip the actual call if we're still skipping */ ret = do_syscall(childno, &errno_saved); sptr = string; @@ -262,7 +266,8 @@ args_done: *sptr = '\0'; - output(2, "%s", string); + if (shm->total_syscalls_done > syscalls_skip) + output(2, "%s", string); /* If the syscall doesn't exist don't bother calling it next time. */ if ((ret == -1) && (errno_saved == ENOSYS)) { diff --git a/tables.c b/tables.c index 2bccd83..de11fb5 100644 --- a/tables.c +++ b/tables.c @@ -19,6 +19,7 @@ const struct syscalltable *syscalls_32bit; const struct syscalltable *syscalls_64bit; unsigned long syscalls_todo = 0; +unsigned long syscalls_skip = 0; unsigned int max_nr_syscalls; unsigned int max_nr_32bit_syscalls;