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;
}
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 load_all(vici_conn_t *conn)
{
bool clear = FALSE, noprompt = FALSE;
command_format_options_t format = COMMAND_FORMAT_NONE;
settings_t *cfg;
int ret = 0;
char *arg;
while (TRUE)
{
switch (command_getopt(&arg))
{
case 'h':
return command_usage(NULL);
case 'c':
clear = TRUE;
continue;
case 'n':
noprompt = TRUE;
continue;
case 'P':
format |= COMMAND_FORMAT_PRETTY;
/* fall through to raw */
case 'r':
format |= COMMAND_FORMAT_RAW;
continue;
case EOF:
break;
default:
return command_usage("invalid --load-all option");
}
break;
}
cfg = settings_create(SWANCTL_CONF);
if (!cfg)
{
fprintf(stderr, "parsing '%s' failed\n", SWANCTL_CONF);
return EINVAL;
}
if (ret == 0)
{
ret = load_creds_cfg(conn, format, cfg, clear, noprompt);
}
if (ret == 0)
{
ret = load_pools_cfg(conn, format, cfg);
}
if (ret == 0)
{
ret = load_conns_cfg(conn, format, cfg);
}
cfg->destroy(cfg);
return ret;
}
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
state_f(
int argc,
char **argv)
{
FILE *fp = NULL;
char *fname = NULL;
int c, flags = 0, type = 0;
while ((c = getopt(argc, argv, "af:gpuv")) != EOF) {
switch (c) {
case 'a':
flags |= ALL_MOUNTS_FLAG;
break;
case 'f':
fname = optarg;
break;
case 'g':
type |= XFS_GROUP_QUOTA;
break;
case 'p':
type |= XFS_PROJ_QUOTA;
break;
case 'u':
type |= XFS_USER_QUOTA;
break;
case 'v':
flags |= VERBOSE_FLAG;
break;
default:
return command_usage(&state_cmd);
}
}
if (argc != optind)
return command_usage(&state_cmd);
if ((fp = fopen_write_secure(fname)) == NULL)
return 0;
if (!type)
type = XFS_USER_QUOTA | XFS_GROUP_QUOTA | XFS_PROJ_QUOTA;
if (flags & ALL_MOUNTS_FLAG)
state_quotafile(fp, type, NULL, flags);
else if (fs_path && fs_path->fs_flags & FS_MOUNT_POINT)
state_quotafile(fp, type, fs_path->fs_dir, flags);
if (fname)
fclose(fp);
return 0;
}
static int
dump_f(
int argc,
char **argv)
{
FILE *fp;
char *fname = NULL;
uint lower = 0, upper = 0;
int c, type = XFS_USER_QUOTA;
while ((c = getopt(argc, argv, "f:gpuL:U:")) != EOF) {
switch(c) {
case 'f':
fname = optarg;
break;
case 'g':
type = XFS_GROUP_QUOTA;
break;
case 'p':
type = XFS_PROJ_QUOTA;
break;
case 'u':
type = XFS_USER_QUOTA;
break;
case 'L':
lower = (uint)atoi(optarg);
break;
case 'U':
upper = (uint)atoi(optarg);
break;
default:
return command_usage(&dump_cmd);
}
}
if (argc != optind)
return command_usage(&dump_cmd);
if ((fp = fopen_write_secure(fname)) == NULL)
return 0;
dump_limits_any_type(fp, type, fs_path->fs_dir, lower, upper);
if (fname)
fclose(fp);
return 0;
}
void command_report_error(buffer_t* out, const command_t* cmd, int error)
{
int do_eol = 1;
if (NULL == out || NULL == cmd)
return;
switch (error)
{
case ENONE:
buf_append(out, "OK");
break;
case EIGNORE:
do_eol = 0;
break;
case ENOCMD:
buf_appendf(out, "ERR: No such command");
break;
case ENOSESSION:
buf_appendf(out, "ERR: Session not found");
break;
case EUSAGE:
command_usage(out, cmd);
do_eol = 0;
break;
default:
buf_appendf(out, "ERR: %s", strerror(error));
break;
}
if (do_eol)
buf_append_eol(out);
}
static int
S_set_verbose(int argc, char * argv[])
{
uint32_t log_flags = 0;
int result;
if (strcasecmp(argv[0], "on") == 0) {
log_flags = -1;
}
else if (strcasecmp(argv[0], "off") == 0) {
log_flags = 0;
}
else {
command_usage();
}
if (EAPOLControlPrefsSetLogFlags(log_flags) == FALSE) {
fprintf(stderr, "Failed to set verbose %s\n",
log_flags != 0 ? "on" : "off");
result = 1;
}
else {
result = 0;
}
return (result);
}
static int list_pools(vici_conn_t *conn)
{
vici_req_t *req;
vici_res_t *res;
bool raw = FALSE;
char *arg;
int ret = 0;
while (TRUE)
{
switch (command_getopt(&arg))
{
case 'h':
return command_usage(NULL);
case 'r':
raw = TRUE;
continue;
case EOF:
break;
default:
return command_usage("invalid --list-pools option");
}
break;
}
req = vici_begin("get-pools");
res = vici_submit(req, conn);
if (!res)
{
fprintf(stderr, "get-pools request failed: %s\n", strerror(errno));
return errno;
}
if (raw)
{
vici_dump(res, "get-pools reply", stdout);
}
else
{
ret = vici_parse_cb(res, list_pool, NULL, NULL, NULL);
}
vici_free_res(res);
return ret;
}
static int load_authorities(vici_conn_t *conn)
{
command_format_options_t format = COMMAND_FORMAT_NONE;
settings_t *cfg;
char *arg, *file = NULL;
int ret;
while (TRUE)
{
switch (command_getopt(&arg))
{
case 'h':
return command_usage(NULL);
case 'P':
format |= COMMAND_FORMAT_PRETTY;
/* fall through to raw */
case 'r':
format |= COMMAND_FORMAT_RAW;
continue;
case 'f':
file = arg;
continue;
case EOF:
break;
default:
return command_usage("invalid --load-authorities option");
}
break;
}
cfg = load_swanctl_conf(file);
if (!cfg)
{
return EINVAL;
}
ret = load_authorities_cfg(conn, format, cfg);
cfg->destroy(cfg);
return ret;
}
static int
off_f(
int argc,
char **argv)
{
int c, flags = 0, qflags = 0, type = 0;
while ((c = getopt(argc, argv, "gpuv")) != EOF) {
switch (c) {
case 'g':
type |= XFS_GROUP_QUOTA;
qflags |= XFS_QUOTA_GDQ_ACCT | XFS_QUOTA_GDQ_ENFD;
break;
case 'p':
type |= XFS_PROJ_QUOTA;
qflags |= XFS_QUOTA_PDQ_ACCT | XFS_QUOTA_PDQ_ENFD;
break;
case 'u':
type |= XFS_USER_QUOTA;
qflags |= XFS_QUOTA_UDQ_ACCT | XFS_QUOTA_UDQ_ENFD;
break;
case 'v':
flags |= VERBOSE_FLAG;
break;
default:
return command_usage(&off_cmd);
}
}
if (argc != optind)
return command_usage(&off_cmd);
if (!type) {
type |= XFS_USER_QUOTA;
qflags |= XFS_QUOTA_UDQ_ACCT | XFS_QUOTA_UDQ_ENFD;
}
if (fs_path->fs_flags & FS_MOUNT_POINT)
quotaoff(fs_path->fs_dir, type, qflags, flags);
return 0;
}
static int
open_f(int argc, char **argv)
{
int flags = 0;
int readonly = 0;
int growable = 0;
int c;
while ((c = getopt(argc, argv, "snCrg")) != EOF) {
switch (c) {
case 's':
flags |= BDRV_O_SNAPSHOT;
break;
case 'n':
flags |= BDRV_O_NOCACHE;
break;
case 'C':
flags |= BDRV_O_CREAT;
break;
case 'r':
readonly = 1;
break;
case 'g':
growable = 1;
break;
default:
return command_usage(&open_cmd);
}
}
if (readonly)
flags |= BDRV_O_RDONLY;
else
flags |= BDRV_O_RDWR;
if (optind != argc - 1)
return command_usage(&open_cmd);
return openfile(argv[optind], flags, growable);
}
static int load_authorities(vici_conn_t *conn)
{
command_format_options_t format = COMMAND_FORMAT_NONE;
settings_t *cfg;
char *arg;
int ret;
while (TRUE)
{
switch (command_getopt(&arg))
{
case 'h':
return command_usage(NULL);
case 'P':
format |= COMMAND_FORMAT_PRETTY;
/* fall through to raw */
case 'r':
format |= COMMAND_FORMAT_RAW;
continue;
case EOF:
break;
default:
return command_usage("invalid --load-authorities option");
}
break;
}
cfg = settings_create(SWANCTL_CONF);
if (!cfg)
{
fprintf(stderr, "parsing '%s' failed\n", SWANCTL_CONF);
return EINVAL;
}
ret = load_authorities_cfg(conn, format, cfg);
cfg->destroy(cfg);
return ret;
}
static int
chproj_f(
int argc,
char **argv)
{
int c;
recurse_all = recurse_dir = 0;
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(&chproj_cmd);
}
}
if (argc != optind + 1)
return command_usage(&chproj_cmd);
prid = prid_from_string(argv[optind]);
if (prid == -1) {
printf(_("invalid project ID -- %s\n"), argv[optind]);
return 0;
}
if (recurse_all || recurse_dir)
nftw(file->name, chproj_callback,
100, FTW_PHYS | FTW_MOUNT | FTW_DEPTH);
else if (setprojid(file->name, file->fd, prid) < 0)
perror("setprojid");
return 0;
}
int
parent_f(int argc, char **argv)
{
int c;
int listpath_flag = 0;
int check_flag = 0;
fs_path_t *fs;
static int tab_init;
if (!tab_init) {
tab_init = 1;
fs_table_initialise(0, NULL, 0, NULL);
}
fs = fs_table_lookup(file->name, FS_MOUNT_POINT);
if (!fs) {
fprintf(stderr, _("file argument, \"%s\", is not in a mounted XFS filesystem\n"),
file->name);
return 1;
}
mntpt = fs->fs_dir;
verbose_flag = 0;
while ((c = getopt(argc, argv, "cpv")) != EOF) {
switch (c) {
case 'c':
check_flag = 1;
break;
case 'p':
listpath_flag = 1;
break;
case 'v':
verbose_flag++;
break;
default:
return command_usage(&parent_cmd);
}
}
if (!check_flag && !listpath_flag) /* default case */
exitcode = parent_list(listpath_flag);
else {
if (listpath_flag)
exitcode = parent_list(listpath_flag);
if (check_flag)
exitcode = parent_check();
}
return 0;
}
static int
remove_f(
int argc,
char **argv)
{
int c, flags = 0, type = 0;
while ((c = getopt(argc, argv, "gpuv")) != EOF) {
switch (c) {
case 'g':
type |= XFS_GROUP_QUOTA;
break;
case 'p':
type |= XFS_PROJ_QUOTA;
break;
case 'u':
type |= XFS_USER_QUOTA;
break;
case 'v':
flags |= VERBOSE_FLAG;
break;
default:
return command_usage(&remove_cmd);
}
}
if (argc != optind)
return command_usage(&remove_cmd);
if (!type) {
type |= XFS_USER_QUOTA;
}
if (fs_path->fs_flags & FS_MOUNT_POINT)
remove_extents(fs_path->fs_dir, type, flags);
return 0;
}
static int logcmd(vici_conn_t *conn)
{
command_format_options_t format = COMMAND_FORMAT_NONE;
char *arg;
while (TRUE)
{
switch (command_getopt(&arg))
{
case 'h':
return command_usage(NULL);
case 'P':
format |= COMMAND_FORMAT_PRETTY;
/* fall through to raw */
case 'r':
format |= COMMAND_FORMAT_RAW;
continue;
case EOF:
break;
default:
return command_usage("invalid --log option");
}
break;
}
if (vici_register(conn, "log", log_cb, &format) != 0)
{
fprintf(stderr, "registering for log failed: %s\n", strerror(errno));
return errno;
}
wait_sigint();
fprintf(stderr, "disconnecting...\n");
return 0;
}
static int
lsproj_f(
int argc,
char **argv)
{
prid_t projid;
int c;
recurse_all = recurse_dir = 0;
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(&lsproj_cmd);
}
}
if (argc != optind)
return command_usage(&lsproj_cmd);
if (recurse_all || recurse_dir)
nftw(file->name, lsproj_callback,
100, FTW_PHYS | FTW_MOUNT | FTW_DEPTH);
else if (getprojid(file->name, file->fd, &projid) < 0)
perror("getprojid");
else
printf(_("projid = %u\n"), (unsigned int)projid);
return 0;
}
static int
lsattr_f(
int argc,
char **argv)
{
struct fsxattr fsx;
char *name = file->name;
int c, aflag = 0, vflag = 0;
recurse_all = recurse_dir = 0;
while ((c = getopt(argc, argv, "DRav")) != EOF) {
switch (c) {
case 'D':
recurse_all = 0;
recurse_dir = 1;
break;
case 'R':
recurse_all = 1;
recurse_dir = 0;
break;
case 'a':
aflag = 1;
vflag = 0;
break;
case 'v':
aflag = 0;
vflag = 1;
break;
default:
return command_usage(&lsattr_cmd);
}
}
if (recurse_all || recurse_dir) {
nftw(name, lsattr_callback,
100, FTW_PHYS | FTW_MOUNT | FTW_DEPTH);
} else if ((xfsctl(name, file->fd, XFS_IOC_FSGETXATTR, &fsx)) < 0) {
fprintf(stderr, _("%s: cannot get flags on %s: %s\n"),
progname, name, strerror(errno));
} else {
printxattr(fsx.fsx_xflags, vflag, !aflag, name, vflag, !aflag);
if (aflag) {
fputs("/", stdout);
printxattr(-1, 0, 1, name, 0, 1);
}
}
return 0;
}
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 funcptr_t
S_lookup_func(char * cmd, int argc)
{
int i;
for (i = 0; commands[i].command; i++) {
if (strcmp(cmd, commands[i].command) == 0) {
S_command_index = i;
if (argc < commands[i].argc) {
command_usage();
exit(1);
}
return commands[i].func;
}
}
return (NULL);
}
static int
S_set_user_autoconnect(int argc, char * argv[])
{
Boolean enable = FALSE;
const char * enable_str = argv[0];
int result;
if (strcasecmp(enable_str, "on") == 0) {
enable = TRUE;
}
else if (strcasecmp(enable_str, "off") == 0) {
enable = FALSE;
}
else {
command_usage();
}
EAPOLControlSetUserAutoConnectEnabled(enable);
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;
}
/**
* Dispatch commands.
*/
int command_dispatch(int c, char *v[])
{
int op, i;
options = options_create();
atexit(cleanup);
active = help_idx = registered;
argc = c;
argv = v;
command_register((command_t){help, 'h', "help", "show usage information"});
build_opts();
op = getopt_long(c, v, command_optstring, command_opts, NULL);
for (i = 0; cmds[i].cmd; i++)
{
if (cmds[i].op == op)
{
active = i;
build_opts();
return cmds[i].call();
}
}
return command_usage(c > 1 ? "invalid operation" : NULL);
}
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;
}
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 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;
}
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 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
bmap_f(
int argc,
char **argv)
{
struct fsxattr fsx;
struct getbmapx *map;
struct xfs_fsop_geom fsgeo;
int map_size;
int loop = 0;
int flg = 0;
int aflag = 0;
int lflag = 0;
int nflag = 0;
int pflag = 0;
int vflag = 0;
int is_rt = 0;
int bmv_iflags = 0; /* flags for XFS_IOC_GETBMAPX */
int i = 0;
int c;
int egcnt;
while ((c = getopt(argc, argv, "adln:pv")) != EOF) {
switch (c) {
case 'a': /* Attribute fork. */
bmv_iflags |= BMV_IF_ATTRFORK;
aflag = 1;
break;
case 'l': /* list number of blocks with each extent */
lflag = 1;
break;
case 'n': /* number of extents specified */
nflag = atoi(optarg);
break;
case 'd':
/* do not recall possibly offline DMAPI files */
bmv_iflags |= BMV_IF_NO_DMAPI_READ;
break;
case 'p':
/* report unwritten preallocated blocks */
pflag = 1;
bmv_iflags |= BMV_IF_PREALLOC;
break;
case 'v': /* Verbose output */
vflag++;
break;
default:
return command_usage(&bmap_cmd);
}
}
if (aflag)
bmv_iflags &= ~(BMV_IF_PREALLOC|BMV_IF_NO_DMAPI_READ);
if (vflag) {
c = xfsctl(file->name, file->fd, XFS_IOC_FSGEOMETRY_V1, &fsgeo);
if (c < 0) {
fprintf(stderr,
_("%s: can't get geometry [\"%s\"]: %s\n"),
progname, file->name, strerror(errno));
exitcode = 1;
return 0;
}
c = xfsctl(file->name, file->fd, XFS_IOC_FSGETXATTR, &fsx);
if (c < 0) {
fprintf(stderr,
_("%s: cannot read attrs on \"%s\": %s\n"),
progname, file->name, strerror(errno));
exitcode = 1;
return 0;
}
if (fsx.fsx_xflags == XFS_XFLAG_REALTIME) {
/*
* ag info not applicable to rt, continue
* without ag output.
*/
is_rt = 1;
}
}
map_size = nflag ? nflag+2 : 32; /* initial guess - 32 */
map = malloc(map_size*sizeof(*map));
if (map == NULL) {
fprintf(stderr, _("%s: malloc of %d bytes failed.\n"),
progname, (int)(map_size * sizeof(*map)));
exitcode = 1;
return 0;
}
/* Try the xfsctl(XFS_IOC_GETBMAPX) for the number of extents specified
* by nflag, or the initial guess number of extents (32).
*
* If there are more extents than we guessed, use xfsctl
* (XFS_IOC_FSGETXATTR[A]) to get the extent count, realloc some more
* space based on this count, and try again.
*
* If the initial FGETBMAPX attempt returns EINVAL, this may mean
* that we tried the FGETBMAPX on a zero length file. If we get
* EINVAL, check the length with fstat() and return "no extents"
* if the length == 0.
*
* Why not do the xfsctl(XFS_IOC_FSGETXATTR[A]) first? Two reasons:
* (1) The extent count may be wrong for a file with delayed
* allocation blocks. The XFS_IOC_GETBMAPX forces the real
* allocation and fixes up the extent count.
* (2) For XFS_IOC_GETBMAP[X] on a DMAPI file that has been moved
* offline by a DMAPI application (e.g., DMF) the
* XFS_IOC_FSGETXATTR only reflects the extents actually online.
* Doing XFS_IOC_GETBMAPX call first forces that data blocks online
* and then everything proceeds normally (see PV #545725).
*
* If you don't want this behavior on a DMAPI offline file,
* try the "-d" option which sets the BMV_IF_NO_DMAPI_READ
* iflag for XFS_IOC_GETBMAPX.
*/
do { /* loop a miximum of two times */
memset(map, 0, sizeof(*map)); /* zero header */
map->bmv_length = -1;
map->bmv_count = map_size;
map->bmv_iflags = bmv_iflags;
i = xfsctl(file->name, file->fd, XFS_IOC_GETBMAPX, map);
if (i < 0) {
if ( errno == EINVAL
&& !aflag && filesize() == 0) {
break;
} else {
fprintf(stderr, _("%s: xfsctl(XFS_IOC_GETBMAPX)"
" iflags=0x%x [\"%s\"]: %s\n"),
progname, map->bmv_iflags, file->name,
strerror(errno));
free(map);
exitcode = 1;
return 0;
}
}
if (nflag)
break;
if (map->bmv_entries < map->bmv_count-1)
break;
/* Get number of extents from xfsctl XFS_IOC_FSGETXATTR[A]
* syscall.
*/
i = xfsctl(file->name, file->fd, aflag ?
XFS_IOC_FSGETXATTRA : XFS_IOC_FSGETXATTR, &fsx);
if (i < 0) {
fprintf(stderr, "%s: xfsctl(XFS_IOC_FSGETXATTR%s) "
"[\"%s\"]: %s\n", progname, aflag ? "A" : "",
file->name, strerror(errno));
free(map);
exitcode = 1;
return 0;
}
if (2 * fsx.fsx_nextents > map_size) {
map_size = 2 * fsx.fsx_nextents + 1;
map = realloc(map, map_size*sizeof(*map));
if (map == NULL) {
fprintf(stderr,
_("%s: cannot realloc %d bytes\n"),
progname, (int)(map_size*sizeof(*map)));
exitcode = 1;
return 0;
}
}
} while (++loop < 2);
if (!nflag) {
if (map->bmv_entries <= 0) {
printf(_("%s: no extents\n"), file->name);
free(map);
return 0;
}
}
egcnt = nflag ? min(nflag, map->bmv_entries) : map->bmv_entries;
printf("%s:\n", file->name);
if (!vflag) {
for (i = 0; i < egcnt; i++) {
printf("\t%d: [%lld..%lld]: ", i,
(long long) map[i + 1].bmv_offset,
(long long)(map[i + 1].bmv_offset +
map[i + 1].bmv_length - 1LL));
if (map[i + 1].bmv_block == -1)
printf(_("hole"));
else {
printf("%lld..%lld",
(long long) map[i + 1].bmv_block,
(long long)(map[i + 1].bmv_block +
map[i + 1].bmv_length - 1LL));
}
if (lflag)
printf(_(" %lld blocks\n"),
(long long)map[i+1].bmv_length);
else
printf("\n");
}
} else {
/*
* Verbose mode displays:
* extent: [startoffset..endoffset]: startblock..endblock \
* ag# (agoffset..agendoffset) totalbbs
*/
#define MINRANGE_WIDTH 16
#define MINAG_WIDTH 2
#define MINTOT_WIDTH 5
#define NFLG 5 /* count of flags */
#define FLG_NULL 000000 /* Null flag */
#define FLG_PRE 010000 /* Unwritten extent */
#define FLG_BSU 001000 /* Not on begin of stripe unit */
#define FLG_ESU 000100 /* Not on end of stripe unit */
#define FLG_BSW 000010 /* Not on begin of stripe width */
#define FLG_ESW 000001 /* Not on end of stripe width */
int agno;
off64_t agoff, bbperag;
int foff_w, boff_w, aoff_w, tot_w, agno_w;
char rbuf[32], bbuf[32], abuf[32];
int sunit, swidth;
foff_w = boff_w = aoff_w = MINRANGE_WIDTH;
tot_w = MINTOT_WIDTH;
if (is_rt)
sunit = swidth = bbperag = 0;
else {
bbperag = (off64_t)fsgeo.agblocks *
(off64_t)fsgeo.blocksize / BBSIZE;
sunit = (fsgeo.sunit * fsgeo.blocksize) / BBSIZE;
swidth = (fsgeo.swidth * fsgeo.blocksize) / BBSIZE;
}
flg = sunit | pflag;
/*
* Go through the extents and figure out the width
* needed for all columns.
*/
for (i = 0; i < egcnt; i++) {
snprintf(rbuf, sizeof(rbuf), "[%lld..%lld]:",
(long long) map[i + 1].bmv_offset,
(long long)(map[i + 1].bmv_offset +
map[i + 1].bmv_length - 1LL));
if (map[i + 1].bmv_oflags & BMV_OF_PREALLOC)
flg = 1;
if (map[i + 1].bmv_block == -1) {
foff_w = max(foff_w, strlen(rbuf));
tot_w = max(tot_w,
numlen(map[i+1].bmv_length));
} else {
snprintf(bbuf, sizeof(bbuf), "%lld..%lld",
(long long) map[i + 1].bmv_block,
(long long)(map[i + 1].bmv_block +
map[i + 1].bmv_length - 1LL));
boff_w = max(boff_w, strlen(bbuf));
if (!is_rt) {
agno = map[i + 1].bmv_block / bbperag;
agoff = map[i + 1].bmv_block -
(agno * bbperag);
snprintf(abuf, sizeof(abuf),
"(%lld..%lld)",
(long long)agoff,
(long long)(agoff +
map[i + 1].bmv_length - 1LL));
aoff_w = max(aoff_w, strlen(abuf));
} else
aoff_w = 0;
foff_w = max(foff_w, strlen(rbuf));
tot_w = max(tot_w,
numlen(map[i+1].bmv_length));
}
}
agno_w = is_rt ? 0 : max(MINAG_WIDTH, numlen(fsgeo.agcount));
printf("%4s: %-*s %-*s %*s %-*s %*s%s\n",
_("EXT"),
foff_w, _("FILE-OFFSET"),
boff_w, is_rt ? _("RT-BLOCK-RANGE") : _("BLOCK-RANGE"),
agno_w, is_rt ? "" : _("AG"),
aoff_w, is_rt ? "" : _("AG-OFFSET"),
tot_w, _("TOTAL"),
flg ? _(" FLAGS") : "");
for (i = 0; i < egcnt; i++) {
flg = FLG_NULL;
if (map[i + 1].bmv_oflags & BMV_OF_PREALLOC) {
flg |= FLG_PRE;
}
/*
* If striping enabled, determine if extent starts/ends
* on a stripe unit boundary.
*/
if (sunit) {
if (map[i + 1].bmv_block % sunit != 0) {
flg |= FLG_BSU;
}
if (((map[i + 1].bmv_block +
map[i + 1].bmv_length ) % sunit ) != 0) {
flg |= FLG_ESU;
}
if (map[i + 1].bmv_block % swidth != 0) {
flg |= FLG_BSW;
}
if (((map[i + 1].bmv_block +
map[i + 1].bmv_length ) % swidth ) != 0) {
flg |= FLG_ESW;
}
}
snprintf(rbuf, sizeof(rbuf), "[%lld..%lld]:",
(long long) map[i + 1].bmv_offset,
(long long)(map[i + 1].bmv_offset +
map[i + 1].bmv_length - 1LL));
if (map[i + 1].bmv_block == -1) {
printf("%4d: %-*s %-*s %*s %-*s %*lld\n",
i,
foff_w, rbuf,
boff_w, _("hole"),
agno_w, "",
aoff_w, "",
tot_w, (long long)map[i+1].bmv_length);
} else {
snprintf(bbuf, sizeof(bbuf), "%lld..%lld",
(long long) map[i + 1].bmv_block,
(long long)(map[i + 1].bmv_block +
map[i + 1].bmv_length - 1LL));
printf("%4d: %-*s %-*s", i, foff_w, rbuf,
boff_w, bbuf);
if (!is_rt) {
agno = map[i + 1].bmv_block / bbperag;
agoff = map[i + 1].bmv_block -
(agno * bbperag);
snprintf(abuf, sizeof(abuf),
"(%lld..%lld)",
(long long)agoff,
(long long)(agoff +
map[i + 1].bmv_length - 1LL));
printf(" %*d %-*s", agno_w, agno,
aoff_w, abuf);
} else
printf(" ");
printf(" %*lld", tot_w,
(long long)map[i+1].bmv_length);
if (flg == FLG_NULL && !pflag) {
printf("\n");
} else {
printf(" %-*.*o\n", NFLG, NFLG, flg);
}
}
}
if ((flg || pflag) && vflag > 1) {
printf(_(" FLAG Values:\n"));
printf(_(" %*.*o Unwritten preallocated extent\n"),
NFLG+1, NFLG+1, FLG_PRE);
printf(_(" %*.*o Doesn't begin on stripe unit\n"),
NFLG+1, NFLG+1, FLG_BSU);
printf(_(" %*.*o Doesn't end on stripe unit\n"),
NFLG+1, NFLG+1, FLG_ESU);
printf(_(" %*.*o Doesn't begin on stripe width\n"),
NFLG+1, NFLG+1, FLG_BSW);
printf(_(" %*.*o Doesn't end on stripe width\n"),
NFLG+1, NFLG+1, FLG_ESW);
}
}
free(map);
return 0;
}