#include <sys/time.h> /* for delays */
#include <ctype.h>
-#ifndef NO_XFS
struct io_req;
int do_xfsctl(struct io_req *);
-#endif
#include "doio.h"
#include "pattern.h"
int c_oflags;
int c_fd;
long c_rtc;
-#ifndef NO_XFS
int c_memalign; /* from xfsctl(XFS_IOC_DIOINFO) */
int c_miniosz;
int c_maxiosz;
-#endif
void *c_memaddr; /* mmapped address */
int c_memlen; /* length of above region */
};
case LEWRITEA:
rval = do_rw(&ioreq);
break;
-#ifndef NO_XFS
case RESVSP:
case UNRESVSP:
rval = do_xfsctl(&ioreq);
break;
-#endif
case FSYNC2:
case FDATASYNC:
rval = do_sync(&ioreq);
{
int fd, offset, nbytes, oflags, rval;
char *addr, *file;
-#ifndef NO_XFS
struct fd_cache *fdc;
-#endif
/*
* Initialize common fields - assumes r_oflags, r_file, r_offset, and
#define wtob(x) (x * sizeof(UINT64_T))
#endif
-#ifndef NO_XFS
/* get memory alignment for using DIRECT I/O */
fdc = alloc_fdcache(file, oflags);
} else {
addr += random_range(0, wtob(1) - 1, 1, NULL);
}
-#else
- if ((rval = alloc_mem(nbytes + wtob(1) * 2)) < 0) {
- return rval;
- }
-
- addr = Memptr;
-#endif /* !NO_XFS */
-
switch (req->r_type) {
case READ:
long offset, woffset = 0;
char *addr, pattern, *file, *msg;
struct wlog_rec wrec;
-#ifndef NO_XFS
struct fd_cache *fdc;
-#endif
/*
* Misc variable setup
* Allocate SDS space for backdoor write if desired
*/
-#ifndef NO_XFS
/* get memory alignment for using DIRECT I/O */
fdc = alloc_fdcache(file, oflags);
if( addr != Memptr )
memmove( addr, Memptr, nbytes);
-#else /* sgi */
- if ((rval = alloc_mem(nbytes + wtob(1) * 2)) < 0) {
- return rval;
- }
-
- addr = Memptr;
-
- (*Data_Fill)(Memptr, nbytes, Pattern, Pattern_Length, 0);
- if( addr != Memptr )
- memmove( addr, Memptr, nbytes);
-#endif /* sgi */
-
rval = -1;
got_lock = 0;
logged_write = 0;
"write() failed: %s (%d)\n%s\n",
SYSERR, errno,
format_rw(req, fd, addr, -1, Pattern, NULL));
-#ifndef NO_XFS
doio_fprintf(stderr,
"write() failed: %s\n\twrite(%d, %#o, %d)\n\toffset %d, nbytes%%miniou(%d)=%d, oflags=%#o memalign=%d, addr%%memalign=%d\n",
strerror(errno),
offset,
fdc->c_miniosz, nbytes%fdc->c_miniosz,
oflags, fdc->c_memalign, (long)addr%fdc->c_memalign);
-#else
- doio_fprintf(stderr,
- "write() failed: %s\n\twrite(%d, %#o, %d)\n\toffset %d, nbytes%%1B=%d, oflags=%#o\n",
- strerror(errno),
- fd, addr, nbytes,
- offset, nbytes%4096, oflags);
-#endif
doio_upanic(U_RVAL);
} else if (rval != nbytes) {
doio_fprintf(stderr,
cp += sprintf(cp, " memory alignment is %s\n",
(io->r_uflags & F_WORD_ALIGNED) ? "aligned" : "unaligned");
-#ifndef NO_XFS
if(io->r_oflags & O_DIRECT) {
struct dioattr finfo;
cp += sprintf(cp, " mem alignment 0x%x xfer size: small: %d large: %d\n",
finfo.d_mem, finfo.d_miniosz, finfo.d_maxiosz);
}
-#endif
-
return(errbuf);
}
struct status *s;
struct wlog_rec wrec;
struct syscall_info *sy;
-#ifndef NO_XFS
struct fd_cache *fdc;
-#endif
/*
* Initialize common fields - assumes r_oflags, r_file, r_offset, and
mem_needed = nbytes;
}
-#ifndef NO_XFS
/* get memory alignment for using DIRECT I/O */
fdc = alloc_fdcache(file, oflags);
if ((rval = alloc_mem(mem_needed + wtob(1) * 2 + fdc->c_memalign)) < 0) {
return rval;
}
-#else
- if ((rval = alloc_mem(mem_needed + wtob(1) * 2)) < 0) {
- return rval;
- }
-#endif
Pattern[0] = pattern;
addr += random_range(0, wtob(1) - 1, 1, NULL);
}
-#ifndef NO_XFS
/*
* Force memory alignment for Direct I/O
*/
if( (oflags & O_DIRECT) && ((long)addr % fdc->c_memalign != 0) ) {
addr += fdc->c_memalign - ((long)addr % fdc->c_memalign);
}
-#endif
/*
* FILL must be done on a word-aligned buffer.
* - XFS_IOC_RESVSP
* - XFS_IOC_UNRESVSP
*/
-#ifndef NO_XFS
int
do_xfsctl(req)
struct io_req *req;
return (rval == -1) ? -1 : 0;
}
-#endif
/*
* fsync(2) and fdatasync(2)
static char errbuf[4096];
int fd, nb, flags;
char *buf, *em, *ep;
-#ifndef NO_XFS
struct fd_cache *fdc;
-#endif
buf = Memptr;
return errbuf;
}
-#ifndef NO_XFS
/* Guarantee a properly aligned address on Direct I/O */
fdc = alloc_fdcache(file, flags);
if( (flags & O_DIRECT) && ((long)buf % fdc->c_memalign != 0) ) {
buf += fdc->c_memalign - ((long)buf % fdc->c_memalign);
}
-#endif
if ((nb = read(fd, buf, length)) == -1) {
-#ifndef NO_XFS
sprintf(errbuf,
"Could not read %d bytes from %s for verification: %s (%d)\n\tread(%d, 0x%p, %d)\n\tbuf %% alignment(%d) = %ld\n",
length, file, SYSERR, errno,
fd, buf, length,
fdc->c_memalign, (long)buf % fdc->c_memalign);
-#else
- sprintf(errbuf,
- "Could not read %d bytes from %s for verification: %s (%d)\n",
- length, file, SYSERR, errno);
-
-#endif
return errbuf;
}
struct fd_cache *free_slot, *oldest_slot, *cp;
static int cache_size = 0;
static struct fd_cache *cache = NULL;
-#ifndef NO_XFS
struct dioattr finfo;
-#endif
/*
* If file is NULL, it means to free up the fd cache.
strcpy(free_slot->c_file, file);
free_slot->c_rtc = Reqno;
-#ifndef NO_XFS
if (oflags & O_DIRECT) {
if (xfsctl(file, fd, XFS_IOC_DIOINFO, &finfo) == -1) {
finfo.d_mem = 1;
free_slot->c_memalign = finfo.d_mem;
free_slot->c_miniosz = finfo.d_miniosz;
free_slot->c_maxiosz = finfo.d_maxiosz;
-#endif
free_slot->c_memaddr = NULL;
free_slot->c_memlen = 0;
int set_sig();
void sig_handler();
static void notify_others();
-#ifndef NO_XFS
int pre_alloc();
-#endif
#define NEWIO 1 /* Use the tlibio.c functions */
char chr;
int ret;
int pre_alloc_space = 0;
-#ifndef NO_XFS
int total_grow_value = 0; /* used in pre-allocations */
-#endif
int backgrnd = 1; /* return control to user */
struct stat statbuf;
int time_iterval = -1;
case 'p' : /* pre allocate space */
-#ifdef NO_XFS
printf("%s%s: --p is illegal option on this system\n",
Progname, TagName);
exit(1);
-#else
- pre_alloc_space++;
-#endif
break;
case 'P':
Progname, Pid, num_files);
}
-#ifndef NO_XFS
if ( pre_alloc_space ) {
if ( iterations == 0 ) {
fprintf(stderr, "%s%s: %d %s/%d: can NOT pre-alloc and grow forever\n",
total_grow_value=bytes_to_consume;
}
}
-#endif
/*
* If delaying between iterations, get amount time to
lkfile(fd, LOCK_EX, LKLVL1); /* lock if lockfile is LKLVL1 */
-#ifndef NO_XFS
/*
* preallocation is only done once, if specified.
*/
Iter_cnt=0; /* reset outside loop to restart from one */
continue;
}
-#endif
/*
* grow file by desired amount.
}
}
}
-#ifndef NO_XFS
/*
* if Iter_cnt == 0, then we pre allocated space to all files
* and we are starting outside loop over. Set pre_alloc_space
if ( Iter_cnt == 0 ) {
pre_alloc_space=0;
}
-#endif
-
-
} /* end iteration for loop */
return 0;
}
-#ifndef NO_XFS
/***********************************************************************
*
***********************************************************************/
int size;
{
-#ifndef NO_XFS
#ifdef XFS_IOC_RESVSP
struct xfs_flock64 f;
__FILE__, __LINE__, errno, strerror(errno));
return -1;
}
-#endif
#endif
return 0;
}
-#endif
{ "write", WRITE, SY_WRITE },
{ "pread", PREAD },
{ "pwrite", PWRITE, SY_WRITE },
-#ifndef NO_XFS
{ "resvsp", RESVSP, SY_WRITE },
{ "unresvsp", UNRESVSP, SY_WRITE },
{ "reserve", RESVSP, SY_WRITE },
{ "unreserve", UNRESVSP, SY_WRITE },
-#endif
{ "readv", READV },
{ "writev", WRITEV, SY_WRITE },
{ "mmread", MMAPR },
struct file_info *rec;
{
struct stat sbuf;
-#ifndef NO_XFS
int fd;
struct dioattr finfo;
-#endif
/*
* Figure out if the files is regular, block or character special. Any
}
rec->f_riou = BSIZE;
-#ifndef NO_XFS
if( (fd = open(rec->f_path, O_RDWR|O_DIRECT, 0)) != -1 ) {
#ifdef XFS_IOC_DIOINFO
if(xfsctl(rec->f_path, fd, XFS_IOC_DIOINFO, &finfo) != -1) {
} else {
rec->f_riou = BBSIZE;
}
-#endif
} else {
rec->f_riou = BSIZE;
int fd, rval;
char c;
struct stat sbuf;
-#ifndef NO_XFS
int nb;
struct flock64 f;
struct fsxattr xattr;
struct dioattr finfo;
char *b, *buf;
-#endif
errno = 0;
rval = stat(path, &sbuf);
}
} else {
-#ifndef NO_XFS
/*
* The file must be designated as Real-Time before any data
* is allocated to it.
fprintf(stderr, "get: fsx_xflags = 0x%x\n",
xattr.fsx_xflags);
}
-#endif
}
/*
* file size.
*/
-#ifndef NO_XFS
if(Owrite == 2) {
close(fd);
if( (fd = open(path, O_CREAT|O_RDWR|O_DIRECT, 0)) != -1 ) {
}
free(b);
} else
-#endif
if(Owrite) {
/*fprintf(stderr,
"create_file_Owrite: lseek(%d, %d {%d}, SEEK_SET)\n",
case 'O':
nopenargs = string_to_tokens(optarg, openargs, 4, ":/");
-#ifndef NO_XFS
if(!strcmp(openargs[0], "realtime")) {
/*
* -O realtime:extsize
TagName, openargs[0]);
exit(1);
}
-#else
- Oflags = parse_open_flags(openargs[0], &errmsg);
- if(Oflags == -1) {
- fprintf(stderr, "iogen%s: -O %s error: %s\n", TagName, optarg, errmsg);
- exit(1);
- }
-#endif
-
O_opt++;
break;
fprintf(stream, "\t-a (Not used on Linux).\n");
#endif /* !linux */
fprintf(stream, "\t-f flag,... Flags to use for file IO. Supported flags are\n");
-#ifndef NO_XFS
fprintf(stream, "\t buffered, direct, sync.\n");
fprintf(stream, "\t Default is 'buffered,sync'.\n");
-#else
- fprintf(stream, "\t buffered, sync.\n");
- fprintf(stream, "\t Default is 'buffered,sync'.\n");
-#endif /* sgi */
fprintf(stream, "\t-h This help.\n");
fprintf(stream, "\t-i iterations[s] # of requests to generate. 0 means causes iogen\n");
fprintf(stream, "\t to run until it's killed. If iterations is suffixed\n");
fprintf(stream, "\t-N tagname Tag name, for Monster.\n");
fprintf(stream, "\t-o Form overlapping consecutive requests.\n");
fprintf(stream, "\t-O Open flags for creating files\n");
-#ifndef NO_XFS
fprintf(stream, "\t realtime:extsize - put file on real-time volume\n");
fprintf(stream, "\t allocate - allocate space with F_ALLOCSP\n");
fprintf(stream, "\t reserve - reserve space with F_RESVSP (default)\n");
fprintf(stream, "\t noreserve - do not reserve with F_RESVSP\n");
fprintf(stream, "\t direct - use O_DIRECT I/O to write to the file\n");
-#else
- fprintf(stream, "\t {O_SYNC,etc}\n");
-#endif
fprintf(stream, "\t-p Output pipe. Default is stdout.\n");
fprintf(stream, "\t-q Quiet mode. Normally iogen spits out info\n");
fprintf(stream, "\t about test files, options, etc. before starting.\n");
projects / xfstests-dev.git / commitdiff