2 * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
4 * Copyright (c) 2013, 2017, Intel Corporation.
6 * This file is part of Lustre, https://wiki.whamcloud.com/
8 * Portals is free software; you can redistribute it and/or
9 * modify it under the terms of version 2 of the GNU General Public
10 * License as published by the Free Software Foundation.
12 * Portals is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with Portals; if not, write to the Free Software
19 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
33 #include <sys/ioctl.h>
36 #include <linux/types.h>
38 #include <libcfs/util/ioctl.h>
39 #include <linux/lnet/libcfs_debug.h>
40 #include <linux/lnet/lnet-dlc.h>
41 #include <linux/lnet/lnetctl.h>
42 #include <linux/lnet/nidstr.h>
43 #include <linux/lnet/socklnd.h>
44 #include <lnetconfig/liblnetconfig.h>
45 #include <lustre/lustreapi.h>
47 unsigned int libcfs_debug;
48 unsigned int libcfs_printk = D_CANTMASK;
50 static bool g_net_interactive;
51 static bool g_net_set;
54 #define IOC_BUF_SIZE 8192
55 static char local_buf[IOC_BUF_SIZE];
56 static char *ioc_buf = local_buf;
58 /* Convert a string boolean to an int; "enable" -> 1 */
60 lnet_parse_bool (int *b, char *str)
62 if (!strcasecmp(str, "no") ||
63 !strcasecmp(str, "n") ||
64 !strcasecmp(str, "off") ||
65 !strcasecmp(str, "down") ||
66 !strcasecmp(str, "disable")) {
72 if (!strcasecmp(str, "yes") ||
73 !strcasecmp(str, "y") ||
74 !strcasecmp(str, "on") ||
75 !strcasecmp(str, "up") ||
76 !strcasecmp(str, "enable")) {
86 lnet_parse_port(int *port, char *str)
90 *port = strtol(str, &end, 0);
92 if (*end == 0 && /* parsed whole string */
93 *port > 0 && *port < 65536) /* minimal sanity check */
99 #ifdef HAVE_GETHOSTBYNAME
100 static struct hostent *
101 ptl_gethostbyname(char *hname)
105 he = gethostbyname(hname);
110 fprintf(stderr, "Unable to resolve hostname: %s\n",
114 fprintf(stderr, "gethostbyname error for %s: %s\n",
115 hname, strerror(h_errno));
125 lnet_parse_ipquad(__u32 *ipaddrp, char *str)
129 if (sscanf(str, "%d.%d.%d.%d", &a, &b, &c, &d) == 4 &&
130 (a & ~0xff) == 0 && (b & ~0xff) == 0 &&
131 (c & ~0xff) == 0 && (d & ~0xff) == 0) {
132 *ipaddrp = (a << 24) | (b << 16) | (c << 8) | d;
141 lnet_parse_ipaddr(__u32 *ipaddrp, char *str)
143 #ifdef HAVE_GETHOSTBYNAME
147 if (!strcmp(str, "_all_")) {
152 if (lnet_parse_ipquad(ipaddrp, str) == 0)
155 #ifdef HAVE_GETHOSTBYNAME
156 if ((('a' <= str[0] && str[0] <= 'z') ||
157 ('A' <= str[0] && str[0] <= 'Z')) &&
158 (he = ptl_gethostbyname(str)) != NULL) {
159 __u32 addr = *(__u32 *)he->h_addr;
161 *ipaddrp = ntohl(addr); /* HOST byte order */
170 ptl_ipaddr_2_str(__u32 ipaddr, char *str, size_t strsize, int lookup)
172 #ifdef HAVE_GETHOSTBYNAME
177 net_ip = htonl(ipaddr);
178 he = gethostbyaddr(&net_ip, sizeof(net_ip), AF_INET);
180 snprintf(str, strsize, "%s", he->h_name);
186 sprintf(str, "%d.%d.%d.%d",
187 (ipaddr >> 24) & 0xff, (ipaddr >> 16) & 0xff,
188 (ipaddr >> 8) & 0xff, ipaddr & 0xff);
193 lnet_parse_time(time_t *t, char *str)
199 *t = strtol(str, &end, 0);
200 if (*end == 0) /* parsed whole string */
203 memset(&tm, 0, sizeof(tm));
204 n = sscanf(str, "%d-%d-%d-%d:%d:%d",
205 &tm.tm_year, &tm.tm_mon, &tm.tm_mday,
206 &tm.tm_hour, &tm.tm_min, &tm.tm_sec);
210 tm.tm_mon--; /* convert to 0 == Jan */
211 tm.tm_year -= 1900; /* y2k quirk */
212 tm.tm_isdst = -1; /* dunno if it's daylight savings... */
215 if (*t == (time_t)-1)
222 lnet_parse_nid(char *nid_str, struct lnet_process_id *id_ptr)
224 id_ptr->pid = LNET_PID_ANY;
225 id_ptr->nid = libcfs_str2nid(nid_str);
226 if (id_ptr->nid == LNET_NID_ANY) {
227 fprintf(stderr, "Can't parse nid \"%s\"\n", nid_str);
234 static int g_net_is_set(char *cmd)
242 if (g_net_interactive)
248 "You must run '%s <network>' command before '%s'\n",
256 static int g_net_is_compatible(char *cmd, ...)
261 if (!g_net_is_set(cmd))
267 nal = va_arg(ap, int);
268 if (nal == LNET_NETTYP(g_net)) {
277 fprintf(stderr, "Command %s not compatible with %s NAL\n",
278 cmd, libcfs_lnd2str(LNET_NETTYP(g_net)));
283 int ptl_initialize(int argc, char **argv)
286 g_net_interactive = true;
288 register_ioc_dev(LNET_DEV_ID, LNET_DEV_PATH);
293 int jt_ptl_network(int argc, char **argv)
295 struct libcfs_ioctl_data data;
296 __u32 net = LNET_NET_ANY;
300 fprintf(stderr, "usage: %s <net>|up|down\n", argv[0]);
304 if (!strcmp(argv[1], "unconfigure") || !strcmp(argv[1], "down")) {
305 LIBCFS_IOC_INIT(data);
306 rc = l_ioctl(LNET_DEV_ID, IOC_LIBCFS_UNCONFIGURE, &data);
309 printf("LNET ready to unload\n");
313 if (errno == ENODEV) {
314 printf("LNET is currently not loaded.");
319 fprintf(stderr, "LNET busy\n");
321 fprintf(stderr, "LNET unconfigure error %d: %s\n",
322 errno, strerror(errno));
324 } else if (!strcmp(argv[1], "configure") || !strcmp(argv[1], "up")) {
325 LIBCFS_IOC_INIT(data);
326 rc = l_ioctl(LNET_DEV_ID, IOC_LIBCFS_CONFIGURE, &data);
329 printf("LNET configured\n");
333 fprintf(stderr, "LNET configure error %d: %s\n",
334 errno, strerror(errno));
338 net = libcfs_str2net(argv[1]);
339 if (net == LNET_NET_ANY) {
340 fprintf(stderr, "Can't parse net %s\n", argv[1]);
349 #ifndef IOC_LIBCFS_GET_NI
350 #define IOC_LIBCFS_GET_NI _IOWR('e', 50, IOCTL_LIBCFS_TYPE)
354 jt_ptl_list_nids(int argc, char **argv)
356 struct libcfs_ioctl_data data;
357 int all = 0, return_nid = 0;
358 yaml_emitter_t request;
366 all = (argc == 2) && (strcmp(argv[1], "all") == 0);
367 /* Hack to pass back value */
368 return_nid = (argc == 2) && (argv[1][0] == 1);
370 if ((argc > 2) && !(all || return_nid)) {
371 fprintf(stderr, "usage: %s [all]\n", argv[0]);
375 sk = nl_socket_alloc();
379 /* Setup parser to receive Netlink packets */
380 rc = yaml_parser_initialize(&reply);
382 yaml_parser_log_error(&reply, stderr, NULL);
386 rc = yaml_parser_set_input_netlink(&reply, sk, false);
388 yaml_parser_log_error(&reply, stderr, NULL);
389 yaml_parser_delete(&reply);
393 /* Create Netlink emitter to send request to kernel */
394 rc = yaml_emitter_initialize(&request);
396 yaml_parser_log_error(&reply, stderr, NULL);
397 yaml_parser_delete(&reply);
401 rc = yaml_emitter_set_output_netlink(&request, sk, LNET_GENL_NAME, 1,
402 LNET_CMD_NETS, NLM_F_DUMP);
404 yaml_emitter_log_error(&request, stderr);
405 yaml_emitter_delete(&request);
406 yaml_parser_delete(&reply);
410 yaml_emitter_open(&request);
411 yaml_document_start_event_initialize(&event, NULL, NULL, NULL, 0);
412 rc = yaml_emitter_emit(&request, &event);
416 yaml_mapping_start_event_initialize(&event, NULL,
417 (yaml_char_t *)YAML_MAP_TAG,
418 1, YAML_ANY_MAPPING_STYLE);
419 rc = yaml_emitter_emit(&request, &event);
423 yaml_scalar_event_initialize(&event, NULL,
424 (yaml_char_t *)YAML_STR_TAG,
425 (yaml_char_t *)"net",
427 YAML_PLAIN_SCALAR_STYLE);
428 rc = yaml_emitter_emit(&request, &event);
433 if (!g_net_set || g_net == LNET_NET_ANY) {
434 yaml_scalar_event_initialize(&event, NULL,
435 (yaml_char_t *)YAML_STR_TAG,
438 YAML_PLAIN_SCALAR_STYLE);
439 rc = yaml_emitter_emit(&request, &event);
443 char *net_id = libcfs_net2str(g_net);
445 yaml_sequence_start_event_initialize(&event, NULL,
446 (yaml_char_t *)YAML_SEQ_TAG,
447 1, YAML_ANY_SEQUENCE_STYLE);
448 rc = yaml_emitter_emit(&request, &event);
452 yaml_mapping_start_event_initialize(&event, NULL,
453 (yaml_char_t *)YAML_MAP_TAG,
454 1, YAML_ANY_MAPPING_STYLE);
455 rc = yaml_emitter_emit(&request, &event);
459 yaml_scalar_event_initialize(&event, NULL,
460 (yaml_char_t *)YAML_STR_TAG,
461 (yaml_char_t *)"net type",
463 1, 0, YAML_PLAIN_SCALAR_STYLE);
464 rc = yaml_emitter_emit(&request, &event);
468 yaml_scalar_event_initialize(&event, NULL,
469 (yaml_char_t *)YAML_STR_TAG,
470 (yaml_char_t *)net_id,
471 strlen(net_id), 1, 0,
472 YAML_PLAIN_SCALAR_STYLE);
473 rc = yaml_emitter_emit(&request, &event);
477 yaml_mapping_end_event_initialize(&event);
478 rc = yaml_emitter_emit(&request, &event);
482 yaml_sequence_end_event_initialize(&event);
483 rc = yaml_emitter_emit(&request, &event);
487 yaml_mapping_end_event_initialize(&event);
488 rc = yaml_emitter_emit(&request, &event);
492 yaml_document_end_event_initialize(&event, 0);
493 rc = yaml_emitter_emit(&request, &event);
497 rc = yaml_emitter_close(&request);
500 yaml_emitter_log_error(&request, stderr);
503 yaml_emitter_delete(&request);
506 rc = yaml_parser_parse(&reply, &event);
510 if (event.type == YAML_SCALAR_EVENT &&
511 strcmp((char *)event.data.scalar.value, "nid") == 0) {
514 yaml_event_delete(&event);
515 rc = yaml_parser_parse(&reply, &event);
517 yaml_event_delete(&event);
521 tmp = (char *)event.data.scalar.value;
522 if (all || strcmp(tmp, "0@lo") != 0) {
525 *(__u64 *)(argv[1]) = libcfs_str2nid(tmp);
530 done = (event.type == YAML_STREAM_END_EVENT);
531 yaml_event_delete(&event);
535 yaml_parser_log_error(&reply, stderr, NULL);
536 yaml_parser_delete(&reply);
543 for (count = 0;; count++) {
544 LIBCFS_IOC_INIT(data);
545 data.ioc_count = count;
546 rc = l_ioctl(LNET_DEV_ID, IOC_LIBCFS_GET_NI, &data);
549 if ((count > 0) && (errno == ENOENT))
550 /* We found them all */
552 fprintf(stderr, "IOC_LIBCFS_GET_NI error %d: %s\n",
553 errno, strerror(errno));
557 if (all || (data.ioc_nid != LNET_NID_LO_0)) {
558 printf("%s\n", libcfs_nid2str(data.ioc_nid));
560 *(__u64 *)(argv[1]) = data.ioc_nid;
570 jt_ptl_which_nid(int argc, char **argv)
572 struct libcfs_ioctl_data data;
575 lnet_nid_t best_nid = LNET_NID_ANY;
584 fprintf(stderr, "usage: %s NID [NID...]\n", argv[0]);
588 for (i = 1; i < argc; i++) {
590 nid = libcfs_str2nid(nidstr);
591 if (nid == LNET_NID_ANY) {
592 fprintf(stderr, "Can't parse NID %s\n", nidstr);
596 LIBCFS_IOC_INIT(data);
599 rc = l_ioctl(LNET_DEV_ID, IOC_LIBCFS_LNET_DIST, &data);
601 fprintf(stderr, "Can't get distance to %s: %s\n",
602 nidstr, strerror(errno));
606 dist = data.ioc_u32[0];
607 order = data.ioc_u32[1];
610 if (dist == -EHOSTUNREACH)
613 fprintf(stderr, "Unexpected distance to %s: %d\n",
618 if (best_nid == LNET_NID_ANY ||
620 (dist == best_dist && order < best_order)) {
627 if (best_nid == LNET_NID_ANY) {
628 fprintf(stderr, "No reachable NID\n");
632 printf("%s\n", libcfs_nid2str(best_nid));
637 jt_ptl_print_interfaces(int argc, char **argv)
639 struct libcfs_ioctl_data data;
640 char buffer[3][HOST_NAME_MAX + 1];
644 if (!g_net_is_compatible(argv[0], SOCKLND, 0))
647 for (index = 0; ; index++) {
648 LIBCFS_IOC_INIT(data);
649 data.ioc_net = g_net;
650 data.ioc_count = index;
652 rc = l_ioctl(LNET_DEV_ID, IOC_LIBCFS_GET_INTERFACE, &data);
656 printf("%s: (%s/%s) npeer %d nroute %d\n",
657 ptl_ipaddr_2_str(data.ioc_u32[0], buffer[2],
658 sizeof(buffer[2]), 1),
659 ptl_ipaddr_2_str(data.ioc_u32[0], buffer[0],
660 sizeof(buffer[0]), 0),
661 ptl_ipaddr_2_str(data.ioc_u32[1], buffer[1],
662 sizeof(buffer[1]), 0),
663 data.ioc_u32[2], data.ioc_u32[3]);
667 if (errno == ENOENT) {
668 printf("<no interfaces>\n");
671 "Error getting interfaces: %s: check dmesg.\n",
680 jt_ptl_add_interface(int argc, char **argv)
682 struct libcfs_ioctl_data data;
685 __u32 netmask = 0xffffff00;
690 if (argc < 2 || argc > 3) {
691 fprintf(stderr, "usage: %s ipaddr [netmask]\n", argv[0]);
695 if (!g_net_is_compatible(argv[0], SOCKLND, 0))
698 if (lnet_parse_ipaddr(&ipaddr, argv[1]) != 0) {
699 fprintf(stderr, "Can't parse ip: %s\n", argv[1]);
704 count = strtol(argv[2], &end, 0);
705 if (count > 0 && count < 32 && *end == 0) {
707 for (i = count; i > 0; i--)
708 netmask = netmask | (1 << (32 - i));
709 } else if (lnet_parse_ipquad(&netmask, argv[2]) != 0) {
710 fprintf(stderr, "Can't parse netmask: %s\n", argv[2]);
715 LIBCFS_IOC_INIT(data);
716 data.ioc_net = g_net;
717 data.ioc_u32[0] = ipaddr;
718 data.ioc_u32[1] = netmask;
720 rc = l_ioctl(LNET_DEV_ID, IOC_LIBCFS_ADD_INTERFACE, &data);
722 fprintf(stderr, "failed to add interface: %s\n",
731 jt_ptl_del_interface(int argc, char **argv)
733 struct libcfs_ioctl_data data;
738 fprintf(stderr, "usage: %s [ipaddr]\n", argv[0]);
742 if (!g_net_is_compatible(argv[0], SOCKLND, 0))
746 lnet_parse_ipaddr(&ipaddr, argv[1]) != 0) {
747 fprintf(stderr, "Can't parse ip: %s\n", argv[1]);
751 LIBCFS_IOC_INIT(data);
752 data.ioc_net = g_net;
753 data.ioc_u32[0] = ipaddr;
755 rc = l_ioctl(LNET_DEV_ID, IOC_LIBCFS_DEL_INTERFACE, &data);
757 fprintf(stderr, "failed to delete interface: %s\n",
766 jt_ptl_print_peers(int argc, char **argv)
768 struct libcfs_ioctl_data data;
769 struct lnet_process_id id;
770 char buffer[2][HOST_NAME_MAX + 1];
774 if (!g_net_is_compatible(argv[0], SOCKLND, O2IBLND, GNILND,
778 for (index = 0; ; index++) {
779 LIBCFS_IOC_INIT(data);
780 data.ioc_net = g_net;
781 data.ioc_count = index;
783 rc = l_ioctl(LNET_DEV_ID, IOC_LIBCFS_GET_PEER, &data);
787 if (g_net_is_compatible(NULL, SOCKLND, 0)) {
788 id.nid = data.ioc_nid;
789 id.pid = data.ioc_u32[4];
790 printf("%-20s [%d]%s->%s:%d #%d\n",
792 data.ioc_count, /* persistence */
794 ptl_ipaddr_2_str(data.ioc_u32[2], buffer[0],
795 sizeof(buffer[0]), 1),
797 ptl_ipaddr_2_str(data.ioc_u32[0], buffer[1],
798 sizeof(buffer[1]), 1),
799 data.ioc_u32[1], /* peer port */
800 data.ioc_u32[3]); /* conn_count */
801 } else if (g_net_is_compatible(NULL, GNILND, 0)) {
802 int disconn = data.ioc_flags >> 16;
808 state = data.ioc_flags & 0xffff ? "C" : "U";
810 printf("%-20s (%d) %s [%d] %ju sq %d/%d tx %d/%d/%d\n",
811 libcfs_nid2str(data.ioc_nid), /* peer nid */
812 data.ioc_net, /* gemini device id */
813 state, /* peer is Connecting, Up, or Down */
814 data.ioc_count, /* peer refcount */
815 (uintmax_t)data.ioc_u64[0], /* peerstamp */
816 data.ioc_u32[2], data.ioc_u32[3], /* tx and rx seq */
817 /* fmaq, nfma, nrdma */
818 data.ioc_u32[0], data.ioc_u32[1],
821 printf("%-20s [%d]\n",
822 libcfs_nid2str(data.ioc_nid), data.ioc_count);
827 if (errno == ENOENT) {
828 printf("<no peers>\n");
831 "Error getting peer list: %s: check dmesg.\n",
838 int jt_ptl_add_peer(int argc, char **argv)
840 struct libcfs_ioctl_data data;
846 if (!g_net_is_compatible(argv[0], SOCKLND, GNILND, 0))
850 fprintf(stderr, "usage(tcp,gni): %s nid ipaddr port\n",
855 nid = libcfs_str2nid(argv[1]);
856 if (nid == LNET_NID_ANY) {
857 fprintf(stderr, "Can't parse NID: %s\n", argv[1]);
861 if (lnet_parse_ipaddr(&ip, argv[2]) != 0) {
862 fprintf(stderr, "Can't parse ip addr: %s\n", argv[2]);
866 if (lnet_parse_port(&port, argv[3]) != 0) {
867 fprintf(stderr, "Can't parse port: %s\n", argv[3]);
871 LIBCFS_IOC_INIT(data);
872 data.ioc_net = g_net;
874 data.ioc_u32[0] = ip;
875 data.ioc_u32[1] = port;
877 rc = l_ioctl(LNET_DEV_ID, IOC_LIBCFS_ADD_PEER, &data);
879 fprintf(stderr, "failed to add peer: %s\n",
888 jt_ptl_del_peer(int argc, char **argv)
890 struct libcfs_ioctl_data data;
891 lnet_nid_t nid = LNET_NID_ANY;
892 lnet_pid_t pid = LNET_PID_ANY;
896 if (!g_net_is_compatible(argv[0], SOCKLND, O2IBLND, GNILND,
900 if (g_net_is_compatible(NULL, SOCKLND, 0)) {
902 fprintf(stderr, "usage: %s [nid] [ipaddr]\n", argv[0]);
905 } else if (argc > 2) {
906 fprintf(stderr, "usage: %s [nid]\n", argv[0]);
910 if (argc > 1 && !libcfs_str2anynid(&nid, argv[1])) {
911 fprintf(stderr, "Can't parse nid: %s\n", argv[1]);
915 if (g_net_is_compatible(NULL, SOCKLND, 0)) {
916 if (argc > 2 && lnet_parse_ipaddr(&ip, argv[2]) != 0) {
917 fprintf(stderr, "Can't parse ip addr: %s\n", argv[2]);
922 LIBCFS_IOC_INIT(data);
923 data.ioc_net = g_net;
925 data.ioc_u32[0] = ip;
926 data.ioc_u32[1] = pid;
928 rc = l_ioctl(LNET_DEV_ID, IOC_LIBCFS_DEL_PEER, &data);
930 fprintf(stderr, "failed to remove peer: %s\n", strerror(errno));
938 jt_ptl_print_connections(int argc, char **argv)
940 struct libcfs_ioctl_data data;
941 struct lnet_process_id id;
942 char buffer[2][HOST_NAME_MAX + 1];
946 if (!g_net_is_compatible(argv[0], SOCKLND, O2IBLND, GNILND, 0))
949 for (index = 0; ; index++) {
950 LIBCFS_IOC_INIT(data);
951 data.ioc_net = g_net;
952 data.ioc_count = index;
954 rc = l_ioctl(LNET_DEV_ID, IOC_LIBCFS_GET_CONN, &data);
958 if (g_net_is_compatible(NULL, SOCKLND, 0)) {
959 id.nid = data.ioc_nid;
960 id.pid = data.ioc_u32[6];
961 printf("%-20s %s[%d]%s->%s:%d %d/%d %s\n",
963 (data.ioc_u32[3] == SOCKLND_CONN_ANY) ? "A" :
964 (data.ioc_u32[3] == SOCKLND_CONN_CONTROL) ? "C" :
965 (data.ioc_u32[3] == SOCKLND_CONN_BULK_IN) ? "I" :
966 (data.ioc_u32[3] == SOCKLND_CONN_BULK_OUT) ? "O" : "?",
967 data.ioc_u32[4], /* scheduler */
969 ptl_ipaddr_2_str(data.ioc_u32[2], buffer[0],
970 sizeof(buffer[0]), 1),
972 ptl_ipaddr_2_str(data.ioc_u32[0], buffer[1],
973 sizeof(buffer[1]), 1),
974 data.ioc_u32[1], /* remote port */
975 data.ioc_count, /* tx buffer size */
976 data.ioc_u32[5], /* rx buffer size */
977 data.ioc_flags ? "nagle" : "nonagle");
978 } else if (g_net_is_compatible(NULL, O2IBLND, 0)) {
979 printf("%s mtu %d\n",
980 libcfs_nid2str(data.ioc_nid),
981 data.ioc_u32[0]); /* path MTU */
982 } else if (g_net_is_compatible(NULL, GNILND, 0)) {
983 printf("%-20s [%d]\n",
984 libcfs_nid2str(data.ioc_nid),
985 data.ioc_u32[0] /* device id */);
987 printf("%s\n", libcfs_nid2str(data.ioc_nid));
992 if (errno == ENOENT) {
993 printf("<no connections>\n");
996 "Error getting connection list: %s: check dmesg.\n",
1003 int jt_ptl_disconnect(int argc, char **argv)
1005 struct libcfs_ioctl_data data;
1006 lnet_nid_t nid = LNET_NID_ANY;
1011 fprintf(stderr, "usage: %s [nid] [ipaddr]\n", argv[0]);
1015 if (!g_net_is_compatible(NULL, SOCKLND, O2IBLND, GNILND, 0))
1018 if (argc >= 2 && !libcfs_str2anynid(&nid, argv[1])) {
1019 fprintf(stderr, "Can't parse nid %s\n", argv[1]);
1023 if (g_net_is_compatible(NULL, SOCKLND, 0) && argc >= 3 &&
1024 lnet_parse_ipaddr(&ipaddr, argv[2]) != 0) {
1025 fprintf(stderr, "Can't parse ip addr %s\n", argv[2]);
1029 LIBCFS_IOC_INIT(data);
1030 data.ioc_net = g_net;
1032 data.ioc_u32[0] = ipaddr;
1034 rc = l_ioctl(LNET_DEV_ID, IOC_LIBCFS_CLOSE_CONNECTION, &data);
1036 fprintf(stderr, "failed to remove connection: %s\n",
1044 int jt_ptl_push_connection(int argc, char **argv)
1046 struct libcfs_ioctl_data data;
1048 lnet_nid_t nid = LNET_NID_ANY;
1051 fprintf(stderr, "usage: %s [nid]\n", argv[0]);
1055 if (!g_net_is_compatible(argv[0], SOCKLND, GNILND, 0))
1058 if (argc > 1 && !libcfs_str2anynid(&nid, argv[1])) {
1059 fprintf(stderr, "Can't parse nid: %s\n", argv[1]);
1063 LIBCFS_IOC_INIT(data);
1064 data.ioc_net = g_net;
1067 rc = l_ioctl(LNET_DEV_ID, IOC_LIBCFS_PUSH_CONNECTION, &data);
1069 fprintf(stderr, "failed to push connection: %s\n",
1077 #ifndef IOC_LIBCFS_PING_PEER
1078 #define IOC_LIBCFS_PING_PEER _IOWR('e', 62, IOCTL_LIBCFS_TYPE)
1081 int jt_ptl_ping(int argc, char **argv)
1083 bool done = false, print = true;
1086 struct lnet_process_id id;
1087 struct lnet_process_id ids[LNET_INTERFACES_MAX_DEFAULT];
1088 lnet_nid_t src = LNET_NID_ANY;
1089 int maxids = sizeof(ids) / sizeof(ids[0]);
1090 struct lnet_ioctl_ping_data ping = { { 0 } };
1091 yaml_emitter_t request;
1092 yaml_parser_t reply;
1099 fprintf(stderr, "usage: %s id [timeout (secs)]\n", argv[0]);
1103 sep = strchr(argv[1], '-');
1105 rc = lnet_parse_nid(argv[1], &id);
1111 if (argv[1][0] == 'u' || argv[1][0] == 'U')
1112 id.pid = strtoul(&argv[1][1], &end, 0) |
1115 id.pid = strtoul(argv[1], &end, 0);
1117 if (end != sep) { /* assuming '-' is part of hostname */
1118 rc = lnet_parse_nid(argv[1], &id);
1122 id.nid = libcfs_str2nid(sep + 1);
1124 if (id.nid == LNET_NID_ANY) {
1126 "Can't parse process id \"%s\"\n",
1134 timeout = 1000 * atol(argv[2]);
1135 if (timeout > 120 * 1000) {
1136 fprintf(stderr, "Timeout %s is to large\n",
1141 timeout = 1000; /* default 1 second timeout */
1144 /* Create Netlink emitter to send request to kernel */
1145 sk = nl_socket_alloc();
1149 /* Setup parser to recieve Netlink packets */
1150 rc = yaml_parser_initialize(&reply);
1154 rc = yaml_parser_set_input_netlink(&reply, sk, false);
1158 /* Create Netlink emitter to send request to kernel */
1159 rc = yaml_emitter_initialize(&request);
1163 rc = yaml_emitter_set_output_netlink(&request, sk, LNET_GENL_NAME,
1164 LNET_GENL_VERSION, LNET_CMD_PING,
1169 yaml_emitter_open(&request);
1170 yaml_document_start_event_initialize(&event, NULL, NULL, NULL, 0);
1171 rc = yaml_emitter_emit(&request, &event);
1175 yaml_mapping_start_event_initialize(&event, NULL,
1176 (yaml_char_t *)YAML_MAP_TAG,
1177 1, YAML_ANY_MAPPING_STYLE);
1178 rc = yaml_emitter_emit(&request, &event);
1182 yaml_scalar_event_initialize(&event, NULL,
1183 (yaml_char_t *)YAML_STR_TAG,
1184 (yaml_char_t *)"ping",
1185 strlen("ping"), 1, 0,
1186 YAML_PLAIN_SCALAR_STYLE);
1187 rc = yaml_emitter_emit(&request, &event);
1191 yaml_mapping_start_event_initialize(&event, NULL,
1192 (yaml_char_t *)YAML_MAP_TAG,
1193 1, YAML_ANY_MAPPING_STYLE);
1194 rc = yaml_emitter_emit(&request, &event);
1198 if (timeout != 1000) {
1199 yaml_scalar_event_initialize(&event, NULL,
1200 (yaml_char_t *)YAML_STR_TAG,
1201 (yaml_char_t *)"timeout",
1202 strlen("timeout"), 1, 0,
1203 YAML_PLAIN_SCALAR_STYLE);
1204 rc = yaml_emitter_emit(&request, &event);
1208 yaml_scalar_event_initialize(&event, NULL,
1209 (yaml_char_t *)YAML_INT_TAG,
1210 (yaml_char_t *)argv[2],
1211 strlen(argv[2]), 1, 0,
1212 YAML_PLAIN_SCALAR_STYLE);
1213 rc = yaml_emitter_emit(&request, &event);
1218 yaml_scalar_event_initialize(&event, NULL,
1219 (yaml_char_t *)YAML_STR_TAG,
1220 (yaml_char_t *)"nids",
1221 strlen("nids"), 1, 0,
1222 YAML_PLAIN_SCALAR_STYLE);
1223 rc = yaml_emitter_emit(&request, &event);
1227 yaml_sequence_start_event_initialize(&event, NULL,
1228 (yaml_char_t *)YAML_SEQ_TAG,
1229 1, YAML_FLOW_SEQUENCE_STYLE);
1230 rc = yaml_emitter_emit(&request, &event);
1234 /* convert NID to string, in case libcfs_str2nid() did name lookup */
1235 yaml_scalar_event_initialize(&event, NULL,
1236 (yaml_char_t *)YAML_STR_TAG,
1237 (yaml_char_t *)libcfs_nid2str(id.nid),
1238 strlen(libcfs_nid2str(id.nid)), 1, 0,
1239 YAML_PLAIN_SCALAR_STYLE);
1240 rc = yaml_emitter_emit(&request, &event);
1244 yaml_sequence_end_event_initialize(&event);
1245 rc = yaml_emitter_emit(&request, &event);
1249 yaml_mapping_end_event_initialize(&event);
1250 rc = yaml_emitter_emit(&request, &event);
1254 yaml_mapping_end_event_initialize(&event);
1255 rc = yaml_emitter_emit(&request, &event);
1259 yaml_document_end_event_initialize(&event, 0);
1260 rc = yaml_emitter_emit(&request, &event);
1264 rc = yaml_emitter_close(&request);
1267 yaml_emitter_log_error(&request, stderr);
1271 yaml_emitter_delete(&request);
1273 /* Now parse the reply results */
1275 rc = yaml_parser_parse(&reply, &event);
1279 if (event.type != YAML_SCALAR_EVENT)
1282 if (strcmp((char *)event.data.scalar.value, "nid") == 0) {
1283 yaml_event_delete(&event);
1284 rc = yaml_parser_parse(&reply, &event);
1286 yaml_event_delete(&event);
1290 /* Print 0@lo. Its not sent */
1291 printf("12345-0@lo\n");
1294 printf("%s\n", (char *)event.data.scalar.value);
1295 } else if (strcmp((char *)event.data.scalar.value,
1297 yaml_event_delete(&event);
1298 rc = yaml_parser_parse(&reply, &event);
1300 yaml_event_delete(&event);
1303 rc = strtol((char *)event.data.scalar.value, NULL, 10);
1304 fprintf(stdout, "failed to ping %s: %s\n",
1305 argv[1], strerror(-rc));
1306 break; /* "rc" is clobbered if loop is run again */
1309 done = (event.type == YAML_STREAM_END_EVENT);
1310 yaml_event_delete(&event);
1314 /* yaml_* functions return 0 for error */
1315 const char *msg = yaml_parser_get_reader_error(&reply);
1317 rc = errno ? -errno : -EHOSTUNREACH;
1318 if (strcmp(msg, "Unspecific failure") != 0) {
1319 fprintf(stdout, "failed to ping %s: %s\n",
1322 fprintf(stdout, "failed to ping %s: %s\n",
1323 argv[1], strerror(errno));
1325 } else if (rc == 1) {
1326 /* yaml_* functions return 1 for success */
1329 yaml_parser_delete(&reply);
1336 LIBCFS_IOC_INIT_V2(ping, ping_hdr);
1337 ping.ping_hdr.ioc_len = sizeof(ping);
1339 ping.ping_src = src;
1340 ping.op_param = timeout;
1341 ping.ping_count = maxids;
1342 ping.ping_buf = ids;
1344 rc = l_ioctl(LNET_DEV_ID, IOC_LIBCFS_PING_PEER, &ping);
1346 fprintf(stderr, "failed to ping %s: %s\n", argv[1],
1351 for (i = 0; i < ping.ping_count && i < maxids; i++)
1352 printf("%s\n", libcfs_id2str(ids[i]));
1354 if (ping.ping_count > maxids)
1355 printf("%d out of %d ids listed\n", maxids, ping.ping_count);
1360 int jt_ptl_mynid(int argc, char **argv)
1362 struct libcfs_ioctl_data data;
1367 fprintf(stderr, "usage: %s NID\n", argv[0]);
1371 nid = libcfs_str2nid(argv[1]);
1372 if (nid == LNET_NID_ANY) {
1373 fprintf(stderr, "Can't parse NID '%s'\n", argv[1]);
1377 LIBCFS_IOC_INIT(data);
1378 data.ioc_net = LNET_NIDNET(nid);
1381 rc = l_ioctl(LNET_DEV_ID, IOC_LIBCFS_REGISTER_MYNID, &data);
1383 fprintf(stderr, "setting my NID failed: %s\n",
1386 printf("registered my nid %s\n", libcfs_nid2str(nid));
1392 jt_ptl_fail_nid(int argc, char **argv)
1397 struct libcfs_ioctl_data data;
1399 if (argc < 2 || argc > 3) {
1400 fprintf(stderr, "usage: %s nid|\"*\" [count (0 == mend)]\n",
1405 if (!libcfs_str2anynid(&nid, argv[1])) {
1406 fprintf(stderr, "Can't parse nid \"%s\"\n", argv[1]);
1411 threshold = LNET_MD_THRESH_INF;
1412 } else if (sscanf(argv[2], "%i", &threshold) != 1) {
1413 fprintf(stderr, "Can't parse count \"%s\"\n", argv[2]);
1417 LIBCFS_IOC_INIT(data);
1419 data.ioc_count = threshold;
1421 rc = l_ioctl(LNET_DEV_ID, IOC_LIBCFS_FAIL_NID, &data);
1423 fprintf(stderr, "IOC_LIBCFS_FAIL_NID failed: %s\n",
1427 threshold == 0 ? "Unfailing" : "Failing", argv[1]);
1433 jt_ptl_add_route(int argc, char **argv)
1435 struct lnet_ioctl_config_data data;
1436 lnet_nid_t gateway_nid;
1437 __u32 hops = LNET_UNDEFINED_HOPS;
1438 unsigned int priority = 0;
1442 if (argc < 2 || argc > 4) {
1443 fprintf(stderr, "usage: %s gateway [hopcount [priority]]\n",
1448 if (g_net_is_set(argv[0]) == 0)
1451 gateway_nid = libcfs_str2nid(argv[1]);
1452 if (gateway_nid == LNET_NID_ANY) {
1453 fprintf(stderr, "Can't parse gateway NID \"%s\"\n", argv[1]);
1458 hops = strtol(argv[2], &end, 0);
1459 if (hops == 0 || hops >= 256 ||
1460 (end && *end != 0)) {
1461 fprintf(stderr, "Can't parse hopcount \"%s\"\n",
1466 priority = strtoul(argv[3], &end, 0);
1467 if (end && *end != 0) {
1469 "Can't parse priority \"%s\"\n",
1476 LIBCFS_IOC_INIT_V2(data, cfg_hdr);
1477 data.cfg_net = g_net;
1478 data.cfg_config_u.cfg_route.rtr_hop = hops;
1479 data.cfg_nid = gateway_nid;
1480 data.cfg_config_u.cfg_route.rtr_priority = priority;
1482 rc = l_ioctl(LNET_DEV_ID, IOC_LIBCFS_ADD_ROUTE, &data);
1484 fprintf(stderr, "IOC_LIBCFS_ADD_ROUTE failed: %s\n",
1493 jt_ptl_del_route(int argc, char **argv)
1495 struct lnet_ioctl_config_data data;
1500 fprintf(stderr, "usage: %s gatewayNID\n", argv[0]);
1504 if (libcfs_str2anynid(&nid, argv[1]) == 0) {
1505 fprintf(stderr, "Can't parse gateway NID \"%s\"\n", argv[1]);
1509 LIBCFS_IOC_INIT_V2(data, cfg_hdr);
1510 data.cfg_net = g_net_set ? g_net : LNET_NET_ANY;
1513 rc = l_ioctl(LNET_DEV_ID, IOC_LIBCFS_DEL_ROUTE, &data);
1515 fprintf(stderr, "IOC_LIBCFS_DEL_ROUTE (%s) failed: %s\n",
1516 libcfs_nid2str(nid), strerror(errno));
1524 jt_ptl_notify_router(int argc, char **argv)
1526 struct libcfs_ioctl_data data;
1534 fprintf(stderr, "usage: %s targetNID <up/down> [<time>]\n",
1539 nid = libcfs_str2nid(argv[1]);
1540 if (nid == LNET_NID_ANY) {
1541 fprintf(stderr, "Can't parse target NID \"%s\"\n", argv[1]);
1545 if (lnet_parse_bool (&enable, argv[2]) != 0) {
1546 fprintf(stderr, "Can't parse boolean %s\n", argv[2]);
1550 gettimeofday(&now, NULL);
1554 } else if (lnet_parse_time(&when, argv[3]) != 0) {
1556 "Can't parse time %s\n Please specify either 'YYYY-MM-DD-HH:MM:SS'\n or an absolute unix time in seconds\n",
1559 } else if (when > now.tv_sec) {
1560 fprintf(stderr, "%s specifies a time in the future\n",
1565 LIBCFS_IOC_INIT(data);
1567 data.ioc_flags = enable;
1568 /* Yeuch; 'cept I need a __u64 on 64 bit machines... */
1569 data.ioc_u64[0] = (__u64)when;
1571 rc = l_ioctl(LNET_DEV_ID, IOC_LIBCFS_NOTIFY_ROUTER, &data);
1573 fprintf(stderr, "IOC_LIBCFS_NOTIFY_ROUTER (%s) failed: %s\n",
1574 libcfs_nid2str(nid), strerror(errno));
1582 jt_ptl_print_routes(int argc, char **argv)
1584 struct lnet_ioctl_config_data data;
1593 for (index = 0; ; index++) {
1594 LIBCFS_IOC_INIT_V2(data, cfg_hdr);
1595 data.cfg_count = index;
1597 rc = l_ioctl(LNET_DEV_ID, IOC_LIBCFS_GET_ROUTE, &data);
1602 hops = data.cfg_config_u.cfg_route.rtr_hop;
1604 alive = data.cfg_config_u.cfg_route.rtr_flags & LNET_RT_ALIVE;
1605 pri = data.cfg_config_u.cfg_route.rtr_priority;
1607 printf("net %18s hops %u gw %32s %s pri %u\n",
1608 libcfs_net2str(net), hops,
1609 libcfs_nid2str(nid), alive ? "up" : "down", pri);
1612 if (errno != ENOENT)
1613 fprintf(stderr, "Error getting routes: %s: check dmesg.\n",
1620 fault_attr_nid_parse(char *str, lnet_nid_t *nid_p)
1626 /* NB: can't support range ipaddress except * and *@net */
1627 if (strlen(str) > 2 && str[0] == '*' && str[1] == '@') {
1628 net = libcfs_str2net(str + 2);
1629 if (net == LNET_NET_ANY)
1632 nid = LNET_MKNID(net, LNET_NIDADDR(LNET_NID_ANY));
1634 rc = libcfs_str2anynid(&nid, str);
1642 fprintf(stderr, "Invalid NID : %s\n", str);
1647 fault_attr_msg_parse(char *msg_str, __u32 *mask_p)
1649 if (!strcasecmp(msg_str, "put")) {
1650 *mask_p |= LNET_PUT_BIT;
1653 } else if (!strcasecmp(msg_str, "ack")) {
1654 *mask_p |= LNET_ACK_BIT;
1657 } else if (!strcasecmp(msg_str, "get")) {
1658 *mask_p |= LNET_GET_BIT;
1661 } else if (!strcasecmp(msg_str, "reply")) {
1662 *mask_p |= LNET_REPLY_BIT;
1666 fprintf(stderr, "unknown message type %s\n", msg_str);
1671 fault_attr_ptl_parse(char *ptl_str, __u64 *mask_p)
1673 unsigned long rc = strtoul(optarg, NULL, 0);
1676 fprintf(stderr, "invalid portal: %lu\n", rc);
1680 *mask_p |= (1ULL << rc);
1685 fault_attr_health_error_parse(char *error, __u32 *mask)
1687 if (!strcasecmp(error, "local_interrupt")) {
1688 *mask |= HSTATUS_LOCAL_INTERRUPT_BIT;
1691 if (!strcasecmp(error, "local_dropped")) {
1692 *mask |= HSTATUS_LOCAL_DROPPED_BIT;
1695 if (!strcasecmp(error, "local_aborted")) {
1696 *mask |= HSTATUS_LOCAL_ABORTED_BIT;
1699 if (!strcasecmp(error, "local_no_route")) {
1700 *mask |= HSTATUS_LOCAL_NO_ROUTE_BIT;
1703 if (!strcasecmp(error, "local_error")) {
1704 *mask |= HSTATUS_LOCAL_ERROR_BIT;
1707 if (!strcasecmp(error, "local_timeout")) {
1708 *mask |= HSTATUS_LOCAL_TIMEOUT_BIT;
1711 if (!strcasecmp(error, "remote_error")) {
1712 *mask |= HSTATUS_REMOTE_ERROR_BIT;
1715 if (!strcasecmp(error, "remote_dropped")) {
1716 *mask |= HSTATUS_REMOTE_DROPPED_BIT;
1719 if (!strcasecmp(error, "remote_timeout")) {
1720 *mask |= HSTATUS_REMOTE_TIMEOUT_BIT;
1723 if (!strcasecmp(error, "network_timeout")) {
1724 *mask |= HSTATUS_NETWORK_TIMEOUT_BIT;
1727 if (!strcasecmp(error, "random")) {
1728 *mask = HSTATUS_RANDOM;
1736 fault_simul_rule_add(__u32 opc, char *name, int argc, char **argv)
1738 struct libcfs_ioctl_data data = { { 0 } };
1739 struct lnet_fault_attr attr;
1743 static const struct option opts[] = {
1744 { .name = "source", .has_arg = required_argument, .val = 's' },
1745 { .name = "dest", .has_arg = required_argument, .val = 'd' },
1746 { .name = "rate", .has_arg = required_argument, .val = 'r' },
1747 { .name = "interval", .has_arg = required_argument, .val = 'i' },
1748 { .name = "random", .has_arg = no_argument, .val = 'n' },
1749 { .name = "latency", .has_arg = required_argument, .val = 'l' },
1750 { .name = "portal", .has_arg = required_argument, .val = 'p' },
1751 { .name = "message", .has_arg = required_argument, .val = 'm' },
1752 { .name = "health_error", .has_arg = required_argument, .val = 'e' },
1753 { .name = "local_nid", .has_arg = required_argument, .val = 'o' },
1754 { .name = "drop_all", .has_arg = no_argument, .val = 'x' },
1759 "Failed, please provide source, destination and rate of rule\n");
1763 optstr = opc == LNET_CTL_DROP_ADD ? "s:d:o:r:i:p:m:e:nx" : "s:d:o:r:l:p:m:";
1764 memset(&attr, 0, sizeof(attr));
1766 int c = getopt_long(argc, argv, optstr, opts, NULL);
1773 rc = fault_attr_nid_parse(optarg, &attr.fa_local_nid);
1777 case 's': /* source NID/NET */
1778 rc = fault_attr_nid_parse(optarg, &attr.fa_src);
1783 case 'd': /* dest NID/NET */
1784 rc = fault_attr_nid_parse(optarg, &attr.fa_dst);
1789 case 'r': /* drop rate */
1790 if (opc == LNET_CTL_DROP_ADD)
1791 attr.u.drop.da_rate = strtoul(optarg, NULL, 0);
1793 attr.u.delay.la_rate = strtoul(optarg, NULL, 0);
1797 if (opc == LNET_CTL_DROP_ADD) {
1798 rc = fault_attr_health_error_parse(optarg,
1799 &attr.u.drop.da_health_error_mask);
1806 if (opc == LNET_CTL_DROP_ADD)
1807 attr.u.drop.da_drop_all = true;
1811 if (opc == LNET_CTL_DROP_ADD)
1812 attr.u.drop.da_random = true;
1815 case 'i': /* time interval (# seconds) for message drop */
1816 if (opc == LNET_CTL_DROP_ADD)
1817 attr.u.drop.da_interval = strtoul(optarg,
1820 attr.u.delay.la_interval = strtoul(optarg,
1824 case 'l': /* seconds to wait before activating rule */
1825 attr.u.delay.la_latency = strtoul(optarg, NULL, 0);
1828 case 'p': /* portal to filter */
1829 rc = fault_attr_ptl_parse(optarg, &attr.fa_ptl_mask);
1834 case 'm': /* message types to filter */
1835 rc = fault_attr_msg_parse(optarg, &attr.fa_msg_mask);
1841 fprintf(stderr, "error: %s: option '%s' unrecognized\n",
1842 argv[0], argv[optind - 1]);
1848 if (opc == LNET_CTL_DROP_ADD) {
1849 /* NB: drop rate and interval are exclusive to each other */
1850 if (!((attr.u.drop.da_rate == 0) ^
1851 (attr.u.drop.da_interval == 0))) {
1853 "please provide either drop rate or interval but not both at the same time.\n");
1857 if (attr.u.drop.da_random &&
1858 attr.u.drop.da_interval == 0) {
1860 "please provide an interval to randomize\n");
1863 } else if (opc == LNET_CTL_DELAY_ADD) {
1864 if (!((attr.u.delay.la_rate == 0) ^
1865 (attr.u.delay.la_interval == 0))) {
1867 "please provide either delay rate or interval but not both at the same time.\n");
1871 if (attr.u.delay.la_latency == 0) {
1872 fprintf(stderr, "latency cannot be zero\n");
1877 if (attr.fa_src == 0 || attr.fa_dst == 0) {
1879 "Please provide both source and destination of %s rule\n",
1884 if (attr.fa_local_nid == 0)
1885 attr.fa_local_nid = LNET_NID_ANY;
1887 data.ioc_flags = opc;
1888 data.ioc_inllen1 = sizeof(attr);
1889 data.ioc_inlbuf1 = (char *)&attr;
1890 if (libcfs_ioctl_pack(&data, &ioc_buf, IOC_BUF_SIZE) != 0) {
1891 fprintf(stderr, "libcfs_ioctl_pack failed\n");
1895 rc = l_ioctl(LNET_DEV_ID, IOC_LIBCFS_LNET_FAULT, ioc_buf);
1897 fprintf(stderr, "add %s rule %s->%s failed: %s\n",
1898 name, libcfs_nid2str(attr.fa_src),
1899 libcfs_nid2str(attr.fa_dst), strerror(errno));
1903 printf("Added %s rule %s->%s (1/%d)\n",
1904 name, libcfs_nid2str(attr.fa_src), libcfs_nid2str(attr.fa_dst),
1905 opc == LNET_CTL_DROP_ADD ?
1906 attr.u.drop.da_rate : attr.u.delay.la_rate);
1915 jt_ptl_drop_add(int argc, char **argv)
1917 return fault_simul_rule_add(LNET_CTL_DROP_ADD, "drop", argc, argv);
1921 jt_ptl_delay_add(int argc, char **argv)
1923 return fault_simul_rule_add(LNET_CTL_DELAY_ADD, "delay", argc, argv);
1927 fault_simul_rule_del(__u32 opc, char *name, int argc, char **argv)
1929 struct libcfs_ioctl_data data = { { 0 } };
1930 struct lnet_fault_attr attr;
1934 static const struct option opts[] = {
1935 { .name = "source", .has_arg = required_argument, .val = 's' },
1936 { .name = "dest", .has_arg = required_argument, .val = 'd' },
1937 { .name = "all", .has_arg = no_argument, .val = 'a' },
1942 "Failed, please provide source and destination of rule\n");
1946 memset(&attr, 0, sizeof(attr));
1948 int c = getopt_long(argc, argv, "s:d:a", opts, NULL);
1955 rc = fault_attr_nid_parse(optarg, &attr.fa_src);
1960 rc = fault_attr_nid_parse(optarg, &attr.fa_dst);
1971 fprintf(stderr, "error: %s: option '%s' unrecognized\n",
1972 argv[0], argv[optind - 1]);
1978 data.ioc_flags = opc;
1979 data.ioc_inllen1 = sizeof(attr);
1980 data.ioc_inlbuf1 = (char *)&attr;
1981 if (libcfs_ioctl_pack(&data, &ioc_buf, IOC_BUF_SIZE) != 0) {
1982 fprintf(stderr, "libcfs_ioctl_pack failed\n");
1986 rc = l_ioctl(LNET_DEV_ID, IOC_LIBCFS_LNET_FAULT, ioc_buf);
1988 fprintf(stderr, "remove %s rule %s->%s failed: %s\n", name,
1989 all ? "all" : libcfs_nid2str(attr.fa_src),
1990 all ? "all" : libcfs_nid2str(attr.fa_dst),
1995 libcfs_ioctl_unpack(&data, ioc_buf);
1996 printf("Removed %d %s rules\n", data.ioc_count, name);
2005 jt_ptl_drop_del(int argc, char **argv)
2007 return fault_simul_rule_del(LNET_CTL_DROP_DEL, "drop", argc, argv);
2011 jt_ptl_delay_del(int argc, char **argv)
2013 return fault_simul_rule_del(LNET_CTL_DELAY_DEL, "delay", argc, argv);
2017 fault_simul_rule_reset(__u32 opc, char *name, int argc, char **argv)
2019 struct libcfs_ioctl_data data = { { 0 } };
2022 LIBCFS_IOC_INIT(data);
2023 data.ioc_flags = opc;
2025 rc = l_ioctl(LNET_DEV_ID, IOC_LIBCFS_LNET_FAULT, &data);
2027 fprintf(stderr, "failed to reset %s stats: %s\n",
2028 name, strerror(errno));
2035 jt_ptl_drop_reset(int argc, char **argv)
2037 return fault_simul_rule_reset(LNET_CTL_DROP_RESET, "drop", argc, argv);
2041 jt_ptl_delay_reset(int argc, char **argv)
2043 return fault_simul_rule_reset(LNET_CTL_DELAY_RESET, "delay",
2048 fault_simul_rule_list(__u32 opc, char *name, int argc, char **argv)
2050 struct libcfs_ioctl_data data = { { 0 } };
2051 struct lnet_fault_attr attr;
2052 struct lnet_fault_stat stat;
2055 printf("LNet %s rules:\n", name);
2056 for (pos = 0;; pos++) {
2059 memset(&attr, 0, sizeof(attr));
2060 memset(&stat, 0, sizeof(stat));
2062 data.ioc_count = pos;
2063 data.ioc_flags = opc;
2064 data.ioc_inllen1 = sizeof(attr);
2065 data.ioc_inlbuf1 = (char *)&attr;
2066 data.ioc_inllen2 = sizeof(stat);
2067 data.ioc_inlbuf2 = (char *)&stat;
2068 if (libcfs_ioctl_pack(&data, &ioc_buf, IOC_BUF_SIZE) != 0) {
2069 fprintf(stderr, "libcfs_ioctl_pack failed\n");
2073 rc = l_ioctl(LNET_DEV_ID, IOC_LIBCFS_LNET_FAULT, ioc_buf);
2077 libcfs_ioctl_unpack(&data, ioc_buf);
2079 if (opc == LNET_CTL_DROP_LIST) {
2080 printf("%s->%s (1/%d | %d) ptl %#jx, msg %x, %ju/%ju, PUT %ju, ACK %ju, GET %ju, REP %ju\n",
2081 libcfs_nid2str(attr.fa_src),
2082 libcfs_nid2str(attr.fa_dst),
2083 attr.u.drop.da_rate, attr.u.drop.da_interval,
2084 (uintmax_t)attr.fa_ptl_mask, attr.fa_msg_mask,
2085 (uintmax_t)stat.u.drop.ds_dropped,
2086 (uintmax_t)stat.fs_count,
2087 (uintmax_t)stat.fs_put,
2088 (uintmax_t)stat.fs_ack,
2089 (uintmax_t)stat.fs_get,
2090 (uintmax_t)stat.fs_reply);
2092 } else if (opc == LNET_CTL_DELAY_LIST) {
2093 printf("%s->%s (1/%d | %d, latency %d) ptl %#jx, msg %x, %ju/%ju, PUT %ju, ACK %ju, GET %ju, REP %ju\n",
2094 libcfs_nid2str(attr.fa_src),
2095 libcfs_nid2str(attr.fa_dst),
2096 attr.u.delay.la_rate, attr.u.delay.la_interval,
2097 attr.u.delay.la_latency,
2098 (uintmax_t)attr.fa_ptl_mask, attr.fa_msg_mask,
2099 (uintmax_t)stat.u.delay.ls_delayed,
2100 (uintmax_t)stat.fs_count,
2101 (uintmax_t)stat.fs_put,
2102 (uintmax_t)stat.fs_ack,
2103 (uintmax_t)stat.fs_get,
2104 (uintmax_t)stat.fs_reply);
2107 printf("found total %d\n", pos);
2113 jt_ptl_drop_list(int argc, char **argv)
2115 return fault_simul_rule_list(LNET_CTL_DROP_LIST, "drop", argc, argv);
2119 jt_ptl_delay_list(int argc, char **argv)
2121 return fault_simul_rule_list(LNET_CTL_DELAY_LIST, "delay", argc, argv);
2125 get_cycles_per_usec()
2127 FILE *f = fopen("/proc/cpuinfo", "r");
2132 while (fgets(line, sizeof(line), f))
2133 if (sscanf(line, "cpu MHz : %lf", &mhz) == 1) {
2140 fprintf(stderr, "Can't read/parse /proc/cpuinfo\n");
2144 int jt_ptl_testprotocompat(int argc, char **argv)
2146 struct libcfs_ioctl_data data;
2152 fprintf(stderr, "usage: %s <number>\n", argv[0]);
2156 flags = strtol(argv[1], &end, 0);
2157 if (flags < 0 || *end != 0) {
2158 fprintf(stderr, "Can't parse flags '%s'\n", argv[1]);
2162 LIBCFS_IOC_INIT(data);
2163 data.ioc_flags = flags;
2164 rc = l_ioctl(LNET_DEV_ID, IOC_LIBCFS_TESTPROTOCOMPAT, &data);
2167 fprintf(stderr, "test proto compat %x failed: %s\n",
2168 flags, strerror(errno));
2172 printf("test proto compat %x OK\n", flags);