* Copyright (C) 2002 Cluster File Systems, Inc.
* Author: Peter J. Braam <braam@clusterfs.com>
* Author: Phil Schwan <phil@clusterfs.com>
- * Author: Robert Read <rread@clusterfs.com>
+ * Author: Andreas Dilger <adilger@clusterfs.com>
+ * Author: Robert Read <rread@clusterfs.com>
*
* This file is part of Lustre, http://www.lustre.org.
*
#include <linux/lustre_lib.h>
#include <linux/lustre_idl.h>
#include <linux/lustre_dlm.h>
+#include <linux/obd_lov.h> /* for IOC_LOV_SET_OSC_ACTIVE */
+#include <linux/obd.h> /* for struct lov_stripe_md */
+#include <linux/lustre_build_version.h>
#include <unistd.h>
#include <sys/un.h>
uint64_t conn_cookie;
char rawbuf[8192];
char *buf = rawbuf;
-int max = 8192;
+int max = sizeof(rawbuf);
static int thread;
+static struct lov_stripe_md saved_lsm;
+static char lsm_valid = 0;
static int getfd(char *func);
static char *cmdname(char *func);
} \
} while (0)
-/*
- pack "LL LL LL LL LL LL LL L L L L L L L L L a60 a60 L L L",
- $obdo->{id}, 0,
- $obdo->{gr}, 0,
- $obdo->{atime}, 0,
- $obdo->{mtime}, 0 ,
- $obdo->{ctime}, 0,
- $obdo->{size}, 0,
- $obdo->{blocks}, 0,
- $obdo->{blksize},
- $obdo->{mode},
- $obdo->{uid},
- $obdo->{gid},
- $obdo->{flags},
- $obdo->{obdflags},
- $obdo->{nlink},
- $obdo->{generation},
- $obdo->{valid},
- $obdo->{inline},
- $obdo->{obdmd},
- 0, 0, # struct list_head
- 0; # struct obd_ops
-}
+#define IOC_PACK(func, data) \
+do { \
+ if (obd_ioctl_pack(&data, &buf, max)) { \
+ fprintf(stderr, "error: %s: invalid ioctl\n", \
+ cmdname(func)); \
+ return -2; \
+ } \
+} while (0)
-*/
+#define IOC_UNPACK(func, data) \
+do { \
+ if (obd_ioctl_unpack(&data, buf, max)) { \
+ fprintf(stderr, "error: %s: invalid reply\n", \
+ cmdname(func)); \
+ return -2; \
+ } \
+} while (0)
char *obdo_print(struct obdo *obd)
{
char buf[1024];
- sprintf(buf, "id: %Ld\ngrp: %Ld\natime: %Ld\nmtime: %Ld\nctime: %Ld\n"
- "size: %Ld\nblocks: %Ld\nblksize: %d\nmode: %o\nuid: %d\n"
- "gid: %d\nflags: %x\nobdflags: %x\nnlink: %d,\nvalid %x\n",
- obd->o_id,
- obd->o_gr,
- obd->o_atime,
- obd->o_mtime,
- obd->o_ctime,
- obd->o_size,
- obd->o_blocks,
- obd->o_blksize,
- obd->o_mode,
- obd->o_uid,
- obd->o_gid,
- obd->o_flags, obd->o_obdflags, obd->o_nlink, obd->o_valid);
+ sprintf(buf, "id: "LPX64"\ngrp: "LPX64"\natime: "LPU64"\nmtime: "LPU64
+ "\nctime: "LPU64"\nsize: "LPU64"\nblocks: "LPU64
+ "\nblksize: %u\nmode: %o\nuid: %d\ngid: %d\nflags: %x\n"
+ "obdflags: %x\nnlink: %d,\nvalid %x\n",
+ obd->o_id, obd->o_gr, obd->o_atime, obd->o_mtime, obd->o_ctime,
+ obd->o_size, obd->o_blocks, obd->o_blksize, obd->o_mode,
+ obd->o_uid, obd->o_gid, obd->o_flags, obd->o_obdflags,
+ obd->o_nlink, obd->o_valid);
return strdup(buf);
}
+#define BAD_VERBOSE (-999999999)
#define N2D_OFF 0x100 /* So we can tell between error codes and devices */
data.ioc_inllen1 = strlen(name) + 1;
data.ioc_inlbuf1 = name;
- if (obd_ioctl_pack(&data, &buf, max)) {
- fprintf(stderr, "error: %s: invalid ioctl\n", cmdname(func));
- return -2;
- }
+ IOC_PACK(func, data);
rc = ioctl(fd, OBD_IOC_NAME2DEV, buf);
if (rc < 0) {
fprintf(stderr, "error: %s: %s - %s\n", cmdname(func),
name, strerror(rc = errno));
return rc;
}
-
- memcpy((char *)(&data), buf, sizeof(data));
+ IOC_UNPACK(func, data);
return data.ioc_dev + N2D_OFF;
}
-/*
+/*
* resolve a device name to a device number.
- * supports a number or name.
- * FIXME: support UUID
+ * supports a number or name.
+ * FIXME: support UUID
*/
-static int parse_devname(char * func, char *name)
+static int parse_devname(char *func, char *name)
{
int rc;
int ret = -1;
- if (!name)
+ if (!name)
return ret;
if (name[0] == '$') {
rc = do_name2dev(func, name + 1);
if (rc >= N2D_OFF) {
ret = rc - N2D_OFF;
- printf("%s is device %d\n", name,
- ret);
+ printf("%s is device %d\n", name, ret);
} else {
fprintf(stderr, "error: %s: %s: %s\n", cmdname(func),
name, "device not found");
}
-
} else
ret = strtoul(name, NULL, 0);
+
return ret;
}
((double)((a)->tv_usec - (b)->tv_usec) / 1000000))
static int be_verbose(int verbose, struct timeval *next_time,
- int num, int *next_num, int num_total)
+ __u64 num, __u64 *next_num, int num_total)
{
struct timeval now;
}
/* A negative verbosity means to print at most each X seconds */
- if (verbose < 0 && next_time != NULL && difftime(&now, next_time) >= 0) {
+ if (verbose < 0 && next_time != NULL && difftime(&now, next_time) >= 0){
next_time->tv_sec = now.tv_sec - verbose;
next_time->tv_usec = now.tv_usec;
if (next_num)
return 0;
}
-static int get_verbose(const char *arg)
+static int get_verbose(char *func, const char *arg)
{
int verbose;
+ char *end;
if (!arg || arg[0] == 'v')
verbose = 1;
else if (arg[0] == 's' || arg[0] == 'q')
verbose = 0;
- else
- verbose = (int)strtoul(arg, NULL, 0);
+ else {
+ verbose = (int)strtoul(arg, &end, 0);
+ if (*end) {
+ fprintf(stderr, "error: %s: bad verbose option '%s'\n",
+ cmdname(func), arg);
+ return BAD_VERBOSE;
+ }
+ }
if (verbose < 0)
printf("Print status every %d seconds\n", -verbose);
OBD_IOC_DISCONNECT, strerror(errno));
} else {
if (verbose)
- printf("%s: disconnected conn %Lx\n", cmdname(func),
+ printf("%s: disconnected conn "LPX64"\n", cmdname(func),
conn_addr);
conn_addr = -1;
}
#if SHMEM_STATS
static void shmem_setup(void)
{
+ /* Create new segment */
int shmid = shmget(IPC_PRIVATE, sizeof(counter_snapshot[0]), 0600);
if (shmid == -1) {
return;
}
+ /* Attatch to new segment */
shared_counters = (long long *)shmat(shmid, NULL, 0);
if (shared_counters == (long long *)(-1)) {
shared_counters = NULL;
return;
}
+
+ /* Mark segment as destroyed, so it will disappear when we exit.
+ * Forks will inherit attached segments, so we should be OK.
+ */
+ if (shmctl(shmid, IPC_RMID, NULL) == -1) {
+ fprintf(stderr, "Can't destroy shared memory counters: %s\n",
+ strerror(errno));
+ }
}
static inline void shmem_reset(void)
if (getfd(func))
return -1;
- if (obd_ioctl_pack(&data, &buf, max)) {
- fprintf(stderr, "error: %s: invalid ioctl\n", cmdname(func));
- return -2;
- }
-
+ IOC_PACK(func, data);
return ioctl(fd, OBD_IOC_DEVICE, buf);
}
int rc, dev;
do_disconnect(argv[0], 1);
- if (argc != 2)
+ if (argc != 2)
return CMD_HELP;
dev = parse_devname(argv[0], argv[1]);
- if (dev < 0) {
- return -1;
- }
+ if (dev < 0)
+ return -1;
rc = do_device(argv[0], dev);
if (rc < 0)
do_disconnect(argv[0], 1);
+#warning TODO: implement timeout per lctl usage for probe
if (argc != 1)
return CMD_HELP;
int ret;
int rc;
- if (argc < 3) {
- fprintf(stderr, "usage: %s devno <command [args ...]>\n",
- cmdname(argv[0]));
- return -1;
- }
+ if (argc < 3)
+ return CMD_HELP;
rc = do_device("device", parse_devname(argv[0], argv[1]));
int jt_opt_threads(int argc, char **argv)
{
- int threads, next_thread;
+ __u64 threads, next_thread;
int verbose;
int rc = 0;
+ char *end;
int i;
- if (argc < 5) {
- fprintf(stderr,
- "usage: %s numthreads verbose devno <cmd [args ...]>\n",
- argv[0]);
- return -1;
- }
+ if (argc < 5)
+ return CMD_HELP;
- threads = strtoul(argv[1], NULL, 0);
+ threads = strtoull(argv[1], &end, 0);
+ if (*end) {
+ fprintf(stderr, "error: %s: invalid page count '%s'\n",
+ cmdname(argv[0]), argv[1]);
+ return CMD_HELP;
+ }
- verbose = get_verbose(argv[2]);
+ verbose = get_verbose(argv[0], argv[2]);
+ if (verbose == BAD_VERBOSE)
+ return CMD_HELP;
if (verbose != 0)
- printf("%s: starting %d threads on device %s running %s\n",
+ printf("%s: starting "LPD64" threads on device %s running %s\n",
argv[0], threads, argv[3], argv[4]);
SHMEM_RESET();
* always returns 1 (OK). See wait(2).
*/
int err = WEXITSTATUS(status);
- if (err)
+ if (err || WIFSIGNALED(status))
fprintf(stderr,
"%s: PID %d had rc=%d\n",
argv[0], ret, err);
int jt_obd_detach(int argc, char **argv)
{
struct obd_ioctl_data data;
+ char force = 'F';
int rc;
IOCINIT(data);
- if (argc != 1)
+ if (argc != 1 && argc != 2)
return CMD_HELP;
- if (obd_ioctl_pack(&data, &buf, max)) {
- fprintf(stderr, "error: %s: invalid ioctl\n", cmdname(argv[0]));
- return -2;
+ if (argc == 2) {
+ data.ioc_inllen1 = 1;
+ data.ioc_inlbuf1 = &force;
}
+ IOC_PACK(argv[0], data);
rc = ioctl(fd, OBD_IOC_DETACH, buf);
if (rc < 0)
fprintf(stderr, "error: %s: %s\n", cmdname(argv[0]),
IOCINIT(data);
- if (argc != 1)
+ if (argc != 1)
return CMD_HELP;
rc = ioctl(fd, OBD_IOC_CLEANUP, &data);
IOCINIT(data);
- if (argc != 1)
+ if (argc != 1)
return CMD_HELP;
rc = ioctl(fd, OBD_IOC_NEWDEV, &data);
return rc;
}
+int jt_get_version(int argc, char **argv)
+{
+ int rc;
+ char buf[8192];
+ struct obd_ioctl_data *data = (struct obd_ioctl_data *)buf;
+
+ if (getfd(argv[0]))
+ return -1;
+
+ memset(buf, 0, sizeof(buf));
+ data->ioc_version = OBD_IOCTL_VERSION;
+ data->ioc_addr = conn_addr;
+ data->ioc_cookie = conn_addr;
+ data->ioc_len = sizeof(buf);
+ data->ioc_inllen1 = sizeof(buf) - size_round(sizeof(*data));
+
+ if (argc != 1)
+ return CMD_HELP;
+
+ rc = ioctl(fd, OBD_GET_VERSION, data);
+ if (rc < 0)
+ fprintf(stderr, "error: %s: %s\n", cmdname(argv[0]),
+ strerror(rc = errno));
+ else {
+ printf("Lustre version: %s\n", data->ioc_bulk);
+ }
+
+ printf("lctl version: %s\n",BUILD_VERSION);
+ return rc;
+}
+
int jt_obd_list(int argc, char **argv)
{
int rc;
- char buf[1024];
+ char buf[8192];
struct obd_ioctl_data *data = (struct obd_ioctl_data *)buf;
if (getfd(argv[0]))
data->ioc_len = sizeof(buf);
data->ioc_inllen1 = sizeof(buf) - size_round(sizeof(*data));
- if (argc != 1)
+ if (argc != 1)
return CMD_HELP;
rc = ioctl(fd, OBD_IOC_LIST, data);
IOCINIT(data);
- if (argc != 2 && argc != 3 && argc != 4)
+ if (argc != 2 && argc != 3 && argc != 4)
return CMD_HELP;
data.ioc_inllen1 = strlen(argv[1]) + 1;
data.ioc_inlbuf3 = argv[3];
}
- if (obd_ioctl_pack(&data, &buf, max)) {
- fprintf(stderr, "error: %s: invalid ioctl\n", cmdname(argv[0]));
- return -2;
- }
-
+ IOC_PACK(argv[0], data);
rc = ioctl(fd, OBD_IOC_ATTACH, buf);
if (rc < 0)
fprintf(stderr, "error: %s: %x %s\n", cmdname(argv[0]),
int jt_obd_name2dev(int argc, char **argv)
{
int rc;
- if (argc != 2)
+
+ if (argc != 2)
return CMD_HELP;
rc = do_name2dev(argv[0], argv[1]);
IOCINIT(data);
- if (argc > 3)
+ if (argc > 3)
return CMD_HELP;
data.ioc_dev = -1;
data.ioc_inlbuf2 = argv[2];
}
- if (obd_ioctl_pack(&data, &buf, max)) {
- fprintf(stderr, "error: %s: invalid ioctl\n", cmdname(argv[0]));
- return -2;
- }
+ IOC_PACK(argv[0], data);
rc = ioctl(fd, OBD_IOC_SETUP, buf);
if (rc < 0)
fprintf(stderr, "error: %s: %s\n", cmdname(argv[0]),
return rc;
}
-
+/* The ioctl API has been extended to provide the LOV stripe metadata to the
+ * caller when applicable. This utility, however, only saves the LSM for the
+ * latest CREATE. */
int jt_obd_create(int argc, char **argv)
{
struct obd_ioctl_data data;
struct timeval next_time;
- int count = 1, next_count;
- int verbose;
- int rc = 0, i;
+ __u64 count = 1, next_count;
+ int verbose = 1, mode = 0100644, rc = 0, i;
+ char *end;
IOCINIT(data);
- if (argc < 2 || argc > 4) {
- fprintf(stderr, "usage: %s num [mode] [verbose]\n",
- cmdname(argv[0]));
- return -1;
+ if (argc < 2 || argc > 4)
+ return CMD_HELP;
+
+ count = strtoull(argv[1], &end, 0);
+ if (*end) {
+ fprintf(stderr, "error: %s: invalid iteration count '%s'\n",
+ cmdname(argv[0]), argv[1]);
+ return CMD_HELP;
}
- count = strtoul(argv[1], NULL, 0);
- if (argc > 2)
- data.ioc_obdo1.o_mode = strtoul(argv[2], NULL, 0);
- else
- data.ioc_obdo1.o_mode = 0100644;
- data.ioc_obdo1.o_valid = OBD_MD_FLMODE;
+ if (argc > 2) {
+ mode = strtoul(argv[2], &end, 0);
+ if (*end) {
+ fprintf(stderr, "error: %s: invalid mode '%s'\n",
+ cmdname(argv[0]), argv[2]);
+ return CMD_HELP;
+ }
+ if (!(mode & S_IFMT))
+ mode |= S_IFREG;
+ }
- verbose = get_verbose(argv[3]);
+ if (argc > 3) {
+ verbose = get_verbose(argv[0], argv[3]);
+ if (verbose == BAD_VERBOSE)
+ return CMD_HELP;
+ }
- printf("%s: %d obdos\n", cmdname(argv[0]), count);
+ printf("%s: "LPD64" objects\n", cmdname(argv[0]), count);
gettimeofday(&next_time, NULL);
next_time.tv_sec -= verbose;
for (i = 1, next_count = verbose; i <= count; i++) {
- rc = ioctl(fd, OBD_IOC_CREATE, &data);
+ data.ioc_obdo1.o_mode = mode;
+ data.ioc_obdo1.o_id = i;
+ data.ioc_obdo1.o_uid = 0;
+ data.ioc_obdo1.o_gid = 0;
+ data.ioc_obdo1.o_valid = OBD_MD_FLTYPE | OBD_MD_FLMODE |
+ OBD_MD_FLID | OBD_MD_FLUID | OBD_MD_FLGID;;
+
+ data.ioc_inllen1 = sizeof(saved_lsm);
+ data.ioc_inlbuf1 = (char *)&saved_lsm;
+
+ IOC_PACK(argv[0], data);
+ rc = ioctl(fd, OBD_IOC_CREATE, buf);
+ IOC_UNPACK(argv[0], data);
+ fprintf(stderr, "lsm->lsm_o_id: "LPX64"\n",
+ saved_lsm.lsm_object_id);
SHMEM_BUMP();
if (rc < 0) {
fprintf(stderr, "error: %s: #%d - %s\n",
cmdname(argv[0]), i, strerror(rc = errno));
break;
}
+ if (!(data.ioc_obdo1.o_valid & OBD_MD_FLID)) {
+ fprintf(stderr, "error: %s: objid not valid #%d:%08x\n",
+ cmdname(argv[0]), i, data.ioc_obdo1.o_valid);
+ rc = EINVAL;
+ break;
+ }
+
+ lsm_valid = 1;
+
if (be_verbose(verbose, &next_time, i, &next_count, count))
- printf("%s: #%d is object id %Ld\n", cmdname(argv[0]),
- i, data.ioc_obdo1.o_id);
+ printf("%s: #%d is object id "LPX64"\n",
+ cmdname(argv[0]), i, data.ioc_obdo1.o_id);
}
return rc;
}
int jt_obd_setattr(int argc, char **argv)
{
struct obd_ioctl_data data;
+ char *end;
int rc;
IOCINIT(data);
if (argc != 2)
return CMD_HELP;
- data.ioc_obdo1.o_id = strtoul(argv[1], NULL, 0);
- data.ioc_obdo1.o_mode = S_IFREG | strtoul(argv[2], NULL, 0);
- data.ioc_obdo1.o_valid = OBD_MD_FLMODE;
+ data.ioc_obdo1.o_id = strtoull(argv[1], &end, 0);
+ if (*end) {
+ fprintf(stderr, "error: %s: invalid objid '%s'\n",
+ cmdname(argv[0]), argv[1]);
+ return CMD_HELP;
+ }
+ data.ioc_obdo1.o_mode = S_IFREG | strtoul(argv[2], &end, 0);
+ if (*end) {
+ fprintf(stderr, "error: %s: invalid mode '%s'\n",
+ cmdname(argv[0]), argv[2]);
+ return CMD_HELP;
+ }
+ data.ioc_obdo1.o_valid = OBD_MD_FLID | OBD_MD_FLTYPE | OBD_MD_FLMODE;
+
+ if (lsm_valid == 1) {
+ data.ioc_inllen1 = sizeof(saved_lsm);
+ data.ioc_inlbuf1 = (char *)&saved_lsm;
+ }
- rc = ioctl(fd, OBD_IOC_SETATTR, &data);
+ IOC_PACK(argv[0], data);
+ rc = ioctl(fd, OBD_IOC_SETATTR, buf);
if (rc < 0)
fprintf(stderr, "error: %s: %s\n", cmdname(argv[0]),
strerror(rc = errno));
int jt_obd_destroy(int argc, char **argv)
{
struct obd_ioctl_data data;
- int rc;
+ struct timeval next_time;
+ __u64 count = 1, next_count;
+ int verbose = 1;
+ __u64 id;
+ char *end;
+ int rc = 0, i;
IOCINIT(data);
- if (argc != 2) {
- fprintf(stderr, "usage: %s id\n", cmdname(argv[0]));
- return -1;
+ if (argc < 2 || argc > 4)
+ return CMD_HELP;
+
+ id = strtoull(argv[1], &end, 0);
+ if (*end) {
+ fprintf(stderr, "error: %s: invalid objid '%s'\n",
+ cmdname(argv[0]), argv[1]);
+ return CMD_HELP;
+ }
+ if (argc > 2) {
+ count = strtoull(argv[2], &end, 0);
+ if (*end) {
+ fprintf(stderr,
+ "error: %s: invalid iteration count '%s'\n",
+ cmdname(argv[0]), argv[2]);
+ return CMD_HELP;
+ }
}
- data.ioc_obdo1.o_id = strtoul(argv[1], NULL, 0);
- data.ioc_obdo1.o_mode = S_IFREG | 0644;
+ if (argc > 3) {
+ verbose = get_verbose(argv[0], argv[3]);
+ if (verbose == BAD_VERBOSE)
+ return CMD_HELP;
+ }
- rc = ioctl(fd, OBD_IOC_DESTROY, &data);
- if (rc < 0)
- fprintf(stderr, "error: %s: %s\n", cmdname(argv[0]),
- strerror(rc = errno));
+ printf("%s: "LPD64" objects\n", cmdname(argv[0]), count);
+ gettimeofday(&next_time, NULL);
+ next_time.tv_sec -= verbose;
+
+ for (i = 1, next_count = verbose; i <= count; i++, id++) {
+ data.ioc_obdo1.o_id = id;
+ data.ioc_obdo1.o_mode = S_IFREG | 0644;
+ data.ioc_obdo1.o_valid = OBD_MD_FLID | OBD_MD_FLMODE;
+
+ data.ioc_inllen1 = sizeof(saved_lsm);
+ data.ioc_inlbuf1 = (char *)&saved_lsm;
+
+ IOC_PACK(argv[0], data);
+ rc = ioctl(fd, OBD_IOC_DESTROY, buf);
+ IOC_UNPACK(argv[0], data);
+ SHMEM_BUMP();
+ if (rc < 0) {
+ fprintf(stderr, "error: %s: objid "LPX64": %s\n",
+ cmdname(argv[0]), id, strerror(rc = errno));
+ break;
+ }
+ lsm_valid = 0;
+
+ if (be_verbose(verbose, &next_time, i, &next_count, count))
+ printf("%s: #%d is object id "LPX64"\n",
+ cmdname(argv[0]), i, id);
+ }
return rc;
}
int jt_obd_getattr(int argc, char **argv)
{
struct obd_ioctl_data data;
+ char *end;
int rc;
- if (argc != 2)
+ if (argc != 2)
return CMD_HELP;
IOCINIT(data);
- data.ioc_obdo1.o_id = strtoul(argv[1], NULL, 0);
+ data.ioc_obdo1.o_id = strtoull(argv[1], &end, 0);
+ if (*end) {
+ fprintf(stderr, "error: %s: invalid objid '%s'\n",
+ cmdname(argv[0]), argv[1]);
+ return CMD_HELP;
+ }
/* to help obd filter */
data.ioc_obdo1.o_mode = 0100644;
data.ioc_obdo1.o_valid = 0xffffffff;
- printf("%s: object id %Ld\n", cmdname(argv[0]), data.ioc_obdo1.o_id);
+ printf("%s: object id "LPX64"\n", cmdname(argv[0]),data.ioc_obdo1.o_id);
+
+ if (lsm_valid == 1) {
+ data.ioc_inllen1 = sizeof(saved_lsm);
+ data.ioc_inlbuf1 = (char *)&saved_lsm;
+ }
- rc = ioctl(fd, OBD_IOC_GETATTR, &data);
+ IOC_PACK(argv[0], data);
+ rc = ioctl(fd, OBD_IOC_GETATTR, buf);
+ IOC_UNPACK(argv[0], data);
if (rc) {
fprintf(stderr, "error: %s: %s\n", cmdname(argv[0]),
strerror(rc = errno));
} else {
- printf("%s: object id %Ld, mode %o\n", cmdname(argv[0]),
+ printf("%s: object id "LPX64", mode %o\n", cmdname(argv[0]),
data.ioc_obdo1.o_id, data.ioc_obdo1.o_mode);
}
return rc;
{
struct obd_ioctl_data data;
struct timeval start, next_time;
- int i, count, next_count;
- int verbose;
+ __u64 i, count, next_count;
+ int verbose = 1;
+ obd_id objid = 3;
+ char *end;
int rc = 0;
- if (argc != 2 && argc != 3)
+ if (argc < 2 && argc > 4)
return CMD_HELP;
IOCINIT(data);
- count = strtoul(argv[1], NULL, 0);
+ count = strtoull(argv[1], &end, 0);
+ if (*end) {
+ fprintf(stderr, "error: %s: invalid iteration count '%s'\n",
+ cmdname(argv[0]), argv[1]);
+ return CMD_HELP;
+ }
- if (argc == 3)
- verbose = get_verbose(argv[2]);
- else
- verbose = 1;
+ if (argc >= 3) {
+ verbose = get_verbose(argv[0], argv[2]);
+ if (verbose == BAD_VERBOSE)
+ return CMD_HELP;
+ }
+
+ if (argc >= 4) {
+ if (argv[3][0] == 't') {
+ objid = strtoull(argv[3] + 1, &end, 0);
+ if (thread)
+ objid += thread - 1;
+ } else
+ objid = strtoull(argv[3], &end, 0);
+ if (*end) {
+ fprintf(stderr, "error: %s: invalid objid '%s'\n",
+ cmdname(argv[0]), argv[3]);
+ return CMD_HELP;
+ }
+ }
- data.ioc_obdo1.o_valid = 0xffffffff;
- data.ioc_obdo1.o_id = 2;
gettimeofday(&start, NULL);
next_time.tv_sec = start.tv_sec - verbose;
next_time.tv_usec = start.tv_usec;
if (verbose != 0)
- printf("%s: getting %d attrs (testing only): %s",
- cmdname(argv[0]), count, ctime(&start.tv_sec));
+ printf("%s: getting "LPD64" attrs (objid "LPX64"): %s",
+ cmdname(argv[0]), count, objid, ctime(&start.tv_sec));
for (i = 1, next_count = verbose; i <= count; i++) {
+ data.ioc_obdo1.o_id = objid;
+ data.ioc_obdo1.o_mode = S_IFREG;
+ data.ioc_obdo1.o_valid = 0xffffffff;
rc = ioctl(fd, OBD_IOC_GETATTR, &data);
SHMEM_BUMP();
if (rc < 0) {
- fprintf(stderr, "error: %s: #%d - %s\n",
+ fprintf(stderr, "error: %s: #"LPD64" - %s\n",
cmdname(argv[0]), i, strerror(rc = errno));
break;
} else {
if (be_verbose
(verbose, &next_time, i, &next_count, count))
- printf("%s: got attr #%d\n", cmdname(argv[0]),
- i);
+ printf("%s: got attr #"LPD64"\n",
+ cmdname(argv[0]), i);
}
}
--i;
if (verbose != 0)
- printf("%s: %d attrs in %.4gs (%.4g attr/s): %s",
+ printf("%s: "LPD64" attrs in %.4gs (%.4g attr/s): %s",
cmdname(argv[0]), i, diff, (double)i / diff,
ctime(&end.tv_sec));
}
{
struct obd_ioctl_data data;
struct timeval start, next_time;
- char *bulk, *b;
- int pages = 1, obdos = 1, count, next_count;
+ int pages = 1;
+ __u64 count, next_count;
+ __u64 objid = 3;
int verbose = 1, write = 0, rw;
- int i, o, p;
+ char *end;
+ int thr_offset = 0;
+ int i;
int len;
int rc = 0;
- if (argc < 2 || argc > 6)
+ if (argc < 2 || argc > 6) {
+ fprintf(stderr, "error: %s: bad number of arguments: %d\n",
+ cmdname(argv[0]), argc);
return CMD_HELP;
+ }
+
+ /* make each thread write to a different offset */
+ if (argv[1][0] == 't') {
+ count = strtoull(argv[1] + 1, &end, 0);
+ if (thread)
+ thr_offset = thread - 1;
+ } else
+ count = strtoull(argv[1], &end, 0);
- count = strtoul(argv[1], NULL, 0);
+ if (*end) {
+ fprintf(stderr, "error: %s: bad iteration count '%s'\n",
+ cmdname(argv[0]), argv[1]);
+ return CMD_HELP;
+ }
if (argc >= 3) {
if (argv[2][0] == 'w' || argv[2][0] == '1')
write = 1;
else if (argv[2][0] == 'r' || argv[2][0] == '0')
write = 0;
-
- verbose = get_verbose(argv[3]);
}
- if (argc >= 5)
- pages = strtoul(argv[4], NULL, 0);
- if (argc >= 6)
- obdos = strtoul(argv[5], NULL, 0);
+ if (argc >= 4) {
+ verbose = get_verbose(argv[0], argv[3]);
+ if (verbose == BAD_VERBOSE)
+ return CMD_HELP;
+ }
- if (obdos != 1 && obdos != 2) {
- fprintf(stderr, "error: %s: only 1 or 2 obdos supported\n",
- cmdname(argv[0]));
- return -2;
+ if (argc >= 5) {
+ pages = strtoul(argv[4], &end, 0);
+ if (*end) {
+ fprintf(stderr, "error: %s: bad page count '%s'\n",
+ cmdname(argv[0]), argv[4]);
+ return CMD_HELP;
+ }
+ }
+ if (argc >= 6) {
+ if (argv[5][0] == 't') {
+ objid = strtoull(argv[5] + 1, &end, 0);
+ if (thread)
+ objid += thread - 1;
+ } else
+ objid = strtoull(argv[5], &end, 0);
+ if (*end) {
+ fprintf(stderr, "error: %s: bad objid '%s'\n",
+ cmdname(argv[0]), argv[5]);
+ return CMD_HELP;
+ }
}
len = pages * PAGE_SIZE;
- bulk = calloc(obdos, len);
- if (!bulk) {
- fprintf(stderr, "error: %s: no memory allocating %dx%d pages\n",
- cmdname(argv[0]), obdos, pages);
- return -2;
- }
IOCINIT(data);
- data.ioc_obdo1.o_id = 2;
+ data.ioc_obdo1.o_id = objid;
+ data.ioc_obdo1.o_mode = S_IFREG;
+ data.ioc_obdo1.o_valid = OBD_MD_FLID | OBD_MD_FLTYPE | OBD_MD_FLMODE;
data.ioc_count = len;
- data.ioc_offset = 0;
- data.ioc_plen1 = len;
- data.ioc_pbuf1 = bulk;
- if (obdos > 1) {
- data.ioc_obdo2.o_id = 3;
- data.ioc_plen2 = len;
- data.ioc_pbuf2 = bulk + len;
+ data.ioc_offset = thr_offset * len * count;
+
+ if (lsm_valid == 1) {
+ data.ioc_inllen1 = sizeof(saved_lsm);
+ data.ioc_inlbuf1 = (char *)&saved_lsm;
}
gettimeofday(&start, NULL);
next_time.tv_usec = start.tv_usec;
if (verbose != 0)
- printf("%s: %s %d (%dx%d pages) (testing only): %s",
- cmdname(argv[0]), write ? "writing" : "reading",
- count, obdos, pages, ctime(&start.tv_sec));
-
- /*
- * We will put in the start time (and loop count inside the loop)
- * at the beginning of each page so that we will be able to validate
- * (at some later time) whether the data actually made it or not.
- *
- * XXX we do not currently use any of this memory in OBD_IOC_BRW_*
- * just to avoid the overhead of the copy_{to,from}_user. It
- * can be fixed if we ever need to send real data around.
- */
- for (o = 0, b = bulk; o < obdos; o++)
- for (p = 0; p < pages; p++, b += PAGE_SIZE)
- memcpy(b, &start, sizeof(start));
+ printf("%s: %s "LPU64"x%d pages (obj "LPX64", off "LPU64"): %s",
+ cmdname(argv[0]), write ? "writing" : "reading", count,
+ pages, objid, data.ioc_offset, ctime(&start.tv_sec));
+
+ IOC_PACK(argv[0], data);
+ rc = ioctl(fd, OBD_IOC_OPEN, buf);
+ IOC_UNPACK(argv[0], data);
+ if (rc) {
+ fprintf(stderr, "error: brw_open: %s\n", strerror(rc = errno));
+ return rc;
+ }
rw = write ? OBD_IOC_BRW_WRITE : OBD_IOC_BRW_READ;
for (i = 1, next_count = verbose; i <= count; i++) {
- if (write) {
- b = bulk + sizeof(struct timeval);
- for (o = 0; o < obdos; o++)
- for (p = 0; p < pages; p++, b += PAGE_SIZE)
- memcpy(b, &count, sizeof(count));
- }
-
- rc = ioctl(fd, rw, &data);
+ rc = ioctl(fd, rw, buf);
SHMEM_BUMP();
if (rc) {
fprintf(stderr, "error: %s: #%d - %s on %s\n",
cmdname(argv[0]), i, strerror(rc = errno),
write ? "write" : "read");
break;
- } else if (be_verbose
- (verbose, &next_time, i, &next_count, count))
- printf("%s: %s number %d\n", cmdname(argv[0]),
- write ? "write" : "read", i);
- }
+ } else if (be_verbose(verbose, &next_time,i, &next_count,count))
+ printf("%s: %s number %dx%d\n", cmdname(argv[0]),
+ write ? "write" : "read", i, pages);
- free(bulk);
+ data.ioc_offset += len;
+ }
if (!rc) {
struct timeval end;
--i;
if (verbose != 0)
- printf("%s: %s %dx%dx%d pages in %.4gs (%.4g pg/s): %s",
+ printf("%s: %s %dx%d pages in %.4gs (%.4g pg/s): %s",
cmdname(argv[0]), write ? "wrote" : "read",
- obdos, pages, i, diff,
- (double)obdos * i * pages / diff,
+ i, pages, diff, (double)i * pages / diff,
ctime(&end.tv_sec));
}
+ rw = ioctl(fd, OBD_IOC_CLOSE, buf);
+ if (rw) {
+ fprintf(stderr, "error: brw_close: %s\n", strerror(rw = errno));
+ if (!rc)
+ rc = rw;
+ }
+
return rc;
}
-int jt_obd_lov_config(int argc, char **argv)
+int jt_obd_lov_setconfig(int argc, char **argv)
{
struct obd_ioctl_data data;
struct lov_desc desc;
- uuid_t *uuidarray;
- int rc, size, i;
- IOCINIT(data);
+ obd_uuid_t *uuidarray, *ptr;
+ int rc, i;
+ char *end;
- printf("WARNING: obdctl lovconfig NOT MAINTAINED\n");
- return -1;
+ IOCINIT(data);
if (argc <= 6)
return CMD_HELP;
- if (strlen(argv[1]) > sizeof(uuid_t) - 1) {
- fprintf(stderr, "lov_config: no %dB memory for uuid's\n",
- strlen(argv[1]));
- return -ENOMEM;
+ if (strlen(argv[1]) > sizeof(desc.ld_uuid) - 1) {
+ fprintf(stderr,
+ "error: %s: LOV uuid '%s' longer than %d characters\n",
+ cmdname(argv[0]), argv[1], sizeof(desc.ld_uuid) - 1);
+ return -EINVAL;
}
memset(&desc, 0, sizeof(desc));
- strcpy(desc.ld_uuid, argv[1]);
- desc.ld_default_stripe_count = strtoul(argv[2], NULL, 0);
- desc.ld_default_stripe_size = strtoul(argv[3], NULL, 0);
- desc.ld_default_stripe_offset = (__u64) strtoul(argv[4], NULL, 0);
- desc.ld_pattern = strtoul(argv[5], NULL, 0);
+ strncpy(desc.ld_uuid, argv[1], sizeof(desc.ld_uuid) - 1);
desc.ld_tgt_count = argc - 6;
+ desc.ld_default_stripe_count = strtoul(argv[2], &end, 0);
+ if (*end) {
+ fprintf(stderr, "error: %s: bad default stripe count '%s'\n",
+ cmdname(argv[0]), argv[2]);
+ return CMD_HELP;
+ }
+ if (desc.ld_default_stripe_count > desc.ld_tgt_count) {
+ fprintf(stderr,
+ "error: %s: default stripe count %u > OST count %u\n",
+ cmdname(argv[0]), desc.ld_default_stripe_count,
+ desc.ld_tgt_count);
+ return -EINVAL;
+ }
+ desc.ld_default_stripe_size = strtoull(argv[3], &end, 0);
+ if (*end) {
+ fprintf(stderr, "error: %s: bad default stripe size '%s'\n",
+ cmdname(argv[0]), argv[3]);
+ return CMD_HELP;
+ }
+ if (desc.ld_default_stripe_size < 4096) {
+ fprintf(stderr,
+ "error: %s: default stripe size "LPU64" too small\n",
+ cmdname(argv[0]), desc.ld_default_stripe_size);
+ return -EINVAL;
+ } else if ((long)desc.ld_default_stripe_size <
+ desc.ld_default_stripe_size) {
+ fprintf(stderr,
+ "error: %s: default stripe size "LPU64" too large\n",
+ cmdname(argv[0]), desc.ld_default_stripe_size);
+ return -EINVAL;
+ }
+ desc.ld_default_stripe_offset = strtoull(argv[4], &end, 0);
+ if (*end) {
+ fprintf(stderr, "error: %s: bad default stripe offset '%s'\n",
+ cmdname(argv[0]), argv[4]);
+ return CMD_HELP;
+ }
+ desc.ld_pattern = strtoul(argv[5], &end, 0);
+ if (*end) {
+ fprintf(stderr, "error: %s: bad stripe pattern '%s'\n",
+ cmdname(argv[0]), argv[5]);
+ return CMD_HELP;
+ }
- size = sizeof(uuid_t) * desc.ld_tgt_count;
- uuidarray = malloc(size);
+ /* NOTE: it is possible to overwrite the default striping parameters,
+ * but EXTREME care must be taken when saving the OST UUID list.
+ * It must be EXACTLY the same, or have only additions at the
+ * end of the list, or only overwrite individual OST entries
+ * that are restored from backups of the previous OST.
+ */
+ uuidarray = calloc(desc.ld_tgt_count, sizeof(*uuidarray));
if (!uuidarray) {
- fprintf(stderr, "lov_config: no %dB memory for uuid's\n", size);
- return -ENOMEM;
+ fprintf(stderr, "error: %s: no memory for %d UUIDs\n",
+ cmdname(argv[0]), desc.ld_tgt_count);
+ rc = -ENOMEM;
+ goto out;
}
- memset(uuidarray, 0, size);
- for (i = 6; i < argc; i++) {
- char *buf = (char *)(uuidarray + i - 6);
- if (strlen(argv[i]) >= sizeof(uuid_t)) {
- fprintf(stderr, "lov_config: arg %d (%s) too long\n",
- i, argv[i]);
- free(uuidarray);
- return -EINVAL;
+ for (i = 6, ptr = uuidarray; i < argc; i++, ptr++) {
+ if (strlen(argv[i]) >= sizeof(*ptr)) {
+ fprintf(stderr, "error: %s: arg %d (%s) too long\n",
+ cmdname(argv[0]), i, argv[i]);
+ rc = -EINVAL;
+ goto out;
}
- strcpy(buf, argv[i]);
+ strcpy((char *)ptr, argv[i]);
}
data.ioc_inllen1 = sizeof(desc);
data.ioc_inlbuf1 = (char *)&desc;
- data.ioc_inllen2 = size;
+ data.ioc_inllen2 = desc.ld_tgt_count * sizeof(*uuidarray);
data.ioc_inlbuf2 = (char *)uuidarray;
if (obd_ioctl_pack(&data, &buf, max)) {
fprintf(stderr, "error: %s: invalid ioctl\n", cmdname(argv[0]));
+ rc = -EINVAL;
+ goto out;
+ }
+ rc = ioctl(fd, OBD_IOC_LOV_SET_CONFIG, buf);
+ if (rc)
+ fprintf(stderr, "error: %s: ioctl error: %s\n",
+ cmdname(argv[0]), strerror(rc = errno));
+out:
+ free(uuidarray);
+ return rc;
+}
+
+#define DEF_UUID_ARRAY_LEN (8192 / 40)
+
+int jt_obd_lov_getconfig(int argc, char **argv)
+{
+ struct obd_ioctl_data data;
+ struct lov_desc desc;
+ obd_uuid_t *uuidarray;
+ int rc;
+
+ IOCINIT(data);
+
+ if (argc != 2)
+ return CMD_HELP;
+
+ if (strlen(argv[1]) > sizeof(desc.ld_uuid) - 1) {
+ fprintf(stderr,
+ "error: %s: LOV uuid '%s' longer than %d characters\n",
+ cmdname(argv[0]), argv[1], sizeof(desc.ld_uuid) - 1);
return -EINVAL;
}
- rc = ioctl(fd, OBD_IOC_LOV_CONFIG, buf);
- if (rc < 0)
- fprintf(stderr, "lov_config: error: %s: %s\n",
+ memset(&desc, 0, sizeof(desc));
+ strncpy(desc.ld_uuid, argv[1], sizeof(desc.ld_uuid) - 1);
+ desc.ld_tgt_count = DEF_UUID_ARRAY_LEN;
+repeat:
+ uuidarray = calloc(desc.ld_tgt_count, sizeof(*uuidarray));
+ if (!uuidarray) {
+ fprintf(stderr, "error: %s: no memory for %d uuid's\n",
+ cmdname(argv[0]), desc.ld_tgt_count);
+ return -ENOMEM;
+ }
+
+ data.ioc_inllen1 = sizeof(desc);
+ data.ioc_inlbuf1 = (char *)&desc;
+ data.ioc_inllen2 = desc.ld_tgt_count * sizeof(*uuidarray);
+ data.ioc_inlbuf2 = (char *)uuidarray;
+
+ if (obd_ioctl_pack(&data, &buf, max)) {
+ fprintf(stderr, "error: %s: invalid ioctl\n", cmdname(argv[0]));
+ rc = -EINVAL;
+ goto out;
+ }
+ rc = ioctl(fd, OBD_IOC_LOV_GET_CONFIG, buf);
+ if (rc == -ENOSPC) {
+ free(uuidarray);
+ goto repeat;
+ } else if (rc) {
+ fprintf(stderr, "error: %s: ioctl error: %s\n",
cmdname(argv[0]), strerror(rc = errno));
+ } else {
+ obd_uuid_t *ptr;
+ int i;
+
+ if (obd_ioctl_unpack(&data, buf, max)) {
+ fprintf(stderr, "error: %s: invalid reply\n",
+ cmdname(argv[0]));
+ rc = -EINVAL;
+ goto out;
+ }
+ printf("default_stripe_count: %u\n",
+ desc.ld_default_stripe_count);
+ printf("default_stripe_size: "LPU64"\n",
+ desc.ld_default_stripe_size);
+ printf("default_stripe_offset: "LPU64"\n",
+ desc.ld_default_stripe_offset);
+ printf("default_stripe_pattern: %u\n", desc.ld_pattern);
+ printf("obd_count: %u\n", desc.ld_tgt_count);
+ for (i = 0, ptr = uuidarray; i < desc.ld_tgt_count; i++, ptr++)
+ printf("%u: %s\n", i, (char *)ptr);
+ }
+out:
free(uuidarray);
return rc;
}
int rc;
IOCINIT(data);
- if (argc != 1)
+ if (argc != 1)
return CMD_HELP;
rc = ioctl(fd, IOC_LDLM_TEST, &data);
int rc;
IOCINIT(data);
- if (argc != 1) {
- fprintf(stderr, "usage: %s\n", cmdname(argv[0]));
- return 1;
- }
+ if (argc != 1)
+ return CMD_HELP;
rc = ioctl(fd, IOC_LDLM_DUMP, &data);
if (rc)
return rc;
}
+int jt_obd_ldlm_regress_start(int argc, char **argv)
+{
+ int rc;
+ struct obd_ioctl_data data;
+ char argstring[200];
+ int i, count = sizeof(argstring) - 1;
+
+ IOCINIT(data);
+ if (argc > 5)
+ return CMD_HELP;
+
+ argstring[0] = '\0';
+ for (i = 1; i < argc; i++) {
+ strncat(argstring, " ", count);
+ count--;
+ strncat(argstring, argv[i], count);
+ count -= strlen(argv[i]);
+ }
+
+ if (strlen(argstring)) {
+ data.ioc_inlbuf1 = argstring;
+ data.ioc_inllen1 = strlen(argstring) + 1;
+ }
+
+ IOC_PACK(argv[0], data);
+ rc = ioctl(fd, IOC_LDLM_REGRESS_START, buf);
+ if (rc)
+ fprintf(stderr, "error: %s: test failed: %s\n",
+ cmdname(argv[0]), strerror(rc = errno));
+
+ return rc;
+}
+
+int jt_obd_ldlm_regress_stop(int argc, char **argv)
+{
+ int rc;
+ struct obd_ioctl_data data;
+ IOCINIT(data);
+
+ if (argc != 1)
+ return CMD_HELP;
+
+ rc = ioctl(fd, IOC_LDLM_REGRESS_STOP, &data);
+
+ if (rc)
+ fprintf(stderr, "error: %s: test failed: %s\n",
+ cmdname(argv[0]), strerror(rc = errno));
+ return rc;
+}
+
+int jt_obd_lov_set_osc_active(int argc, char **argv)
+{
+ struct obd_ioctl_data data;
+ int rc;
+
+ IOCINIT(data);
+ if (argc != 3)
+ return CMD_HELP;
+
+ data.ioc_inlbuf1 = argv[1];
+ data.ioc_inllen1 = strlen(argv[1]) + 1;
+
+ /* reuse offset for 'active' */
+ data.ioc_offset = atoi(argv[2]);
+
+ IOC_PACK(argv[0], data);
+ rc = ioctl(fd, IOC_LOV_SET_OSC_ACTIVE, buf);
+ if (rc)
+ fprintf(stderr, "error: %s: failed: %s\n",
+ cmdname(argv[0]), strerror(rc = errno));
+
+ return rc;
+}
+
int jt_obd_newconn(int argc, char **argv)
{
int rc;
struct obd_ioctl_data data;
IOCINIT(data);
- if (argc != 1)
+ if (argc < 2 || argc > 3)
return CMD_HELP;
- rc = ioctl(fd, OBD_IOC_RECOVD_NEWCONN, &data);
+ data.ioc_inllen1 = strlen(argv[1]) + 1;
+ data.ioc_inlbuf1 = argv[1];
+
+ if (argc == 3) {
+ data.ioc_inllen2 = strlen(argv[2]) + 1;
+ data.ioc_inlbuf2 = argv[2];
+ }
+
+ IOC_PACK(argv[0], data);
+ rc = ioctl(fd, OBD_IOC_RECOVD_NEWCONN, buf);
if (rc < 0)
fprintf(stderr, "error: %s: %s\n", cmdname(argv[0]),
strerror(rc = errno));
return rc;
}
+int jt_obd_failconn(int argc, char **argv)
+{
+ int rc;
+ struct obd_ioctl_data data;
+
+ IOCINIT(data);
+ if (argc < 2)
+ return CMD_HELP;
+
+ data.ioc_inllen1 = strlen(argv[1]) + 1;
+ data.ioc_inlbuf1 = argv[1];
+
+ IOC_PACK(argv[0], data);
+ rc = ioctl(fd, OBD_IOC_RECOVD_FAILCONN, buf);
+ if (rc < 0)
+ fprintf(stderr, "error: %s: %s\n", cmdname(argv[0]),
+ strerror(rc = errno));
+
+ return rc;
+}
+
static void signal_server(int sig)
{
if (sig == SIGINT) {
fprintf(stderr, "%s: got signal %d\n", cmdname("sigint"), sig);
}
-int obd_initialize(int argc, char **argv)
+int obd_initialize(int argc, char **argv)
{
SHMEM_SETUP();
return 0;
}
-void obd_cleanup(int argc, char **argv)
+void obd_cleanup(int argc, char **argv)
{
struct sigaction sigact;
git://git.whamcloud.com / fs / lustre-release.git / blobdiff