1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
2 * vim:expandtab:shiftwidth=8:tabstop=8:
4 * Copyright (C) 2002 Cluster File Systems, Inc.
5 * Author: Peter J. Braam <braam@clusterfs.com>
6 * Author: Phil Schwan <phil@clusterfs.com>
7 * Author: Robert Read <rread@clusterfs.com>
9 * This file is part of Lustre, http://www.lustre.org.
11 * Lustre is free software; you can redistribute it and/or
12 * modify it under the terms of version 2 of the GNU General Public
13 * License as published by the Free Software Foundation.
15 * Lustre is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
20 * You should have received a copy of the GNU General Public License
21 * along with Lustre; if not, write to the Free Software
22 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
28 #include <sys/ioctl.h>
30 #include <sys/socket.h>
31 #include <sys/types.h>
39 #include <linux/lustre_lib.h>
40 #include <linux/lustre_idl.h>
41 #include <linux/lustre_dlm.h>
47 #include <netinet/in.h>
51 #include <asm/page.h> /* needed for PAGE_SIZE - rread */
54 #include <linux/list.h>
66 # define MAX_SHMEM_COUNT 1024
67 static long long *shared_counters;
68 static long long counter_snapshot[2][MAX_SHMEM_COUNT];
69 struct timeval prev_time;
73 uint64_t conn_addr = -1;
81 static int getfd(char *func);
82 static char *cmdname(char *func);
84 #define IOCINIT(data) \
86 memset(&data, 0, sizeof(data)); \
87 data.ioc_version = OBD_IOCTL_VERSION; \
88 data.ioc_addr = conn_addr; \
89 data.ioc_cookie = conn_cookie; \
90 data.ioc_len = sizeof(data); \
92 fprintf(stderr, "No device open, use device\n"); \
98 pack "LL LL LL LL LL LL LL L L L L L L L L L a60 a60 L L L",
117 0, 0, # struct list_head
123 char *obdo_print(struct obdo *obd)
127 sprintf(buf, "id: %Ld\ngrp: %Ld\natime: %Ld\nmtime: %Ld\nctime: %Ld\n"
128 "size: %Ld\nblocks: %Ld\nblksize: %d\nmode: %o\nuid: %d\n"
129 "gid: %d\nflags: %x\nobdflags: %x\nnlink: %d,\nvalid %x\n",
141 obd->o_flags, obd->o_obdflags, obd->o_nlink, obd->o_valid);
147 #define N2D_OFF 0x100 /* So we can tell between error codes and devices */
149 static int do_name2dev(char *func, char *name)
151 struct obd_ioctl_data data;
159 data.ioc_inllen1 = strlen(name) + 1;
160 data.ioc_inlbuf1 = name;
162 if (obd_ioctl_pack(&data, &buf, max)) {
163 fprintf(stderr, "error: %s: invalid ioctl\n", cmdname(func));
166 rc = ioctl(fd, OBD_IOC_NAME2DEV, buf);
168 fprintf(stderr, "error: %s: %s - %s\n", cmdname(func),
169 name, strerror(rc = errno));
173 memcpy((char *)(&data), buf, sizeof(data));
175 return data.ioc_dev + N2D_OFF;
179 * resolve a device name to a device number.
180 * supports a number or name.
181 * FIXME: support UUID
183 static int parse_devname(char * func, char *name)
190 if (name[0] == '$') {
191 rc = do_name2dev(func, name + 1);
194 printf("%s is device %d\n", name,
197 fprintf(stderr, "error: %s: %s: %s\n", cmdname(func),
198 name, "device not found");
202 ret = strtoul(name, NULL, 0);
206 static char *cmdname(char *func)
208 static char buf[512];
211 sprintf(buf, "%s-%d", func, thread);
218 static int getfd(char *func)
221 fd = open("/dev/obd", O_RDWR);
223 fprintf(stderr, "error: %s: opening /dev/obd: %s\n"
224 "hint: lustre kernel modules may not be loaded.\n",
225 cmdname(func), strerror(errno));
231 #define difftime(a, b) \
232 ((double)(a)->tv_sec - (b)->tv_sec + \
233 ((double)((a)->tv_usec - (b)->tv_usec) / 1000000))
235 static int be_verbose(int verbose, struct timeval *next_time,
236 int num, int *next_num, int num_total)
243 if (next_time != NULL)
244 gettimeofday(&now, NULL);
246 /* A positive verbosity means to print every X iterations */
248 (next_num == NULL || num >= *next_num || num >= num_total)) {
249 *next_num += verbose;
251 next_time->tv_sec = now.tv_sec - verbose;
252 next_time->tv_usec = now.tv_usec;
257 /* A negative verbosity means to print at most each X seconds */
258 if (verbose < 0 && next_time != NULL && difftime(&now, next_time) >= 0) {
259 next_time->tv_sec = now.tv_sec - verbose;
260 next_time->tv_usec = now.tv_usec;
269 static int get_verbose(const char *arg)
273 if (!arg || arg[0] == 'v')
275 else if (arg[0] == 's' || arg[0] == 'q')
278 verbose = (int)strtoul(arg, NULL, 0);
281 printf("Print status every %d seconds\n", -verbose);
282 else if (verbose == 1)
283 printf("Print status every operation\n");
284 else if (verbose > 1)
285 printf("Print status every %d operations\n", verbose);
290 int do_disconnect(char *func, int verbose)
293 struct obd_ioctl_data data;
300 rc = ioctl(fd, OBD_IOC_DISCONNECT, &data);
302 fprintf(stderr, "error: %s: %x %s\n", cmdname(func),
303 OBD_IOC_DISCONNECT, strerror(errno));
306 printf("%s: disconnected conn %Lx\n", cmdname(func),
315 static void shmem_setup(void)
317 int shmid = shmget(IPC_PRIVATE, sizeof(counter_snapshot[0]), 0600);
320 fprintf(stderr, "Can't create shared memory counters: %s\n",
325 shared_counters = (long long *)shmat(shmid, NULL, 0);
327 if (shared_counters == (long long *)(-1)) {
328 fprintf(stderr, "Can't attach shared memory counters: %s\n",
330 shared_counters = NULL;
335 static inline void shmem_reset(void)
337 if (shared_counters == NULL)
340 memset(shared_counters, 0, sizeof(counter_snapshot[0]));
341 memset(counter_snapshot, 0, sizeof(counter_snapshot));
342 gettimeofday(&prev_time, NULL);
345 static inline void shmem_bump(void)
347 if (shared_counters == NULL || thread <= 0 || thread > MAX_SHMEM_COUNT)
350 shared_counters[thread - 1]++;
353 static void shmem_snap(int n)
355 struct timeval this_time;
361 if (shared_counters == NULL || n > MAX_SHMEM_COUNT)
364 memcpy(counter_snapshot[1], counter_snapshot[0],
365 n * sizeof(counter_snapshot[0][0]));
366 memcpy(counter_snapshot[0], shared_counters,
367 n * sizeof(counter_snapshot[0][0]));
368 gettimeofday(&this_time, NULL);
370 for (i = 0; i < n; i++) {
371 long long this_count =
372 counter_snapshot[0][i] - counter_snapshot[1][i];
374 if (this_count != 0) {
380 secs = (this_time.tv_sec + this_time.tv_usec / 1000000.0) -
381 (prev_time.tv_sec + prev_time.tv_usec / 1000000.0);
383 printf("%d/%d Total: %f/second\n", non_zero, n, total / secs);
385 prev_time = this_time;
388 #define SHMEM_SETUP() shmem_setup()
389 #define SHMEM_RESET() shmem_reset()
390 #define SHMEM_BUMP() shmem_bump()
391 #define SHMEM_SNAP(n) shmem_snap(n)
393 #define SHMEM_SETUP()
394 #define SHMEM_RESET()
396 #define SHMEM_SNAP(n)
399 extern command_t cmdlist[];
401 static int do_device(char *func, int dev)
403 struct obd_ioctl_data data;
405 memset(&data, 0, sizeof(data));
412 if (obd_ioctl_pack(&data, &buf, max)) {
413 fprintf(stderr, "error: %s: invalid ioctl\n", cmdname(func));
417 return ioctl(fd, OBD_IOC_DEVICE, buf);
420 int jt_obd_device(int argc, char **argv)
423 do_disconnect(argv[0], 1);
428 dev = parse_devname(argv[0], argv[1]);
433 rc = do_device(argv[0], dev);
435 fprintf(stderr, "error: %s: %s\n", cmdname(argv[0]),
436 strerror(rc = errno));
441 int jt_obd_connect(int argc, char **argv)
443 struct obd_ioctl_data data;
448 do_disconnect(argv[0], 1);
453 rc = ioctl(fd, OBD_IOC_CONNECT, &data);
455 fprintf(stderr, "error: %s: %x %s\n", cmdname(argv[0]),
456 OBD_IOC_CONNECT, strerror(rc = errno));
458 conn_addr = data.ioc_addr;
459 conn_cookie = data.ioc_cookie;
464 int jt_obd_disconnect(int argc, char **argv)
472 return do_disconnect(argv[0], 0);
475 int jt_opt_device(int argc, char **argv)
482 fprintf(stderr, "usage: %s devno <command [args ...]>\n",
487 rc = do_device("device", parse_devname(argv[0], argv[1]));
492 rc = jt_obd_connect(1, arg2);
496 rc = Parser_execarg(argc - 2, argv + 2, cmdlist);
498 ret = do_disconnect(argv[0], 0);
505 int jt_opt_threads(int argc, char **argv)
507 int threads, next_thread;
514 "usage: %s numthreads verbose devno <cmd [args ...]>\n",
519 threads = strtoul(argv[1], NULL, 0);
521 verbose = get_verbose(argv[2]);
524 printf("%s: starting %d threads on device %s running %s\n",
525 argv[0], threads, argv[3], argv[4]);
529 for (i = 1, next_thread = verbose; i <= threads; i++) {
532 fprintf(stderr, "error: %s: #%d - %s\n", argv[0], i,
533 strerror(rc = errno));
535 } else if (rc == 0) {
537 argv[2] = "--device";
538 return jt_opt_device(argc - 2, argv + 2);
539 } else if (be_verbose(verbose, NULL, i, &next_thread, threads))
540 printf("%s: thread #%d (PID %d) started\n",
545 if (!thread) { /* parent process */
546 int live_threads = threads;
548 while (live_threads > 0) {
552 ret = waitpid(0, &status, verbose < 0 ? WNOHANG : 0);
563 fprintf(stderr, "error: %s: wait - %s\n",
564 argv[0], strerror(errno));
569 * This is a hack. We _should_ be able to use
570 * WIFEXITED(status) to see if there was an
571 * error, but it appears to be broken and it
572 * always returns 1 (OK). See wait(2).
574 int err = WEXITSTATUS(status);
577 "%s: PID %d had rc=%d\n",
590 int jt_obd_detach(int argc, char **argv)
592 struct obd_ioctl_data data;
600 if (obd_ioctl_pack(&data, &buf, max)) {
601 fprintf(stderr, "error: %s: invalid ioctl\n", cmdname(argv[0]));
605 rc = ioctl(fd, OBD_IOC_DETACH, buf);
607 fprintf(stderr, "error: %s: %s\n", cmdname(argv[0]),
608 strerror(rc = errno));
613 int jt_obd_cleanup(int argc, char **argv)
615 struct obd_ioctl_data data;
623 rc = ioctl(fd, OBD_IOC_CLEANUP, &data);
625 fprintf(stderr, "error: %s: %s\n", cmdname(argv[0]),
626 strerror(rc = errno));
631 int jt_obd_newdev(int argc, char **argv)
634 struct obd_ioctl_data data;
644 rc = ioctl(fd, OBD_IOC_NEWDEV, &data);
646 fprintf(stderr, "error: %s: %s\n", cmdname(argv[0]),
647 strerror(rc = errno));
649 printf("Current device set to %d\n", data.ioc_dev);
655 int jt_obd_list(int argc, char **argv)
659 struct obd_ioctl_data *data = (struct obd_ioctl_data *)buf;
664 memset(buf, 0, sizeof(buf));
665 data->ioc_version = OBD_IOCTL_VERSION;
666 data->ioc_addr = conn_addr;
667 data->ioc_cookie = conn_addr;
668 data->ioc_len = sizeof(buf);
669 data->ioc_inllen1 = sizeof(buf) - size_round(sizeof(*data));
674 rc = ioctl(fd, OBD_IOC_LIST, data);
676 fprintf(stderr, "error: %s: %s\n", cmdname(argv[0]),
677 strerror(rc = errno));
679 printf("%s", data->ioc_bulk);
685 int jt_obd_attach(int argc, char **argv)
687 struct obd_ioctl_data data;
692 if (argc != 2 && argc != 3 && argc != 4)
695 data.ioc_inllen1 = strlen(argv[1]) + 1;
696 data.ioc_inlbuf1 = argv[1];
698 data.ioc_inllen2 = strlen(argv[2]) + 1;
699 data.ioc_inlbuf2 = argv[2];
703 data.ioc_inllen3 = strlen(argv[3]) + 1;
704 data.ioc_inlbuf3 = argv[3];
707 if (obd_ioctl_pack(&data, &buf, max)) {
708 fprintf(stderr, "error: %s: invalid ioctl\n", cmdname(argv[0]));
712 rc = ioctl(fd, OBD_IOC_ATTACH, buf);
714 fprintf(stderr, "error: %s: %x %s\n", cmdname(argv[0]),
715 OBD_IOC_ATTACH, strerror(rc = errno));
716 else if (argc == 3) {
718 if (strlen(argv[2]) > 128) {
719 printf("Name too long to set environment\n");
722 snprintf(name, 512, "LUSTRE_DEV_%s", argv[2]);
723 rc = setenv(name, argv[1], 1);
725 printf("error setting env variable %s\n", name);
732 int jt_obd_name2dev(int argc, char **argv)
738 rc = do_name2dev(argv[0], argv[1]);
740 int dev = rc - N2D_OFF;
741 rc = do_device(argv[0], dev);
748 int jt_obd_setup(int argc, char **argv)
750 struct obd_ioctl_data data;
760 data.ioc_dev = parse_devname(argv[0], argv[1]);
761 if (data.ioc_dev < 0)
763 data.ioc_inllen1 = strlen(argv[1]) + 1;
764 data.ioc_inlbuf1 = argv[1];
767 data.ioc_inllen2 = strlen(argv[2]) + 1;
768 data.ioc_inlbuf2 = argv[2];
771 if (obd_ioctl_pack(&data, &buf, max)) {
772 fprintf(stderr, "error: %s: invalid ioctl\n", cmdname(argv[0]));
775 rc = ioctl(fd, OBD_IOC_SETUP, buf);
777 fprintf(stderr, "error: %s: %s\n", cmdname(argv[0]),
778 strerror(rc = errno));
784 int jt_obd_create(int argc, char **argv)
786 struct obd_ioctl_data data;
787 struct timeval next_time;
788 int count = 1, next_count;
793 if (argc < 2 || argc > 4) {
794 fprintf(stderr, "usage: %s num [mode] [verbose]\n",
798 count = strtoul(argv[1], NULL, 0);
801 data.ioc_obdo1.o_mode = strtoul(argv[2], NULL, 0);
803 data.ioc_obdo1.o_mode = 0100644;
804 data.ioc_obdo1.o_valid = OBD_MD_FLMODE;
806 verbose = get_verbose(argv[3]);
808 printf("%s: %d obdos\n", cmdname(argv[0]), count);
809 gettimeofday(&next_time, NULL);
810 next_time.tv_sec -= verbose;
812 for (i = 1, next_count = verbose; i <= count; i++) {
813 rc = ioctl(fd, OBD_IOC_CREATE, &data);
816 fprintf(stderr, "error: %s: #%d - %s\n",
817 cmdname(argv[0]), i, strerror(rc = errno));
820 if (be_verbose(verbose, &next_time, i, &next_count, count))
821 printf("%s: #%d is object id %Ld\n", cmdname(argv[0]),
822 i, data.ioc_obdo1.o_id);
827 int jt_obd_setattr(int argc, char **argv)
829 struct obd_ioctl_data data;
836 data.ioc_obdo1.o_id = strtoul(argv[1], NULL, 0);
837 data.ioc_obdo1.o_mode = S_IFREG | strtoul(argv[2], NULL, 0);
838 data.ioc_obdo1.o_valid = OBD_MD_FLMODE;
840 rc = ioctl(fd, OBD_IOC_SETATTR, &data);
842 fprintf(stderr, "error: %s: %s\n", cmdname(argv[0]),
843 strerror(rc = errno));
848 int jt_obd_destroy(int argc, char **argv)
850 struct obd_ioctl_data data;
855 fprintf(stderr, "usage: %s id\n", cmdname(argv[0]));
859 data.ioc_obdo1.o_id = strtoul(argv[1], NULL, 0);
860 data.ioc_obdo1.o_mode = S_IFREG | 0644;
862 rc = ioctl(fd, OBD_IOC_DESTROY, &data);
864 fprintf(stderr, "error: %s: %s\n", cmdname(argv[0]),
865 strerror(rc = errno));
870 int jt_obd_getattr(int argc, char **argv)
872 struct obd_ioctl_data data;
879 data.ioc_obdo1.o_id = strtoul(argv[1], NULL, 0);
880 /* to help obd filter */
881 data.ioc_obdo1.o_mode = 0100644;
882 data.ioc_obdo1.o_valid = 0xffffffff;
883 printf("%s: object id %Ld\n", cmdname(argv[0]), data.ioc_obdo1.o_id);
885 rc = ioctl(fd, OBD_IOC_GETATTR, &data);
887 fprintf(stderr, "error: %s: %s\n", cmdname(argv[0]),
888 strerror(rc = errno));
890 printf("%s: object id %Ld, mode %o\n", cmdname(argv[0]),
891 data.ioc_obdo1.o_id, data.ioc_obdo1.o_mode);
896 int jt_obd_test_getattr(int argc, char **argv)
898 struct obd_ioctl_data data;
899 struct timeval start, next_time;
900 int i, count, next_count;
904 if (argc != 2 && argc != 3)
908 count = strtoul(argv[1], NULL, 0);
911 verbose = get_verbose(argv[2]);
915 data.ioc_obdo1.o_valid = 0xffffffff;
916 data.ioc_obdo1.o_id = 2;
917 gettimeofday(&start, NULL);
918 next_time.tv_sec = start.tv_sec - verbose;
919 next_time.tv_usec = start.tv_usec;
921 printf("%s: getting %d attrs (testing only): %s",
922 cmdname(argv[0]), count, ctime(&start.tv_sec));
924 for (i = 1, next_count = verbose; i <= count; i++) {
925 rc = ioctl(fd, OBD_IOC_GETATTR, &data);
928 fprintf(stderr, "error: %s: #%d - %s\n",
929 cmdname(argv[0]), i, strerror(rc = errno));
933 (verbose, &next_time, i, &next_count, count))
934 printf("%s: got attr #%d\n", cmdname(argv[0]),
943 gettimeofday(&end, NULL);
945 diff = difftime(&end, &start);
949 printf("%s: %d attrs in %.4gs (%.4g attr/s): %s",
950 cmdname(argv[0]), i, diff, (double)i / diff,
956 int jt_obd_test_brw(int argc, char **argv)
958 struct obd_ioctl_data data;
959 struct timeval start, next_time;
960 int pages = 1, objid = 3, count, next_count;
961 int verbose = 1, write = 0, rw;
967 if (argc < 2 || argc > 6)
970 count = strtoul(argv[1], NULL, 0);
973 if (argv[2][0] == 'w' || argv[2][0] == '1')
975 else if (argv[2][0] == 'r' || argv[2][0] == '0')
978 verbose = get_verbose(argv[3]);
982 pages = strtoul(argv[4], NULL, 0);
984 objid = strtoul(argv[5], NULL, 0);
986 len = pages * PAGE_SIZE;
989 data.ioc_obdo1.o_id = objid;
990 data.ioc_count = len;
993 gettimeofday(&start, NULL);
994 next_time.tv_sec = start.tv_sec - verbose;
995 next_time.tv_usec = start.tv_usec;
998 printf("%s: %s %dx%d pages (testing only): %s",
999 cmdname(argv[0]), write ? "writing" : "reading",
1000 count, pages, ctime(&start.tv_sec));
1002 rw = write ? OBD_IOC_BRW_WRITE : OBD_IOC_BRW_READ;
1003 for (i = 1, next_count = verbose, offset = 0; i <= count; i++) {
1004 rc = ioctl(fd, rw, &data);
1007 fprintf(stderr, "error: %s: #%d - %s on %s\n",
1008 cmdname(argv[0]), i, strerror(rc = errno),
1009 write ? "write" : "read");
1011 } else if (be_verbose
1012 (verbose, &next_time, i, &next_count, count))
1013 printf("%s: %s number %d\n", cmdname(argv[0]),
1014 write ? "write" : "read", i);
1016 data.ioc_offset += len;
1023 gettimeofday(&end, NULL);
1025 diff = difftime(&end, &start);
1029 printf("%s: %s %dx%d pages in %.4gs (%.4g pg/s): %s",
1030 cmdname(argv[0]), write ? "wrote" : "read",
1031 i, pages, diff, (double)i * pages / diff,
1032 ctime(&end.tv_sec));
1037 int jt_obd_lov_config(int argc, char **argv)
1039 struct obd_ioctl_data data;
1040 struct lov_desc desc;
1048 if (strlen(argv[1]) > sizeof(uuid_t) - 1) {
1049 fprintf(stderr, "lov_config: no %dB memory for uuid's\n",
1054 memset(&desc, 0, sizeof(desc));
1055 strcpy(desc.ld_uuid, argv[1]);
1056 desc.ld_default_stripe_count = strtoul(argv[2], NULL, 0);
1057 desc.ld_default_stripe_size = strtoul(argv[3], NULL, 0);
1058 desc.ld_default_stripe_offset = (__u64) strtoul(argv[4], NULL, 0);
1059 desc.ld_pattern = strtoul(argv[5], NULL, 0);
1060 desc.ld_tgt_count = argc - 6;
1063 size = sizeof(uuid_t) * desc.ld_tgt_count;
1064 uuidarray = malloc(size);
1066 fprintf(stderr, "lov_config: no %dB memory for uuid's\n", size);
1069 memset(uuidarray, 0, size);
1070 for (i = 6; i < argc; i++) {
1071 char *buf = (char *)(uuidarray + i - 6);
1072 if (strlen(argv[i]) >= sizeof(uuid_t)) {
1073 fprintf(stderr, "lov_config: arg %d (%s) too long\n",
1078 strcpy(buf, argv[i]);
1081 data.ioc_inllen1 = sizeof(desc);
1082 data.ioc_inlbuf1 = (char *)&desc;
1083 data.ioc_inllen2 = size;
1084 data.ioc_inlbuf2 = (char *)uuidarray;
1086 if (obd_ioctl_pack(&data, &buf, max)) {
1087 fprintf(stderr, "error: %s: invalid ioctl\n", cmdname(argv[0]));
1091 rc = ioctl(fd, OBD_IOC_LOV_CONFIG, buf);
1093 fprintf(stderr, "lov_config: error: %s: %s\n",
1094 cmdname(argv[0]), strerror(rc = errno));
1099 int jt_obd_test_ldlm(int argc, char **argv)
1101 struct obd_ioctl_data data;
1108 rc = ioctl(fd, IOC_LDLM_TEST, &data);
1110 fprintf(stderr, "error: %s: test failed: %s\n",
1111 cmdname(argv[0]), strerror(rc = errno));
1115 int jt_obd_dump_ldlm(int argc, char **argv)
1117 struct obd_ioctl_data data;
1122 fprintf(stderr, "usage: %s\n", cmdname(argv[0]));
1126 rc = ioctl(fd, IOC_LDLM_DUMP, &data);
1128 fprintf(stderr, "error: %s failed: %s\n",
1129 cmdname(argv[0]), strerror(rc = errno));
1133 int jt_obd_ldlm_regress_start(int argc, char **argv)
1136 struct obd_ioctl_data data;
1141 fprintf(stderr, "usage: %s [numthreads]\n", cmdname(argv[0]));
1143 } else if (argc == 2) {
1144 data.ioc_inllen1 = strlen(argv[1]) + 1;
1145 data.ioc_inlbuf1 = argv[1];
1147 data.ioc_inllen1 = 0;
1150 if (obd_ioctl_pack(&data, &buf, max)) {
1151 fprintf(stderr, "error: %s: invalid ioctl\n", cmdname(argv[0]));
1155 rc = ioctl(fd, IOC_LDLM_REGRESS_START, buf);
1158 fprintf(stderr, "error: %s: test failed: %s\n",
1159 cmdname(argv[0]), strerror(rc = errno));
1164 int jt_obd_ldlm_regress_stop(int argc, char **argv)
1167 struct obd_ioctl_data data;
1171 fprintf(stderr, "usage: %s\n", cmdname(argv[0]));
1175 rc = ioctl(fd, IOC_LDLM_REGRESS_STOP, &data);
1178 fprintf(stderr, "error: %s: test failed: %s\n",
1179 cmdname(argv[0]), strerror(rc = errno));
1183 int jt_obd_newconn(int argc, char **argv)
1186 struct obd_ioctl_data data;
1192 rc = ioctl(fd, OBD_IOC_RECOVD_NEWCONN, &data);
1194 fprintf(stderr, "error: %s: %s\n", cmdname(argv[0]),
1195 strerror(rc = errno));
1200 static void signal_server(int sig)
1202 if (sig == SIGINT) {
1203 do_disconnect("sigint", 1);
1206 fprintf(stderr, "%s: got signal %d\n", cmdname("sigint"), sig);
1209 int obd_initialize(int argc, char **argv)
1216 void obd_cleanup(int argc, char **argv)
1218 struct sigaction sigact;
1220 sigact.sa_handler = signal_server;
1221 sigfillset(&sigact.sa_mask);
1222 sigact.sa_flags = SA_RESTART;
1223 sigaction(SIGINT, &sigact, NULL);
1225 do_disconnect(argv[0], 1);