int main(int argc, char *const *argv)
{
struct stat st;
off_t length = 0, offset = 0;
io_context_t myctx;
int c;
extern char *optarg;
extern int optind, opterr, optopt;
while ((c = getopt(argc, argv, "a:b:df:n:s:wzD:")) != -1) {
char *endp;
switch (c) {
case 'a': /* alignment of data buffer */
alignment = strtol(optarg, &endp, 0);
alignment = (long)scale_by_kmg((long long)alignment,
*endp);
break;
case 'f': /* use these open flags */
if (strcmp(optarg, "LARGEFILE") == 0 ||
strcmp(optarg, "O_LARGEFILE") == 0) {
source_open_flag |= O_LARGEFILE;
dest_open_flag |= O_LARGEFILE;
} else if (strcmp(optarg, "TRUNC") == 0 ||
strcmp(optarg, "O_TRUNC") == 0) {
dest_open_flag |= O_TRUNC;
} else if (strcmp(optarg, "SYNC") == 0 ||
strcmp(optarg, "O_SYNC") == 0) {
dest_open_flag |= O_SYNC;
} else if (strcmp(optarg, "DIRECT") == 0 ||
strcmp(optarg, "O_DIRECT") == 0) {
source_open_flag |= O_DIRECT;
dest_open_flag |= O_DIRECT;
} else if (strncmp(optarg, "CREAT", 5) == 0 ||
strncmp(optarg, "O_CREAT", 5) == 0) {
dest_open_flag |= O_CREAT;
}
break;
case 'd':
debug++;
break;
case 'D':
delay.tv_usec = atoi(optarg);
break;
case 'b': /* block size */
aio_blksize = strtol(optarg, &endp, 0);
aio_blksize = (long)scale_by_kmg((long long)aio_blksize, *endp);
break;
case 'n': /* num io */
aio_maxio = strtol(optarg, &endp, 0);
break;
case 's': /* size to transfer */
length = strtoll(optarg, &endp, 0);
length = scale_by_kmg(length, *endp);
break;
case 'w': /* no write */
no_write = 1;
break;
case 'z': /* write zero's */
zero = 1;
break;
default:
usage();
}
}
argc -= optind;
argv += optind;
#ifndef DEBUG
if (argc < 1) {
usage();
}
#else
source_open_flag |= O_DIRECT;
dest_open_flag |= O_DIRECT;
aio_blksize = 1;
aio_maxio=1;
srcname = "junkdata";
dstname = "ff2";
#endif
if (!zero) {
#ifndef DEBUG
if ((srcfd = open(srcname = *argv, source_open_flag)) < 0) {
#else
if ((srcfd = open(srcname, source_open_flag)) < 0) {
#endif
perror(srcname);
exit(1);
}
argv++;
argc--;
length = 1073741824;
#if 0
if (fstat(srcfd, &st) < 0) {
perror("fstat");
exit(1);
}
if (length == 0)
length = st.st_size;
#endif
}
if (!no_write) {
/*
* We are either copying or writing zeros to dstname
*/
#ifndef DEBUG
if (argc < 1) {
usage();
}
if ((dstfd = open(dstname = *argv, dest_open_flag, 0666)) < 0) {
#else
if ((dstfd = open(dstname, dest_open_flag, 0666)) < 0) {
#endif
perror(dstname);
exit(1);
}
if (zero) {
/*
* get size of dest, if we are zeroing it.
* TODO: handle devices.
*/
if (fstat(dstfd, &st) < 0) {
perror("fstat");
exit(1);
}
if (length == 0)
length = st.st_size;
}
}
/* initialize state machine */
memset(&myctx, 0, sizeof(myctx));
io_queue_init(aio_maxio, &myctx);
tocopy = howmany(length, aio_blksize);
if (init_iocb(aio_maxio, aio_blksize) < 0) {
fprintf(stderr, "Error allocating the i/o buffers\n");
exit(1);
}
while (tocopy > 0) {
int i, rc;
/* Submit as many reads as once as possible upto aio_maxio */
int n = MIN(MIN(aio_maxio - busy, aio_maxio),
howmany(length - offset, aio_blksize));
if (n > 0) {
struct iocb *ioq[n];
for (i = 0; i < n; i++) {
struct iocb *io = alloc_iocb();
int iosize = MIN(length - offset, aio_blksize);
if (zero) {
/*
* We are writing zero's to dstfd
*/
io_prep_pwrite(io, dstfd, io->u.c.buf,
iosize, offset);
io_set_callback(io, wr_done);
} else {
io_prep_pread(io, srcfd, io->u.c.buf,
iosize, offset);
io_set_callback(io, rd_done);
}
ioq[i] = io;
offset += iosize;
}
rc = io_submit(myctx, n, ioq);
if (rc < 0)
io_error("io_submit", rc);
busy += n;
if (debug > 1)
printf("io_submit(%d) busy:%d\n", n, busy);
if (delay.tv_usec) {
struct timeval t = delay;
(void)select(0,0,0,0,&t);
}
}
/*
* We have submitted all the i/o requests. Wait for at least one to complete
* and call the callbacks.
*/
count_io_q_waits++;
rc = io_wait_run(myctx, 0);
if (rc < 0)
io_error("io_wait_run", rc);
if (debug > 1) {
printf("io_wait_run: rc == %d\n", rc);
printf("busy:%d aio_maxio:%d tocopy:%d\n",
busy, aio_maxio, tocopy);
}
}
if (srcfd != -1)
close(srcfd);
if (dstfd != -1)
close(dstfd);
exit(0);
}
/* 一次提交多个io请求的操作 */
int io_tio(char *pathname, int flag, int n, int operation)
{
int res, fd = 0, i = 0;
void *bufptr = NULL;
off_t offset = 0;
struct timespec timeout;
io_context_t myctx;
struct iocb iocb_array[AIO_MAXIO];
struct iocb *iocbps[AIO_MAXIO];
fd = open(pathname, flag, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
if (fd <= 0) {
printf("open for %s failed: %s\n", pathname, strerror(errno));
return -1;
}
res = io_queue_init(n, &myctx);
//printf (" res = %d \n", res);
for (i = 0; i < AIO_MAXIO; i++) {
switch (operation) {
case IO_CMD_PWRITE:
if (posix_memalign(&bufptr, alignment, AIO_BLKSIZE)) {
perror(" posix_memalign failed ");
return -1;
}
memset(bufptr, 0, AIO_BLKSIZE);
io_prep_pwrite(&iocb_array[i], fd, bufptr,
AIO_BLKSIZE, offset);
io_set_callback(&iocb_array[i], work_done);
iocbps[i] = &iocb_array[i];
offset += AIO_BLKSIZE;
break;
case IO_CMD_PREAD:
if (posix_memalign(&bufptr, alignment, AIO_BLKSIZE)) {
perror(" posix_memalign failed ");
return -1;
}
memset(bufptr, 0, AIO_BLKSIZE);
io_prep_pread(&iocb_array[i], fd, bufptr,
AIO_BLKSIZE, offset);
io_set_callback(&iocb_array[i], work_done);
iocbps[i] = &iocb_array[i];
offset += AIO_BLKSIZE;
break;
case IO_CMD_POLL:
case IO_CMD_NOOP:
break;
default:
tst_resm(TFAIL,
"Command failed; opcode returned: %d\n",
operation);
return -1;
break;
}
}
do {
res = io_submit(myctx, AIO_MAXIO, iocbps);
} while (res == -EAGAIN);
if (res < 0) {
io_error("io_submit tio", res);
}
/*
* We have submitted all the i/o requests. Wait for at least one to complete
* and call the callbacks.
*/
wait_count = AIO_MAXIO;
timeout.tv_sec = 30;
timeout.tv_nsec = 0;
switch (operation) {
case IO_CMD_PREAD:
case IO_CMD_PWRITE:
{
while (wait_count) {
res = io_wait_run(myctx, &timeout);
if (res < 0)
io_error("io_wait_run", res);
}
}
break;
}
close(fd);
for (i = 0; i < AIO_MAXIO; i++) {
if (iocb_array[i].u.c.buf != NULL) {
free(iocb_array[i].u.c.buf);
}
}
io_queue_release(myctx);
return 0;
}
static int io_tio(char *pathname, int flag, int operation)
{
int res, fd = 0, i = 0;
void *bufptr = NULL;
off_t offset = 0;
struct timespec timeout;
struct stat fi_stat;
size_t alignment;
io_context_t myctx;
struct iocb iocb_array[AIO_MAXIO];
struct iocb *iocbps[AIO_MAXIO];
fd = SAFE_OPEN(pathname, flag, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
/* determine the alignment from the blksize of the underlying device */
SAFE_FSTAT(fd, &fi_stat);
alignment = fi_stat.st_blksize;
res = io_queue_init(AIO_MAXIO, &myctx);
for (i = 0; i < AIO_MAXIO; i++) {
switch (operation) {
case IO_CMD_PWRITE:
if (posix_memalign(&bufptr, alignment, AIO_BLKSIZE)) {
tst_brk(TBROK | TERRNO, "posix_memalign failed");
return -1;
}
memset(bufptr, 0, AIO_BLKSIZE);
io_prep_pwrite(&iocb_array[i], fd, bufptr,
AIO_BLKSIZE, offset);
io_set_callback(&iocb_array[i], work_done);
iocbps[i] = &iocb_array[i];
offset += AIO_BLKSIZE;
break;
case IO_CMD_PREAD:
if (posix_memalign(&bufptr, alignment, AIO_BLKSIZE)) {
tst_brk(TBROK | TERRNO, "posix_memalign failed");
return -1;
}
memset(bufptr, 0, AIO_BLKSIZE);
io_prep_pread(&iocb_array[i], fd, bufptr,
AIO_BLKSIZE, offset);
io_set_callback(&iocb_array[i], work_done);
iocbps[i] = &iocb_array[i];
offset += AIO_BLKSIZE;
break;
default:
tst_res(TFAIL, "Command failed; opcode returned: %d\n", operation);
return -1;
break;
}
}
do {
res = io_submit(myctx, AIO_MAXIO, iocbps);
} while (res == -EAGAIN);
if (res < 0)
io_error("io_submit tio", res);
/*
* We have submitted all the i/o requests. Wait for them to complete and
* call the callbacks.
*/
wait_count = AIO_MAXIO;
timeout.tv_sec = 30;
timeout.tv_nsec = 0;
switch (operation) {
case IO_CMD_PREAD:
case IO_CMD_PWRITE:
{
while (wait_count) {
res = io_wait_run(myctx, &timeout);
if (res < 0)
io_error("io_wait_run", res);
}
}
break;
}
SAFE_CLOSE(fd);
for (i = 0; i < AIO_MAXIO; i++)
if (iocb_array[i].u.c.buf != NULL)
free(iocb_array[i].u.c.buf);
io_queue_release(myctx);
return 0;
}
