int
msync_f(
int argc,
char **argv)
{
off64_t offset;
ssize_t length;
void *start;
int c, flags = 0;
size_t blocksize, sectsize;
while ((c = getopt(argc, argv, "ais")) != EOF) {
switch (c) {
case 'a':
flags |= MS_ASYNC;
break;
case 'i':
flags |= MS_INVALIDATE;
break;
case 's':
flags |= MS_SYNC;
break;
default:
return command_usage(&msync_cmd);
}
}
if (optind == argc) {
offset = mapping->offset;
length = mapping->length;
} else if (optind == argc - 2) {
init_cvtnum(&blocksize, §size);
offset = cvtnum(blocksize, sectsize, argv[optind]);
if (offset < 0) {
printf(_("non-numeric offset argument -- %s\n"),
argv[optind]);
return 0;
}
optind++;
length = cvtnum(blocksize, sectsize, argv[optind]);
if (length < 0) {
printf(_("non-numeric length argument -- %s\n"),
argv[optind]);
return 0;
}
} else {
return command_usage(&msync_cmd);
}
start = check_mapping_range(mapping, offset, length, 1);
if (!start)
return 0;
if (msync(start, length, flags) < 0)
perror("msync");
return 0;
}
static int discard_f(int argc, char **argv)
{
struct timeval t1, t2;
int Cflag = 0, qflag = 0;
int c, ret;
int64_t offset;
int count;
while ((c = getopt(argc, argv, "Cq")) != EOF) {
switch (c) {
case 'C':
Cflag = 1;
break;
case 'q':
qflag = 1;
break;
default:
return command_usage(&discard_cmd);
}
}
if (optind != argc - 2) {
return command_usage(&discard_cmd);
}
offset = cvtnum(argv[optind]);
if (offset < 0) {
printf("non-numeric length argument -- %s\n", argv[optind]);
return 0;
}
optind++;
count = cvtnum(argv[optind]);
if (count < 0) {
printf("non-numeric length argument -- %s\n", argv[optind]);
return 0;
}
gettimeofday(&t1, NULL);
ret = bdrv_discard(bs, offset >> BDRV_SECTOR_BITS,
count >> BDRV_SECTOR_BITS);
gettimeofday(&t2, NULL);
if (ret < 0) {
printf("discard failed: %s\n", strerror(-ret));
goto out;
}
/* Finally, report back -- -C gives a parsable format */
if (!qflag) {
t2 = tsub(t2, t1);
print_report("discard", &t2, offset, count, count, 1, Cflag);
}
out:
return 0;
}
static int alloc_f(int argc, char **argv)
{
int64_t offset, sector_num;
int nb_sectors, remaining;
char s1[64];
int num, sum_alloc;
int ret;
offset = cvtnum(argv[1]);
if (offset & 0x1ff) {
printf("offset %" PRId64 " is not sector aligned\n",
offset);
return 0;
}
if (argc == 3) {
nb_sectors = cvtnum(argv[2]);
} else {
nb_sectors = 1;
}
remaining = nb_sectors;
sum_alloc = 0;
sector_num = offset >> 9;
while (remaining) {
ret = bdrv_is_allocated(bs, sector_num, remaining, &num);
if (ret < 0) {
printf("is_allocated failed: %s\n", strerror(-ret));
return 0;
}
sector_num += num;
remaining -= num;
if (ret) {
sum_alloc += num;
}
if (num == 0) {
nb_sectors -= remaining;
remaining = 0;
}
}
cvtstr(offset, s1, sizeof(s1));
if (nb_sectors == 1)
printf("sector allocated at offset %s\n", s1);
else
printf("%d/%d sectors allocated at offset %s\n",
sum_alloc, nb_sectors, s1);
return 0;
}
static int aio_write_f(int argc, char **argv)
{
int nr_iov, c;
int pattern = 0xcd;
struct aio_ctx *ctx = g_new0(struct aio_ctx, 1);
while ((c = getopt(argc, argv, "CqP:")) != EOF) {
switch (c) {
case 'C':
ctx->Cflag = 1;
break;
case 'q':
ctx->qflag = 1;
break;
case 'P':
pattern = parse_pattern(optarg);
if (pattern < 0) {
g_free(ctx);
return 0;
}
break;
default:
g_free(ctx);
return command_usage(&aio_write_cmd);
}
}
if (optind > argc - 2) {
g_free(ctx);
return command_usage(&aio_write_cmd);
}
ctx->offset = cvtnum(argv[optind]);
if (ctx->offset < 0) {
printf("non-numeric length argument -- %s\n", argv[optind]);
g_free(ctx);
return 0;
}
optind++;
if (ctx->offset & 0x1ff) {
printf("offset %" PRId64 " is not sector aligned\n",
ctx->offset);
g_free(ctx);
return 0;
}
nr_iov = argc - optind;
ctx->buf = create_iovec(&ctx->qiov, &argv[optind], nr_iov, pattern);
if (ctx->buf == NULL) {
g_free(ctx);
return 0;
}
gettimeofday(&ctx->t1, NULL);
bdrv_aio_writev(bs, ctx->offset >> 9, &ctx->qiov,
ctx->qiov.size >> 9, aio_write_done, ctx);
return 0;
}
static int
alloc_f(int argc, char **argv)
{
int64_t offset;
int nb_sectors, remaining;
char s1[64];
int num, sum_alloc;
int ret;
offset = cvtnum(argv[1]);
if (offset & 0x1ff) {
printf("offset %lld is not sector aligned\n",
(long long)offset);
return 0;
}
if (argc == 3)
nb_sectors = cvtnum(argv[2]);
else
nb_sectors = 1;
remaining = nb_sectors;
sum_alloc = 0;
while (remaining) {
ret = bdrv_is_allocated(bs, offset >> 9, nb_sectors, &num);
remaining -= num;
if (ret) {
sum_alloc += num;
}
}
cvtstr(offset, s1, sizeof(s1));
if (nb_sectors == 1)
printf("sector allocated at offset %s\n", s1);
else
printf("%d/%d sectors allocated at offset %s\n",
sum_alloc, nb_sectors, s1);
return 0;
}
/*
* Parse multiple length statements for vectored I/O, and construct an I/O
* vector matching it.
*/
static void *
create_iovec(QEMUIOVector *qiov, char **argv, int nr_iov, int pattern)
{
size_t *sizes = g_new0(size_t, nr_iov);
size_t count = 0;
void *buf = NULL;
void *p;
int i;
for (i = 0; i < nr_iov; i++) {
char *arg = argv[i];
int64_t len;
len = cvtnum(arg);
if (len < 0) {
printf("non-numeric length argument -- %s\n", arg);
goto fail;
}
/* should be SIZE_T_MAX, but that doesn't exist */
if (len > INT_MAX) {
printf("too large length argument -- %s\n", arg);
goto fail;
}
if (len & 0x1ff) {
printf("length argument %" PRId64
" is not sector aligned\n", len);
goto fail;
}
sizes[i] = len;
count += len;
}
qemu_iovec_init(qiov, nr_iov);
buf = p = qemu_io_alloc(count, pattern);
for (i = 0; i < nr_iov; i++) {
qemu_iovec_add(qiov, p, sizes[i]);
p += sizes[i];
}
fail:
g_free(sizes);
return buf;
}
static int
extsize_f(
int argc,
char **argv)
{
size_t blocksize, sectsize;
int c;
recurse_all = recurse_dir = 0;
init_cvtnum(&blocksize, §size);
while ((c = getopt(argc, argv, "DR")) != EOF) {
switch (c) {
case 'D':
recurse_all = 0;
recurse_dir = 1;
break;
case 'R':
recurse_all = 1;
recurse_dir = 0;
break;
default:
return command_usage(&extsize_cmd);
}
}
if (optind < argc) {
extsize = (long)cvtnum(blocksize, sectsize, argv[optind]);
if (extsize < 0) {
printf(_("non-numeric extsize argument -- %s\n"),
argv[optind]);
return 0;
}
} else {
extsize = -1;
}
if (recurse_all || recurse_dir)
nftw(file->name, (extsize >= 0) ?
set_extsize_callback : get_extsize_callback,
100, FTW_PHYS | FTW_MOUNT | FTW_DEPTH);
else if (extsize >= 0)
set_extsize(file->name, file->fd, extsize);
else
get_extsize(file->name, file->fd);
return 0;
}
static int truncate_f(int argc, char **argv)
{
int64_t offset;
int ret;
offset = cvtnum(argv[1]);
if (offset < 0) {
printf("non-numeric truncate argument -- %s\n", argv[1]);
return 0;
}
ret = bdrv_truncate(bs, offset);
if (ret < 0) {
printf("truncate: %s\n", strerror(-ret));
return 0;
}
return 0;
}
int
mremap_f(
int argc,
char **argv)
{
ssize_t new_length;
void *new_addr;
int flags = 0;
int c;
size_t blocksize, sectsize;
while ((c = getopt(argc, argv, "fm")) != EOF) {
switch (c) {
case 'f':
flags = MREMAP_FIXED|MREMAP_MAYMOVE;
break;
case 'm':
flags = MREMAP_MAYMOVE;
break;
default:
return command_usage(&mremap_cmd);
}
}
init_cvtnum(&blocksize, §size);
new_length = cvtnum(blocksize, sectsize, argv[optind]);
if (new_length < 0) {
printf(_("non-numeric offset argument -- %s\n"),
argv[optind]);
return 0;
}
new_addr = mremap(mapping->addr, mapping->length, new_length, flags);
if (new_addr == MAP_FAILED)
perror("mremap");
else {
mapping->addr = new_addr;
mapping->length = new_length;
}
return 0;
}
static int
truncate_f(
int argc,
char **argv)
{
off64_t offset;
size_t blocksize, sectsize;
init_cvtnum(&blocksize, §size);
offset = cvtnum(blocksize, sectsize, argv[1]);
if (offset < 0) {
printf(_("non-numeric truncate argument -- %s\n"), argv[1]);
return 0;
}
if (ftruncate64(file->fd, offset) < 0) {
perror("ftruncate");
return 0;
}
return 0;
}
static int
pread_f(
int argc,
char **argv)
{
size_t bsize;
off64_t offset;
unsigned int zeed = 0;
long long count, total, tmp;
size_t fsblocksize, fssectsize;
struct timeval t1, t2;
char s1[64], s2[64], ts[64];
char *sp;
int Cflag, qflag, uflag, vflag;
int eof = 0, direction = IO_FORWARD;
int c;
Cflag = qflag = uflag = vflag = 0;
init_cvtnum(&fsblocksize, &fssectsize);
bsize = fsblocksize;
while ((c = getopt(argc, argv, "b:BCFRquvV:Z:")) != EOF) {
switch (c) {
case 'b':
tmp = cvtnum(fsblocksize, fssectsize, optarg);
if (tmp < 0) {
printf(_("non-numeric bsize -- %s\n"), optarg);
return 0;
}
bsize = tmp;
break;
case 'C':
Cflag = 1;
break;
case 'F':
direction = IO_FORWARD;
break;
case 'B':
direction = IO_BACKWARD;
break;
case 'R':
direction = IO_RANDOM;
break;
case 'q':
qflag = 1;
break;
case 'u':
uflag = 1;
break;
case 'v':
vflag = 1;
break;
#ifdef HAVE_PREADV
case 'V':
vectors = strtoul(optarg, &sp, 0);
if (!sp || sp == optarg) {
printf(_("non-numeric vector count == %s\n"),
optarg);
return 0;
}
break;
#endif
case 'Z':
zeed = strtoul(optarg, &sp, 0);
if (!sp || sp == optarg) {
printf(_("non-numeric seed -- %s\n"), optarg);
return 0;
}
break;
default:
return command_usage(&pread_cmd);
}
}
if (optind != argc - 2)
return command_usage(&pread_cmd);
offset = cvtnum(fsblocksize, fssectsize, argv[optind]);
if (offset < 0 && (direction & (IO_RANDOM|IO_BACKWARD))) {
eof = -1; /* read from EOF */
} else if (offset < 0) {
printf(_("non-numeric length argument -- %s\n"), argv[optind]);
return 0;
}
optind++;
count = cvtnum(fsblocksize, fssectsize, argv[optind]);
if (count < 0 && (direction & (IO_RANDOM|IO_FORWARD))) {
eof = -1; /* read to EOF */
} else if (count < 0) {
printf(_("non-numeric length argument -- %s\n"), argv[optind]);
return 0;
}
if (alloc_buffer(bsize, uflag, 0xabababab) < 0)
return 0;
gettimeofday(&t1, NULL);
switch (direction) {
case IO_RANDOM:
if (!zeed) /* srandom seed */
zeed = time(NULL);
c = read_random(file->fd, offset, count, &total, zeed, eof);
break;
case IO_FORWARD:
c = read_forward(file->fd, offset, count, &total, vflag, 0, eof);
if (eof)
count = total;
break;
case IO_BACKWARD:
c = read_backward(file->fd, &offset, &count, &total, eof);
break;
default:
ASSERT(0);
}
if (c < 0)
return 0;
if (qflag)
return 0;
gettimeofday(&t2, NULL);
t2 = tsub(t2, t1);
/* Finally, report back -- -C gives a parsable format */
timestr(&t2, ts, sizeof(ts), Cflag ? VERBOSE_FIXED_TIME : 0);
if (!Cflag) {
cvtstr((double)total, s1, sizeof(s1));
cvtstr(tdiv((double)total, t2), s2, sizeof(s2));
printf(_("read %lld/%lld bytes at offset %lld\n"),
total, count, (long long)offset);
printf(_("%s, %d ops; %s (%s/sec and %.4f ops/sec)\n"),
s1, c, ts, s2, tdiv((double)c, t2));
} else {/* bytes,ops,time,bytes/sec,ops/sec */
printf("%lld,%d,%s,%.3f,%.3f\n",
total, c, ts,
tdiv((double)total, t2), tdiv((double)c, t2));
}
return 0;
}
static char *
evalvar(char *p, int flag)
{
int subtype;
int varflags;
char *var;
const char *val;
int patloc;
int c;
int set;
int special;
int startloc;
int varlen;
int varlenb;
int easy;
int quotes = flag & (EXP_FULL | EXP_CASE);
int record = 0;
varflags = (unsigned char)*p++;
subtype = varflags & VSTYPE;
var = p;
special = 0;
if (! is_name(*p))
special = 1;
p = strchr(p, '=') + 1;
again: /* jump here after setting a variable with ${var=text} */
if (varflags & VSLINENO) {
set = 1;
special = 1;
val = NULL;
} else if (special) {
set = varisset(var, varflags & VSNUL);
val = NULL;
} else {
val = bltinlookup(var, 1);
if (val == NULL || ((varflags & VSNUL) && val[0] == '\0')) {
val = NULL;
set = 0;
} else
set = 1;
}
varlen = 0;
startloc = expdest - stackblock();
if (!set && uflag && *var != '@' && *var != '*') {
switch (subtype) {
case VSNORMAL:
case VSTRIMLEFT:
case VSTRIMLEFTMAX:
case VSTRIMRIGHT:
case VSTRIMRIGHTMAX:
case VSLENGTH:
error("%.*s: parameter not set", (int)(p - var - 1),
var);
}
}
if (set && subtype != VSPLUS) {
/* insert the value of the variable */
if (special) {
if (varflags & VSLINENO)
STPUTBIN(var, p - var - 1, expdest);
else
varvalue(var, varflags & VSQUOTE, subtype, flag);
if (subtype == VSLENGTH) {
varlenb = expdest - stackblock() - startloc;
varlen = varlenb;
if (localeisutf8) {
val = stackblock() + startloc;
for (;val != expdest; val++)
if ((*val & 0xC0) == 0x80)
varlen--;
}
STADJUST(-varlenb, expdest);
}
} else {
if (subtype == VSLENGTH) {
for (;*val; val++)
if (!localeisutf8 ||
(*val & 0xC0) != 0x80)
varlen++;
}
else
strtodest(val, flag, subtype,
varflags & VSQUOTE);
}
}
if (subtype == VSPLUS)
set = ! set;
easy = ((varflags & VSQUOTE) == 0 ||
(*var == '@' && shellparam.nparam != 1));
switch (subtype) {
case VSLENGTH:
expdest = cvtnum(varlen, expdest);
record = 1;
break;
case VSNORMAL:
record = easy;
break;
case VSPLUS:
case VSMINUS:
if (!set) {
argstr(p, flag | (flag & EXP_FULL ? EXP_SPLIT_LIT : 0) |
(varflags & VSQUOTE ? EXP_LIT_QUOTED : 0));
break;
}
record = easy;
break;
case VSTRIMLEFT:
case VSTRIMLEFTMAX:
case VSTRIMRIGHT:
case VSTRIMRIGHTMAX:
if (!set)
break;
/*
* Terminate the string and start recording the pattern
* right after it
*/
STPUTC('\0', expdest);
patloc = expdest - stackblock();
if (subevalvar(p, NULL, patloc, subtype,
startloc, varflags, quotes) == 0) {
int amount = (expdest - stackblock() - patloc) + 1;
STADJUST(-amount, expdest);
}
/* Remove any recorded regions beyond start of variable */
removerecordregions(startloc);
record = 1;
break;
case VSASSIGN:
case VSQUESTION:
if (!set) {
if (subevalvar(p, var, 0, subtype, startloc, varflags,
quotes)) {
varflags &= ~VSNUL;
/*
* Remove any recorded regions beyond
* start of variable
*/
removerecordregions(startloc);
goto again;
}
break;
}
record = easy;
break;
case VSERROR:
c = p - var - 1;
error("${%.*s%s}: Bad substitution", c, var,
(c > 0 && *p != CTLENDVAR) ? "..." : "");
default:
abort();
}
if (record)
recordregion(startloc, expdest - stackblock(),
varflags & VSQUOTE || (ifsset() && ifsval()[0] == '\0' &&
(*var == '@' || *var == '*')));
if (subtype != VSNORMAL) { /* skip to end of alternative */
int nesting = 1;
for (;;) {
if ((c = *p++) == CTLESC)
p++;
else if (c == CTLBACKQ || c == (CTLBACKQ|CTLQUOTE)) {
if (set)
argbackq = argbackq->next;
} else if (c == CTLVAR) {
if ((*p++ & VSTYPE) != VSNORMAL)
nesting++;
} else if (c == CTLENDVAR) {
if (--nesting == 0)
break;
}
}
}
return p;
}
static void
varvalue(const char *name, int quoted, int subtype, int flag)
{
int num;
char *p;
int i;
char sep[2];
char **ap;
switch (*name) {
case '$':
num = rootpid;
break;
case '?':
num = oexitstatus;
break;
case '#':
num = shellparam.nparam;
break;
case '!':
num = backgndpidval();
break;
case '-':
for (i = 0 ; i < NOPTS ; i++) {
if (optlist[i].val)
STPUTC(optlist[i].letter, expdest);
}
return;
case '@':
if (flag & EXP_FULL && quoted) {
for (ap = shellparam.p ; (p = *ap++) != NULL ; ) {
strtodest(p, flag, subtype, quoted);
if (*ap)
STPUTC('\0', expdest);
}
return;
}
/* FALLTHROUGH */
case '*':
if (ifsset())
sep[0] = ifsval()[0];
else
sep[0] = ' ';
sep[1] = '\0';
for (ap = shellparam.p ; (p = *ap++) != NULL ; ) {
strtodest(p, flag, subtype, quoted);
if (!*ap)
break;
if (sep[0])
strtodest(sep, flag, subtype, quoted);
else if (flag & EXP_FULL && !quoted && **ap != '\0')
STPUTC('\0', expdest);
}
return;
default:
if (is_digit(*name)) {
num = atoi(name);
if (num == 0)
p = arg0;
else if (num > 0 && num <= shellparam.nparam)
p = shellparam.p[num - 1];
else
return;
strtodest(p, flag, subtype, quoted);
}
return;
}
expdest = cvtnum(num, expdest);
}
int main(int argc, char **argv)
{
int fd;
char *fname;
int opt;
loff_t length = -2LL;
loff_t offset = 0;
int falloc_mode = 0;
int error;
int tflag = 0;
while ((opt = getopt(argc, argv, "nl:ot")) != -1) {
switch(opt) {
case 'n':
/* do not change filesize */
falloc_mode = FALLOC_FL_KEEP_SIZE;
break;
case 'l':
length = cvtnum(optarg);
break;
case 'o':
offset = cvtnum(optarg);
break;
case 't':
tflag++;
break;
default:
usage();
}
}
if (length == -2LL) {
printf("Error: no length argument specified\n");
usage();
}
if (length <= 0) {
printf("Error: invalid length value specified\n");
usage();
}
if (offset < 0) {
printf("Error: invalid offset value specified\n");
usage();
}
if (tflag && (falloc_mode & FALLOC_FL_KEEP_SIZE)) {
printf("-n and -t options incompatible\n");
usage();
}
if (tflag && offset) {
printf("-n and -o options incompatible\n");
usage();
}
if (optind == argc) {
printf("Error: no filename specified\n");
usage();
}
fname = argv[optind++];
/* Should we create the file if it doesn't already exist? */
fd = open(fname, O_WRONLY|O_LARGEFILE);
if (fd < 0) {
perror("Error opening file");
exit(EXIT_FAILURE);
}
if (tflag)
error = ftruncate(fd, length);
else
error = syscall(SYS_fallocate, fd, falloc_mode, offset, length);
if (error < 0) {
perror("fallocate failed");
exit(EXIT_FAILURE);
}
close(fd);
return 0;
}
int main(int argc, char **argv)
{
int c;
int fd;
int mode = 0;
int dig = 0;
loff_t length = -2LL;
loff_t offset = 0;
static const struct option longopts[] = {
{ "help", 0, 0, 'h' },
{ "version", 0, 0, 'V' },
{ "keep-size", 0, 0, 'n' },
{ "punch-hole", 0, 0, 'p' },
{ "collapse-range", 0, 0, 'c' },
{ "dig-holes", 0, 0, 'd' },
{ "insert-range", 0, 0, 'i' },
{ "zero-range", 0, 0, 'z' },
{ "offset", 1, 0, 'o' },
{ "length", 1, 0, 'l' },
{ "verbose", 0, 0, 'v' },
{ NULL, 0, 0, 0 }
};
static const ul_excl_t excl[] = { /* rows and cols in in ASCII order */
{ 'c', 'd', 'p', 'z' },
{ 'c', 'n' },
{ 0 }
};
int excl_st[ARRAY_SIZE(excl)] = UL_EXCL_STATUS_INIT;
setlocale(LC_ALL, "");
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
atexit(close_stdout);
while ((c = getopt_long(argc, argv, "hvVncpdizl:o:", longopts, NULL))
!= -1) {
err_exclusive_options(c, longopts, excl, excl_st);
switch(c) {
case 'h':
usage(stdout);
break;
case 'c':
mode |= FALLOC_FL_COLLAPSE_RANGE;
break;
case 'd':
dig = 1;
break;
case 'i':
mode |= FALLOC_FL_INSERT_RANGE;
break;
case 'l':
length = cvtnum(optarg);
break;
case 'n':
mode |= FALLOC_FL_KEEP_SIZE;
break;
case 'o':
offset = cvtnum(optarg);
break;
case 'p':
mode |= FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE;
break;
case 'z':
mode |= FALLOC_FL_ZERO_RANGE;
break;
case 'v':
verbose++;
break;
case 'V':
printf(UTIL_LINUX_VERSION);
return EXIT_SUCCESS;
default:
usage(stderr);
break;
}
}
if (optind == argc)
errx(EXIT_FAILURE, _("no filename specified"));
filename = argv[optind++];
if (optind != argc)
errx(EXIT_FAILURE, _("unexpected number of arguments"));
if (dig) {
/* for --dig-holes the default is analyze all file */
if (length == -2LL)
length = 0;
if (length < 0)
errx(EXIT_FAILURE, _("invalid length value specified"));
} else {
/* it's safer to require the range specification (--length --offset) */
if (length == -2LL)
errx(EXIT_FAILURE, _("no length argument specified"));
if (length <= 0)
errx(EXIT_FAILURE, _("invalid length value specified"));
}
if (offset < 0)
errx(EXIT_FAILURE, _("invalid offset value specified"));
/* O_CREAT makes sense only for the default fallocate(2) behavior
* when mode is no specified and new space is allocated */
fd = open(filename, O_RDWR | (!dig && !mode ? O_CREAT : 0),
S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH);
if (fd < 0)
err(EXIT_FAILURE, _("cannot open %s"), filename);
if (dig)
dig_holes(fd, offset, length);
else
xfallocate(fd, mode, offset, length);
if (close_fd(fd) != 0)
err(EXIT_FAILURE, _("write failed: %s"), filename);
return EXIT_SUCCESS;
}
static int
multiwrite_f(int argc, char **argv)
{
struct timeval t1, t2;
int Cflag = 0, qflag = 0;
int c, cnt;
char **buf;
int64_t offset, first_offset = 0;
int total = 0;
int nr_iov;
int nr_reqs;
int pattern = 0xcd;
QEMUIOVector *qiovs;
int i;
BlockRequest *reqs;
while ((c = getopt(argc, argv, "CqP:")) != EOF) {
switch (c) {
case 'C':
Cflag = 1;
break;
case 'q':
qflag = 1;
break;
case 'P':
pattern = parse_pattern(optarg);
if (pattern < 0)
return 0;
break;
default:
return command_usage(&writev_cmd);
}
}
if (optind > argc - 2)
return command_usage(&writev_cmd);
nr_reqs = 1;
for (i = optind; i < argc; i++) {
if (!strcmp(argv[i], ";")) {
nr_reqs++;
}
}
reqs = qemu_malloc(nr_reqs * sizeof(*reqs));
buf = qemu_malloc(nr_reqs * sizeof(*buf));
qiovs = qemu_malloc(nr_reqs * sizeof(*qiovs));
for (i = 0; i < nr_reqs; i++) {
int j;
offset = cvtnum(argv[optind]);
if (offset < 0) {
printf("non-numeric offset argument -- %s\n", argv[optind]);
return 0;
}
optind++;
if (offset & 0x1ff) {
printf("offset %lld is not sector aligned\n",
(long long)offset);
return 0;
}
if (i == 0) {
first_offset = offset;
}
for (j = optind; j < argc; j++) {
if (!strcmp(argv[j], ";")) {
break;
}
}
nr_iov = j - optind;
reqs[i].qiov = &qiovs[i];
buf[i] = create_iovec(reqs[i].qiov, &argv[optind], nr_iov, pattern);
reqs[i].sector = offset >> 9;
reqs[i].nb_sectors = reqs[i].qiov->size >> 9;
optind = j + 1;
offset += reqs[i].qiov->size;
pattern++;
}
gettimeofday(&t1, NULL);
cnt = do_aio_multiwrite(reqs, nr_reqs, &total);
gettimeofday(&t2, NULL);
if (cnt < 0) {
printf("aio_multiwrite failed: %s\n", strerror(-cnt));
goto out;
}
if (qflag)
goto out;
t2 = tsub(t2, t1);
print_report("wrote", &t2, first_offset, total, total, cnt, Cflag);
out:
for (i = 0; i < nr_reqs; i++) {
qemu_io_free(buf[i]);
qemu_iovec_destroy(&qiovs[i]);
}
qemu_free(buf);
qemu_free(reqs);
qemu_free(qiovs);
return 0;
}
static int
aio_read_f(int argc, char **argv)
{
int nr_iov, c;
struct aio_ctx *ctx = calloc(1, sizeof(struct aio_ctx));
BlockDriverAIOCB *acb;
while ((c = getopt(argc, argv, "CP:qv")) != EOF) {
switch (c) {
case 'C':
ctx->Cflag = 1;
break;
case 'P':
ctx->Pflag = 1;
ctx->pattern = parse_pattern(optarg);
if (ctx->pattern < 0)
return 0;
break;
case 'q':
ctx->qflag = 1;
break;
case 'v':
ctx->vflag = 1;
break;
default:
free(ctx);
return command_usage(&aio_read_cmd);
}
}
if (optind > argc - 2) {
free(ctx);
return command_usage(&aio_read_cmd);
}
ctx->offset = cvtnum(argv[optind]);
if (ctx->offset < 0) {
printf("non-numeric length argument -- %s\n", argv[optind]);
free(ctx);
return 0;
}
optind++;
if (ctx->offset & 0x1ff) {
printf("offset %" PRId64 " is not sector aligned\n",
ctx->offset);
free(ctx);
return 0;
}
nr_iov = argc - optind;
ctx->buf = create_iovec(&ctx->qiov, &argv[optind], nr_iov, 0xab);
gettimeofday(&ctx->t1, NULL);
acb = bdrv_aio_readv(bs, ctx->offset >> 9, &ctx->qiov,
ctx->qiov.size >> 9, aio_read_done, ctx);
if (!acb) {
free(ctx->buf);
free(ctx);
return -EIO;
}
return 0;
}
static int readv_f(int argc, char **argv)
{
struct timeval t1, t2;
int Cflag = 0, qflag = 0, vflag = 0;
int c, cnt;
char *buf;
int64_t offset;
/* Some compilers get confused and warn if this is not initialized. */
int total = 0;
int nr_iov;
QEMUIOVector qiov;
int pattern = 0;
int Pflag = 0;
while ((c = getopt(argc, argv, "CP:qv")) != EOF) {
switch (c) {
case 'C':
Cflag = 1;
break;
case 'P':
Pflag = 1;
pattern = parse_pattern(optarg);
if (pattern < 0) {
return 0;
}
break;
case 'q':
qflag = 1;
break;
case 'v':
vflag = 1;
break;
default:
return command_usage(&readv_cmd);
}
}
if (optind > argc - 2) {
return command_usage(&readv_cmd);
}
offset = cvtnum(argv[optind]);
if (offset < 0) {
printf("non-numeric length argument -- %s\n", argv[optind]);
return 0;
}
optind++;
if (offset & 0x1ff) {
printf("offset %" PRId64 " is not sector aligned\n",
offset);
return 0;
}
nr_iov = argc - optind;
buf = create_iovec(&qiov, &argv[optind], nr_iov, 0xab);
if (buf == NULL) {
return 0;
}
gettimeofday(&t1, NULL);
cnt = do_aio_readv(&qiov, offset, &total);
gettimeofday(&t2, NULL);
if (cnt < 0) {
printf("readv failed: %s\n", strerror(-cnt));
goto out;
}
if (Pflag) {
void *cmp_buf = g_malloc(qiov.size);
memset(cmp_buf, pattern, qiov.size);
if (memcmp(buf, cmp_buf, qiov.size)) {
printf("Pattern verification failed at offset %"
PRId64 ", %zd bytes\n", offset, qiov.size);
}
g_free(cmp_buf);
}
if (qflag) {
goto out;
}
if (vflag) {
dump_buffer(buf, offset, qiov.size);
}
/* Finally, report back -- -C gives a parsable format */
t2 = tsub(t2, t1);
print_report("read", &t2, offset, qiov.size, total, cnt, Cflag);
out:
qemu_iovec_destroy(&qiov);
qemu_io_free(buf);
return 0;
}
static int writev_f(int argc, char **argv)
{
struct timeval t1, t2;
int Cflag = 0, qflag = 0;
int c, cnt;
char *buf;
int64_t offset;
/* Some compilers get confused and warn if this is not initialized. */
int total = 0;
int nr_iov;
int pattern = 0xcd;
QEMUIOVector qiov;
while ((c = getopt(argc, argv, "CqP:")) != EOF) {
switch (c) {
case 'C':
Cflag = 1;
break;
case 'q':
qflag = 1;
break;
case 'P':
pattern = parse_pattern(optarg);
if (pattern < 0) {
return 0;
}
break;
default:
return command_usage(&writev_cmd);
}
}
if (optind > argc - 2) {
return command_usage(&writev_cmd);
}
offset = cvtnum(argv[optind]);
if (offset < 0) {
printf("non-numeric length argument -- %s\n", argv[optind]);
return 0;
}
optind++;
if (offset & 0x1ff) {
printf("offset %" PRId64 " is not sector aligned\n",
offset);
return 0;
}
nr_iov = argc - optind;
buf = create_iovec(&qiov, &argv[optind], nr_iov, pattern);
if (buf == NULL) {
return 0;
}
gettimeofday(&t1, NULL);
cnt = do_aio_writev(&qiov, offset, &total);
gettimeofday(&t2, NULL);
if (cnt < 0) {
printf("writev failed: %s\n", strerror(-cnt));
goto out;
}
if (qflag) {
goto out;
}
/* Finally, report back -- -C gives a parsable format */
t2 = tsub(t2, t1);
print_report("wrote", &t2, offset, qiov.size, total, cnt, Cflag);
out:
qemu_iovec_destroy(&qiov);
qemu_io_free(buf);
return 0;
}
STATIC char *
evalvar(shinstance *psh, char *p, int flag)
{
int subtype;
int varflags;
char *var;
char *val;
int patloc;
int c;
int set;
int special;
int startloc;
int varlen;
int apply_ifs;
int quotes = flag & (EXP_FULL | EXP_CASE);
varflags = (unsigned char)*p++;
subtype = varflags & VSTYPE;
var = p;
special = !is_name(*p);
p = strchr(p, '=') + 1;
again: /* jump here after setting a variable with ${var=text} */
if (special) {
set = varisset(psh, var, varflags & VSNUL);
val = NULL;
} else {
val = lookupvar(psh, var);
if (val == NULL || ((varflags & VSNUL) && val[0] == '\0')) {
val = NULL;
set = 0;
} else
set = 1;
}
varlen = 0;
startloc = (int)(psh->expdest - stackblock(psh));
if (!set && uflag(psh)) {
switch (subtype) {
case VSNORMAL:
case VSTRIMLEFT:
case VSTRIMLEFTMAX:
case VSTRIMRIGHT:
case VSTRIMRIGHTMAX:
case VSLENGTH:
error(psh, "%.*s: parameter not set", p - var - 1, var);
/* NOTREACHED */
}
}
if (set && subtype != VSPLUS) {
/* insert the value of the variable */
if (special) {
varvalue(psh, var, varflags & VSQUOTE, subtype, flag);
if (subtype == VSLENGTH) {
varlen = (int)(psh->expdest - stackblock(psh) - startloc);
STADJUST(psh, -varlen, psh->expdest);
}
} else {
char const *syntax = (varflags & VSQUOTE) ? DQSYNTAX
: BASESYNTAX;
if (subtype == VSLENGTH) {
for (;*val; val++)
varlen++;
} else {
while (*val) {
if (quotes && syntax[(int)*val] == CCTL)
STPUTC(psh, CTLESC, psh->expdest);
STPUTC(psh, *val++, psh->expdest);
}
}
}
}
apply_ifs = ((varflags & VSQUOTE) == 0 ||
(*var == '@' && psh->shellparam.nparam != 1));
switch (subtype) {
case VSLENGTH:
psh->expdest = cvtnum(psh, varlen, psh->expdest);
break;
case VSNORMAL:
break;
case VSPLUS:
set = !set;
/* FALLTHROUGH */
case VSMINUS:
if (!set) {
argstr(psh, p, flag | (apply_ifs ? EXP_IFS_SPLIT : 0));
/*
* ${x-a b c} doesn't get split, but removing the
* 'apply_ifs = 0' apparantly breaks ${1+"$@"}..
* ${x-'a b' c} should generate 2 args.
*/
/* We should have marked stuff already */
apply_ifs = 0;
}
break;
case VSTRIMLEFT:
case VSTRIMLEFTMAX:
case VSTRIMRIGHT:
case VSTRIMRIGHTMAX:
if (!set)
break;
/*
* Terminate the string and start recording the pattern
* right after it
*/
STPUTC(psh, '\0', psh->expdest);
patloc = (int)(psh->expdest - stackblock(psh));
if (subevalvar(psh, p, NULL, patloc, subtype,
startloc, varflags) == 0) {
int amount = (int)(psh->expdest - stackblock(psh) - patloc) + 1;
STADJUST(psh, -amount, psh->expdest);
}
/* Remove any recorded regions beyond start of variable */
removerecordregions(psh, startloc);
apply_ifs = 1;
break;
case VSASSIGN:
case VSQUESTION:
if (set)
break;
if (subevalvar(psh, p, var, 0, subtype, startloc, varflags)) {
varflags &= ~VSNUL;
/*
* Remove any recorded regions beyond
* start of variable
*/
removerecordregions(psh, startloc);
goto again;
}
apply_ifs = 0;
break;
default:
sh_abort(psh);
}
if (apply_ifs)
recordregion(psh, startloc, (int)(psh->expdest - stackblock(psh)),
varflags & VSQUOTE);
if (subtype != VSNORMAL) { /* skip to end of alternative */
int nesting = 1;
for (;;) {
if ((c = *p++) == CTLESC)
p++;
else if (c == CTLBACKQ || c == (CTLBACKQ|CTLQUOTE)) {
if (set)
psh->argbackq = psh->argbackq->next;
} else if (c == CTLVAR) {
if ((*p++ & VSTYPE) != VSNORMAL)
nesting++;
} else if (c == CTLENDVAR) {
if (--nesting == 0)
break;
}
}
}
return p;
}
static int
reflink_f(
int argc,
char **argv)
{
off64_t soffset = 0, doffset = 0;
long long count = 0, total;
char s1[64], s2[64], ts[64];
char *infile = NULL;
int Cflag, qflag, wflag, Wflag;
struct xfs_ioctl_clone_range_args args;
size_t fsblocksize, fssectsize;
struct timeval t1, t2;
int c, fd = -1;
Cflag = qflag = wflag = Wflag = 0;
init_cvtnum(&fsblocksize, &fssectsize);
while ((c = getopt(argc, argv, "CqwW")) != EOF) {
switch (c) {
case 'C':
Cflag = 1;
break;
case 'q':
qflag = 1;
break;
case 'w':
wflag = 1;
break;
case 'W':
Wflag = 1;
break;
default:
return command_usage(&reflink_cmd);
}
}
if (optind != argc - 4 && optind != argc - 1)
return command_usage(&reflink_cmd);
infile = argv[optind];
optind++;
if (optind == argc)
goto clone_all;
soffset = cvtnum(fsblocksize, fssectsize, argv[optind]);
if (soffset < 0) {
printf(_("non-numeric src offset argument -- %s\n"), argv[optind]);
return 0;
}
optind++;
doffset = cvtnum(fsblocksize, fssectsize, argv[optind]);
if (doffset < 0) {
printf(_("non-numeric dest offset argument -- %s\n"), argv[optind]);
return 0;
}
optind++;
count = cvtnum(fsblocksize, fssectsize, argv[optind]);
if (count < 1) {
printf(_("non-positive length argument -- %s\n"), argv[optind]);
return 0;
}
clone_all:
c = IO_READONLY;
fd = openfile(infile, NULL, c, 0);
if (fd < 0)
return 0;
gettimeofday(&t1, NULL);
if (count) {
args.src_fd = fd;
args.src_offset = soffset;
args.src_length = count;
args.dest_offset = doffset;
c = ioctl(file->fd, XFS_IOC_CLONE_RANGE, &args);
} else {
c = ioctl(file->fd, XFS_IOC_CLONE, fd);
}
if (c < 0) {
perror(_("reflink"));
goto done;
}
total = count;
c = 1;
if (Wflag)
fsync(file->fd);
if (wflag)
fdatasync(file->fd);
if (qflag)
goto done;
gettimeofday(&t2, NULL);
t2 = tsub(t2, t1);
/* Finally, report back -- -C gives a parsable format */
timestr(&t2, ts, sizeof(ts), Cflag ? VERBOSE_FIXED_TIME : 0);
if (!Cflag) {
cvtstr((double)total, s1, sizeof(s1));
cvtstr(tdiv((double)total, t2), s2, sizeof(s2));
printf(_("linked %lld/%lld bytes at offset %lld\n"),
total, count, (long long)doffset);
printf(_("%s, %d ops; %s (%s/sec and %.4f ops/sec)\n"),
s1, c, ts, s2, tdiv((double)c, t2));
} else {/* bytes,ops,time,bytes/sec,ops/sec */
printf("%lld,%d,%s,%.3f,%.3f\n",
total, c, ts,
tdiv((double)total, t2), tdiv((double)c, t2));
}
done:
close(fd);
return 0;
}
STATIC void
varvalue(shinstance *psh, char *name, int quoted, int subtype, int flag)
{
int num;
char *p;
int i;
char sep;
char **ap;
char const *syntax;
#define STRTODEST(p) \
do {\
if (flag & (EXP_FULL | EXP_CASE) && subtype != VSLENGTH) { \
syntax = quoted? DQSYNTAX : BASESYNTAX; \
while (*p) { \
if (syntax[(int)*p] == CCTL) \
STPUTC(psh, CTLESC, psh->expdest); \
STPUTC(psh, *p++, psh->expdest); \
} \
} else \
while (*p) \
STPUTC(psh, *p++, psh->expdest); \
} while (0)
switch (*name) {
case '$':
num = psh->rootpid;
goto numvar;
case '?':
num = psh->exitstatus;
goto numvar;
case '#':
num = psh->shellparam.nparam;
goto numvar;
case '!':
num = psh->backgndpid;
numvar:
psh->expdest = cvtnum(psh, num, psh->expdest);
break;
case '-':
for (i = 0; psh->optlist[i].name; i++) {
if (psh->optlist[i].val)
STPUTC(psh, psh->optlist[i].letter, psh->expdest);
}
break;
case '@':
if (flag & EXP_FULL && quoted) {
for (ap = psh->shellparam.p ; (p = *ap++) != NULL ; ) {
STRTODEST(p);
if (*ap)
STPUTC(psh, '\0', psh->expdest);
}
break;
}
/* fall through */
case '*':
if (ifsset(psh) != 0)
sep = ifsval(psh)[0];
else
sep = ' ';
for (ap = psh->shellparam.p ; (p = *ap++) != NULL ; ) {
STRTODEST(p);
if (*ap && sep)
STPUTC(psh, sep, psh->expdest);
}
break;
case '0':
p = psh->arg0;
STRTODEST(p);
break;
default:
if (is_digit(*name)) {
num = atoi(name);
if (num > 0 && num <= psh->shellparam.nparam) {
p = psh->shellparam.p[num - 1];
STRTODEST(p);
}
}
break;
}
}
static int
pwrite_f(
int argc,
char **argv)
{
size_t bsize;
off64_t offset, skip = 0;
long long count, total, tmp;
unsigned int zeed = 0, seed = 0xcdcdcdcd;
size_t fsblocksize, fssectsize;
struct timeval t1, t2;
char s1[64], s2[64], ts[64];
char *sp, *infile = NULL;
int Cflag, qflag, uflag, dflag, wflag, Wflag;
int direction = IO_FORWARD;
int c, fd = -1;
Cflag = qflag = uflag = dflag = wflag = Wflag = 0;
init_cvtnum(&fsblocksize, &fssectsize);
bsize = fsblocksize;
while ((c = getopt(argc, argv, "b:Cdf:i:qs:S:uwWZ:")) != EOF) {
switch (c) {
case 'b':
tmp = cvtnum(fsblocksize, fssectsize, optarg);
if (tmp < 0) {
printf(_("non-numeric bsize -- %s\n"), optarg);
return 0;
}
bsize = tmp;
break;
case 'C':
Cflag = 1;
break;
case 'F':
direction = IO_FORWARD;
break;
case 'B':
direction = IO_BACKWARD;
break;
case 'R':
direction = IO_RANDOM;
break;
case 'd':
dflag = 1;
break;
case 'f':
case 'i':
infile = optarg;
break;
case 's':
skip = cvtnum(fsblocksize, fssectsize, optarg);
if (skip < 0) {
printf(_("non-numeric skip -- %s\n"), optarg);
return 0;
}
break;
case 'S':
seed = strtoul(optarg, &sp, 0);
if (!sp || sp == optarg) {
printf(_("non-numeric seed -- %s\n"), optarg);
return 0;
}
break;
case 'q':
qflag = 1;
break;
case 'u':
uflag = 1;
break;
case 'w':
wflag = 1;
break;
case 'W':
Wflag = 1;
break;
case 'Z':
zeed = strtoul(optarg, &sp, 0);
if (!sp || sp == optarg) {
printf(_("non-numeric seed -- %s\n"), optarg);
return 0;
}
break;
default:
return command_usage(&pwrite_cmd);
}
}
if (((skip || dflag) && !infile) || (optind != argc - 2))
return command_usage(&pwrite_cmd);
if (infile && direction != IO_FORWARD)
return command_usage(&pwrite_cmd);
offset = cvtnum(fsblocksize, fssectsize, argv[optind]);
if (offset < 0) {
printf(_("non-numeric offset argument -- %s\n"), argv[optind]);
return 0;
}
optind++;
count = cvtnum(fsblocksize, fssectsize, argv[optind]);
if (count < 0) {
printf(_("non-numeric length argument -- %s\n"), argv[optind]);
return 0;
}
if (alloc_buffer(bsize, uflag, seed) < 0)
return 0;
c = IO_READONLY | (dflag ? IO_DIRECT : 0);
if (infile && ((fd = openfile(infile, NULL, c, 0)) < 0))
return 0;
gettimeofday(&t1, NULL);
switch (direction) {
case IO_RANDOM:
if (!zeed) /* srandom seed */
zeed = time(NULL);
c = write_random(offset, count, zeed, &total);
break;
case IO_FORWARD:
c = write_buffer(offset, count, bsize, fd, skip, &total);
break;
case IO_BACKWARD:
c = write_backward(offset, &count, &total);
break;
default:
total = 0;
ASSERT(0);
}
if (c < 0)
goto done;
if (Wflag)
fsync(file->fd);
if (wflag)
fdatasync(file->fd);
if (qflag)
goto done;
gettimeofday(&t2, NULL);
t2 = tsub(t2, t1);
/* Finally, report back -- -C gives a parsable format */
timestr(&t2, ts, sizeof(ts), Cflag ? VERBOSE_FIXED_TIME : 0);
if (!Cflag) {
cvtstr((double)total, s1, sizeof(s1));
cvtstr(tdiv((double)total, t2), s2, sizeof(s2));
printf(_("wrote %lld/%lld bytes at offset %lld\n"),
total, count, (long long)offset);
printf(_("%s, %d ops; %s (%s/sec and %.4f ops/sec)\n"),
s1, c, ts, s2, tdiv((double)c, t2));
} else {/* bytes,ops,time,bytes/sec,ops/sec */
printf("%lld,%d,%s,%.3f,%.3f\n",
total, c, ts,
tdiv((double)total, t2), tdiv((double)c, t2));
}
done:
if (infile)
close(fd);
return 0;
}
static int
pread_f(
int argc,
char **argv)
{
size_t bsize;
off64_t offset;
unsigned int zeed = 0;
long long count, total, tmp;
size_t fsblocksize, fssectsize;
struct timeval t1, t2;
char *sp;
int Cflag, qflag, uflag, vflag;
int eof = 0, direction = IO_FORWARD;
int c;
Cflag = qflag = uflag = vflag = 0;
init_cvtnum(&fsblocksize, &fssectsize);
bsize = fsblocksize;
while ((c = getopt(argc, argv, "b:BCFRquvV:Z:")) != EOF) {
switch (c) {
case 'b':
tmp = cvtnum(fsblocksize, fssectsize, optarg);
if (tmp < 0) {
printf(_("non-numeric bsize -- %s\n"), optarg);
return 0;
}
bsize = tmp;
break;
case 'C':
Cflag = 1;
break;
case 'F':
direction = IO_FORWARD;
break;
case 'B':
direction = IO_BACKWARD;
break;
case 'R':
direction = IO_RANDOM;
break;
case 'q':
qflag = 1;
break;
case 'u':
uflag = 1;
break;
case 'v':
vflag = 1;
break;
#ifdef HAVE_PREADV
case 'V':
vectors = strtoul(optarg, &sp, 0);
if (!sp || sp == optarg) {
printf(_("non-numeric vector count == %s\n"),
optarg);
return 0;
}
break;
#endif
case 'Z':
zeed = strtoul(optarg, &sp, 0);
if (!sp || sp == optarg) {
printf(_("non-numeric seed -- %s\n"), optarg);
return 0;
}
break;
default:
return command_usage(&pread_cmd);
}
}
if (optind != argc - 2)
return command_usage(&pread_cmd);
offset = cvtnum(fsblocksize, fssectsize, argv[optind]);
if (offset < 0 && (direction & (IO_RANDOM|IO_BACKWARD))) {
eof = -1; /* read from EOF */
} else if (offset < 0) {
printf(_("non-numeric length argument -- %s\n"), argv[optind]);
return 0;
}
optind++;
count = cvtnum(fsblocksize, fssectsize, argv[optind]);
if (count < 0 && (direction & (IO_RANDOM|IO_FORWARD))) {
eof = -1; /* read to EOF */
} else if (count < 0) {
printf(_("non-numeric length argument -- %s\n"), argv[optind]);
return 0;
}
if (alloc_buffer(bsize, uflag, 0xabababab) < 0)
return 0;
gettimeofday(&t1, NULL);
switch (direction) {
case IO_RANDOM:
if (!zeed) /* srandom seed */
zeed = time(NULL);
c = read_random(file->fd, offset, count, &total, zeed, eof);
break;
case IO_FORWARD:
c = read_forward(file->fd, offset, count, &total, vflag, 0, eof);
if (eof)
count = total;
break;
case IO_BACKWARD:
c = read_backward(file->fd, &offset, &count, &total, eof);
break;
default:
ASSERT(0);
}
if (c < 0)
return 0;
if (qflag)
return 0;
gettimeofday(&t2, NULL);
t2 = tsub(t2, t1);
report_io_times("read", &t2, (long long)offset, count, total, c, Cflag);
return 0;
}
static int read_f(int argc, char **argv)
{
struct timeval t1, t2;
int Cflag = 0, pflag = 0, qflag = 0, vflag = 0;
int Pflag = 0, sflag = 0, lflag = 0, bflag = 0;
int c, cnt;
char *buf;
int64_t offset;
int count;
/* Some compilers get confused and warn if this is not initialized. */
int total = 0;
int pattern = 0, pattern_offset = 0, pattern_count = 0;
while ((c = getopt(argc, argv, "bCl:pP:qs:v")) != EOF) {
switch (c) {
case 'b':
bflag = 1;
break;
case 'C':
Cflag = 1;
break;
case 'l':
lflag = 1;
pattern_count = cvtnum(optarg);
if (pattern_count < 0) {
printf("non-numeric length argument -- %s\n", optarg);
return 0;
}
break;
case 'p':
pflag = 1;
break;
case 'P':
Pflag = 1;
pattern = parse_pattern(optarg);
if (pattern < 0) {
return 0;
}
break;
case 'q':
qflag = 1;
break;
case 's':
sflag = 1;
pattern_offset = cvtnum(optarg);
if (pattern_offset < 0) {
printf("non-numeric length argument -- %s\n", optarg);
return 0;
}
break;
case 'v':
vflag = 1;
break;
default:
return command_usage(&read_cmd);
}
}
if (optind != argc - 2) {
return command_usage(&read_cmd);
}
if (bflag && pflag) {
printf("-b and -p cannot be specified at the same time\n");
return 0;
}
offset = cvtnum(argv[optind]);
if (offset < 0) {
printf("non-numeric length argument -- %s\n", argv[optind]);
return 0;
}
optind++;
count = cvtnum(argv[optind]);
if (count < 0) {
printf("non-numeric length argument -- %s\n", argv[optind]);
return 0;
}
if (!Pflag && (lflag || sflag)) {
return command_usage(&read_cmd);
}
if (!lflag) {
pattern_count = count - pattern_offset;
}
if ((pattern_count < 0) || (pattern_count + pattern_offset > count)) {
printf("pattern verification range exceeds end of read data\n");
return 0;
}
if (!pflag) {
if (offset & 0x1ff) {
printf("offset %" PRId64 " is not sector aligned\n",
offset);
return 0;
}
if (count & 0x1ff) {
printf("count %d is not sector aligned\n",
count);
return 0;
}
}
buf = qemu_io_alloc(count, 0xab);
gettimeofday(&t1, NULL);
if (pflag) {
cnt = do_pread(buf, offset, count, &total);
} else if (bflag) {
cnt = do_load_vmstate(buf, offset, count, &total);
} else {
cnt = do_read(buf, offset, count, &total);
}
gettimeofday(&t2, NULL);
if (cnt < 0) {
printf("read failed: %s\n", strerror(-cnt));
goto out;
}
if (Pflag) {
void *cmp_buf = g_malloc(pattern_count);
memset(cmp_buf, pattern, pattern_count);
if (memcmp(buf + pattern_offset, cmp_buf, pattern_count)) {
printf("Pattern verification failed at offset %"
PRId64 ", %d bytes\n",
offset + pattern_offset, pattern_count);
}
g_free(cmp_buf);
}
if (qflag) {
goto out;
}
if (vflag) {
dump_buffer(buf, offset, count);
}
/* Finally, report back -- -C gives a parsable format */
t2 = tsub(t2, t1);
print_report("read", &t2, offset, count, total, cnt, Cflag);
out:
qemu_io_free(buf);
return 0;
}
int
madvise_f(
int argc,
char **argv)
{
off64_t offset, llength;
size_t length;
void *start;
int advise = MADV_NORMAL, c;
size_t blocksize, sectsize;
while ((c = getopt(argc, argv, "drsw")) != EOF) {
switch (c) {
case 'd': /* Don't need these pages */
advise = MADV_DONTNEED;
break;
case 'r': /* Expect random page references */
advise = MADV_RANDOM;
break;
case 's': /* Expect sequential page references */
advise = MADV_SEQUENTIAL;
break;
case 'w': /* Will need these pages */
advise = MADV_WILLNEED;
break;
default:
return command_usage(&madvise_cmd);
}
}
if (optind == argc) {
offset = mapping->offset;
length = mapping->length;
} else if (optind == argc - 2) {
init_cvtnum(&blocksize, §size);
offset = cvtnum(blocksize, sectsize, argv[optind]);
if (offset < 0) {
printf(_("non-numeric offset argument -- %s\n"),
argv[optind]);
return 0;
}
optind++;
llength = cvtnum(blocksize, sectsize, argv[optind]);
if (llength < 0) {
printf(_("non-numeric length argument -- %s\n"),
argv[optind]);
return 0;
} else if (llength > (size_t)llength) {
printf(_("length argument too large -- %lld\n"),
(long long)llength);
return 0;
} else
length = (size_t)llength;
} else {
return command_usage(&madvise_cmd);
}
start = check_mapping_range(mapping, offset, length, 1);
if (!start)
return 0;
if (madvise(start, length, advise) < 0) {
perror("madvise");
return 0;
}
return 0;
}
static int write_f(int argc, char **argv)
{
struct timeval t1, t2;
int Cflag = 0, pflag = 0, qflag = 0, bflag = 0, Pflag = 0, zflag = 0;
int cflag = 0;
int c, cnt;
char *buf = NULL;
int64_t offset;
int count;
/* Some compilers get confused and warn if this is not initialized. */
int total = 0;
int pattern = 0xcd;
while ((c = getopt(argc, argv, "bcCpP:qz")) != EOF) {
switch (c) {
case 'b':
bflag = 1;
break;
case 'c':
cflag = 1;
break;
case 'C':
Cflag = 1;
break;
case 'p':
pflag = 1;
break;
case 'P':
Pflag = 1;
pattern = parse_pattern(optarg);
if (pattern < 0) {
return 0;
}
break;
case 'q':
qflag = 1;
break;
case 'z':
zflag = 1;
break;
default:
return command_usage(&write_cmd);
}
}
if (optind != argc - 2) {
return command_usage(&write_cmd);
}
if (bflag + pflag + zflag > 1) {
printf("-b, -p, or -z cannot be specified at the same time\n");
return 0;
}
if (zflag && Pflag) {
printf("-z and -P cannot be specified at the same time\n");
return 0;
}
offset = cvtnum(argv[optind]);
if (offset < 0) {
printf("non-numeric length argument -- %s\n", argv[optind]);
return 0;
}
optind++;
count = cvtnum(argv[optind]);
if (count < 0) {
printf("non-numeric length argument -- %s\n", argv[optind]);
return 0;
}
if (!pflag) {
if (offset & 0x1ff) {
printf("offset %" PRId64 " is not sector aligned\n",
offset);
return 0;
}
if (count & 0x1ff) {
printf("count %d is not sector aligned\n",
count);
return 0;
}
}
if (!zflag) {
buf = qemu_io_alloc(count, pattern);
}
gettimeofday(&t1, NULL);
if (pflag) {
cnt = do_pwrite(buf, offset, count, &total);
} else if (bflag) {
cnt = do_save_vmstate(buf, offset, count, &total);
} else if (zflag) {
cnt = do_co_write_zeroes(offset, count, &total);
} else if (cflag) {
cnt = do_write_compressed(buf, offset, count, &total);
} else {
cnt = do_write(buf, offset, count, &total);
}
gettimeofday(&t2, NULL);
if (cnt < 0) {
printf("write failed: %s\n", strerror(-cnt));
goto out;
}
if (qflag) {
goto out;
}
/* Finally, report back -- -C gives a parsable format */
t2 = tsub(t2, t1);
print_report("wrote", &t2, offset, count, total, cnt, Cflag);
out:
if (!zflag) {
qemu_io_free(buf);
}
return 0;
}
int main(int argc, char **argv)
{
int fd;
char *fname;
int opt;
off_t length = -2LL;
off_t offset = 0;
int falloc_mode = 0;
int error = 0;
int tflag = 0, mflag = 0, rflag = 0, sflag = 0;
while ((opt = getopt(argc, argv, "nl:o:tmrs")) != -1) {
switch(opt) {
case 'n':
/* do not change filesize */
falloc_mode = FALLOC_FL_KEEP_SIZE;
break;
case 'l':
length = cvtnum(optarg);
break;
case 'o':
offset = cvtnum(optarg);
break;
case 't':
tflag++;
break;
case 'm':
mflag++;
break;
case 'r':
rflag++;
break;
case 's':
sflag++;
break;
default:
usage();
}
}
if (length == -2LL) {
printf("Error: no length argument specified\n");
usage();
}
if (length <= 0) {
printf("Error: invalid length value specified\n");
usage();
}
if (offset < 0) {
printf("Error: invalid offset value specified\n");
usage();
}
if (tflag && (falloc_mode & FALLOC_FL_KEEP_SIZE)) {
printf("-n and -t options incompatible\n");
usage();
}
if (tflag && offset) {
printf("-t and -o options incompatible\n");
usage();
}
if (optind == argc) {
printf("Error: no filename specified\n");
usage();
}
fname = argv[optind++];
/* Should we create the file if it doesn't already exist? */
fd = open(fname, O_CREAT|O_RDWR/*|O_LARGEFILE*/);
if (fd < 0) {
perror("Error opening file");
exit(EXIT_FAILURE);
}
if (tflag || mflag)
error = ftruncate(fd, length);
else
error = syscall(SYS_fallocate, fd, falloc_mode, offset, length);
//error = posix_fallocate(fd, offset, length);
if (rflag) {
time_t now = time(NULL);
srand(now);
}
while (!error && mflag && length > 0) {
char *start, *end, *p;
const int pagesize = 4096;
int len = length;//16*1024*pagesize;
if (len > length)
len = length;
start = mmap(NULL, len, PROT_WRITE, MAP_SHARED, fd, offset);
if (start == MAP_FAILED) {
error = (int)start;
break;
}
end = start + len;
for (p = start; p < end; p += pagesize)
*(int *)p = rflag ? rand() : 0;
if (!error)
error = munmap(start, len);
length -= len;
offset += len;
}
if (error < 0) {
perror("fallocate failed");
exit(EXIT_FAILURE);
}
if (sflag)
fdatasync(fd);
close(fd);
return 0;
}
static int multiwrite_f(int argc, char **argv)
{
struct timeval t1, t2;
int Cflag = 0, qflag = 0;
int c, cnt;
char **buf;
int64_t offset, first_offset = 0;
/* Some compilers get confused and warn if this is not initialized. */
int total = 0;
int nr_iov;
int nr_reqs;
int pattern = 0xcd;
QEMUIOVector *qiovs;
int i;
BlockRequest *reqs;
while ((c = getopt(argc, argv, "CqP:")) != EOF) {
switch (c) {
case 'C':
Cflag = 1;
break;
case 'q':
qflag = 1;
break;
case 'P':
pattern = parse_pattern(optarg);
if (pattern < 0) {
return 0;
}
break;
default:
return command_usage(&writev_cmd);
}
}
if (optind > argc - 2) {
return command_usage(&writev_cmd);
}
nr_reqs = 1;
for (i = optind; i < argc; i++) {
if (!strcmp(argv[i], ";")) {
nr_reqs++;
}
}
reqs = g_malloc0(nr_reqs * sizeof(*reqs));
buf = g_malloc0(nr_reqs * sizeof(*buf));
qiovs = g_malloc(nr_reqs * sizeof(*qiovs));
for (i = 0; i < nr_reqs && optind < argc; i++) {
int j;
/* Read the offset of the request */
offset = cvtnum(argv[optind]);
if (offset < 0) {
printf("non-numeric offset argument -- %s\n", argv[optind]);
goto out;
}
optind++;
if (offset & 0x1ff) {
printf("offset %lld is not sector aligned\n",
(long long)offset);
goto out;
}
if (i == 0) {
first_offset = offset;
}
/* Read lengths for qiov entries */
for (j = optind; j < argc; j++) {
if (!strcmp(argv[j], ";")) {
break;
}
}
nr_iov = j - optind;
/* Build request */
buf[i] = create_iovec(&qiovs[i], &argv[optind], nr_iov, pattern);
if (buf[i] == NULL) {
goto out;
}
reqs[i].qiov = &qiovs[i];
reqs[i].sector = offset >> 9;
reqs[i].nb_sectors = reqs[i].qiov->size >> 9;
optind = j + 1;
pattern++;
}
/* If there were empty requests at the end, ignore them */
nr_reqs = i;
gettimeofday(&t1, NULL);
cnt = do_aio_multiwrite(reqs, nr_reqs, &total);
gettimeofday(&t2, NULL);
if (cnt < 0) {
printf("aio_multiwrite failed: %s\n", strerror(-cnt));
goto out;
}
if (qflag) {
goto out;
}
/* Finally, report back -- -C gives a parsable format */
t2 = tsub(t2, t1);
print_report("wrote", &t2, first_offset, total, total, cnt, Cflag);
out:
for (i = 0; i < nr_reqs; i++) {
qemu_io_free(buf[i]);
if (reqs[i].qiov != NULL) {
qemu_iovec_destroy(&qiovs[i]);
}
}
g_free(buf);
g_free(reqs);
g_free(qiovs);
return 0;
}
int main(int argc, char **argv)
{
char *fname;
int c;
int error;
int fd;
int mode = 0;
loff_t length = -2LL;
loff_t offset = 0;
struct option longopts[] = {
{ "help", 0, 0, 'h' },
{ "keep-size", 0, 0, 'n' },
{ "offset", 1, 0, 'o' },
{ "lenght", 1, 0, 'l' },
{ NULL, 0, 0, 0 }
};
setlocale(LC_ALL, "");
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
while ((c = getopt_long(argc, argv, "hnl:o:", longopts, NULL)) != -1) {
switch(c) {
case 'h':
usage(stdout);
break;
case 'n':
mode |= FALLOC_FL_KEEP_SIZE;
break;
case 'l':
length = cvtnum(optarg);
break;
case 'o':
offset = cvtnum(optarg);
break;
default:
usage(stderr);
break;
}
}
if (length == -2LL)
errx(EXIT_FAILURE, _("no length argument specified"));
if (length <= 0)
errx(EXIT_FAILURE, _("invalid length value specified"));
if (offset < 0)
errx(EXIT_FAILURE, _("invalid offset value specified"));
if (optind == argc)
errx(EXIT_FAILURE, _("no filename specified."));
fname = argv[optind++];
if (optind != argc) {
warnx(_("unexpected number of arguments"));
usage(stderr);
}
fd = open(fname, O_WRONLY|O_CREAT, 0644);
if (fd < 0)
err(EXIT_FAILURE, _("%s: open failed"), fname);
#ifdef HAVE_FALLOCATE
error = fallocate(fd, mode, offset, length);
#else
error = syscall(SYS_fallocate, fd, mode, offset, length);
#endif
/*
* EOPNOTSUPP: The FALLOC_FL_KEEP_SIZE is unsupported
* ENOSYS: The filesystem does not support sys_fallocate
*/
if (error < 0) {
if ((mode & FALLOC_FL_KEEP_SIZE) && errno == EOPNOTSUPP)
errx(EXIT_FAILURE,
_("keep size mode (-n option) unsupported"));
err(EXIT_FAILURE, _("%s: fallocate failed"), fname);
}
close(fd);
return EXIT_SUCCESS;
}