static void
runtests(GSList* task_list)
{
size_t i;
for (i = 0; i < g_slist_length(task_list); i++){
struct task* task;
task = g_slist_nth_data(task_list, i);
switch(task->op){
case OPEN:
open_testfile();
break;
case MANOPEN:
manopen_testfile();
break;
case CLOSE:
close_testfile();
break;
case CLOSE_SAVEFD:
close_savefd();
break;
case WAIT:
waitnotice();
break;
case SEND:
sendnotice();
break;
case WRITE:
write_testfile(task);
break;
case READ:
read_testfile(task);
break;
case RUN:
test( task->run_param.num,
task->run_param.sec,
task->run_param.func,
task->run_param.offset,
task->run_param.length,
task->run_param.pass,
FATAL);
break;
case FORK:{
int subpid = fork();
if (subpid < 0){
perror("can't fork off child");
exit(1);
}
if (subpid == 0){
test( task->run_param.num,
task->run_param.sec,
task->run_param.func,
task->run_param.offset,
task->run_param.length,
task->run_param.pass,
FATAL);
while(1) {
sleep(1);
}
}else{
gi.forkpid = subpid;
}
break;
}
case KILL:
if(kill(gi.forkpid, SIGINT) == -1){
perror("kill");
exit(1);
}
break;
case SLEEP:
sleep(task->sleep_param.time);
break;
case PUSHFD:
pushfd();
break;
case POPFD:
popfd();
break;
case TRUNC:
hb_trunc();
break;
}
}
}
static void test_readahead(void)
{
unsigned long read_bytes, read_bytes_ra;
long usec, usec_ra;
unsigned long cached_max, cached_low, cached, cached_ra;
char proc_io_fname[128];
sprintf(proc_io_fname, "/proc/%u/io", getpid());
/* find out how much can cache hold if we read whole file */
read_testfile(0, testfile, testfile_size, &read_bytes, &usec, &cached);
cached_max = get_cached_size();
sync();
drop_caches();
cached_low = get_cached_size();
cached_max = cached_max - cached_low;
tst_resm(TINFO, "read_testfile(0)");
read_testfile(0, testfile, testfile_size, &read_bytes, &usec, &cached);
cached = cached - cached_low;
sync();
drop_caches();
cached_low = get_cached_size();
tst_resm(TINFO, "read_testfile(1)");
read_testfile(1, testfile, testfile_size, &read_bytes_ra,
&usec_ra, &cached_ra);
cached_ra = cached_ra - cached_low;
tst_resm(TINFO, "read_testfile(0) took: %ld usec", usec);
tst_resm(TINFO, "read_testfile(1) took: %ld usec", usec_ra);
if (has_file(proc_io_fname, 0)) {
tst_resm(TINFO, "read_testfile(0) read: %ld bytes", read_bytes);
tst_resm(TINFO, "read_testfile(1) read: %ld bytes",
read_bytes_ra);
/* actual number of read bytes depends on total RAM */
if (read_bytes_ra < read_bytes)
tst_resm(TPASS, "readahead saved some I/O");
else
tst_resm(TFAIL, "readahead failed to save any I/O");
} else {
tst_resm(TCONF, "Your system doesn't have /proc/pid/io,"
" unable to determine read bytes during test");
}
tst_resm(TINFO, "cache can hold at least: %ld kB", cached_max);
tst_resm(TINFO, "read_testfile(0) used cache: %ld kB", cached);
tst_resm(TINFO, "read_testfile(1) used cache: %ld kB", cached_ra);
if (cached_max * 1024 >= testfile_size) {
/*
* if cache can hold ~testfile_size then cache increase
* for readahead should be at least testfile_size/2
*/
if (cached_ra * 1024 > testfile_size / 2)
tst_resm(TPASS, "using cache as expected");
else
tst_resm(TWARN, "using less cache than expected");
} else {
tst_resm(TCONF, "Page cache on your system is too small "
"to hold whole testfile.");
}
}
static void test_readahead(unsigned int n)
{
unsigned long read_bytes, read_bytes_ra;
long long usec, usec_ra;
unsigned long cached_high, cached_low, cached, cached_ra;
int ret;
struct tcase *tc = &tcases[n];
tst_res(TINFO, "Test #%d: %s", n, tc->tname);
if (tc->use_overlay && !ovl_mounted) {
tst_res(TCONF,
"overlayfs is not configured in this kernel.");
return;
}
create_testfile(tc->use_overlay);
/* find out how much can cache hold if we read whole file */
read_testfile(tc, 0, testfile, testfile_size, &read_bytes, &usec,
&cached);
cached_high = get_cached_size();
sync();
drop_caches();
cached_low = get_cached_size();
cached_max = MAX(cached_max, cached_high - cached_low);
tst_res(TINFO, "read_testfile(0)");
read_testfile(tc, 0, testfile, testfile_size, &read_bytes, &usec,
&cached);
if (cached > cached_low)
cached = cached - cached_low;
else
cached = 0;
sync();
drop_caches();
cached_low = get_cached_size();
tst_res(TINFO, "read_testfile(1)");
ret = read_testfile(tc, 1, testfile, testfile_size, &read_bytes_ra,
&usec_ra, &cached_ra);
if (ret == EINVAL) {
if (tc->use_fadvise &&
(!tc->use_overlay || !fadvise_supported)) {
fadvise_supported = 0;
tst_res(TCONF, "CONFIG_ADVISE_SYSCALLS not configured "
"in kernel?");
return;
}
if (!tc->use_overlay || !readahead_supported) {
readahead_supported = 0;
tst_res(TCONF, "readahead not supported on %s",
tst_device->fs_type);
return;
}
}
if (ret) {
tst_res(TFAIL | TTERRNO, "%s failed on %s",
tc->use_fadvise ? "fadvise" : "readahead",
tc->use_overlay ? "overlayfs" :
tst_device->fs_type);
return;
}
if (cached_ra > cached_low)
cached_ra = cached_ra - cached_low;
else
cached_ra = 0;
tst_res(TINFO, "read_testfile(0) took: %lli usec", usec);
tst_res(TINFO, "read_testfile(1) took: %lli usec", usec_ra);
if (has_file(PROC_IO_FNAME, 0)) {
tst_res(TINFO, "read_testfile(0) read: %ld bytes", read_bytes);
tst_res(TINFO, "read_testfile(1) read: %ld bytes",
read_bytes_ra);
/* actual number of read bytes depends on total RAM */
if (read_bytes_ra < read_bytes)
tst_res(TPASS, "readahead saved some I/O");
else
tst_res(TFAIL, "readahead failed to save any I/O");
} else {
tst_res(TCONF, "Your system doesn't have /proc/self/io,"
" unable to determine read bytes during test");
}
tst_res(TINFO, "cache can hold at least: %ld kB", cached_max);
tst_res(TINFO, "read_testfile(0) used cache: %ld kB", cached);
tst_res(TINFO, "read_testfile(1) used cache: %ld kB", cached_ra);
if (cached_max * 1024 >= testfile_size) {
/*
* if cache can hold ~testfile_size then cache increase
* for readahead should be at least testfile_size/2
*/
if (cached_ra * 1024 > testfile_size / 2)
tst_res(TPASS, "using cache as expected");
else if (!cached_ra)
tst_res(TFAIL, "readahead failed to use any cache");
else
tst_res(TWARN, "using less cache than expected");
} else {
tst_res(TCONF, "Page cache on your system is too small "
"to hold whole testfile.");
}
}
