tools/net/ynl/generated/netdev-user.c

   1 // SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause)
   2 /* Do not edit directly, auto-generated from: */
   3 /*      Documentation/netlink/specs/netdev.yaml */
   4 /* YNL-GEN user source */
   5
   6 #include <stdlib.h>
   7 #include <string.h>
   8 #include "netdev-user.h"
   9 #include "ynl.h"
  10 #include <linux/netdev.h>
  11
  12 #include <libmnl/libmnl.h>
  13 #include <linux/genetlink.h>
  14
  15 /* Enums */
  16 static const char * const netdev_op_strmap[] = {
  17         [NETDEV_CMD_DEV_GET] = "dev-get",
  18         [NETDEV_CMD_DEV_ADD_NTF] = "dev-add-ntf",
  19         [NETDEV_CMD_DEV_DEL_NTF] = "dev-del-ntf",
  20         [NETDEV_CMD_DEV_CHANGE_NTF] = "dev-change-ntf",
  21 };
  22
  23 const char *netdev_op_str(int op)
  24 {
  25         if (op < 0 || op >= (int)MNL_ARRAY_SIZE(netdev_op_strmap))
  26                 return NULL;
  27         return netdev_op_strmap[op];
  28 }
  29
  30 static const char * const netdev_xdp_act_strmap[] = {
  31         [0] = "basic",
  32         [1] = "redirect",
  33         [2] = "ndo-xmit",
  34         [3] = "xsk-zerocopy",
  35         [4] = "hw-offload",
  36         [5] = "rx-sg",
  37         [6] = "ndo-xmit-sg",
  38 };
  39
  40 const char *netdev_xdp_act_str(enum netdev_xdp_act value)
  41 {
  42         value = ffs(value) - 1;
  43         if (value < 0 || value >= (int)MNL_ARRAY_SIZE(netdev_xdp_act_strmap))
  44                 return NULL;
  45         return netdev_xdp_act_strmap[value];
  46 }
  47
  48 /* Policies */
  49 struct ynl_policy_attr netdev_dev_policy[NETDEV_A_DEV_MAX + 1] = {
  50         [NETDEV_A_DEV_IFINDEX] = { .name = "ifindex", .type = YNL_PT_U32, },
  51         [NETDEV_A_DEV_PAD] = { .name = "pad", .type = YNL_PT_IGNORE, },
  52         [NETDEV_A_DEV_XDP_FEATURES] = { .name = "xdp-features", .type = YNL_PT_U64, },
  53 };
  54
  55 struct ynl_policy_nest netdev_dev_nest = {
  56         .max_attr = NETDEV_A_DEV_MAX,
  57         .table = netdev_dev_policy,
  58 };
  59
  60 /* Common nested types */
  61 /* ============== NETDEV_CMD_DEV_GET ============== */
  62 /* NETDEV_CMD_DEV_GET - do */
  63 void netdev_dev_get_req_free(struct netdev_dev_get_req *req)
  64 {
  65         free(req);
  66 }
  67
  68 void netdev_dev_get_rsp_free(struct netdev_dev_get_rsp *rsp)
  69 {
  70         free(rsp);
  71 }
  72
  73 int netdev_dev_get_rsp_parse(const struct nlmsghdr *nlh, void *data)
  74 {
  75         struct ynl_parse_arg *yarg = data;
  76         struct netdev_dev_get_rsp *dst;
  77         const struct nlattr *attr;
  78
  79         dst = yarg->data;
  80
  81         mnl_attr_for_each(attr, nlh, sizeof(struct genlmsghdr)) {
  82                 if (mnl_attr_get_type(attr) == NETDEV_A_DEV_IFINDEX) {
  83                         if (ynl_attr_validate(yarg, attr))
  84                                 return MNL_CB_ERROR;
  85                         dst->_present.ifindex = 1;
  86                         dst->ifindex = mnl_attr_get_u32(attr);
  87                 }
  88                 else if (mnl_attr_get_type(attr) == NETDEV_A_DEV_XDP_FEATURES) {
  89                         if (ynl_attr_validate(yarg, attr))
  90                                 return MNL_CB_ERROR;
  91                         dst->_present.xdp_features = 1;
  92                         dst->xdp_features = mnl_attr_get_u64(attr);
  93                 }
  94         }
  95
  96         return MNL_CB_OK;
  97 }
  98
  99 struct netdev_dev_get_rsp *
 100 netdev_dev_get(struct ynl_sock *ys, struct netdev_dev_get_req *req)
 101 {
 102         struct ynl_req_state yrs = { .yarg = { .ys = ys, }, };
 103         struct netdev_dev_get_rsp *rsp;
 104         struct nlmsghdr *nlh;
 105         int err;
 106
 107         nlh = ynl_gemsg_start_req(ys, ys->family_id, NETDEV_CMD_DEV_GET, 1);
 108         ys->req_policy = &netdev_dev_nest;
 109         yrs.yarg.rsp_policy = &netdev_dev_nest;
 110
 111         if (req->_present.ifindex)
 112                 mnl_attr_put_u32(nlh, NETDEV_A_DEV_IFINDEX, req->ifindex);
 113
 114         rsp = calloc(1, sizeof(*rsp));
 115         yrs.yarg.data = rsp;
 116         yrs.cb = netdev_dev_get_rsp_parse;
 117         yrs.rsp_cmd = NETDEV_CMD_DEV_GET;
 118
 119         err = ynl_exec(ys, nlh, &yrs);
 120         if (err < 0)
 121                 goto err_free;
 122
 123         return rsp;
 124
 125 err_free:
 126         netdev_dev_get_rsp_free(rsp);
 127         return NULL;
 128 }
 129
 130 /* NETDEV_CMD_DEV_GET - dump */
 131 void netdev_dev_get_list_free(struct netdev_dev_get_list *rsp)
 132 {
 133         struct netdev_dev_get_list *next = rsp;
 134
 135         while ((void *)next != YNL_LIST_END) {
 136                 rsp = next;
 137                 next = rsp->next;
 138
 139                 free(rsp);
 140         }
 141 }
 142
 143 struct netdev_dev_get_list *netdev_dev_get_dump(struct ynl_sock *ys)
 144 {
 145         struct ynl_dump_state yds = {};
 146         struct nlmsghdr *nlh;
 147         int err;
 148
 149         yds.ys = ys;
 150         yds.alloc_sz = sizeof(struct netdev_dev_get_list);
 151         yds.cb = netdev_dev_get_rsp_parse;
 152         yds.rsp_cmd = NETDEV_CMD_DEV_GET;
 153         yds.rsp_policy = &netdev_dev_nest;
 154
 155         nlh = ynl_gemsg_start_dump(ys, ys->family_id, NETDEV_CMD_DEV_GET, 1);
 156
 157         err = ynl_exec_dump(ys, nlh, &yds);
 158         if (err < 0)
 159                 goto free_list;
 160
 161         return yds.first;
 162
 163 free_list:
 164         netdev_dev_get_list_free(yds.first);
 165         return NULL;
 166 }
 167
 168 /* NETDEV_CMD_DEV_GET - notify */
 169 void netdev_dev_get_ntf_free(struct netdev_dev_get_ntf *rsp)
 170 {
 171         free(rsp);
 172 }
 173
 174 /* --------------- Common notification parsing --------------- */
 175 struct ynl_ntf_base_type *netdev_ntf_parse(struct ynl_sock *ys)
 176 {
 177         struct ynl_parse_arg yarg = { .ys = ys, };
 178         struct ynl_ntf_base_type *rsp;
 179         struct genlmsghdr *genlh;
 180         struct nlmsghdr *nlh;
 181         mnl_cb_t parse;
 182         int len, err;
 183
 184         len = mnl_socket_recvfrom(ys->sock, ys->rx_buf, MNL_SOCKET_BUFFER_SIZE);
 185         if (len < (ssize_t)(sizeof(*nlh) + sizeof(*genlh)))
 186                 return NULL;
 187
 188         nlh = (struct nlmsghdr *)ys->rx_buf;
 189         genlh = mnl_nlmsg_get_payload(nlh);
 190
 191         switch (genlh->cmd) {
 192         case NETDEV_CMD_DEV_ADD_NTF:
 193         case NETDEV_CMD_DEV_DEL_NTF:
 194         case NETDEV_CMD_DEV_CHANGE_NTF:
 195                 rsp = calloc(1, sizeof(struct netdev_dev_get_ntf));
 196                 parse = netdev_dev_get_rsp_parse;
 197                 yarg.rsp_policy = &netdev_dev_nest;
 198                 rsp->free = (void *)netdev_dev_get_ntf_free;
 199                 break;
 200         default:
 201                 ynl_error_unknown_notification(ys, genlh->cmd);
 202                 return NULL;
 203         }
 204
 205         yarg.data = rsp->data;
 206
 207         err = mnl_cb_run2(ys->rx_buf, len, 0, 0, parse, &yarg,
 208                          ynl_cb_array, NLMSG_MIN_TYPE);
 209         if (err < 0)
 210                 goto err_free;
 211
 212         rsp->family = nlh->nlmsg_type;
 213         rsp->cmd = genlh->cmd;
 214         return rsp;
 215
 216 err_free:
 217         free(rsp);
 218         return NULL;
 219 }
 220
 221 static const struct ynl_ntf_info netdev_ntf_info[] =  {
 222         [NETDEV_CMD_DEV_ADD_NTF] =  {
 223                 .alloc_sz       = sizeof(struct netdev_dev_get_ntf),
 224                 .cb             = netdev_dev_get_rsp_parse,
 225                 .policy         = &netdev_dev_nest,
 226                 .free           = (void *)netdev_dev_get_ntf_free,
 227         },
 228         [NETDEV_CMD_DEV_DEL_NTF] =  {
 229                 .alloc_sz       = sizeof(struct netdev_dev_get_ntf),
 230                 .cb             = netdev_dev_get_rsp_parse,
 231                 .policy         = &netdev_dev_nest,
 232                 .free           = (void *)netdev_dev_get_ntf_free,
 233         },
 234         [NETDEV_CMD_DEV_CHANGE_NTF] =  {
 235                 .alloc_sz       = sizeof(struct netdev_dev_get_ntf),
 236                 .cb             = netdev_dev_get_rsp_parse,
 237                 .policy         = &netdev_dev_nest,
 238                 .free           = (void *)netdev_dev_get_ntf_free,
 239         },
 240 };
 241
 242 const struct ynl_family ynl_netdev_family =  {
 243         .name           = "netdev",
 244         .ntf_info       = netdev_ntf_info,
 245         .ntf_info_size  = MNL_ARRAY_SIZE(netdev_ntf_info),
 246 };