923 lines
19 KiB
C
923 lines
19 KiB
C
#include <stdio.h>
|
|
#include <sys/errno.h>
|
|
#include <string.h>
|
|
#include <strings.h>
|
|
#include <unistd.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/file.h>
|
|
#include <sys/fcntl.h>
|
|
#include <dirent.h>
|
|
#include "tests.h"
|
|
#include "subr.h"
|
|
|
|
#define DEFAULT_LEVELS 5
|
|
#define DEFAULT_MINDIRS 5
|
|
#define DEFAULT_MAXDIRS 10
|
|
#define DEFAULT_MINFILES 5
|
|
#define DEFAULT_MAXFILES 10
|
|
#define DEFAULT_MINSIZE 4096
|
|
#define DEFAULT_MAXSIZE 4096*4
|
|
#define BASE_FILE_NAME "testfile"
|
|
#define BASE_DIR_NAME "testdir"
|
|
#define DIRPERMS 0755
|
|
#define OPTSTR "Vp"
|
|
#define CONFIGPATH "./.exconf"
|
|
|
|
#define PROB_MIN 1
|
|
#define PROB_MAX 100
|
|
|
|
/*
|
|
* file operation probabilities
|
|
*/
|
|
#define FREAD_PROB 50
|
|
#define FREAD_MIN PROB_MIN
|
|
#define FREAD_MAX FREAD_PROB
|
|
#define FSTAT_PROB 50
|
|
#define FSTAT_MIN FREAD_MAX + 1
|
|
#define FSTAT_MAX FREAD_MAX + FSTAT_PROB
|
|
/*
|
|
* directory operation probabilities
|
|
*/
|
|
#define DREAD_PROB 34
|
|
#define DREAD_MIN PROB_MIN
|
|
#define DREAD_MAX DREAD_PROB
|
|
#define DCWD_PROB 33
|
|
#define DCWD_MIN DREAD_MAX + 1
|
|
#define DCWD_MAX DREAD_MAX + DCWD_PROB
|
|
#define DSTAT_PROB 33
|
|
#define DSTAT_MIN DCWD_MAX + 1
|
|
#define DSTAT_MAX PROB_MAX
|
|
#define FREAD_LOOP 1
|
|
#define FSTAT_LOOP 1
|
|
#define DREAD_LOOP 1
|
|
#define DSTAT_LOOP 1
|
|
|
|
#define OPERATION_RATIO 50
|
|
#define OPERATION_COUNT 500
|
|
|
|
#define NAMELIST_CHUNK 256
|
|
#define READBUFLEN 1025
|
|
|
|
#define FILE_LIST 0x1
|
|
#define DIR_LIST 0x2
|
|
#define LIST_ALL 0x4
|
|
|
|
#define MINFILE 16
|
|
#define MAXFILE 4096*64
|
|
|
|
#define PROC_ENTER(str) if ( Verbose ) { printf( "%s\n", str ); }
|
|
|
|
enum opid {
|
|
FILE_READ,
|
|
FILE_STAT,
|
|
DIR_READ,
|
|
DIR_CWD,
|
|
DIR_STAT,
|
|
NULLOP
|
|
};
|
|
|
|
enum confid {
|
|
RATIO_CONFIG,
|
|
OP_CONFIG,
|
|
FILE_LOOP_CONFIG,
|
|
DIR_LOOP_CONFIG,
|
|
FILE_PROB_CONFIG,
|
|
DIR_PROB_CONFIG,
|
|
NULLCONF
|
|
};
|
|
|
|
struct operation {
|
|
char *op_name;
|
|
enum opid op_id;
|
|
int op_rmin;
|
|
int op_rmax;
|
|
int op_loop;
|
|
};
|
|
|
|
struct configuration {
|
|
char *cf_key;
|
|
enum confid cf_id;
|
|
int cf_val;
|
|
char *cf_opname;
|
|
struct operation *cf_optab;
|
|
void (*cf_func)();
|
|
};
|
|
|
|
extern int errno;
|
|
extern char *optarg;
|
|
extern int optind;
|
|
|
|
void set_oprange();
|
|
void set_oploop();
|
|
|
|
extern char *malloc();
|
|
extern char *re_comp();
|
|
extern int re_exec();
|
|
|
|
char *Progname = "exercise";
|
|
char StartDir[MAXPATHLEN + 1];
|
|
int Verbose = 0;
|
|
int Level = 0;
|
|
struct operation Fileops[] = {
|
|
{"read", FILE_READ, FREAD_MIN, FREAD_MAX, FREAD_LOOP},
|
|
{"stat", FILE_STAT, FSTAT_MIN, FSTAT_MAX, 1},
|
|
{ NULL, NULLOP, 0, 0 }
|
|
};
|
|
struct operation Dirops[] = {
|
|
{"read", DIR_READ, DREAD_MIN, DREAD_MAX, DREAD_LOOP},
|
|
{"chdir", DIR_CWD, DCWD_MIN, DCWD_MAX, 1},
|
|
{"stat", DIR_STAT, DSTAT_MIN, DSTAT_MAX, DSTAT_LOOP},
|
|
{ NULL, NULLOP, 0, 0 }
|
|
};
|
|
struct configuration Configtab[] = {
|
|
{ "RATIO", RATIO_CONFIG, OPERATION_RATIO, NULL, NULL },
|
|
{ "OPERATIONS", OP_CONFIG, OPERATION_COUNT, NULL, NULL },
|
|
{ "FREADPROB", FILE_PROB_CONFIG, FREAD_PROB, "read", Fileops, set_oprange },
|
|
{ "FSTATPROB", FILE_PROB_CONFIG, FSTAT_PROB, "stat", Fileops, set_oprange },
|
|
{ "DREADPROB", DIR_PROB_CONFIG, DREAD_PROB, "read", Dirops, set_oprange },
|
|
{ "DCHDIRPROB", DIR_PROB_CONFIG, DCWD_PROB, "chdir", Dirops, set_oprange },
|
|
{ "DSTATPROB", DIR_PROB_CONFIG, DSTAT_PROB, "stat", Dirops, set_oprange },
|
|
{ "FREADLOOP", FILE_LOOP_CONFIG, FREAD_LOOP, "read", Fileops, set_oploop },
|
|
{ "FSTATLOOP", FILE_LOOP_CONFIG, FSTAT_LOOP, "stat", Fileops, set_oploop },
|
|
{ "DREADLOOP", DIR_LOOP_CONFIG, DREAD_LOOP, "read", Dirops, set_oploop },
|
|
{ "DSTATLOOP", DIR_LOOP_CONFIG, DSTAT_LOOP, "stat", Dirops, set_oploop },
|
|
{ NULL, NULLCONF, 0, NULL, NULL }
|
|
};
|
|
|
|
void
|
|
usage( void )
|
|
{
|
|
fprintf( stderr, "usage: %s [-Vp] [dir1 dir2 ...]\n", Progname );
|
|
}
|
|
|
|
void
|
|
set_range( char *argp, int *minval, int *maxval )
|
|
{
|
|
char *tokp;
|
|
|
|
if ( argp ) {
|
|
tokp = strtok( argp, ", " );
|
|
if ( tokp ) {
|
|
*minval = atoi( tokp );
|
|
tokp = strtok( NULL, " " );
|
|
if ( tokp ) {
|
|
*maxval = atoi( tokp );
|
|
} else {
|
|
fprintf( stderr,
|
|
"set_range: invalid range specification\n" );
|
|
exit( 1 );
|
|
}
|
|
} else {
|
|
*minval = *maxval = atoi( argp );
|
|
}
|
|
} else {
|
|
fprintf( stderr, "set_range: NULL argp\n" );
|
|
exit( 1 );
|
|
}
|
|
}
|
|
|
|
struct configuration *
|
|
lookup_config( char *str )
|
|
{
|
|
struct configuration *config_ent = NULL;
|
|
int i;
|
|
|
|
if ( str ) {
|
|
for ( i = 0; Configtab[i].cf_key; i++ ) {
|
|
if ( !strcmp( str, Configtab[i].cf_key ) ) {
|
|
config_ent = &Configtab[i];
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return( config_ent );
|
|
}
|
|
|
|
struct operation *
|
|
lookup_op_byname( char *name, struct operation *table )
|
|
{
|
|
struct operation *opent = NULL;
|
|
|
|
if ( name && table && table->op_name ) {
|
|
for ( ; table->op_name; table++ ) {
|
|
if ( strcmp( name, table->op_name ) ) {
|
|
opent = table;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return( opent );
|
|
}
|
|
|
|
struct operation *
|
|
lookup_op_byrange( int val, struct operation *table )
|
|
{
|
|
struct operation *opent = NULL;
|
|
|
|
if ( table && table->op_name ) {
|
|
for ( ; table->op_name; table++ ) {
|
|
if ( (table->op_rmin <= val) && (table->op_rmax >= val) ) {
|
|
opent = table;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return( opent );
|
|
}
|
|
|
|
void
|
|
set_oprange( struct operation *opent, int val )
|
|
{
|
|
struct operation *prev = opent - 1;
|
|
|
|
if ( (opent == Fileops) || (opent == Dirops) ) {
|
|
opent->op_rmin = PROB_MIN;
|
|
opent->op_rmax = opent->op_rmin + val;
|
|
while( (prev = opent++) && (opent->op_name) ) {
|
|
opent->op_rmin = prev->op_rmax + 1;
|
|
opent->op_rmax = opent->op_rmin + val;
|
|
}
|
|
} else {
|
|
do {
|
|
opent->op_rmin = prev->op_rmax + 1;
|
|
opent->op_rmax = opent->op_rmin + val;
|
|
prev = opent++;
|
|
} while ( opent->op_name );
|
|
}
|
|
}
|
|
|
|
void
|
|
set_oploop( struct operation *opent, int val )
|
|
{
|
|
opent->op_loop = val;
|
|
}
|
|
|
|
void
|
|
check_tables( void )
|
|
{
|
|
int i;
|
|
int filesum = 0;
|
|
int dirsum = 0;
|
|
int errcount = 0;
|
|
|
|
PROC_ENTER( "check_tables" );
|
|
for ( i = 0; Configtab[i].cf_key; i++ ) {
|
|
switch ( Configtab[i].cf_id ) {
|
|
case FILE_PROB_CONFIG:
|
|
filesum += Configtab[i].cf_val;
|
|
break;
|
|
case DIR_PROB_CONFIG:
|
|
dirsum += Configtab[i].cf_val;
|
|
break;
|
|
case RATIO_CONFIG:
|
|
if ( (Configtab[i].cf_val > PROB_MAX) ||
|
|
(Configtab[i].cf_val < PROB_MIN) ) {
|
|
fprintf( stderr, "check_tables: RATIO out of range\n" );
|
|
errcount++;
|
|
} else if ( Configtab[i].cf_val == PROB_MAX ) {
|
|
fprintf( stderr,
|
|
"check_tables: WARNING: RATIO == PROB_MAX\n" );
|
|
} else if ( Configtab[i].cf_val == PROB_MIN ) {
|
|
fprintf( stderr,
|
|
"check_tables: WARNING: RATIO == PROB_MIN\n" );
|
|
}
|
|
}
|
|
}
|
|
if ( filesum != PROB_MAX ) {
|
|
fprintf( stderr,
|
|
"check_tables: file probabilities do not sum to %d\n",
|
|
PROB_MAX );
|
|
errcount++;
|
|
}
|
|
if ( dirsum != PROB_MAX ) {
|
|
fprintf( stderr,
|
|
"check_tables: dir probabilities do not sum to %d\n",
|
|
PROB_MAX );
|
|
errcount++;
|
|
}
|
|
for ( i = 0; Fileops[i].op_name; i++ ) {
|
|
if ( (Fileops[i].op_rmax > PROB_MAX) ||
|
|
(Fileops[i].op_rmin < PROB_MIN) ) {
|
|
fprintf( stderr, "check_tables: file op %s: bad range\n",
|
|
Fileops[i].op_name );
|
|
errcount++;
|
|
}
|
|
}
|
|
for ( i = 0; Dirops[i].op_name; i++ ) {
|
|
if ( (Dirops[i].op_rmax > PROB_MAX) ||
|
|
(Dirops[i].op_rmin < PROB_MIN) ) {
|
|
fprintf( stderr, "check_tables: dir op %s: bad range\n",
|
|
Dirops[i].op_name );
|
|
errcount++;
|
|
}
|
|
}
|
|
if ( errcount ) {
|
|
exit( 1 );
|
|
}
|
|
}
|
|
|
|
struct operation *
|
|
select_optab( void )
|
|
{
|
|
struct configuration *configent;
|
|
struct operation *optab = NULL;
|
|
|
|
if ( configent = lookup_config( "RATIO" ) ) {
|
|
if ( GEN_NUM( PROB_MIN, PROB_MAX ) <= configent->cf_val ) {
|
|
optab = Fileops;
|
|
} else {
|
|
optab = Dirops;
|
|
}
|
|
} else {
|
|
fprintf( stderr, "select_optab: unable to find RATIO configurator\n" );
|
|
}
|
|
return( optab );
|
|
}
|
|
|
|
struct operation *
|
|
select_op( void )
|
|
{
|
|
struct operation *table;
|
|
struct operation *opent = NULL;
|
|
|
|
if ( table = select_optab() ) {
|
|
opent = lookup_op_byrange( GEN_NUM( PROB_MIN, PROB_MAX ), table );
|
|
} else {
|
|
fprintf( stderr, "select_op: optab selection error\n" );
|
|
}
|
|
return( opent );
|
|
}
|
|
|
|
void
|
|
check_dir_list( char **lp, int cnt )
|
|
{
|
|
char *cp;
|
|
int spaces;
|
|
|
|
if ( lp ) {
|
|
while ( cnt-- ) {
|
|
if ( cp = lp[cnt] ) {
|
|
spaces = 0;
|
|
while( *cp ) {
|
|
if ( isspace(*cp) ) {
|
|
spaces++;
|
|
}
|
|
cp++;
|
|
}
|
|
if ( spaces == strlen( lp[cnt] ) ) {
|
|
printf( "check_dir_list: blank file name in entry %d\n",
|
|
cnt );
|
|
}
|
|
} else {
|
|
printf( "check_dir_list: NULL entry %d\n", cnt );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
char **
|
|
list_dir( int type, char *path, int *count )
|
|
{
|
|
DIR *dirp;
|
|
struct dirent *dentp;
|
|
char **namelist = NULL;
|
|
char *name;
|
|
struct stat statbuf;
|
|
char filename[MAXPATHLEN];
|
|
|
|
if ( dirp = opendir( path ) ) {
|
|
namelist = (char **)malloc( sizeof(char *) * NAMELIST_CHUNK );
|
|
if ( namelist ) {
|
|
*count = 0;
|
|
while ( dentp = readdir( dirp ) ) {
|
|
sprintf( filename, "%s/%s", path, dentp->d_name );
|
|
if ( stat( filename, &statbuf ) == -1 ) {
|
|
error( "list_dir: stat error for %s in dir %s",
|
|
dentp->d_name, path );
|
|
} else {
|
|
if ( (type == LIST_ALL) ||
|
|
((type == FILE_LIST) && S_ISREG( statbuf.st_mode )) ||
|
|
((type == DIR_LIST) && S_ISDIR( statbuf.st_mode )) ) {
|
|
name = malloc( strlen(dentp->d_name) + 1 );
|
|
if ( name ) {
|
|
namelist[*count] = name;
|
|
(*count)++;
|
|
strcpy( name, dentp->d_name );
|
|
} else {
|
|
error(
|
|
"list_dir: unable to malloc name space" );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if ( !*count ) {
|
|
free( namelist );
|
|
namelist = NULL;
|
|
}
|
|
if ( closedir( dirp ) == -1 ) {
|
|
error( "list_dir: close error on dir %s", path );
|
|
}
|
|
} else {
|
|
error( "list_dir: unable to malloc name list" );
|
|
}
|
|
} else {
|
|
error( "list_dir: open error on dir %s", path );
|
|
}
|
|
if ( (Verbose > 1) && namelist ) {
|
|
check_dir_list( namelist, *count );
|
|
}
|
|
return( namelist );
|
|
}
|
|
|
|
void
|
|
free_dir_list( char **list, int count )
|
|
{
|
|
char **lp = list;
|
|
|
|
if ( list ) {
|
|
while ( count ) {
|
|
if ( *lp ) {
|
|
free( *lp );
|
|
*lp = NULL;
|
|
}
|
|
count--;
|
|
lp++;
|
|
}
|
|
free( list );
|
|
}
|
|
}
|
|
|
|
char *
|
|
find_file( char *exp )
|
|
{
|
|
char *name = NULL;
|
|
char *errstr;
|
|
int i;
|
|
DIR *dirp;
|
|
struct dirent *dentp;
|
|
struct stat statbuf;
|
|
|
|
PROC_ENTER( "find_file" );
|
|
if ( errstr = re_comp( exp ) ) {
|
|
fprintf( stderr, "find_file: re_comp: %s", errstr );
|
|
} else if ( dirp = opendir( "." ) ) {
|
|
while ( dentp = readdir( dirp ) ) {
|
|
if ( stat( dentp->d_name, &statbuf ) == -1 ) {
|
|
error( "list_dir: stat error for %s", dentp->d_name );
|
|
} else if ( re_exec( dentp->d_name ) ) {
|
|
name = malloc( strlen(dentp->d_name) + 1 );
|
|
if ( name ) {
|
|
strcpy( name, dentp->d_name );
|
|
} else {
|
|
error( "list_dir: unable to malloc name space" );
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if ( closedir( dirp ) == -1 ) {
|
|
error( "list_dir: close error on dir ." );
|
|
}
|
|
} else {
|
|
error( "list_dir: open error on dir ." );
|
|
}
|
|
return( name );
|
|
}
|
|
|
|
/*
|
|
* read the current directory
|
|
* pick a regular file, but not *.DIRINFO
|
|
* return the file name
|
|
*/
|
|
char *
|
|
select_file( void )
|
|
{
|
|
char **flist;
|
|
char *name = NULL;
|
|
int count = 0;
|
|
int n;
|
|
char *errstr;
|
|
|
|
if ( flist = list_dir( FILE_LIST, ".", &count ) ) {
|
|
if ( errstr = re_comp( DIRINFO_FORM ) ) {
|
|
fprintf( stderr, "select_file: re_comp: %s", errstr );
|
|
} else {
|
|
if ( count > 1 ) {
|
|
n = GEN_NUM( 0, count-1 );
|
|
if ( re_exec( flist[n] ) ) {
|
|
n = (n + 1) % count;
|
|
}
|
|
name = flist[n];
|
|
flist[n] = NULL;
|
|
}
|
|
}
|
|
free_dir_list( flist, count );
|
|
}
|
|
return( name );
|
|
}
|
|
|
|
/*
|
|
* read the current directory
|
|
* pick a directory
|
|
* return the file name
|
|
*/
|
|
char *
|
|
select_dir( void )
|
|
{
|
|
char **flist;
|
|
char *name = NULL;
|
|
int count = 0;
|
|
int n;
|
|
|
|
if ( flist = list_dir( DIR_LIST, ".", &count ) ) {
|
|
n = GEN_NUM( 0, count-1 );
|
|
name = flist[n];
|
|
flist[n] = NULL;
|
|
free_dir_list( flist, count );
|
|
}
|
|
return( name );
|
|
}
|
|
|
|
void
|
|
do_file_read( struct operation *opent )
|
|
{
|
|
char *name;
|
|
int fd;
|
|
int res;
|
|
char buffer[READBUFLEN];
|
|
int i;
|
|
|
|
PROC_ENTER( "do_file_read" );
|
|
if ( name = select_file() ) {
|
|
if ( Verbose ) {
|
|
printf( "do_file_read: reading file %s\n", name );
|
|
}
|
|
for ( i = 0; i < opent->op_loop; i++ ) {
|
|
if ( (fd = open( name, O_RDONLY )) == -1 ) {
|
|
error( "do_file_read: unable to open %s for reading", name );
|
|
break;
|
|
} else {
|
|
while ( (res = read( fd, buffer, BUFLEN )) > 0 ) {
|
|
;
|
|
}
|
|
if ( res == -1 ) {
|
|
error( "do_file_read: read error on %s", name );
|
|
break;
|
|
}
|
|
if ( close( fd ) == -1 ) {
|
|
error( "do_file_read: close error on %s", name );
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
free( name );
|
|
}
|
|
}
|
|
|
|
void
|
|
do_file_stat( struct operation *opent )
|
|
{
|
|
char *name;
|
|
int fd;
|
|
int i;
|
|
struct stat statbuf;
|
|
|
|
PROC_ENTER( "do_file_stat" );
|
|
if ( name = select_file() ) {
|
|
if ( Verbose ) {
|
|
printf( "do_file_stat: stating file %s\n", name );
|
|
}
|
|
for ( i = 0; i < opent->op_loop; i++ ) {
|
|
switch ( GEN_NUM( 1, 3 ) ) {
|
|
case 1:
|
|
if ( stat( name, &statbuf ) == -1 ) {
|
|
error( "do_file_stat: stat error on %s", name );
|
|
return;
|
|
}
|
|
break;
|
|
case 2:
|
|
if ( lstat( name, &statbuf ) == -1 ) {
|
|
error( "do_file_stat: lstat error on %s", name );
|
|
return;
|
|
}
|
|
break;
|
|
case 3:
|
|
if ( (fd = open( name, O_RDONLY )) == -1 ) {
|
|
error( "do_file_stat: open error on %s", name );
|
|
return;
|
|
} else if ( fstat( fd, &statbuf ) == -1 ) {
|
|
error( "do_file_stat: fstat error on %s", name );
|
|
return;
|
|
} else if ( close( fd ) == -1 ) {
|
|
error( "do_file_stat: close error on %s", name );
|
|
return;
|
|
}
|
|
break;
|
|
default:
|
|
error( "do_file_stat: bad stat op" );
|
|
}
|
|
}
|
|
free( name );
|
|
}
|
|
}
|
|
|
|
void
|
|
do_dir_read( struct operation *opent )
|
|
{
|
|
char *name;
|
|
char **namelist;
|
|
int count;
|
|
int i;
|
|
|
|
PROC_ENTER( "do_dir_read" );
|
|
if ( name = select_dir() ) {
|
|
if ( Verbose ) {
|
|
printf( "do_dir_read: reading dir %s\n", name );
|
|
}
|
|
for ( i = 0; i < opent->op_loop; i++ ) {
|
|
namelist = list_dir( LIST_ALL, name, &count );
|
|
}
|
|
free( name );
|
|
}
|
|
}
|
|
|
|
void
|
|
do_chdir( struct operation *opent )
|
|
{
|
|
char *name;
|
|
int isdotdot;
|
|
|
|
PROC_ENTER( "do_chdir" );
|
|
if ( name = select_dir() ) {
|
|
/*
|
|
* don't cd to .
|
|
*/
|
|
if ( strcmp( name, "." ) != 0 ) {
|
|
/*
|
|
* if we're at the top level, don't cd ..
|
|
*/
|
|
isdotdot = (strcmp( name, ".." ) == 0);
|
|
if ( (Level == 0) && !isdotdot ) {
|
|
if ( Verbose ) {
|
|
printf( "cd to %s\n", name );
|
|
}
|
|
if ( chdir( name ) == -1 ) {
|
|
error( "do_chdir: unable to cd to %s", name );
|
|
} else if ( isdotdot ) {
|
|
Level--;
|
|
} else {
|
|
Level++;
|
|
}
|
|
}
|
|
}
|
|
free( name );
|
|
}
|
|
}
|
|
|
|
void
|
|
do_dir_stat( struct operation *opent )
|
|
{
|
|
char *name;
|
|
int fd;
|
|
struct stat statbuf;
|
|
int i;
|
|
|
|
if ( name = select_dir() ) {
|
|
if ( Verbose ) {
|
|
printf( "do_dir_stat: stating dir %s\n", name );
|
|
}
|
|
for ( i = 0; i < opent->op_loop; i++ ) {
|
|
switch ( GEN_NUM( 1, 3 ) ) {
|
|
case 1:
|
|
if ( stat( name, &statbuf ) == -1 ) {
|
|
error( "do_dir_stat: stat error on %s", name );
|
|
return;
|
|
}
|
|
break;
|
|
case 2:
|
|
if ( lstat( name, &statbuf ) == -1 ) {
|
|
error( "do_dir_stat: lstat error on %s", name );
|
|
return;
|
|
}
|
|
break;
|
|
case 3:
|
|
if ( (fd = open( name, O_RDONLY )) == -1 ) {
|
|
error( "do_dir_stat: open error on %s", name );
|
|
return;
|
|
} else if ( fstat( fd, &statbuf ) == -1 ) {
|
|
error( "do_dir_stat: fstat error on %s", name );
|
|
return;
|
|
} else if ( close( fd ) == -1 ) {
|
|
error( "do_dir_stat: close error on %s", name );
|
|
return;
|
|
}
|
|
break;
|
|
default:
|
|
error( "do_dir_stat: bad stat op" );
|
|
}
|
|
}
|
|
free( name );
|
|
}
|
|
}
|
|
|
|
void
|
|
do_op( struct operation *opent )
|
|
{
|
|
char *cwd = NULL;
|
|
|
|
if ( (cwd = getcwd( NULL, MAXPATHLEN )) == NULL ) {
|
|
perror( "do_op: getcwd" );
|
|
} else if ( strncmp( cwd, StartDir, strlen( StartDir ) ) != 0 ) {
|
|
fprintf( stderr, "do_op: illegal working directory: %s\n", cwd );
|
|
exit( 1 );
|
|
} else {
|
|
switch ( opent->op_id ) {
|
|
case FILE_READ:
|
|
do_file_read( opent );
|
|
break;
|
|
case FILE_STAT:
|
|
do_file_stat( opent );
|
|
break;
|
|
case DIR_READ:
|
|
do_dir_read( opent );
|
|
break;
|
|
case DIR_CWD:
|
|
do_chdir( opent );
|
|
break;
|
|
case DIR_STAT:
|
|
do_dir_stat( opent );
|
|
break;
|
|
default:
|
|
fprintf( stderr, "do_op: bad op entry: %s\n", opent->op_name );
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
traverse_tree( char *name )
|
|
{
|
|
int opcount;
|
|
struct configuration *configent;
|
|
struct operation *opent;
|
|
int lev;
|
|
int ignore_err = 0;
|
|
int files_checked = 0;
|
|
int dirs_checked = 0;
|
|
int toterror = 0;
|
|
char *dirinfo;
|
|
|
|
PROC_ENTER( "traverse_tree" );
|
|
mtestdir( name );
|
|
if ( getwd( StartDir ) == NULL ) {
|
|
fprintf( stderr, "traverse_tree: getwd: %s\n", StartDir );
|
|
exit( 1 );
|
|
} else {
|
|
if ( configent = lookup_config( "OPERATIONS" ) ) {
|
|
opcount = configent->cf_val;
|
|
while ( opcount-- ) {
|
|
if ( opent = select_op() ) {
|
|
do_op( opent );
|
|
} else {
|
|
fprintf( stderr,
|
|
"traverse_tree: operation selection error\n" );
|
|
exit( 1 );
|
|
}
|
|
}
|
|
} else {
|
|
fprintf( stderr,
|
|
"traverse_tree: unable to find operation count configurator\n" );
|
|
exit( 1 );
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
get_config( void )
|
|
{
|
|
char *path;
|
|
FILE *fp;
|
|
char config[256];
|
|
struct configuration *configent;
|
|
struct operation *opent;
|
|
char *tok;
|
|
char *getenv();
|
|
FILE *fopen();
|
|
|
|
PROC_ENTER( "get_config" );
|
|
if ( (path = getenv("NFSTESTCONF")) == NULL ) {
|
|
path = CONFIGPATH;
|
|
}
|
|
if ( fp = fopen( path, "r" ) ) {
|
|
if ( Verbose ) {
|
|
printf( "Configuration:\n " );
|
|
}
|
|
while ( fgets( config, 256, fp ) ) {
|
|
tok = strtok( config, " =" );
|
|
if ( !(configent = lookup_config( tok )) ) {
|
|
fprintf( stderr, "get_config: %s: invalid configurator\n",
|
|
config );
|
|
} else {
|
|
if ( Verbose ) {
|
|
printf( "\t%s = ", tok );
|
|
}
|
|
tok = strtok( NULL, " " );
|
|
if ( !tok ) {
|
|
fprintf( stderr, "get_config: %s: invalid configurator\n",
|
|
config );
|
|
} else {
|
|
configent->cf_val = atoi( tok );
|
|
if ( Verbose ) {
|
|
printf( "%d", configent->cf_val );
|
|
}
|
|
if ( configent->cf_opname ) {
|
|
opent = lookup_op_byname( configent->cf_opname,
|
|
configent->cf_optab );
|
|
if ( !opent ) {
|
|
fprintf( stderr,
|
|
"get_config: %s: invalid operation\n",
|
|
configent->cf_opname );
|
|
} else {
|
|
(*configent->cf_func)( opent, configent->cf_val );
|
|
}
|
|
}
|
|
}
|
|
if ( Verbose ) {
|
|
printf( "\n" );
|
|
}
|
|
}
|
|
}
|
|
(void)fclose( fp );
|
|
}
|
|
check_tables();
|
|
}
|
|
|
|
main( int argc, char **argv )
|
|
{
|
|
int opt;
|
|
int opterr = 0;
|
|
int parallel = 0;
|
|
int children = 0;
|
|
int pid;
|
|
int use_current_dir = 0;
|
|
int i;
|
|
int files_checked = 0;
|
|
int dirs_checked = 0;
|
|
int toterror = 0;
|
|
|
|
Progname = *argv;
|
|
while ( (opt = getopt( argc, argv, OPTSTR )) != -1 ) {
|
|
switch ( opt ) {
|
|
case 'p':
|
|
parallel = 1;
|
|
break;
|
|
case 'V':
|
|
Verbose++;
|
|
break;
|
|
deafult:
|
|
opterr++;
|
|
}
|
|
}
|
|
if ( opterr ) {
|
|
usage();
|
|
exit( 1 );
|
|
}
|
|
initialize();
|
|
get_config();
|
|
if ( optind >= argc ) {
|
|
use_current_dir = 1;
|
|
}
|
|
if ( Verbose ) {
|
|
printf( "%s:\n", Progname );
|
|
printf( "\ttarget directories:\n" );
|
|
if ( use_current_dir ) {
|
|
printf( "\t\tcurrent dir\n" );
|
|
} else {
|
|
for ( i = optind; i < argc; i++ ) {
|
|
printf( "\t\t%s\n", argv[i] );
|
|
}
|
|
}
|
|
}
|
|
if ( parallel ) {
|
|
for ( i = optind; i < argc; i++ ) {
|
|
if ( (pid = fork()) == -1 ) {
|
|
error( "main: fork error" );
|
|
} else if ( pid ) {
|
|
children++;
|
|
} else {
|
|
traverse_tree( argv[i] );
|
|
exit( 0 );
|
|
}
|
|
}
|
|
/*
|
|
* wait for all processes to finish
|
|
*/
|
|
while ( wait( NULL ) != -1 ) {
|
|
;
|
|
}
|
|
} else {
|
|
for ( i = optind; i < argc; i++ ) {
|
|
traverse_tree( argv[i] );
|
|
}
|
|
}
|
|
return( 0 );
|
|
}
|