X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Futils%2Fobd.c;h=bdd533a76fda8a9ad66702263a4e489b19fb372b;hb=4a26f0c56cb0109a5df85bf2ddcd4af3fea6a6af;hp=3860e99b63db58670174249b90ea379eba7284d8;hpb=5b8b57483984c5e9d1066f3b9a62e0a17e47203b;p=fs%2Flustre-release.git diff --git a/lustre/utils/obd.c b/lustre/utils/obd.c index 3860e99..bdd533a 100644 --- a/lustre/utils/obd.c +++ b/lustre/utils/obd.c @@ -35,17 +35,16 @@ #include #include #include -#define printk printf -#include -#include -#include +#include "obdctl.h" + +#include /* for struct lov_stripe_md */ +#include #include #include #include #include -#include #include #include @@ -55,7 +54,8 @@ #include #undef __KERNEL__ -#include "obdctl.h" +#include +#include #include "parser.h" #include @@ -70,50 +70,109 @@ static long long counter_snapshot[2][MAX_SHMEM_COUNT]; struct timeval prev_time; #endif -int fd = -1; -uint64_t conn_addr = -1; -uint64_t conn_cookie; -char rawbuf[8192]; -char *buf = rawbuf; -int max = 8192; +static int jt_recording; +static char rawbuf[8192]; +static char *buf = rawbuf; +static int max = sizeof(rawbuf); static int thread; -static int getfd(char *func); -static char *cmdname(char *func); +static uint32_t cur_device = MAX_OBD_DEVICES; + +union lsm_buffer { + char space [4096]; + struct lov_stripe_md lsm; +} lsm_buffer; -#define IOCINIT(data) \ +static int l2_ioctl(int dev_id, int opc, void *buf) +{ + return l_ioctl(dev_id, opc, buf); +} + +#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; \ + data.ioc_dev = cur_device; \ +} 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", \ + jt_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", \ + jt_cmdname(func)); \ + return -2; \ } \ } while (0) +int obd_record(enum cfg_record_type type, int len, void *ptr) +{ + struct obd_ioctl_data data; + + IOC_INIT(data); + data.ioc_type = type; + data.ioc_plen1 = len; + data.ioc_pbuf1 = ptr; + IOC_PACK("obd_record", data); + + return l_ioctl(OBD_DEV_ID, OBD_IOC_DORECORD, &data); +} + +int lcfg_ioctl(char * func, int dev_id, struct lustre_cfg *lcfg) +{ + int opc; + char lcfg_rawbuf[8192]; + char * lcfg_buf= lcfg_rawbuf; + struct obd_ioctl_data data; + int len; + int rc; + + memset(lcfg_buf, 0, sizeof(lcfg_rawbuf)); + if (lustre_cfg_pack(lcfg, &lcfg_buf, sizeof(lcfg_rawbuf), &len)) { + fprintf(stderr, "error: %s: invalid ioctl\n", + jt_cmdname(func)); + return -2; + } + + IOC_INIT(data); + data.ioc_type = LUSTRE_CFG_TYPE; + data.ioc_plen1 = len; + data.ioc_pbuf1 = lcfg_buf; + IOC_PACK(func, data); + + if (jt_recording) + opc = OBD_IOC_DORECORD; + else + opc = OBD_IOC_PROCESS_CFG; + + rc = l_ioctl(dev_id, opc, buf); + if (rc == 0) + rc = lustre_cfg_unpack(lcfg, lcfg_buf, sizeof(lcfg_rawbuf)); + + return rc; +} + 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); } @@ -127,58 +186,159 @@ static int do_name2dev(char *func, char *name) 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 = l2_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) +int parse_devname(char *func, char *name) { int rc; int ret = -1; 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 *cmdname(char *func) +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", + lsm->lsm_stripe_size, + lsm->lsm_stripe_count); + p += nob; + space -= nob; + + for (i = 0; i < lsm->lsm_stripe_count; i++) { + nob = snprintf (p, space, "@%u:"LPX64, + lsm->lsm_oinfo[i].loi_ost_idx, + 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 == 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_ost_idx = strtoul(string, &end, 0); + if (*end != ':') + return (-1); + string = end + 1; + lsm->lsm_oinfo[i].loi_id = strtoull(string, &end, 0); + string = end; + } + + if (*string != 0) + return (-1); + + return (0); +} + +char *jt_cmdname(char *func) { static char buf[512]; @@ -190,22 +350,9 @@ static char *cmdname(char *func) 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)) +#define difftime(a, b) \ + ((a)->tv_sec - (b)->tv_sec + \ + ((a)->tv_usec - (b)->tv_usec) / 1000000.0) static int be_verbose(int verbose, struct timeval *next_time, __u64 num, __u64 *next_num, int num_total) @@ -230,7 +377,8 @@ static int be_verbose(int verbose, struct timeval *next_time, } /* 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.0){ next_time->tv_sec = now.tv_sec - verbose; next_time->tv_usec = now.tv_usec; if (next_num) @@ -254,7 +402,7 @@ static int get_verbose(char *func, const char *arg) verbose = (int)strtoul(arg, &end, 0); if (*end) { fprintf(stderr, "error: %s: bad verbose option '%s'\n", - cmdname(func), arg); + jt_cmdname(func), arg); return BAD_VERBOSE; } } @@ -271,31 +419,14 @@ static int get_verbose(char *func, const char *arg) int do_disconnect(char *func, int verbose) { - int rc; - struct obd_ioctl_data data; - - if (conn_addr == -1) - return 0; - - IOCINIT(data); - - rc = ioctl(fd, OBD_IOC_DISCONNECT, &data); - if (rc < 0) { - fprintf(stderr, "error: %s: %x %s\n", cmdname(func), - OBD_IOC_DISCONNECT, strerror(errno)); - } else { - if (verbose) - printf("%s: disconnected conn %Lx\n", cmdname(func), - conn_addr); - conn_addr = -1; - } - - return rc; + cur_device = MAX_OBD_DEVICES; + return 0; } #if SHMEM_STATS static void shmem_setup(void) { + /* Create new segment */ int shmid = shmget(IPC_PRIVATE, sizeof(counter_snapshot[0]), 0600); if (shmid == -1) { @@ -304,6 +435,7 @@ static void shmem_setup(void) return; } + /* Attatch to new segment */ shared_counters = (long long *)shmat(shmid, NULL, 0); if (shared_counters == (long long *)(-1)) { @@ -312,6 +444,14 @@ static void shmem_setup(void) 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) @@ -367,10 +507,10 @@ static void shmem_snap(int n) 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() @@ -380,67 +520,36 @@ static void shmem_snap(int n) extern command_t cmdlist[]; -static int do_device(char *func, int dev) +static int do_device(char *func, char *devname) { struct obd_ioctl_data data; + int dev; memset(&data, 0, sizeof(data)); - data.ioc_dev = dev; - - if (getfd(func)) + dev = parse_devname(func, devname); + if (dev < 0) 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); + cur_device = dev; + return 0; } int jt_obd_device(int argc, char **argv) { - int rc, dev; + int rc; do_disconnect(argv[0], 1); if (argc != 2) return CMD_HELP; - dev = parse_devname(argv[0], argv[1]); - if (dev < 0) - return -1; - - rc = do_device(argv[0], dev); - if (rc < 0) - fprintf(stderr, "error: %s: %s\n", cmdname(argv[0]), - strerror(rc = errno)); - + rc = do_device(argv[0], argv[1]); return rc; } int jt_obd_connect(int argc, char **argv) { - struct obd_ioctl_data data; - int rc; - - IOCINIT(data); - - do_disconnect(argv[0], 1); - -#warning TODO: implement timeout per lctl usage for probe - if (argc != 1) - return CMD_HELP; - - rc = ioctl(fd, OBD_IOC_CONNECT, &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; - conn_cookie = data.ioc_cookie; - } - return rc; + return 0; } int jt_obd_disconnect(int argc, char **argv) @@ -448,28 +557,18 @@ int jt_obd_disconnect(int argc, char **argv) if (argc != 1) return CMD_HELP; - if (conn_addr == -1) - return 0; - return do_disconnect(argv[0], 0); } int jt_opt_device(int argc, char **argv) { - char *arg2[3]; int ret; int rc; if (argc < 3) return CMD_HELP; - rc = do_device("device", parse_devname(argv[0], argv[1])); - - if (!rc) { - arg2[0] = "connect"; - arg2[1] = NULL; - rc = jt_obd_connect(1, arg2); - } + rc = do_device("device", argv[1]); if (!rc) rc = Parser_execarg(argc - 2, argv + 2, cmdlist); @@ -495,7 +594,7 @@ int jt_opt_threads(int argc, char **argv) threads = strtoull(argv[1], &end, 0); if (*end) { fprintf(stderr, "error: %s: invalid page count '%s'\n", - cmdname(argv[0]), argv[1]); + jt_cmdname(argv[0]), argv[1]); return CMD_HELP; } @@ -570,93 +669,125 @@ int jt_opt_threads(int argc, char **argv) return rc; } -int jt_obd_detach(int argc, char **argv) +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_no_transno(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 = l2_ioctl(OBD_DEV_ID, OBD_IOC_NO_TRANSNO, buf); if (rc < 0) - fprintf(stderr, "error: %s: %s\n", cmdname(argv[0]), + fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]), strerror(rc = errno)); return rc; } -int jt_obd_cleanup(int argc, char **argv) +int jt_obd_set_readonly(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 = l2_ioctl(OBD_DEV_ID, OBD_IOC_SET_READONLY, buf); if (rc < 0) - fprintf(stderr, "error: %s: %s\n", cmdname(argv[0]), + fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]), strerror(rc = errno)); return rc; } -int jt_obd_newdev(int argc, char **argv) +int jt_obd_abort_recovery(int argc, char **argv) { - int rc; struct obd_ioctl_data data; + int rc; - if (getfd(argv[0])) - return -1; - - IOCINIT(data); + IOC_INIT(data); if (argc != 1) return CMD_HELP; - rc = ioctl(fd, OBD_IOC_NEWDEV, &data); + IOC_PACK(argv[0], data); + rc = l2_ioctl(OBD_DEV_ID, OBD_IOC_ABORT_RECOVERY, buf); if (rc < 0) - fprintf(stderr, "error: %s: %s\n", cmdname(argv[0]), + fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]), strerror(rc = errno)); - else { - printf("Current device set to %d\n", data.ioc_dev); - } return rc; } -int jt_obd_list(int argc, char **argv) +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_inllen1 = sizeof(buf) - size_round(sizeof(*data)); + data->ioc_len = obd_ioctl_packlen(data); + + rc = l2_ioctl(OBD_DEV_ID, OBD_GET_VERSION, buf); + if (rc < 0) + fprintf(stderr, "error: %s: %s\n", jt_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[OBD_MAX_IOCTL_BUFFER]; + 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_inllen1 = sizeof(buf) - size_round(sizeof(*data)); + data->ioc_len = obd_ioctl_packlen(data); + + rc = l2_ioctl(OBD_DEV_ID, OBD_IOC_LIST, data); if (rc < 0) - fprintf(stderr, "error: %s: %s\n", cmdname(argv[0]), + fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]), strerror(rc = errno)); else { printf("%s", data->ioc_bulk); @@ -665,124 +796,157 @@ int jt_obd_list(int argc, char **argv) return rc; } -int jt_obd_attach(int argc, char **argv) +/* 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; - int rc; - - IOCINIT(data); + __u64 id; + int rc; + char *end; - if (argc != 2 && argc != 3 && argc != 4) - return CMD_HELP; + if (argc != 2) + return (CMD_HELP); - 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]; + id = strtoull (argv[1], &end, 0); + if (*end) { + fprintf (stderr, "Error: %s: invalid object id '%s'\n", + jt_cmdname (argv[0]), argv[1]); + return (CMD_HELP); } - if (argc == 4) { - data.ioc_inllen3 = strlen(argv[3]) + 1; - data.ioc_inlbuf3 = argv[3]; - } + memset (&lsm_buffer, 0, sizeof (lsm_buffer)); - if (obd_ioctl_pack(&data, &buf, max)) { - fprintf(stderr, "error: %s: invalid ioctl\n", cmdname(argv[0])); - return -2; - } + 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); - rc = ioctl(fd, OBD_IOC_ATTACH, buf); - if (rc < 0) - fprintf(stderr, "error: %s: %x %s\n", cmdname(argv[0]), - OBD_IOC_ATTACH, strerror(rc = errno)); - else if (argc == 3) { - char name[1024]; - if (strlen(argv[2]) > 128) { - printf("Name too long to set environment\n"); - return -EINVAL; - } - snprintf(name, 512, "LUSTRE_DEV_%s", argv[2]); - rc = setenv(name, argv[1], 1); - if (rc) { - printf("error setting env variable %s\n", name); - } + IOC_PACK(argv[0], data); + rc = l2_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", + jt_cmdname (argv[0]), rc, strerror (errno)); + return (rc); } - return rc; + printf ("%s\n", lsm_string (&lsm_buffer.lsm)); + + return (rc); } -int jt_obd_name2dev(int argc, char **argv) +/* 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) + if (argc < 2 || argc > 3) 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); + rc = parse_lsm (&lsm_buffer, argv[1]); + if (rc != 0) { + fprintf (stderr, "error: %s: invalid object '%s'\n", + jt_cmdname (argv[0]), argv[1]); + return CMD_HELP; } - return rc; + + if (argc > 2) { + count = strtol (argv[2], &end, 0); + if (*end != 0) { + fprintf (stderr, "error: %s: invalid count '%s'\n", + jt_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 = l2_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", + jt_cmdname (argv[0]), rc, strerror (errno)); + return (rc); + } + } + + return (0); } -int jt_obd_setup(int argc, char **argv) +/* 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; - IOCINIT(data); - - if (argc > 3) + if (argc != 2) return CMD_HELP; - data.ioc_dev = -1; - if (argc > 1) { - data.ioc_dev = parse_devname(argv[0], argv[1]); - if (data.ioc_dev < 0) - return -1; - 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]; + id = strtoull (argv[1], &end, 0); + if (*end != 0) { + fprintf (stderr, "error: %s: invalid object id '%s'\n", + jt_cmdname (argv[0]), argv[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_SETUP, buf); - if (rc < 0) - fprintf(stderr, "error: %s: %s\n", cmdname(argv[0]), - strerror(rc = errno)); + 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; - return rc; -} + IOC_PACK (argv[0], data); + rc = l2_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", + jt_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) { struct obd_ioctl_data data; struct timeval next_time; - __u64 count = 1, next_count; - int verbose = 1; - int mode = 0100644; - int rc = 0, i; + __u64 count = 1, next_count, base_id = 0; + int verbose = 1, mode = 0100644, rc = 0, i, valid_lsm = 0; 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); if (*end) { fprintf(stderr, "error: %s: invalid iteration count '%s'\n", - cmdname(argv[0]), argv[1]); + jt_cmdname(argv[0]), argv[1]); return CMD_HELP; } @@ -790,7 +954,7 @@ int jt_obd_create(int argc, char **argv) mode = strtoul(argv[2], &end, 0); if (*end) { fprintf(stderr, "error: %s: invalid mode '%s'\n", - cmdname(argv[0]), argv[2]); + jt_cmdname(argv[0]), argv[2]); return CMD_HELP; } if (!(mode & S_IFMT)) @@ -803,35 +967,55 @@ int jt_obd_create(int argc, char **argv) return CMD_HELP; } - printf("%s: "LPD64" objects\n", cmdname(argv[0]), count); + 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", + jt_cmdname(argv[0]), argv[4]); + return CMD_HELP; + } + base_id = lsm_buffer.lsm.lsm_object_id; + valid_lsm = 1; + } + + printf("%s: "LPD64" objects\n", jt_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_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_FDUID | OBD_MD_FLGID;; + OBD_MD_FLID | OBD_MD_FLUID | OBD_MD_FLGID; + + if (valid_lsm) { + data.ioc_plen1 = sizeof lsm_buffer; + data.ioc_pbuf1 = (char *)&lsm_buffer; + } - rc = ioctl(fd, OBD_IOC_CREATE, &data); + IOC_PACK(argv[0], data); + rc = l2_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", - cmdname(argv[0]), i, strerror(rc = errno)); + jt_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); + jt_cmdname(argv[0]), i, data.ioc_obdo1.o_valid); rc = EINVAL; break; } 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", + jt_cmdname(argv[0]), i, data.ioc_obdo1.o_id); } return rc; } @@ -842,27 +1026,28 @@ int jt_obd_setattr(int argc, char **argv) char *end; int rc; - IOCINIT(data); + IOC_INIT(data); if (argc != 2) return CMD_HELP; 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]); + jt_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]); + jt_cmdname(argv[0]), argv[2]); return CMD_HELP; } 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 = l2_ioctl(OBD_DEV_ID, OBD_IOC_SETATTR, buf); if (rc < 0) - fprintf(stderr, "error: %s: %s\n", cmdname(argv[0]), + fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]), strerror(rc = errno)); return rc; @@ -871,25 +1056,62 @@ int jt_obd_setattr(int argc, char **argv) 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]); + jt_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", + jt_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", jt_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 = l2_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", + jt_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", + jt_cmdname(argv[0]), i, id); + } return rc; } @@ -903,24 +1125,26 @@ int jt_obd_getattr(int argc, char **argv) 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", - cmdname(argv[0]), argv[1]); + jt_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", jt_cmdname(argv[0]),data.ioc_obdo1.o_id); - rc = ioctl(fd, OBD_IOC_GETATTR, &data); + IOC_PACK(argv[0], data); + rc = l2_ioctl(OBD_DEV_ID, OBD_IOC_GETATTR, buf); + IOC_UNPACK(argv[0], data); if (rc) { - fprintf(stderr, "error: %s: %s\n", cmdname(argv[0]), + fprintf(stderr, "error: %s: %s\n", jt_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", jt_cmdname(argv[0]), data.ioc_obdo1.o_id, data.ioc_obdo1.o_mode); } return rc; @@ -939,11 +1163,11 @@ int jt_obd_test_getattr(int argc, char **argv) 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", - cmdname(argv[0]), argv[1]); + jt_cmdname(argv[0]), argv[1]); return CMD_HELP; } @@ -962,7 +1186,7 @@ int jt_obd_test_getattr(int argc, char **argv) objid = strtoull(argv[3], &end, 0); if (*end) { fprintf(stderr, "error: %s: invalid objid '%s'\n", - cmdname(argv[0]), argv[3]); + jt_cmdname(argv[0]), argv[3]); return CMD_HELP; } } @@ -972,23 +1196,24 @@ int jt_obd_test_getattr(int argc, char **argv) next_time.tv_usec = start.tv_usec; if (verbose != 0) printf("%s: getting "LPD64" attrs (objid "LPX64"): %s", - cmdname(argv[0]), count, objid, ctime(&start.tv_sec)); + jt_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); + IOC_PACK(argv[0], data); + rc = l2_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", + jt_cmdname(argv[0]), i, errno, strerror(rc = errno)); break; } else { if (be_verbose (verbose, &next_time, i, &next_count, count)) printf("%s: got attr #"LPD64"\n", - cmdname(argv[0]), i); + jt_cmdname(argv[0]), i); } } @@ -1002,8 +1227,8 @@ int jt_obd_test_getattr(int argc, char **argv) --i; if (verbose != 0) - printf("%s: "LPD64" attrs in %.4gs (%.4g attr/s): %s", - cmdname(argv[0]), i, diff, (double)i / diff, + printf("%s: "LPD64" attrs in %.3fs (%.3f attr/s): %s", + jt_cmdname(argv[0]), i, diff, i / diff, ctime(&end.tv_sec)); } return rc; @@ -1013,19 +1238,13 @@ int jt_obd_test_brw(int argc, char **argv) { struct obd_ioctl_data data; struct timeval start, next_time; - int pages = 1; - __u64 count, next_count; - __u64 objid = 3; - int verbose = 1, write = 0, rw; + __u64 count, next_count, len, thr_offset = 0, objid = 3; + int write = 0, verbose = 1, cmd, i, rc = 0, pages = 1; char *end; - int thr_offset = 0; - int i; - int len; - int rc = 0; - if (argc < 2 || argc > 6) { + if (argc < 2 || argc > 7) { fprintf(stderr, "error: %s: bad number of arguments: %d\n", - cmdname(argv[0]), argc); + jt_cmdname(argv[0]), argc); return CMD_HELP; } @@ -1039,7 +1258,7 @@ int jt_obd_test_brw(int argc, char **argv) if (*end) { fprintf(stderr, "error: %s: bad iteration count '%s'\n", - cmdname(argv[0]), argv[1]); + jt_cmdname(argv[0]), argv[1]); return CMD_HELP; } @@ -1060,7 +1279,7 @@ int jt_obd_test_brw(int argc, char **argv) pages = strtoul(argv[4], &end, 0); if (*end) { fprintf(stderr, "error: %s: bad page count '%s'\n", - cmdname(argv[0]), argv[4]); + jt_cmdname(argv[0]), argv[4]); return CMD_HELP; } } @@ -1073,14 +1292,48 @@ int jt_obd_test_brw(int argc, char **argv) objid = strtoull(argv[5], &end, 0); if (*end) { fprintf(stderr, "error: %s: bad objid '%s'\n", - cmdname(argv[0]), argv[5]); + jt_cmdname(argv[0]), argv[5]); + return CMD_HELP; + } + } + + IOC_INIT(data); + + /* communicate the 'type' of brw test and batching to echo_client. + * don't start. we'd love to refactor this lctl->echo_client + * interface */ + data.ioc_pbuf1 = (void *)1; + data.ioc_plen1 = 1; + + if (argc >= 7) { + switch(argv[6][0]) { + case 'g': /* plug and unplug */ + data.ioc_pbuf1 = (void *)2; + data.ioc_plen1 = strtoull(argv[6] + 1, &end, + 0); + break; + case 'p': /* prep and commit */ + data.ioc_pbuf1 = (void *)3; + data.ioc_plen1 = strtoull(argv[6] + 1, &end, + 0); + break; + default: + fprintf(stderr, "error: %s: batching '%s' " + "needs to specify 'p' or 'g'\n", + jt_cmdname(argv[0]), argv[6]); + return CMD_HELP; + } + + if (*end) { + fprintf(stderr, "error: %s: bad batching '%s'\n", + jt_cmdname(argv[0]), argv[6]); return CMD_HELP; } + data.ioc_plen1 *= PAGE_SIZE; } len = pages * PAGE_SIZE; - IOCINIT(data); 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; @@ -1093,26 +1346,22 @@ int jt_obd_test_brw(int argc, char **argv) if (verbose != 0) printf("%s: %s "LPU64"x%d pages (obj "LPX64", off "LPU64"): %s", - cmdname(argv[0]), write ? "writing" : "reading", count, + jt_cmdname(argv[0]), write ? "writing" : "reading", count, pages, objid, data.ioc_offset, ctime(&start.tv_sec)); - rc = ioctl(fd, OBD_IOC_OPEN, &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; + cmd = write ? OBD_IOC_BRW_WRITE : OBD_IOC_BRW_READ; for (i = 1, next_count = verbose; i <= count; i++) { - rc = ioctl(fd, rw, &data); + data.ioc_obdo1.o_valid &= ~(OBD_MD_FLBLOCKS|OBD_MD_FLRDEV); + IOC_PACK(argv[0], data); + rc = l2_ioctl(OBD_DEV_ID, cmd, buf); SHMEM_BUMP(); if (rc) { fprintf(stderr, "error: %s: #%d - %s on %s\n", - cmdname(argv[0]), i, strerror(rc = errno), + jt_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 %dx%d\n", cmdname(argv[0]), + printf("%s: %s number %dx%d\n", jt_cmdname(argv[0]), write ? "write" : "read", i, pages); data.ioc_offset += len; @@ -1128,117 +1377,94 @@ int jt_obd_test_brw(int argc, char **argv) --i; if (verbose != 0) - printf("%s: %s %dx%d pages in %.4gs (%.4g pg/s): %s", - cmdname(argv[0]), write ? "wrote" : "read", - i, pages, diff, (double)i * pages / diff, + printf("%s: %s %dx%d pages in %.3fs (%.3f MB/s): %s", + jt_cmdname(argv[0]), write ? "wrote" : "read", + i, pages, diff, + ((double)i * pages * getpagesize()) / + (diff * 1048576.0), ctime(&end.tv_sec)); } - rw = ioctl(fd, OBD_IOC_CLOSE, &data); - 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_getconfig(int argc, char **argv) { struct obd_ioctl_data data; struct lov_desc desc; - obd_uuid_t *uuidarray; - int rc, size, i; - char *end; + struct obd_uuid *uuidarray; + char *path; + int rc, fd; - IOCINIT(data); + IOC_INIT(data); - if (argc <= 6) + if (argc != 2) 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; + 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)); - strncpy(desc.ld_uuid, argv[1], sizeof(*uuidarray) - 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: stripe count %d more than OST count %d\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); - 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); - return -EINVAL; - } - desc.ld_default_stripe_offset = (__u64) strtoul(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; - } + obd_str2uuid(&desc.ld_uuid, argv[1]); + desc.ld_tgt_count = ((OBD_MAX_IOCTL_BUFFER-sizeof(data)-sizeof(desc)) / + sizeof(*uuidarray)); - size = desc.ld_tgt_count * sizeof(*uuidarray); - uuidarray = malloc(size); +repeat: + 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: arg %d (%s) too long\n", - cmdname(argv[0]), i, argv[i]); - free(uuidarray); - return -EINVAL; - } - strcpy(buf, argv[i]); + fprintf(stderr, "error: %s: no memory for %d uuid's\n", + jt_cmdname(argv[0]), desc.ld_tgt_count); + rc = -ENOMEM; + goto out; } 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 = ioctl(fd, OBD_IOC_LOV_CONFIG, buf); - if (rc) - fprintf(stderr, "lov_config: error: %s: %s\n", - cmdname(argv[0]), strerror(rc = errno)); + fprintf(stderr, "error: %s: invalid ioctl\n", + jt_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", + jt_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", + jt_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; } @@ -1247,14 +1473,15 @@ int jt_obd_test_ldlm(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, IOC_LDLM_TEST, &data); + IOC_PACK(argv[0], data); + rc = l2_ioctl(OBD_DEV_ID, IOC_LDLM_TEST, buf); if (rc) fprintf(stderr, "error: %s: test failed: %s\n", - cmdname(argv[0]), strerror(rc = errno)); + jt_cmdname(argv[0]), strerror(rc = errno)); return rc; } @@ -1263,14 +1490,15 @@ int jt_obd_dump_ldlm(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, IOC_LDLM_DUMP, &data); + IOC_PACK(argv[0], data); + rc = l2_ioctl(OBD_DEV_ID, IOC_LDLM_DUMP, buf); if (rc) fprintf(stderr, "error: %s failed: %s\n", - cmdname(argv[0]), strerror(rc = errno)); + jt_cmdname(argv[0]), strerror(rc = errno)); return rc; } @@ -1281,7 +1509,7 @@ int jt_obd_ldlm_regress_start(int argc, char **argv) char argstring[200]; int i, count = sizeof(argstring) - 1; - IOCINIT(data); + IOC_INIT(data); if (argc > 5) return CMD_HELP; @@ -1298,16 +1526,11 @@ int jt_obd_ldlm_regress_start(int argc, char **argv) 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 = l2_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)); + jt_cmdname(argv[0]), strerror(rc = errno)); return rc; } @@ -1316,91 +1539,453 @@ int jt_obd_ldlm_regress_stop(int argc, char **argv) { 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 = l2_ioctl(OBD_DEV_ID, IOC_LDLM_REGRESS_STOP, buf); if (rc) fprintf(stderr, "error: %s: test failed: %s\n", - cmdname(argv[0]), strerror(rc = errno)); + jt_cmdname(argv[0]), strerror(rc = errno)); 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 = l2_ioctl(OBD_DEV_ID, IOC_OSC_SET_ACTIVE, buf); + if (rc) + fprintf(stderr, "error: %s: failed: %s\n", + jt_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 = l2_ioctl(OBD_DEV_ID, OBD_IOC_CLIENT_RECOVER, buf); + if (rc < 0) { + fprintf(stderr, "error: %s: %s\n", jt_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", + jt_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; +} + + +int jt_obd_close_uuid(int argc, char **argv) +{ + int rc, nal; + struct obd_ioctl_data data; + + if (argc != 3) { + fprintf(stderr, "usage: %s \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 = l2_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_cfg_record(int argc, char **argv) +{ + struct obd_ioctl_data data; + int rc; + + 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_RECORD, buf); + if (rc == 0) { + jt_recording = 1; + ptl_set_cfg_record_cb(obd_record); + } else { + fprintf(stderr, "OBD_IOC_RECORD failed: %s\n", + strerror(errno)); } - rc = ioctl(fd, OBD_IOC_RECOVD_NEWCONN, buf); + return rc; +} + +int jt_cfg_parse(int argc, char **argv) +{ + struct obd_ioctl_data data; + int rc; + + 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_PARSE, buf); if (rc < 0) - fprintf(stderr, "error: %s: %s\n", cmdname(argv[0]), - strerror(rc = errno)); + fprintf(stderr, "OBD_IOC_PARSE failed: %s\n", + strerror(errno)); return rc; } -int jt_obd_failconn(int argc, char **argv) + +int jt_cfg_dump_log(int argc, char **argv) { - int rc; struct obd_ioctl_data data; + int rc; + + IOC_INIT(data); - IOCINIT(data); - if (argc < 2) + if (argc != 2) return CMD_HELP; data.ioc_inllen1 = strlen(argv[1]) + 1; data.ioc_inlbuf1 = argv[1]; - 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 = l_ioctl(OBD_DEV_ID, OBD_IOC_DUMP_LOG, buf); + if (rc < 0) + fprintf(stderr, "OBD_IOC_DUMP_LOG failed: %s\n", + strerror(errno)); + + return rc; +} + + +int jt_cfg_endrecord(int argc, char **argv) +{ + struct obd_ioctl_data data; + int rc; + + IOC_INIT(data); + + if (argc != 1) + return CMD_HELP; + + if (!jt_recording) { + fprintf(stderr, "Not recording, so endrecord doesn't make sense.\n"); + return 0; } - rc = ioctl(fd, OBD_IOC_RECOVD_FAILCONN, buf); - if (rc < 0) - fprintf(stderr, "error: %s: %s\n", cmdname(argv[0]), - strerror(rc = errno)); + IOC_PACK(argv[0], data); + rc = l_ioctl(OBD_DEV_ID, OBD_IOC_ENDRECORD, buf); + if (rc == 0) { + jt_recording = 0; + ptl_set_cfg_record_cb(NULL); + } else { + fprintf(stderr, "OBD_IOC_ENDRECORD failed: %s\n", + strerror(errno)); + } + return rc; +} + +int jt_llog_catlist(int argc, char **argv) +{ + struct obd_ioctl_data data; + int rc; + + if (argc != 1) + return CMD_HELP; + + IOC_INIT(data); + data.ioc_inllen1 = max - size_round(sizeof(data)); + IOC_PACK(argv[0], data); + + rc = l_ioctl(OBD_DEV_ID, OBD_IOC_CATLOGLIST, buf); + if (rc == 0) + fprintf(stdout, "%s", ((struct obd_ioctl_data*)buf)->ioc_bulk); + else + fprintf(stderr, "OBD_IOC_CATLOGLIST failed: %s\n", + strerror(errno)); return rc; } +int jt_llog_info(int argc, char **argv) +{ + struct obd_ioctl_data data; + int rc; + + if (argc != 2) + return CMD_HELP; + + IOC_INIT(data); + data.ioc_inllen1 = strlen(argv[1]) + 1; + data.ioc_inlbuf1 = argv[1]; + data.ioc_inllen2 = max - size_round(sizeof(data)) - + size_round(data.ioc_inllen1); + IOC_PACK(argv[0], data); + + rc = l_ioctl(OBD_DEV_ID, OBD_IOC_LLOG_INFO, buf); + if (rc == 0) + fprintf(stdout, "%s", ((struct obd_ioctl_data*)buf)->ioc_bulk); + else + fprintf(stderr, "OBD_IOC_LLOG_INFO failed: %s\n", + strerror(errno)); + + return rc; +} + +int jt_llog_print(int argc, char **argv) +{ + struct obd_ioctl_data data; + int rc; + + if (argc != 2 && argc != 4) + return CMD_HELP; + + IOC_INIT(data); + data.ioc_inllen1 = strlen(argv[1]) + 1; + data.ioc_inlbuf1 = argv[1]; + if (argc == 4) { + data.ioc_inllen2 = strlen(argv[2]) + 1; + data.ioc_inlbuf2 = argv[2]; + data.ioc_inllen3 = strlen(argv[3]) + 1; + data.ioc_inlbuf3 = argv[3]; + } else { + char from[2] = "1", to[3] = "-1"; + data.ioc_inllen2 = strlen(from) + 1; + data.ioc_inlbuf2 = from; + data.ioc_inllen3 = strlen(to) + 1; + data.ioc_inlbuf3 = to; + } + data.ioc_inllen4 = max - size_round(sizeof(data)) - + size_round(data.ioc_inllen1) - + size_round(data.ioc_inllen2) - + size_round(data.ioc_inllen3); + IOC_PACK(argv[0], data); + + rc = l_ioctl(OBD_DEV_ID, OBD_IOC_LLOG_PRINT, buf); + if (rc == 0) + fprintf(stdout, "%s", ((struct obd_ioctl_data*)buf)->ioc_bulk); + else + fprintf(stderr, "OBD_IOC_LLOG_PRINT failed: %s\n", + strerror(errno)); + + return rc; +} + +int jt_llog_cancel(int argc, char **argv) +{ + struct obd_ioctl_data data; + int rc; + + if (argc != 4) + return CMD_HELP; + + IOC_INIT(data); + data.ioc_inllen1 = strlen(argv[1]) + 1; + data.ioc_inlbuf1 = argv[1]; + data.ioc_inllen2 = strlen(argv[2]) + 1; + data.ioc_inlbuf2 = argv[2]; + data.ioc_inllen3 = strlen(argv[3]) + 1; + data.ioc_inlbuf3 = argv[3]; + IOC_PACK(argv[0], data); + + rc = l_ioctl(OBD_DEV_ID, OBD_IOC_LLOG_CANCEL, buf); + if (rc == 0) + fprintf(stdout, "index %s be canceled.\n", argv[3]); + else + fprintf(stderr, "OBD_IOC_LLOG_CANCEL failed: %s\n", + strerror(errno)); + + return rc; + +} +int jt_llog_check(int argc, char **argv) +{ + struct obd_ioctl_data data; + int rc; + + if (argc != 2 && argc != 4) + return CMD_HELP; + + IOC_INIT(data); + data.ioc_inllen1 = strlen(argv[1]) + 1; + data.ioc_inlbuf1 = argv[1]; + if (argc == 4) { + data.ioc_inllen2 = strlen(argv[2]) + 1; + data.ioc_inlbuf2 = argv[2]; + data.ioc_inllen3 = strlen(argv[3]) + 1; + data.ioc_inlbuf3 = argv[3]; + } else { + char from[2] = "1", to[3] = "-1"; + data.ioc_inllen2 = strlen(from) + 1; + data.ioc_inlbuf2 = from; + data.ioc_inllen3 = strlen(to) + 1; + data.ioc_inlbuf3 = to; + } + data.ioc_inllen4 = max - size_round(sizeof(data)) - + size_round(data.ioc_inllen1) - + size_round(data.ioc_inllen2) - + size_round(data.ioc_inllen3); + IOC_PACK(argv[0], data); + + rc = l_ioctl(OBD_DEV_ID, OBD_IOC_LLOG_CHECK, buf); + if (rc == 0) + fprintf(stdout, "%s", ((struct obd_ioctl_data*)buf)->ioc_bulk); + else + fprintf(stderr, "OBD_IOC_LLOG_CHECK failed: %s\n", + strerror(errno)); + return rc; +} + +int jt_llog_remove(int argc, char **argv) +{ + struct obd_ioctl_data data; + int rc; + + if (argc != 3 && argc != 2) + return CMD_HELP; + + IOC_INIT(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 = l_ioctl(OBD_DEV_ID, OBD_IOC_LLOG_REMOVE, buf); + if (rc == 0) { + if (argc == 3) + fprintf(stdout, "log %s are removed.\n", argv[2]); + else + fprintf(stdout, "the log in catlog %s are removed. \n", argv[1]); + } else + fprintf(stderr, "OBD_IOC_LLOG_REMOVE failed: %s\n", + strerror(errno)); + + return rc; +} + static void signal_server(int sig) { if (sig == SIGINT) { do_disconnect("sigint", 1); exit(1); } else - fprintf(stderr, "%s: got signal %d\n", cmdname("sigint"), sig); + fprintf(stderr, "%s: got signal %d\n", jt_cmdname("sigint"), sig); } int obd_initialize(int argc, char **argv) { SHMEM_SETUP(); + register_ioc_dev(OBD_DEV_ID, OBD_DEV_PATH); + return 0; } -void obd_cleanup(int argc, char **argv) +void obd_finalize(int argc, char **argv) { struct sigaction sigact; @@ -1409,5 +1994,10 @@ void obd_cleanup(int argc, char **argv) sigact.sa_flags = SA_RESTART; sigaction(SIGINT, &sigact, NULL); + if (jt_recording) { + printf("END RECORD\n"); + jt_cfg_endrecord(argc, argv); + } + do_disconnect(argv[0], 1); }