#include <stdio.h>
#include <stdarg.h>
#include <signal.h>
-#define printk printf
+#ifndef __KERNEL__
+#include <liblustre.h>
+#endif
#include <linux/lustre_lib.h>
#include <linux/lustre_idl.h>
#include <linux/lustre_dlm.h>
+#include <linux/obd.h> /* for struct lov_stripe_md */
+#include <linux/lustre_build_version.h>
#include <unistd.h>
#include <sys/un.h>
#include <time.h>
#include <sys/time.h>
-#include <netinet/in.h>
#include <errno.h>
#include <string.h>
#undef __KERNEL__
#include "obdctl.h"
+#include <portals/ptlctl.h>
#include "parser.h"
#include <stdio.h>
struct timeval prev_time;
#endif
-int fd = -1;
-uint64_t conn_addr = -1;
-uint64_t conn_cookie;
+uint64_t conn_cookie = -1;
char rawbuf[8192];
char *buf = rawbuf;
-int max = 8192;
+int max = sizeof(rawbuf);
static int thread;
-static int getfd(char *func);
+union lsm_buffer {
+ char space [4096];
+ struct lov_stripe_md lsm;
+} lsm_buffer;
+
static char *cmdname(char *func);
-#define IOCINIT(data) \
+#define IOC_INIT(data) \
do { \
memset(&data, 0, sizeof(data)); \
- data.ioc_version = OBD_IOCTL_VERSION; \
- data.ioc_addr = conn_addr; \
data.ioc_cookie = conn_cookie; \
- data.ioc_len = sizeof(data); \
- if (fd < 0) { \
- fprintf(stderr, "No device open, use device\n"); \
- return 1; \
+} while (0)
+
+#define IOC_PACK(func, data) \
+do { \
+ memset(buf, 0, sizeof(rawbuf)); \
+ 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 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);
}
struct obd_ioctl_data data;
int rc;
- if (getfd(func))
- return -1;
-
- IOCINIT(data);
+ IOC_INIT(data);
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;
- }
- 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_PACK(func, data);
+ rc = l_ioctl(OBD_DEV_ID, OBD_IOC_NAME2DEV, buf);
+ if (rc < 0)
+ return errno;
+ 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, $name or %uuid.
*/
static int parse_devname(char *func, char *name)
{
if (!name)
return ret;
- if (name[0] == '$') {
- rc = do_name2dev(func, name + 1);
+ if (name[0] == '$' || name[0] == '%') {
+ name++;
+ rc = do_name2dev(func, name);
if (rc >= N2D_OFF) {
ret = rc - N2D_OFF;
- printf("%s is device %d\n", name, ret);
+ printf("Name %s is device %d\n", name, ret);
} else {
- fprintf(stderr, "error: %s: %s: %s\n", cmdname(func),
- name, "device not found");
+ printf("No device found for name %s: %s\n",
+ name, strerror(rc));
}
- } else
+ } else {
+ /* Assume it's a number. This means that bogus strings become
+ * 0. I might care about that some day. */
ret = strtoul(name, NULL, 0);
+ printf("Selected device %d\n", ret);
+ }
return ret;
}
+static char *
+lsm_string (struct lov_stripe_md *lsm)
+{
+ static char buffer[4096];
+ char *p = buffer;
+ int space = sizeof (buffer);
+ int i;
+ int nob;
+
+ *p = 0;
+ space--;
+
+ nob = snprintf(p, space, LPX64, lsm->lsm_object_id);
+ p += nob;
+ space -= nob;
+
+ if (lsm->lsm_stripe_count != 0) {
+ nob = snprintf (p, space, "=%u#%u@%d",
+ lsm->lsm_stripe_size,
+ lsm->lsm_stripe_count,
+ lsm->lsm_stripe_offset);
+ p += nob;
+ space -= nob;
+
+ for (i = 0; i < lsm->lsm_stripe_count; i++) {
+ nob = snprintf (p, space, ":"LPX64,
+ lsm->lsm_oinfo[i].loi_id);
+ p += nob;
+ space -= nob;
+ }
+ }
+
+ if (space == 0) { /* probable overflow */
+ fprintf (stderr, "lsm_string() overflowed buffer\n");
+ abort ();
+ }
+
+ return (buffer);
+}
+
+static void
+reset_lsmb (union lsm_buffer *lsmb)
+{
+ memset (lsmb->space, 0, sizeof (lsmb->space));
+ lsmb->lsm.lsm_magic = LOV_MAGIC;
+}
+
+static int
+parse_lsm (union lsm_buffer *lsmb, char *string)
+{
+ struct lov_stripe_md *lsm = &lsmb->lsm;
+ char *end;
+ int i;
+
+ /*
+ * object_id[=size#count[@offset][:id]*]
+ */
+
+ reset_lsmb (lsmb);
+
+ lsm->lsm_object_id = strtoull (string, &end, 0);
+ if (end == string)
+ return (-1);
+ string = end;
+
+ if (*string == 0)
+ return (0);
+
+ if (*string != '=')
+ return (-1);
+ string++;
+
+ lsm->lsm_stripe_size = strtoul (string, &end, 0);
+ if (end == string)
+ return (-1);
+ string = end;
+
+ if (*string != '#')
+ return (-1);
+ string++;
+
+ lsm->lsm_stripe_count = strtoul (string, &end, 0);
+ if (end == string)
+ return (-1);
+ string = end;
+
+ if (*string == '@') {
+ string++;
+ lsm->lsm_stripe_offset = strtol (string, &end, 0);
+ if (end == string)
+ return (-1);
+ string = end;
+ }
+
+ if (*string == 0) /* don't have to specify obj ids */
+ return (0);
+
+ for (i = 0; i < lsm->lsm_stripe_count; i++) {
+ if (*string != ':')
+ return (-1);
+ string++;
+ lsm->lsm_oinfo[i].loi_id = strtoull (string, &end, 0);
+ string = end;
+ }
+
+ if (*string != 0)
+ return (-1);
+
+ return (0);
+}
+
static char *cmdname(char *func)
{
static char buf[512];
return func;
}
-static int getfd(char *func)
-{
- if (fd == -1)
- fd = open("/dev/obd", O_RDWR);
- if (fd == -1) {
- fprintf(stderr, "error: %s: opening /dev/obd: %s\n"
- "hint: lustre kernel modules may not be loaded.\n",
- cmdname(func), strerror(errno));
- return -1;
- }
- return 0;
-}
-
#define difftime(a, b) \
((double)(a)->tv_sec - (b)->tv_sec + \
((double)((a)->tv_usec - (b)->tv_usec) / 1000000))
int rc;
struct obd_ioctl_data data;
- if (conn_addr == -1)
+ if (conn_cookie == -1)
return 0;
- IOCINIT(data);
+ IOC_INIT(data);
- rc = ioctl(fd, OBD_IOC_DISCONNECT, &data);
+ IOC_PACK(func, data);
+ rc = l_ioctl(OBD_DEV_ID, OBD_IOC_DISCONNECT, buf);
if (rc < 0) {
- fprintf(stderr, "error: %s: %x %s\n", cmdname(func),
- OBD_IOC_DISCONNECT, strerror(errno));
+ fprintf(stderr, "error: %s: OPD_IOC_DISCONNECT %s\n",
+ cmdname(func),strerror(errno));
} else {
if (verbose)
- printf("%s: disconnected conn %Lx\n", cmdname(func),
- conn_addr);
- conn_addr = -1;
+ printf("%s: disconnected conn "LPX64"\n", cmdname(func),
+ conn_cookie);
+ conn_cookie = -1;
}
return rc;
#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)
prev_time = this_time;
}
-#define SHMEM_SETUP() shmem_setup()
-#define SHMEM_RESET() shmem_reset()
-#define SHMEM_BUMP() shmem_bump()
-#define SHMEM_SNAP(n) shmem_snap(n)
+#define SHMEM_SETUP() shmem_setup()
+#define SHMEM_RESET() shmem_reset()
+#define SHMEM_BUMP() shmem_bump()
+#define SHMEM_SNAP(n) shmem_snap(n)
#else
#define SHMEM_SETUP()
#define SHMEM_RESET()
data.ioc_dev = dev;
- if (getfd(func))
- return -1;
-
- if (obd_ioctl_pack(&data, &buf, max)) {
- fprintf(stderr, "error: %s: invalid ioctl\n", cmdname(func));
- return -2;
- }
-
- return ioctl(fd, OBD_IOC_DEVICE, buf);
+ IOC_PACK(func, data);
+ return l_ioctl(OBD_DEV_ID, OBD_IOC_DEVICE, buf);
}
int jt_obd_device(int argc, char **argv)
struct obd_ioctl_data data;
int rc;
- IOCINIT(data);
+ IOC_INIT(data);
do_disconnect(argv[0], 1);
-#warning TODO: implement timeout per lctl usage for probe
+ /* XXX TODO: implement timeout per lctl usage for probe */
if (argc != 1)
return CMD_HELP;
- rc = ioctl(fd, OBD_IOC_CONNECT, &data);
+ IOC_PACK(argv[0], data);
+ rc = l_ioctl(OBD_DEV_ID, OBD_IOC_CONNECT, buf);
+ IOC_UNPACK(argv[0], data);
if (rc < 0)
- fprintf(stderr, "error: %s: %x %s\n", cmdname(argv[0]),
- OBD_IOC_CONNECT, strerror(rc = errno));
- else {
- conn_addr = data.ioc_addr;
+ fprintf(stderr, "error: %s: OBD_IOC_CONNECT %s\n",
+ cmdname(argv[0]), strerror(rc = errno));
+ else
conn_cookie = data.ioc_cookie;
- }
return rc;
}
if (argc != 1)
return CMD_HELP;
- if (conn_addr == -1)
+ if (conn_cookie == -1)
return 0;
return do_disconnect(argv[0], 0);
return rc;
}
+int jt_opt_net(int argc, char **argv)
+{
+ char *arg2[3];
+ int rc;
+
+ if (argc < 3)
+ return CMD_HELP;
+
+ arg2[0] = argv[0];
+ arg2[1] = argv[1];
+ arg2[2] = NULL;
+ rc = jt_ptl_network (2, arg2);
+
+ if (!rc)
+ rc = Parser_execarg(argc - 2, argv + 2, cmdlist);
+
+ return rc;
+}
+
int jt_obd_detach(int argc, char **argv)
{
struct obd_ioctl_data data;
int rc;
- IOCINIT(data);
+ IOC_INIT(data);
if (argc != 1)
return CMD_HELP;
- if (obd_ioctl_pack(&data, &buf, max)) {
- fprintf(stderr, "error: %s: invalid ioctl\n", cmdname(argv[0]));
- return -2;
- }
-
- rc = ioctl(fd, OBD_IOC_DETACH, buf);
+ IOC_PACK(argv[0], data);
+ rc = l_ioctl(OBD_DEV_ID, OBD_IOC_DETACH, buf);
if (rc < 0)
fprintf(stderr, "error: %s: %s\n", cmdname(argv[0]),
strerror(rc = errno));
int jt_obd_cleanup(int argc, char **argv)
{
struct obd_ioctl_data data;
+ char force = 'F';
+ char failover = 'A';
+ char flags[3];
+ int flag_cnt = 0, n;
+ int rc;
+
+ IOC_INIT(data);
+
+ if (argc < 1 || argc > 3)
+ return CMD_HELP;
+
+ for (n = 1; n < argc; n++)
+ if (strcmp(argv[n], "force") == 0) {
+ flags[flag_cnt++] = force;
+ } else if (strcmp(argv[n], "failover") == 0) {
+ flags[flag_cnt++] = failover;
+ } else {
+ fprintf(stderr, "unknown option: %s", argv[n]);
+ return CMD_HELP;
+ }
+
+ data.ioc_inllen1 = flag_cnt;
+ if (flag_cnt)
+ data.ioc_inlbuf1 = flags;
+
+ IOC_PACK(argv[0], data);
+ rc = l_ioctl(OBD_DEV_ID, OBD_IOC_CLEANUP, buf);
+ if (rc < 0)
+ fprintf(stderr, "error: %s: %s\n", cmdname(argv[0]),
+ strerror(rc = errno));
+
+ return rc;
+}
+
+int jt_obd_no_transno(int argc, char **argv)
+{
+ struct obd_ioctl_data data;
int rc;
- IOCINIT(data);
+ IOC_INIT(data);
if (argc != 1)
return CMD_HELP;
- rc = ioctl(fd, OBD_IOC_CLEANUP, &data);
+ IOC_PACK(argv[0], data);
+ rc = l_ioctl(OBD_DEV_ID, OBD_IOC_NO_TRANSNO, buf);
if (rc < 0)
fprintf(stderr, "error: %s: %s\n", cmdname(argv[0]),
strerror(rc = errno));
return rc;
}
-int jt_obd_newdev(int argc, char **argv)
+int jt_obd_set_readonly(int argc, char **argv)
{
+ struct obd_ioctl_data data;
int rc;
+
+ IOC_INIT(data);
+
+ if (argc != 1)
+ return CMD_HELP;
+
+ IOC_PACK(argv[0], data);
+ rc = l_ioctl(OBD_DEV_ID, OBD_IOC_SET_READONLY, buf);
+ if (rc < 0)
+ fprintf(stderr, "error: %s: %s\n", cmdname(argv[0]),
+ strerror(rc = errno));
+
+ return rc;
+}
+
+int jt_obd_abort_recovery(int argc, char **argv)
+{
struct obd_ioctl_data data;
+ int rc;
- if (getfd(argv[0]))
- return -1;
+ IOC_INIT(data);
- IOCINIT(data);
+ if (argc != 1)
+ return CMD_HELP;
+
+ IOC_PACK(argv[0], data);
+ rc = l_ioctl(OBD_DEV_ID, OBD_IOC_ABORT_RECOVERY, buf);
+ if (rc < 0)
+ fprintf(stderr, "error: %s: %s\n", cmdname(argv[0]),
+ strerror(rc = errno));
+
+ return rc;
+}
+
+int jt_obd_newdev(int argc, char **argv)
+{
+ int rc;
+ struct obd_ioctl_data data;
+
+ IOC_INIT(data);
if (argc != 1)
return CMD_HELP;
- rc = ioctl(fd, OBD_IOC_NEWDEV, &data);
+ IOC_PACK(argv[0], data);
+ rc = l_ioctl(OBD_DEV_ID, OBD_IOC_NEWDEV, buf);
if (rc < 0)
fprintf(stderr, "error: %s: %s\n", cmdname(argv[0]),
strerror(rc = errno));
else {
+ IOC_UNPACK(argv[0], data);
printf("Current device set to %d\n", data.ioc_dev);
}
return rc;
}
-int jt_obd_list(int argc, char **argv)
+int jt_obd_mount_option(int argc, char **argv)
+{
+ int rc;
+ struct obd_ioctl_data data;
+
+ IOC_INIT(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 = l_ioctl(OBD_DEV_ID, OBD_IOC_MOUNTOPT, buf);
+ if (rc < 0) {
+ fprintf(stderr, "error: %s: %s\n", cmdname(argv[0]),
+ strerror(rc = errno));
+ }
+
+ 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;
+ if (argc != 1)
+ return CMD_HELP;
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_cookie = conn_cookie;
data->ioc_inllen1 = sizeof(buf) - size_round(sizeof(*data));
+ data->ioc_len = obd_ioctl_packlen(data);
+
+ rc = l_ioctl(OBD_DEV_ID, OBD_GET_VERSION, buf);
+ 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[8192];
+ struct obd_ioctl_data *data = (struct obd_ioctl_data *)buf;
if (argc != 1)
return CMD_HELP;
- rc = ioctl(fd, OBD_IOC_LIST, data);
+ memset(buf, 0, sizeof(buf));
+ data->ioc_version = OBD_IOCTL_VERSION;
+ data->ioc_cookie = conn_cookie;
+ data->ioc_inllen1 = sizeof(buf) - size_round(sizeof(*data));
+ data->ioc_len = obd_ioctl_packlen(data);
+
+ rc = l_ioctl(OBD_DEV_ID, OBD_IOC_LIST, data);
if (rc < 0)
fprintf(stderr, "error: %s: %s\n", cmdname(argv[0]),
strerror(rc = errno));
struct obd_ioctl_data data;
int rc;
- IOCINIT(data);
+ IOC_INIT(data);
if (argc != 2 && argc != 3 && argc != 4)
return CMD_HELP;
data.ioc_inlbuf3 = argv[3];
}
- if (obd_ioctl_pack(&data, &buf, max)) {
- fprintf(stderr, "error: %s: invalid ioctl\n", cmdname(argv[0]));
- return -2;
- }
-
- rc = ioctl(fd, OBD_IOC_ATTACH, buf);
+ IOC_PACK(argv[0], data);
+ rc = l_ioctl(OBD_DEV_ID, OBD_IOC_ATTACH, buf);
if (rc < 0)
- fprintf(stderr, "error: %s: %x %s\n", cmdname(argv[0]),
- OBD_IOC_ATTACH, strerror(rc = errno));
+ fprintf(stderr, "error: %s: OBD_IOC_ATTACH %s\n",
+ cmdname(argv[0]), strerror(rc = errno));
else if (argc == 3) {
char name[1024];
if (strlen(argv[2]) > 128) {
return rc;
}
-int jt_obd_name2dev(int argc, char **argv)
-{
- int rc;
-
- if (argc != 2)
- return CMD_HELP;
-
- rc = do_name2dev(argv[0], argv[1]);
- if (rc >= N2D_OFF) {
- int dev = rc - N2D_OFF;
- rc = do_device(argv[0], dev);
- if (rc == 0)
- printf("%d\n", dev);
- }
- return rc;
-}
-
int jt_obd_setup(int argc, char **argv)
{
struct obd_ioctl_data data;
int rc;
- IOCINIT(data);
+ IOC_INIT(data);
- if (argc > 3)
+ if (argc > 5)
return CMD_HELP;
data.ioc_dev = -1;
data.ioc_inllen1 = strlen(argv[1]) + 1;
data.ioc_inlbuf1 = argv[1];
}
- if (argc == 3) {
+ if (argc > 2) {
data.ioc_inllen2 = strlen(argv[2]) + 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;
+ if (argc > 3) {
+ data.ioc_inllen3 = strlen(argv[3]) + 1;
+ data.ioc_inlbuf3 = argv[3];
+ }
+ if (argc > 4) {
+ data.ioc_inllen4 = strlen(argv[4]) + 1;
+ data.ioc_inlbuf4 = argv[4];
}
- rc = ioctl(fd, OBD_IOC_SETUP, buf);
+
+ IOC_PACK(argv[0], data);
+ rc = l_ioctl(OBD_DEV_ID, OBD_IOC_SETUP, buf);
if (rc < 0)
fprintf(stderr, "error: %s: %s\n", cmdname(argv[0]),
strerror(rc = errno));
return rc;
}
+/* Get echo client's stripe meta-data for the given object
+ */
+int jt_obd_get_stripe (int argc, char **argv)
+{
+ struct obd_ioctl_data data;
+ __u64 id;
+ int rc;
+ char *end;
+
+ if (argc != 2)
+ return (CMD_HELP);
+
+ id = strtoull (argv[1], &end, 0);
+ if (*end) {
+ fprintf (stderr, "Error: %s: invalid object id '%s'\n",
+ cmdname (argv[0]), argv[1]);
+ return (CMD_HELP);
+ }
+
+ memset (&lsm_buffer, 0, sizeof (lsm_buffer));
+
+ IOC_INIT (data);
+ 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_pbuf1 = (char *)&lsm_buffer;
+ data.ioc_plen1 = sizeof (lsm_buffer);
+
+ IOC_PACK(argv[0], data);
+ rc = l_ioctl(OBD_DEV_ID, ECHO_IOC_GET_STRIPE, buf);
+ IOC_UNPACK(argv[0], data);
+
+ if (rc != 0) {
+ fprintf (stderr, "Error: %s: rc %d(%s)\n",
+ cmdname (argv[0]), rc, strerror (errno));
+ return (rc);
+ }
+
+ printf ("%s\n", lsm_string (&lsm_buffer.lsm));
+
+ return (rc);
+}
+
+/* Set stripe meta-data for 1 or more objects. Object must be new to
+ * this echo client instance.
+ */
+int jt_obd_set_stripe (int argc, char **argv)
+{
+ struct obd_ioctl_data data;
+ char *end;
+ int count = 1;
+ int i;
+ int rc;
+
+ if (argc < 2 || argc > 3)
+ return CMD_HELP;
+
+ rc = parse_lsm (&lsm_buffer, argv[1]);
+ if (rc != 0) {
+ fprintf (stderr, "error: %s: invalid object '%s'\n",
+ cmdname (argv[0]), argv[1]);
+ return CMD_HELP;
+ }
+
+ if (argc > 2) {
+ count = strtol (argv[2], &end, 0);
+ if (*end != 0) {
+ fprintf (stderr, "error: %s: invalid count '%s'\n",
+ cmdname (argv[0]), argv[1]);
+ return CMD_HELP;
+ }
+ }
+
+ for (i = 0; i < count; i++) {
+ IOC_INIT (data);
+ data.ioc_obdo1.o_id = lsm_buffer.lsm.lsm_object_id + i;
+ data.ioc_obdo1.o_mode = S_IFREG | 0644;
+ data.ioc_obdo1.o_valid = OBD_MD_FLID | OBD_MD_FLMODE;
+ data.ioc_pbuf1 = (char *)&lsm_buffer;
+ data.ioc_plen1 = sizeof (lsm_buffer);
+ IOC_PACK (argv[0], data);
+ rc = l_ioctl (OBD_DEV_ID, ECHO_IOC_SET_STRIPE, buf);
+ IOC_UNPACK (argv[0], data);
+
+ if (rc != 0) {
+ fprintf (stderr, "Error: %s: rc %d(%s)\n",
+ cmdname (argv[0]), rc, strerror (errno));
+ return (rc);
+ }
+ }
+
+ return (0);
+}
+
+/* Clear stripe meta-data info for an object on this echo-client instance
+ */
+int jt_obd_unset_stripe (int argc, char **argv)
+{
+ struct obd_ioctl_data data;
+ char *end;
+ obd_id id;
+ int rc;
+
+ if (argc != 2)
+ return CMD_HELP;
+
+ id = strtoull (argv[1], &end, 0);
+ if (*end != 0) {
+ fprintf (stderr, "error: %s: invalid object id '%s'\n",
+ cmdname (argv[0]), argv[1]);
+ return CMD_HELP;
+ }
+
+ IOC_INIT (data);
+ 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;
+
+ IOC_PACK (argv[0], data);
+ rc = l_ioctl (OBD_DEV_ID, ECHO_IOC_SET_STRIPE, buf);
+ IOC_UNPACK (argv[0], data);
+
+ if (rc != 0)
+ fprintf (stderr, "Error: %s: rc %d(%s)\n",
+ cmdname (argv[0]), rc, strerror (errno));
+
+ return (0);
+}
+
+/* Create one or more objects, arg[4] may describe stripe meta-data. If
+ * not, defaults assumed. This echo-client instance stashes the stripe
+ * object ids. Use get_stripe on this node to print full lsm and
+ * set_stripe on another node to cut/paste between nodes.
+ */
int jt_obd_create(int argc, char **argv)
{
+ static __u64 base_id = 1;
+
struct obd_ioctl_data data;
struct timeval next_time;
__u64 count = 1, next_count;
- int verbose = 1;
- int mode = 0100644;
- int rc = 0, i;
+ int verbose = 1, mode = 0100644, rc = 0, i;
char *end;
- IOCINIT(data);
- if (argc < 2 || argc > 4)
+ IOC_INIT(data);
+ if (argc < 2 || argc > 5)
return CMD_HELP;
count = strtoull(argv[1], &end, 0);
cmdname(argv[0]), argv[2]);
return CMD_HELP;
}
+ if (!(mode & S_IFMT))
+ mode |= S_IFREG;
}
if (argc > 3) {
return CMD_HELP;
}
+ if (argc < 5)
+ reset_lsmb (&lsm_buffer); /* will set default */
+ else {
+ rc = parse_lsm (&lsm_buffer, argv[4]);
+ if (rc != 0) {
+ fprintf(stderr, "error: %s: invalid lsm '%s'\n",
+ cmdname(argv[0]), argv[4]);
+ return CMD_HELP;
+ }
+ base_id = lsm_buffer.lsm.lsm_object_id;
+ }
+
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++) {
data.ioc_obdo1.o_mode = mode;
- data.ioc_obdo1.o_id = i;
- data.ioc_obdo1.o_valid = OBD_MD_FLMODE | OBD_MD_FLID;
-
- rc = ioctl(fd, OBD_IOC_CREATE, &data);
+ data.ioc_obdo1.o_id = base_id++;
+ 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_plen1 = sizeof (lsm_buffer);
+ data.ioc_pbuf1 = (char *)&lsm_buffer;
+
+ IOC_PACK(argv[0], data);
+ rc = l_ioctl(OBD_DEV_ID, OBD_IOC_CREATE, buf);
+ IOC_UNPACK(argv[0], data);
SHMEM_BUMP();
if (rc < 0) {
fprintf(stderr, "error: %s: #%d - %s\n",
}
if (be_verbose(verbose, &next_time, i, &next_count, count))
- printf("%s: #%d is object id 0x%Lx\n", cmdname(argv[0]),
- i, (long long)data.ioc_obdo1.o_id);
+ printf("%s: #%d is object id "LPX64"\n",
+ cmdname(argv[0]), i, data.ioc_obdo1.o_id);
}
return rc;
}
char *end;
int rc;
- IOCINIT(data);
+ IOC_INIT(data);
if (argc != 2)
return CMD_HELP;
cmdname(argv[0]), argv[2]);
return CMD_HELP;
}
- data.ioc_obdo1.o_valid = OBD_MD_FLID | OBD_MD_FLMODE;
+ data.ioc_obdo1.o_valid = OBD_MD_FLID | OBD_MD_FLTYPE | OBD_MD_FLMODE;
- rc = ioctl(fd, OBD_IOC_SETATTR, &data);
+ IOC_PACK(argv[0], data);
+ rc = l_ioctl(OBD_DEV_ID, 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;
+ struct timeval next_time;
+ __u64 count = 1, next_count;
+ int verbose = 1;
+ __u64 id;
char *end;
- int rc;
+ int rc = 0, i;
- IOCINIT(data);
- if (argc != 2)
+ IOC_INIT(data);
+ if (argc < 2 || argc > 4)
return CMD_HELP;
- data.ioc_obdo1.o_id = strtoull(argv[1], &end, 0);
+ 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 | 0644;
+ 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;
+ }
+ }
- rc = ioctl(fd, OBD_IOC_DESTROY, &data);
- if (rc < 0)
- fprintf(stderr, "error: %s: %s\n", cmdname(argv[0]),
- strerror(rc = errno));
+ if (argc > 3) {
+ verbose = get_verbose(argv[0], argv[3]);
+ if (verbose == BAD_VERBOSE)
+ return CMD_HELP;
+ }
+
+ 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;
+
+ IOC_PACK(argv[0], data);
+ rc = l_ioctl(OBD_DEV_ID, 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;
+ }
+
+ 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;
}
if (argc != 2)
return CMD_HELP;
- IOCINIT(data);
+ IOC_INIT(data);
data.ioc_obdo1.o_id = strtoull(argv[1], &end, 0);
if (*end) {
fprintf(stderr, "error: %s: invalid objid '%s'\n",
/* 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);
- rc = ioctl(fd, OBD_IOC_GETATTR, &data);
+ IOC_PACK(argv[0], data);
+ rc = l_ioctl(OBD_DEV_ID, 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;
if (argc < 2 && argc > 4)
return CMD_HELP;
- IOCINIT(data);
+ IOC_INIT(data);
count = strtoull(argv[1], &end, 0);
if (*end) {
fprintf(stderr, "error: %s: invalid iteration count '%s'\n",
}
if (argc >= 4) {
- if (argv[3][0] == 't')
- objid = strtoull(argv[3] + 1, &end, 0) + thread - 1;
- else
+ 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",
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);
+ IOC_PACK(argv[0], data);
+ rc = l_ioctl(OBD_DEV_ID, OBD_IOC_GETATTR, &data);
SHMEM_BUMP();
if (rc < 0) {
- fprintf(stderr, "error: %s: #"LPD64" - %s\n",
- cmdname(argv[0]), i, strerror(rc = errno));
+ fprintf(stderr, "error: %s: #"LPD64" - %d:%s\n",
+ cmdname(argv[0]), i, errno, strerror(rc = errno));
break;
} else {
if (be_verbose
/* make each thread write to a different offset */
if (argv[1][0] == 't') {
- thr_offset = thread - 1;
count = strtoull(argv[1] + 1, &end, 0);
+ if (thread)
+ thr_offset = thread - 1;
} else
count = strtoull(argv[1], &end, 0);
}
}
if (argc >= 6) {
- if (argv[5][0] == 't')
- objid = strtoull(argv[5] + 1, &end, 0) + thread - 1;
- else
+ 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",
len = pages * PAGE_SIZE;
- IOCINIT(data);
+ IOC_INIT(data);
data.ioc_obdo1.o_id = objid;
data.ioc_obdo1.o_mode = S_IFREG;
- data.ioc_obdo1.o_valid = OBD_MD_FLID | OBD_MD_FLMODE;
+ data.ioc_obdo1.o_valid = OBD_MD_FLID | OBD_MD_FLTYPE | OBD_MD_FLMODE;
data.ioc_count = len;
data.ioc_offset = thr_offset * len * count;
cmdname(argv[0]), write ? "writing" : "reading", count,
pages, objid, data.ioc_offset, ctime(&start.tv_sec));
- rc = ioctl(fd, OBD_IOC_OPEN, &data);
+ IOC_PACK(argv[0], data);
+ rc = l_ioctl(OBD_DEV_ID, 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++) {
- rc = ioctl(fd, rw, &data);
+ rc = l_ioctl(OBD_DEV_ID, rw, buf);
SHMEM_BUMP();
if (rc) {
fprintf(stderr, "error: %s: #%d - %s on %s\n",
i, pages, diff, (double)i * pages / diff,
ctime(&end.tv_sec));
}
- rw = ioctl(fd, OBD_IOC_CLOSE, &data);
+ rw = l_ioctl(OBD_DEV_ID, OBD_IOC_CLOSE, buf);
if (rw) {
fprintf(stderr, "error: brw_close: %s\n", strerror(rw = errno));
if (!rc)
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;
- obd_uuid_t *uuidarray;
- int rc, size, i;
+ struct obd_uuid *uuidarray, *ptr;
+ int rc, i;
char *end;
- IOCINIT(data);
+ IOC_INIT(data);
if (argc <= 6)
return CMD_HELP;
- if (strlen(argv[1]) > sizeof(*uuidarray) - 1) {
- fprintf(stderr, "error: %s: no %dB memory for uuid's\n",
- cmdname(argv[0]), strlen(argv[1]));
- return -ENOMEM;
+ if (strlen(argv[1]) > sizeof(desc.ld_uuid) - 1) {
+ fprintf(stderr,
+ "error: %s: LOV uuid '%s' longer than "LPSZ" chars\n",
+ cmdname(argv[0]), argv[1], sizeof(desc.ld_uuid) - 1);
+ return -EINVAL;
}
memset(&desc, 0, sizeof(desc));
- strncpy(desc.ld_uuid, argv[1], sizeof(*uuidarray) - 1);
+ obd_str2uuid(&desc.ld_uuid, argv[1]);
desc.ld_tgt_count = argc - 6;
desc.ld_default_stripe_count = strtoul(argv[2], &end, 0);
if (*end) {
}
if (desc.ld_default_stripe_count > desc.ld_tgt_count) {
fprintf(stderr,
- "error: %s: stripe count %d more than OST count %d\n",
+ "error: %s: default stripe count %u > OST count %u\n",
cmdname(argv[0]), desc.ld_default_stripe_count,
desc.ld_tgt_count);
return -EINVAL;
}
- if (desc.ld_default_stripe_count == 0)
- desc.ld_default_stripe_count = desc.ld_tgt_count;
- desc.ld_default_stripe_size = strtoul(argv[3], &end, 0);
+ 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: stripe size %ld too small\n",
- cmdname(argv[0]), (long)desc.ld_default_stripe_size);
+ 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 = (__u64) strtoul(argv[4], &end, 0);
+ 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;
}
- size = desc.ld_tgt_count * sizeof(*uuidarray);
- 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, "error: %s: no %dB memory for uuid's\n",
- cmdname(argv[0]), size);
- return -ENOMEM;
- }
- memset(uuidarray, 0, size);
- for (i = 6; i < argc; i++) {
- char *buf = (char *)(uuidarray + i - 6);
- if (strlen(argv[i]) >= sizeof(*uuidarray)) {
+ fprintf(stderr, "error: %s: no memory for %d UUIDs\n",
+ cmdname(argv[0]), desc.ld_tgt_count);
+ rc = -ENOMEM;
+ goto out;
+ }
+ 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]);
- free(uuidarray);
- return -EINVAL;
+ 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]));
- return -EINVAL;
+ rc = -EINVAL;
+ goto out;
}
-
- rc = ioctl(fd, OBD_IOC_LOV_CONFIG, buf);
+ rc = l_ioctl(OBD_DEV_ID, OBD_IOC_LOV_SET_CONFIG, buf);
if (rc)
- fprintf(stderr, "lov_config: error: %s: %s\n",
+ 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;
+ struct obd_uuid *uuidarray;
+ char *path;
+ int rc, fd;
+
+ IOC_INIT(data);
+
+ if (argc != 2)
+ return CMD_HELP;
+
+ path = argv[1];
+ fd = open(path, O_RDONLY);
+ if (fd < 0) {
+ fprintf(stderr, "open \"%s\" failed: %s\n", path,
+ strerror(errno));
+ return -1;
+ }
+
+ memset(&desc, 0, sizeof(desc));
+ obd_str2uuid(&desc.ld_uuid, argv[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);
+ rc = -ENOMEM;
+ goto out;
+ }
+
+ 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 {
+ struct obd_uuid *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);
+ close(fd);
return rc;
}
struct obd_ioctl_data data;
int rc;
- IOCINIT(data);
+ IOC_INIT(data);
if (argc != 1)
return CMD_HELP;
- rc = ioctl(fd, IOC_LDLM_TEST, &data);
+ IOC_PACK(argv[0], data);
+ rc = l_ioctl(OBD_DEV_ID, IOC_LDLM_TEST, buf);
if (rc)
fprintf(stderr, "error: %s: test failed: %s\n",
cmdname(argv[0]), strerror(rc = errno));
struct obd_ioctl_data data;
int rc;
- IOCINIT(data);
+ IOC_INIT(data);
if (argc != 1)
return CMD_HELP;
- rc = ioctl(fd, IOC_LDLM_DUMP, &data);
+ IOC_PACK(argv[0], data);
+ rc = l_ioctl(OBD_DEV_ID, IOC_LDLM_DUMP, buf);
if (rc)
fprintf(stderr, "error: %s failed: %s\n",
cmdname(argv[0]), strerror(rc = errno));
char argstring[200];
int i, count = sizeof(argstring) - 1;
- IOCINIT(data);
+ IOC_INIT(data);
if (argc > 5)
return CMD_HELP;
data.ioc_inllen1 = strlen(argstring) + 1;
}
- if (obd_ioctl_pack(&data, &buf, max)) {
- fprintf(stderr, "error: %s: invalid ioctl\n", cmdname(argv[0]));
- return -2;
- }
-
- rc = ioctl(fd, IOC_LDLM_REGRESS_START, buf);
-
+ IOC_PACK(argv[0], data);
+ rc = l_ioctl(OBD_DEV_ID, IOC_LDLM_REGRESS_START, buf);
if (rc)
fprintf(stderr, "error: %s: test failed: %s\n",
cmdname(argv[0]), strerror(rc = errno));
{
int rc;
struct obd_ioctl_data data;
- IOCINIT(data);
+ IOC_INIT(data);
if (argc != 1)
return CMD_HELP;
- rc = ioctl(fd, IOC_LDLM_REGRESS_STOP, &data);
+ IOC_PACK(argv[0], data);
+ rc = l_ioctl(OBD_DEV_ID, IOC_LDLM_REGRESS_STOP, buf);
if (rc)
fprintf(stderr, "error: %s: test failed: %s\n",
return rc;
}
-int jt_obd_newconn(int argc, char **argv)
+static int do_activate(int argc, char **argv, int flag)
+{
+ struct obd_ioctl_data data;
+ int rc;
+
+ IOC_INIT(data);
+ if (argc != 1)
+ return CMD_HELP;
+
+ /* reuse offset for 'active' */
+ data.ioc_offset = flag;
+
+ IOC_PACK(argv[0], data);
+ rc = l_ioctl(OBD_DEV_ID, IOC_OSC_SET_ACTIVE, buf);
+ if (rc)
+ fprintf(stderr, "error: %s: failed: %s\n",
+ cmdname(argv[0]), strerror(rc = errno));
+
+ return rc;
+}
+
+int jt_obd_deactivate(int argc, char **argv)
+{
+ return do_activate(argc, argv, 0);
+}
+
+int jt_obd_activate(int argc, char **argv)
+{
+ return do_activate(argc, argv, 1);
+}
+
+int jt_obd_recover(int argc, char **argv)
{
int rc;
struct obd_ioctl_data data;
- IOCINIT(data);
- if (argc < 2 || argc > 3)
+ IOC_INIT(data);
+ if (argc > 2)
+ return CMD_HELP;
+
+ if (argc == 2) {
+ data.ioc_inllen1 = strlen(argv[1]) + 1;
+ data.ioc_inlbuf1 = argv[1];
+ }
+
+ IOC_PACK(argv[0], data);
+ rc = l_ioctl(OBD_DEV_ID, OBD_IOC_CLIENT_RECOVER, buf);
+ if (rc < 0) {
+ fprintf(stderr, "error: %s: %s\n", cmdname(argv[0]),
+ strerror(rc = errno));
+ }
+
+ return rc;
+}
+
+int jt_obd_mdc_lookup(int argc, char **argv)
+{
+ struct obd_ioctl_data data;
+ char *parent, *child;
+ int rc, fd, verbose = 1;
+
+ if (argc < 3 || argc > 4)
+ return CMD_HELP;
+
+ parent = argv[1];
+ child = argv[2];
+ if (argc == 4)
+ verbose = get_verbose(argv[0], argv[3]);
+
+ IOC_INIT(data);
+
+ data.ioc_inllen1 = strlen(child) + 1;
+ data.ioc_inlbuf1 = child;
+
+ IOC_PACK(argv[0], data);
+
+ fd = open(parent, O_RDONLY);
+ if (fd < 0) {
+ fprintf(stderr, "open \"%s\" failed: %s\n", parent,
+ strerror(errno));
+ return -1;
+ }
+
+ rc = ioctl(fd, IOC_MDC_LOOKUP, buf);
+ if (rc < 0) {
+ fprintf(stderr, "error: %s: ioctl error: %s\n",
+ cmdname(argv[0]), strerror(rc = errno));
+ }
+ close(fd);
+
+ if (verbose) {
+ IOC_UNPACK(argv[0], data);
+ printf("%s: mode %o uid %d gid %d\n", child,
+ data.ioc_obdo1.o_mode, data.ioc_obdo1.o_uid,
+ data.ioc_obdo1.o_gid);
+ }
+
+ return rc;
+}
+
+static
+int do_add_uuid(char * func, char *uuid, ptl_nid_t nid, int nal)
+{
+ char tmp[64];
+ int rc;
+ struct obd_ioctl_data data;
+
+ IOC_INIT(data);
+ data.ioc_nid = nid;
+ data.ioc_inllen1 = strlen(uuid) + 1;
+ data.ioc_inlbuf1 = uuid;
+ data.ioc_nal = nal;
+
+ IOC_PACK(func, data);
+ rc = l_ioctl(OBD_DEV_ID, OBD_IOC_ADD_UUID, buf);
+ if (rc) {
+ fprintf(stderr, "IOC_PORTAL_ADD_UUID failed: %s\n",
+ strerror(errno));
+ return -1;
+ }
+
+ printf ("Added uuid %s: %s\n", uuid, ptl_nid2str (tmp, nid));
+ return 0;
+}
+
+int jt_obd_add_uuid(int argc, char **argv)
+{
+ ptl_nid_t nid = 0;
+ int nal;
+
+ if (argc != 4) {
return CMD_HELP;
+ }
+
+ if (ptl_parse_nid (&nid, argv[2]) != 0) {
+ fprintf (stderr, "Can't parse NID %s\n", argv[2]);
+ return (-1);
+ }
+
+ nal = ptl_name2nal(argv[3]);
+
+ if (nal <= 0) {
+ fprintf (stderr, "Can't parse NAL %s\n", argv[3]);
+ return -1;
+ }
+
+ return do_add_uuid(argv[0], argv[1], nid, nal);
+}
+
+int jt_obd_close_uuid(int argc, char **argv)
+{
+ int rc, nal;
+ struct obd_ioctl_data data;
+
+ if (argc != 3) {
+ fprintf(stderr, "usage: %s <uuid> <net-type>\n", argv[0]);
+ return 0;
+ }
+
+ nal = ptl_name2nal(argv[2]);
+
+ if (nal <= 0) {
+ fprintf (stderr, "Can't parse NAL %s\n", argv[2]);
+ return -1;
+ }
+ IOC_INIT(data);
data.ioc_inllen1 = strlen(argv[1]) + 1;
data.ioc_inlbuf1 = argv[1];
+ data.ioc_nal = nal;
- if (argc == 3) {
- data.ioc_inllen2 = strlen(argv[2]) + 1;
- data.ioc_inlbuf2 = argv[2];
+ IOC_PACK(argv[0], data);
+ rc = l_ioctl(OBD_DEV_ID, OBD_IOC_CLOSE_UUID, buf);
+ if (rc) {
+ fprintf(stderr, "IOC_PORTAL_CLOSE_UUID failed: %s\n",
+ strerror(errno));
+ return -1;
}
+ return 0;
+}
- if (obd_ioctl_pack(&data, &buf, max)) {
- fprintf(stderr, "error: %s: invalid ioctl\n", cmdname(argv[0]));
- return -2;
+
+int jt_obd_del_uuid(int argc, char **argv)
+{
+ int rc;
+ struct obd_ioctl_data data;
+
+ if (argc != 2) {
+ fprintf(stderr, "usage: %s <uuid>\n", argv[0]);
+ return 0;
}
- rc = ioctl(fd, OBD_IOC_RECOVD_NEWCONN, buf);
- if (rc < 0)
- fprintf(stderr, "error: %s: %s\n", cmdname(argv[0]),
- strerror(rc = errno));
+ IOC_INIT(data);
- return rc;
+ if (strcmp (argv[1], "_all_"))
+ {
+ data.ioc_inllen1 = strlen(argv[1]) + 1;
+ data.ioc_inlbuf1 = argv[1];
+ }
+
+ IOC_PACK(argv[0], data);
+ rc = l_ioctl(OBD_DEV_ID, OBD_IOC_DEL_UUID, buf);
+ if (rc) {
+ fprintf(stderr, "IOC_PORTAL_DEL_UUID failed: %s\n",
+ strerror(errno));
+ return -1;
+ }
+ return 0;
}
static void signal_server(int sig)
int obd_initialize(int argc, char **argv)
{
SHMEM_SETUP();
+ register_ioc_dev(OBD_DEV_ID, OBD_DEV_PATH);
+
return 0;
}