rdma/rdma.c

   1 // SPDX-License-Identifier: GPL-2.0 OR Linux-OpenIB
   2 /*
   3  * rdma.c       RDMA tool
   4  * Authors:     Leon Romanovsky <leonro@mellanox.com>
   5  */
   6
   7 #include "rdma.h"
   8 #include "SNAPSHOT.h"
   9 #include "color.h"
  10
  11 static void help(char *name)
  12 {
  13         pr_out("Usage: %s [ OPTIONS ] OBJECT { COMMAND | help }\n"
  14                "       %s [ -f[orce] ] -b[atch] filename\n"
  15                "where  OBJECT := { dev | link | resource | system | statistic | help }\n"
  16                "       OPTIONS := { -V[ersion] | -d[etails] | -j[son] | -p[retty]}\n", name, name);
  17 }
  18
  19 static int cmd_help(struct rd *rd)
  20 {
  21         help(rd->filename);
  22         return 0;
  23 }
  24
  25 static int rd_cmd(struct rd *rd, int argc, char **argv)
  26 {
  27         const struct rd_cmd cmds[] = {
  28                 { NULL,         cmd_help },
  29                 { "help",       cmd_help },
  30                 { "dev",        cmd_dev },
  31                 { "link",       cmd_link },
  32                 { "resource",   cmd_res },
  33                 { "system",     cmd_sys },
  34                 { "statistic",  cmd_stat },
  35                 { 0 }
  36         };
  37
  38         rd->argc = argc;
  39         rd->argv = argv;
  40
  41         return rd_exec_cmd(rd, cmds, "object");
  42 }
  43
  44 static int rd_batch(struct rd *rd, const char *name, bool force)
  45 {
  46         char *line = NULL;
  47         size_t len = 0;
  48         int ret = 0;
  49
  50         if (name && strcmp(name, "-") != 0) {
  51                 if (!freopen(name, "r", stdin)) {
  52                         pr_err("Cannot open file \"%s\" for reading: %s\n",
  53                                name, strerror(errno));
  54                         return errno;
  55                 }
  56         }
  57
  58         cmdlineno = 0;
  59         while (getcmdline(&line, &len, stdin) != -1) {
  60                 char *largv[512];
  61                 int largc;
  62
  63                 largc = makeargs(line, largv, ARRAY_SIZE(largv));
  64                 if (!largc)
  65                         continue;       /* blank line */
  66
  67                 ret = rd_cmd(rd, largc, largv);
  68                 if (ret) {
  69                         pr_err("Command failed %s:%d\n", name, cmdlineno);
  70                         if (!force)
  71                                 break;
  72                 }
  73         }
  74
  75         free(line);
  76
  77         return ret;
  78 }
  79
  80 static int rd_init(struct rd *rd, char *filename)
  81 {
  82         uint32_t seq;
  83         int ret;
  84
  85         rd->filename = filename;
  86         INIT_LIST_HEAD(&rd->dev_map_list);
  87         INIT_LIST_HEAD(&rd->filter_list);
  88
  89         rd->buff = malloc(MNL_SOCKET_BUFFER_SIZE);
  90         if (!rd->buff)
  91                 return -ENOMEM;
  92
  93         rd_prepare_msg(rd, RDMA_NLDEV_CMD_GET,
  94                        &seq, (NLM_F_REQUEST | NLM_F_ACK | NLM_F_DUMP));
  95         ret = rd_send_msg(rd);
  96         if (ret)
  97                 return ret;
  98
  99         return rd_recv_msg(rd, rd_dev_init_cb, rd, seq);
 100 }
 101
 102 static void rd_cleanup(struct rd *rd)
 103 {
 104         rd_free(rd);
 105 }
 106
 107 int main(int argc, char **argv)
 108 {
 109         static const struct option long_options[] = {
 110                 { "version",            no_argument,            NULL, 'V' },
 111                 { "help",               no_argument,            NULL, 'h' },
 112                 { "json",               no_argument,            NULL, 'j' },
 113                 { "pretty",             no_argument,            NULL, 'p' },
 114                 { "details",            no_argument,            NULL, 'd' },
 115                 { "force",              no_argument,            NULL, 'f' },
 116                 { "batch",              required_argument,      NULL, 'b' },
 117                 { NULL, 0, NULL, 0 }
 118         };
 119         bool show_driver_details = false;
 120         const char *batch_file = NULL;
 121         bool show_details = false;
 122         bool json_output = false;
 123         bool force = false;
 124         struct rd rd = {};
 125         char *filename;
 126         int opt;
 127         int err;
 128         filename = basename(argv[0]);
 129
 130         while ((opt = getopt_long(argc, argv, ":Vhdpjfb:",
 131                                   long_options, NULL)) >= 0) {
 132                 switch (opt) {
 133                 case 'V':
 134                         printf("%s utility, iproute2-ss%s\n",
 135                                filename, SNAPSHOT);
 136                         return EXIT_SUCCESS;
 137                 case 'p':
 138                         pretty = 1;
 139                         break;
 140                 case 'd':
 141                         if (show_details)
 142                                 show_driver_details = true;
 143                         else
 144                                 show_details = true;
 145                         break;
 146                 case 'j':
 147                         json_output = 1;
 148                         break;
 149                 case 'f':
 150                         force = true;
 151                         break;
 152                 case 'b':
 153                         batch_file = optarg;
 154                         break;
 155                 case 'h':
 156                         help(filename);
 157                         return EXIT_SUCCESS;
 158                 case ':':
 159                         pr_err("-%c option requires an argument\n", optopt);
 160                         return EXIT_FAILURE;
 161                 default:
 162                         pr_err("Unknown option.\n");
 163                         help(filename);
 164                         return EXIT_FAILURE;
 165                 }
 166         }
 167
 168         argc -= optind;
 169         argv += optind;
 170
 171         rd.show_details = show_details;
 172         rd.show_driver_details = show_driver_details;
 173         rd.json_output = json_output;
 174         rd.pretty_output = pretty;
 175
 176         err = rd_init(&rd, filename);
 177         if (err)
 178                 goto out;
 179
 180         if (batch_file)
 181                 err = rd_batch(&rd, batch_file, force);
 182         else
 183                 err = rd_cmd(&rd, argc, argv);
 184 out:
 185         /* Always cleanup */
 186         rd_cleanup(&rd);
 187         return err ? EXIT_FAILURE : EXIT_SUCCESS;
 188 }