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