mirrors/linux
1
0
Fork 0
mirror of https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git synced 2026-01-18 12:59:06 -05:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'tools-ynl-gen-code-gen-improvements-before-ethtool'

Browse Source 
Jakub Kicinski says:

====================
tools: ynl-gen: code gen improvements before ethtool

I was going to post ethtool but I couldn't stand the ugliness
of the if conditions which were previously generated.
So I cleaned that up and improved a number of other things
ethtool will benefit from.
====================

Link: https://lore.kernel.org/r/20230608211200.1247213-1-kuba@kernel.org
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
This commit is contained in:
Jakub Kicinski
2023-06-09 14:40:33 -07:00
parent 7ec5d48fdb 76abff37f0
commit ded5c1a16e
8 changed files with 186 additions and 329 deletions
Download Patch File Download Diff File Expand all files Collapse all files

78
tools/net/ynl/generated/devlink-user.c
View File

@@ -4,13 +4,11 @@
/* YNL-GEN user source */
#include <stdlib.h>
#include <string.h>
#include "devlink-user.h"
#include "ynl.h"
#include <linux/devlink.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <libmnl/libmnl.h>
#include <linux/genetlink.h>
@@ -128,7 +126,9 @@ int devlink_dl_info_version_parse(struct ynl_parse_arg *yarg,
const struct nlattr *attr;
mnl_attr_for_each_nested(attr, nested) {
if (mnl_attr_get_type(attr) == DEVLINK_ATTR_INFO_VERSION_NAME) {
unsigned int type = mnl_attr_get_type(attr);
if (type == DEVLINK_ATTR_INFO_VERSION_NAME) {
unsigned int len;
if (ynl_attr_validate(yarg, attr))
@@ -139,8 +139,7 @@ int devlink_dl_info_version_parse(struct ynl_parse_arg *yarg,
dst->info_version_name = malloc(len + 1);
memcpy(dst->info_version_name, mnl_attr_get_str(attr), len);
dst->info_version_name[len] = 0;
}
else if (mnl_attr_get_type(attr) == DEVLINK_ATTR_INFO_VERSION_VALUE) {
} else if (type == DEVLINK_ATTR_INFO_VERSION_VALUE) {
unsigned int len;
if (ynl_attr_validate(yarg, attr))
@@ -169,13 +168,14 @@ int devlink_dl_reload_stats_entry_parse(struct ynl_parse_arg *yarg,
const struct nlattr *attr;
mnl_attr_for_each_nested(attr, nested) {
if (mnl_attr_get_type(attr) == DEVLINK_ATTR_RELOAD_STATS_LIMIT) {
unsigned int type = mnl_attr_get_type(attr);
if (type == DEVLINK_ATTR_RELOAD_STATS_LIMIT) {
if (ynl_attr_validate(yarg, attr))
return MNL_CB_ERROR;
dst->_present.reload_stats_limit = 1;
dst->reload_stats_limit = mnl_attr_get_u8(attr);
}
else if (mnl_attr_get_type(attr) == DEVLINK_ATTR_RELOAD_STATS_VALUE) {
} else if (type == DEVLINK_ATTR_RELOAD_STATS_VALUE) {
if (ynl_attr_validate(yarg, attr))
return MNL_CB_ERROR;
dst->_present.reload_stats_value = 1;
@@ -210,7 +210,9 @@ int devlink_dl_reload_act_stats_parse(struct ynl_parse_arg *yarg,
return ynl_error_parse(yarg, "attribute already present (dl-reload-act-stats.reload-stats-entry)");
mnl_attr_for_each_nested(attr, nested) {
if (mnl_attr_get_type(attr) == DEVLINK_ATTR_RELOAD_STATS_ENTRY) {
unsigned int type = mnl_attr_get_type(attr);
if (type == DEVLINK_ATTR_RELOAD_STATS_ENTRY) {
n_reload_stats_entry++;
}
}
@@ -257,13 +259,14 @@ int devlink_dl_reload_act_info_parse(struct ynl_parse_arg *yarg,
return ynl_error_parse(yarg, "attribute already present (dl-reload-act-info.reload-action-stats)");
mnl_attr_for_each_nested(attr, nested) {
if (mnl_attr_get_type(attr) == DEVLINK_ATTR_RELOAD_ACTION) {
unsigned int type = mnl_attr_get_type(attr);
if (type == DEVLINK_ATTR_RELOAD_ACTION) {
if (ynl_attr_validate(yarg, attr))
return MNL_CB_ERROR;
dst->_present.reload_action = 1;
dst->reload_action = mnl_attr_get_u8(attr);
}
else if (mnl_attr_get_type(attr) == DEVLINK_ATTR_RELOAD_ACTION_STATS) {
} else if (type == DEVLINK_ATTR_RELOAD_ACTION_STATS) {
n_reload_action_stats++;
}
}
@@ -310,7 +313,9 @@ int devlink_dl_reload_stats_parse(struct ynl_parse_arg *yarg,
return ynl_error_parse(yarg, "attribute already present (dl-reload-stats.reload-action-info)");
mnl_attr_for_each_nested(attr, nested) {
if (mnl_attr_get_type(attr) == DEVLINK_ATTR_RELOAD_ACTION_INFO) {
unsigned int type = mnl_attr_get_type(attr);
if (type == DEVLINK_ATTR_RELOAD_ACTION_INFO) {
n_reload_action_info++;
}
}
@@ -349,7 +354,9 @@ int devlink_dl_dev_stats_parse(struct ynl_parse_arg *yarg,
parg.ys = yarg->ys;
mnl_attr_for_each_nested(attr, nested) {
if (mnl_attr_get_type(attr) == DEVLINK_ATTR_RELOAD_STATS) {
unsigned int type = mnl_attr_get_type(attr);
if (type == DEVLINK_ATTR_RELOAD_STATS) {
if (ynl_attr_validate(yarg, attr))
return MNL_CB_ERROR;
dst->_present.reload_stats = 1;
@@ -358,8 +365,7 @@ int devlink_dl_dev_stats_parse(struct ynl_parse_arg *yarg,
parg.data = &dst->reload_stats;
if (devlink_dl_reload_stats_parse(&parg, attr))
return MNL_CB_ERROR;
}
else if (mnl_attr_get_type(attr) == DEVLINK_ATTR_REMOTE_RELOAD_STATS) {
} else if (type == DEVLINK_ATTR_REMOTE_RELOAD_STATS) {
if (ynl_attr_validate(yarg, attr))
return MNL_CB_ERROR;
dst->_present.remote_reload_stats = 1;
@@ -402,7 +408,9 @@ int devlink_get_rsp_parse(const struct nlmsghdr *nlh, void *data)
parg.ys = yarg->ys;
mnl_attr_for_each(attr, nlh, sizeof(struct genlmsghdr)) {
if (mnl_attr_get_type(attr) == DEVLINK_ATTR_BUS_NAME) {
unsigned int type = mnl_attr_get_type(attr);
if (type == DEVLINK_ATTR_BUS_NAME) {
unsigned int len;
if (ynl_attr_validate(yarg, attr))
@@ -413,8 +421,7 @@ int devlink_get_rsp_parse(const struct nlmsghdr *nlh, void *data)
dst->bus_name = malloc(len + 1);
memcpy(dst->bus_name, mnl_attr_get_str(attr), len);
dst->bus_name[len] = 0;
}
else if (mnl_attr_get_type(attr) == DEVLINK_ATTR_DEV_NAME) {
} else if (type == DEVLINK_ATTR_DEV_NAME) {
unsigned int len;
if (ynl_attr_validate(yarg, attr))
@@ -425,20 +432,17 @@ int devlink_get_rsp_parse(const struct nlmsghdr *nlh, void *data)
dst->dev_name = malloc(len + 1);
memcpy(dst->dev_name, mnl_attr_get_str(attr), len);
dst->dev_name[len] = 0;
}
else if (mnl_attr_get_type(attr) == DEVLINK_ATTR_RELOAD_FAILED) {
} else if (type == DEVLINK_ATTR_RELOAD_FAILED) {
if (ynl_attr_validate(yarg, attr))
return MNL_CB_ERROR;
dst->_present.reload_failed = 1;
dst->reload_failed = mnl_attr_get_u8(attr);
}
else if (mnl_attr_get_type(attr) == DEVLINK_ATTR_RELOAD_ACTION) {
} else if (type == DEVLINK_ATTR_RELOAD_ACTION) {
if (ynl_attr_validate(yarg, attr))
return MNL_CB_ERROR;
dst->_present.reload_action = 1;
dst->reload_action = mnl_attr_get_u8(attr);
}
else if (mnl_attr_get_type(attr) == DEVLINK_ATTR_DEV_STATS) {
} else if (type == DEVLINK_ATTR_DEV_STATS) {
if (ynl_attr_validate(yarg, attr))
return MNL_CB_ERROR;
dst->_present.dev_stats = 1;
@@ -578,7 +582,9 @@ int devlink_info_get_rsp_parse(const struct nlmsghdr *nlh, void *data)
return ynl_error_parse(yarg, "attribute already present (devlink.info-version-stored)");
mnl_attr_for_each(attr, nlh, sizeof(struct genlmsghdr)) {
if (mnl_attr_get_type(attr) == DEVLINK_ATTR_BUS_NAME) {
unsigned int type = mnl_attr_get_type(attr);
if (type == DEVLINK_ATTR_BUS_NAME) {
unsigned int len;
if (ynl_attr_validate(yarg, attr))
@@ -589,8 +595,7 @@ int devlink_info_get_rsp_parse(const struct nlmsghdr *nlh, void *data)
dst->bus_name = malloc(len + 1);
memcpy(dst->bus_name, mnl_attr_get_str(attr), len);
dst->bus_name[len] = 0;
}
else if (mnl_attr_get_type(attr) == DEVLINK_ATTR_DEV_NAME) {
} else if (type == DEVLINK_ATTR_DEV_NAME) {
unsigned int len;
if (ynl_attr_validate(yarg, attr))
@@ -601,8 +606,7 @@ int devlink_info_get_rsp_parse(const struct nlmsghdr *nlh, void *data)
dst->dev_name = malloc(len + 1);
memcpy(dst->dev_name, mnl_attr_get_str(attr), len);
dst->dev_name[len] = 0;
}
else if (mnl_attr_get_type(attr) == DEVLINK_ATTR_INFO_DRIVER_NAME) {
} else if (type == DEVLINK_ATTR_INFO_DRIVER_NAME) {
unsigned int len;
if (ynl_attr_validate(yarg, attr))
@@ -613,8 +617,7 @@ int devlink_info_get_rsp_parse(const struct nlmsghdr *nlh, void *data)
dst->info_driver_name = malloc(len + 1);
memcpy(dst->info_driver_name, mnl_attr_get_str(attr), len);
dst->info_driver_name[len] = 0;
}
else if (mnl_attr_get_type(attr) == DEVLINK_ATTR_INFO_SERIAL_NUMBER) {
} else if (type == DEVLINK_ATTR_INFO_SERIAL_NUMBER) {
unsigned int len;
if (ynl_attr_validate(yarg, attr))
@@ -625,14 +628,11 @@ int devlink_info_get_rsp_parse(const struct nlmsghdr *nlh, void *data)
dst->info_serial_number = malloc(len + 1);
memcpy(dst->info_serial_number, mnl_attr_get_str(attr), len);
dst->info_serial_number[len] = 0;
}
else if (mnl_attr_get_type(attr) == DEVLINK_ATTR_INFO_VERSION_FIXED) {
} else if (type == DEVLINK_ATTR_INFO_VERSION_FIXED) {
n_info_version_fixed++;
}
else if (mnl_attr_get_type(attr) == DEVLINK_ATTR_INFO_VERSION_RUNNING) {
} else if (type == DEVLINK_ATTR_INFO_VERSION_RUNNING) {
n_info_version_running++;
}
else if (mnl_attr_get_type(attr) == DEVLINK_ATTR_INFO_VERSION_STORED) {
} else if (type == DEVLINK_ATTR_INFO_VERSION_STORED) {
n_info_version_stored++;
}
}

35
tools/net/ynl/generated/fou-user.c
View File

@@ -4,13 +4,11 @@
/* YNL-GEN user source */
#include <stdlib.h>
#include <string.h>
#include "fou-user.h"
#include "ynl.h"
#include <linux/fou.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <libmnl/libmnl.h>
#include <linux/genetlink.h>
@@ -174,42 +172,38 @@ int fou_get_rsp_parse(const struct nlmsghdr *nlh, void *data)
dst = yarg->data;
mnl_attr_for_each(attr, nlh, sizeof(struct genlmsghdr)) {
if (mnl_attr_get_type(attr) == FOU_ATTR_PORT) {
unsigned int type = mnl_attr_get_type(attr);
if (type == FOU_ATTR_PORT) {
if (ynl_attr_validate(yarg, attr))
return MNL_CB_ERROR;
dst->_present.port = 1;
dst->port = mnl_attr_get_u16(attr);
}
else if (mnl_attr_get_type(attr) == FOU_ATTR_IPPROTO) {
} else if (type == FOU_ATTR_IPPROTO) {
if (ynl_attr_validate(yarg, attr))
return MNL_CB_ERROR;
dst->_present.ipproto = 1;
dst->ipproto = mnl_attr_get_u8(attr);
}
else if (mnl_attr_get_type(attr) == FOU_ATTR_TYPE) {
} else if (type == FOU_ATTR_TYPE) {
if (ynl_attr_validate(yarg, attr))
return MNL_CB_ERROR;
dst->_present.type = 1;
dst->type = mnl_attr_get_u8(attr);
}
else if (mnl_attr_get_type(attr) == FOU_ATTR_REMCSUM_NOPARTIAL) {
} else if (type == FOU_ATTR_REMCSUM_NOPARTIAL) {
if (ynl_attr_validate(yarg, attr))
return MNL_CB_ERROR;
dst->_present.remcsum_nopartial = 1;
}
else if (mnl_attr_get_type(attr) == FOU_ATTR_LOCAL_V4) {
} else if (type == FOU_ATTR_LOCAL_V4) {
if (ynl_attr_validate(yarg, attr))
return MNL_CB_ERROR;
dst->_present.local_v4 = 1;
dst->local_v4 = mnl_attr_get_u32(attr);
}
else if (mnl_attr_get_type(attr) == FOU_ATTR_PEER_V4) {
} else if (type == FOU_ATTR_PEER_V4) {
if (ynl_attr_validate(yarg, attr))
return MNL_CB_ERROR;
dst->_present.peer_v4 = 1;
dst->peer_v4 = mnl_attr_get_u32(attr);
}
else if (mnl_attr_get_type(attr) == FOU_ATTR_LOCAL_V6) {
} else if (type == FOU_ATTR_LOCAL_V6) {
unsigned int len;
if (ynl_attr_validate(yarg, attr))
@@ -219,8 +213,7 @@ int fou_get_rsp_parse(const struct nlmsghdr *nlh, void *data)
dst->_present.local_v6_len = len;
dst->local_v6 = malloc(len);
memcpy(dst->local_v6, mnl_attr_get_payload(attr), len);
}
else if (mnl_attr_get_type(attr) == FOU_ATTR_PEER_V6) {
} else if (type == FOU_ATTR_PEER_V6) {
unsigned int len;
if (ynl_attr_validate(yarg, attr))
@@ -230,14 +223,12 @@ int fou_get_rsp_parse(const struct nlmsghdr *nlh, void *data)
dst->_present.peer_v6_len = len;
dst->peer_v6 = malloc(len);
memcpy(dst->peer_v6, mnl_attr_get_payload(attr), len);
}
else if (mnl_attr_get_type(attr) == FOU_ATTR_PEER_PORT) {
} else if (type == FOU_ATTR_PEER_PORT) {
if (ynl_attr_validate(yarg, attr))
return MNL_CB_ERROR;
dst->_present.peer_port = 1;
dst->peer_port = mnl_attr_get_u16(attr);
}
else if (mnl_attr_get_type(attr) == FOU_ATTR_IFINDEX) {
} else if (type == FOU_ATTR_IFINDEX) {
if (ynl_attr_validate(yarg, attr))
return MNL_CB_ERROR;
dst->_present.ifindex = 1;

78
tools/net/ynl/generated/handshake-user.c
View File

@@ -4,13 +4,11 @@
/* YNL-GEN user source */
#include <stdlib.h>
#include <string.h>
#include "handshake-user.h"
#include "ynl.h"
#include <linux/handshake.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <libmnl/libmnl.h>
#include <linux/genetlink.h>
@@ -118,13 +116,14 @@ int handshake_x509_parse(struct ynl_parse_arg *yarg,
const struct nlattr *attr;
mnl_attr_for_each_nested(attr, nested) {
if (mnl_attr_get_type(attr) == HANDSHAKE_A_X509_CERT) {
unsigned int type = mnl_attr_get_type(attr);
if (type == HANDSHAKE_A_X509_CERT) {
if (ynl_attr_validate(yarg, attr))
return MNL_CB_ERROR;
dst->_present.cert = 1;
dst->cert = mnl_attr_get_u32(attr);
}
else if (mnl_attr_get_type(attr) == HANDSHAKE_A_X509_PRIVKEY) {
} else if (type == HANDSHAKE_A_X509_PRIVKEY) {
if (ynl_attr_validate(yarg, attr))
return MNL_CB_ERROR;
dst->_present.privkey = 1;
@@ -173,37 +172,33 @@ int handshake_accept_rsp_parse(const struct nlmsghdr *nlh, void *data)
return ynl_error_parse(yarg, "attribute already present (accept.peer-identity)");
mnl_attr_for_each(attr, nlh, sizeof(struct genlmsghdr)) {
if (mnl_attr_get_type(attr) == HANDSHAKE_A_ACCEPT_SOCKFD) {
unsigned int type = mnl_attr_get_type(attr);
if (type == HANDSHAKE_A_ACCEPT_SOCKFD) {
if (ynl_attr_validate(yarg, attr))
return MNL_CB_ERROR;
dst->_present.sockfd = 1;
dst->sockfd = mnl_attr_get_u32(attr);
}
else if (mnl_attr_get_type(attr) == HANDSHAKE_A_ACCEPT_MESSAGE_TYPE) {
} else if (type == HANDSHAKE_A_ACCEPT_MESSAGE_TYPE) {
if (ynl_attr_validate(yarg, attr))
return MNL_CB_ERROR;
dst->_present.message_type = 1;
dst->message_type = mnl_attr_get_u32(attr);
}
else if (mnl_attr_get_type(attr) == HANDSHAKE_A_ACCEPT_TIMEOUT) {
} else if (type == HANDSHAKE_A_ACCEPT_TIMEOUT) {
if (ynl_attr_validate(yarg, attr))
return MNL_CB_ERROR;
dst->_present.timeout = 1;
dst->timeout = mnl_attr_get_u32(attr);
}
else if (mnl_attr_get_type(attr) == HANDSHAKE_A_ACCEPT_AUTH_MODE) {
} else if (type == HANDSHAKE_A_ACCEPT_AUTH_MODE) {
if (ynl_attr_validate(yarg, attr))
return MNL_CB_ERROR;
dst->_present.auth_mode = 1;
dst->auth_mode = mnl_attr_get_u32(attr);
}
else if (mnl_attr_get_type(attr) == HANDSHAKE_A_ACCEPT_PEER_IDENTITY) {
} else if (type == HANDSHAKE_A_ACCEPT_PEER_IDENTITY) {
n_peer_identity++;
}
else if (mnl_attr_get_type(attr) == HANDSHAKE_A_ACCEPT_CERTIFICATE) {
} else if (type == HANDSHAKE_A_ACCEPT_CERTIFICATE) {
n_certificate++;
}
else if (mnl_attr_get_type(attr) == HANDSHAKE_A_ACCEPT_PEERNAME) {
} else if (type == HANDSHAKE_A_ACCEPT_PEERNAME) {
unsigned int len;
if (ynl_attr_validate(yarg, attr))
@@ -320,51 +315,6 @@ int handshake_done(struct ynl_sock *ys, struct handshake_done_req *req)
return 0;
}
/* --------------- Common notification parsing --------------- */
struct ynl_ntf_base_type *handshake_ntf_parse(struct ynl_sock *ys)
{
struct ynl_parse_arg yarg = { .ys = ys, };
struct ynl_ntf_base_type *rsp;
struct genlmsghdr *genlh;
struct nlmsghdr *nlh;
mnl_cb_t parse;
int len, err;
len = mnl_socket_recvfrom(ys->sock, ys->rx_buf, MNL_SOCKET_BUFFER_SIZE);
if (len < (ssize_t)(sizeof(*nlh) + sizeof(*genlh)))
return NULL;
nlh = (struct nlmsghdr *)ys->rx_buf;
genlh = mnl_nlmsg_get_payload(nlh);
switch (genlh->cmd) {
case HANDSHAKE_CMD_READY:
rsp = calloc(1, sizeof(struct handshake_accept_ntf));
parse = handshake_accept_rsp_parse;
yarg.rsp_policy = &handshake_accept_nest;
rsp->free = (void *)handshake_accept_ntf_free;
break;
default:
ynl_error_unknown_notification(ys, genlh->cmd);
return NULL;
}
yarg.data = rsp->data;
err = mnl_cb_run2(ys->rx_buf, len, 0, 0, parse, &yarg,
ynl_cb_array, NLMSG_MIN_TYPE);
if (err < 0)
goto err_free;
rsp->family = nlh->nlmsg_type;
rsp->cmd = genlh->cmd;
return rsp;
err_free:
free(rsp);
return NULL;
}
static const struct ynl_ntf_info handshake_ntf_info[] = {
[HANDSHAKE_CMD_READY] = {
.alloc_sz = sizeof(struct handshake_accept_ntf),

3
tools/net/ynl/generated/handshake-user.h
View File

@@ -142,7 +142,4 @@ __handshake_done_req_set_remote_auth(struct handshake_done_req *req,
*/
int handshake_done(struct ynl_sock *ys, struct handshake_done_req *req);
/* --------------- Common notification parsing --------------- */
struct ynl_ntf_base_type *handshake_ntf_parse(struct ynl_sock *ys);
#endif /* _LINUX_HANDSHAKE_GEN_H */

58
tools/net/ynl/generated/netdev-user.c
View File

@@ -4,13 +4,11 @@
/* YNL-GEN user source */
#include <stdlib.h>
#include <string.h>
#include "netdev-user.h"
#include "ynl.h"
#include <linux/netdev.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <libmnl/libmnl.h>
#include <linux/genetlink.h>
@@ -81,13 +79,14 @@ int netdev_dev_get_rsp_parse(const struct nlmsghdr *nlh, void *data)
dst = yarg->data;
mnl_attr_for_each(attr, nlh, sizeof(struct genlmsghdr)) {
if (mnl_attr_get_type(attr) == NETDEV_A_DEV_IFINDEX) {
unsigned int type = mnl_attr_get_type(attr);
if (type == NETDEV_A_DEV_IFINDEX) {
if (ynl_attr_validate(yarg, attr))
return MNL_CB_ERROR;
dst->_present.ifindex = 1;
dst->ifindex = mnl_attr_get_u32(attr);
}
else if (mnl_attr_get_type(attr) == NETDEV_A_DEV_XDP_FEATURES) {
} else if (type == NETDEV_A_DEV_XDP_FEATURES) {
if (ynl_attr_validate(yarg, attr))
return MNL_CB_ERROR;
dst->_present.xdp_features = 1;
@@ -173,53 +172,6 @@ void netdev_dev_get_ntf_free(struct netdev_dev_get_ntf *rsp)
free(rsp);
}
/* --------------- Common notification parsing --------------- */
struct ynl_ntf_base_type *netdev_ntf_parse(struct ynl_sock *ys)
{
struct ynl_parse_arg yarg = { .ys = ys, };
struct ynl_ntf_base_type *rsp;
struct genlmsghdr *genlh;
struct nlmsghdr *nlh;
mnl_cb_t parse;
int len, err;
len = mnl_socket_recvfrom(ys->sock, ys->rx_buf, MNL_SOCKET_BUFFER_SIZE);
if (len < (ssize_t)(sizeof(*nlh) + sizeof(*genlh)))
return NULL;
nlh = (struct nlmsghdr *)ys->rx_buf;
genlh = mnl_nlmsg_get_payload(nlh);
switch (genlh->cmd) {
case NETDEV_CMD_DEV_ADD_NTF:
case NETDEV_CMD_DEV_DEL_NTF:
case NETDEV_CMD_DEV_CHANGE_NTF:
rsp = calloc(1, sizeof(struct netdev_dev_get_ntf));
parse = netdev_dev_get_rsp_parse;
yarg.rsp_policy = &netdev_dev_nest;
rsp->free = (void *)netdev_dev_get_ntf_free;
break;
default:
ynl_error_unknown_notification(ys, genlh->cmd);
return NULL;
}
yarg.data = rsp->data;
err = mnl_cb_run2(ys->rx_buf, len, 0, 0, parse, &yarg,
ynl_cb_array, NLMSG_MIN_TYPE);
if (err < 0)
goto err_free;
rsp->family = nlh->nlmsg_type;
rsp->cmd = genlh->cmd;
return rsp;
err_free:
free(rsp);
return NULL;
}
static const struct ynl_ntf_info netdev_ntf_info[] = {
[NETDEV_CMD_DEV_ADD_NTF] = {
.alloc_sz = sizeof(struct netdev_dev_get_ntf),

3
tools/net/ynl/generated/netdev-user.h
View File

@@ -82,7 +82,4 @@ struct netdev_dev_get_ntf {
void netdev_dev_get_ntf_free(struct netdev_dev_get_ntf *rsp);
/* --------------- Common notification parsing --------------- */
struct ynl_ntf_base_type *netdev_ntf_parse(struct ynl_sock *ys);
#endif /* _LINUX_NETDEV_GEN_H */

7
tools/net/ynl/lib/nlspec.py
View File

@@ -329,8 +329,8 @@ class SpecFamily(SpecElement):
attr_sets dict of attribute sets
msgs dict of all messages (index by name)
msgs_by_value dict of all messages (indexed by name)
ops dict of all valid requests / responses
ntfs dict of all async events
consts dict of all constants/enums
fixed_header string, optional name of family default fixed header struct
"""
@@ -370,6 +370,7 @@ class SpecFamily(SpecElement):
self.req_by_value = collections.OrderedDict()
self.rsp_by_value = collections.OrderedDict()
self.ops = collections.OrderedDict()
self.ntfs = collections.OrderedDict()
self.consts = collections.OrderedDict()
last_exception = None
@@ -422,7 +423,7 @@ class SpecFamily(SpecElement):
self.fixed_header = self.yaml['operations'].get('fixed-header')
req_val = rsp_val = 1
for elem in self.yaml['operations']['list']:
if 'notify' in elem:
if 'notify' in elem or 'event' in elem:
if 'value' in elem:
rsp_val = elem['value']
req_val_next = req_val
@@ -491,3 +492,5 @@ class SpecFamily(SpecElement):
self.rsp_by_value[op.rsp_value] = op
if not op.is_async and 'attribute-set' in op:
self.ops[op.name] = op
elif op.is_async:
self.ntfs[op.name] = op

253
tools/net/ynl/ynl-gen-c.py
View File

@@ -153,7 +153,7 @@ class Type(SpecAttr):
init_lines = [init_lines]
kw = 'if' if first else 'else if'
ri.cw.block_start(line=f"{kw} (mnl_attr_get_type(attr) == {self.enum_name})")
ri.cw.block_start(line=f"{kw} (type == {self.enum_name})")
if local_vars:
for local in local_vars:
ri.cw.p(local)
@@ -227,12 +227,18 @@ class TypePad(Type):
def _attr_typol(self):
return '.type = YNL_PT_IGNORE, '
def attr_put(self, ri, var):
pass
def attr_get(self, ri, var, first):
pass
def attr_policy(self, cw):
pass
def setter(self, ri, space, direction, deref=False, ref=None):
pass
class TypeScalar(Type):
def __init__(self, family, attr_set, attr, value):
@@ -714,6 +720,8 @@ class Operation(SpecOperation):
self.dual_policy = ('do' in yaml and 'request' in yaml['do']) and \
('dump' in yaml and 'request' in yaml['dump'])
self.has_ntf = False
# Added by resolve:
self.enum_name = None
delattr(self, "enum_name")
@@ -726,12 +734,8 @@ class Operation(SpecOperation):
else:
self.enum_name = self.family.async_op_prefix + c_upper(self.name)
def add_notification(self, op):
if 'notify' not in self.yaml:
self.yaml['notify'] = dict()
self.yaml['notify']['reply'] = self.yaml['do']['reply']
self.yaml['notify']['cmds'] = []
self.yaml['notify']['cmds'].append(op)
def mark_has_ntf(self):
self.has_ntf = True
class Family(SpecFamily):
@@ -793,14 +797,12 @@ class Family(SpecFamily):
self.root_sets = dict()
# dict space-name -> set('request', 'reply')
self.pure_nested_structs = dict()
self.all_notify = dict()
self._mark_notify()
self._mock_up_events()
self._dictify()
self._load_root_sets()
self._load_nested_sets()
self._load_all_notify()
self._load_hooks()
self.kernel_policy = self.yaml.get('kernel-policy', 'split')
@@ -816,6 +818,11 @@ class Family(SpecFamily):
def new_operation(self, elem, req_value, rsp_value):
return Operation(self, elem, req_value, rsp_value)
def _mark_notify(self):
for op in self.msgs.values():
if 'notify' in op:
self.ops[op['notify']].mark_has_ntf()
# Fake a 'do' equivalent of all events, so that we can render their response parsing
def _mock_up_events(self):
for op in self.yaml['operations']['list']:
@@ -826,16 +833,8 @@ class Family(SpecFamily):
}
}
def _dictify(self):
ntf = []
for msg in self.msgs.values():
if 'notify' in msg:
ntf.append(msg)
for n in ntf:
self.ops[n['notify']].add_notification(n)
def _load_root_sets(self):
for op_name, op in self.ops.items():
for op_name, op in self.msgs.items():
if 'attribute-set' not in op:
continue
@@ -846,6 +845,8 @@ class Family(SpecFamily):
req_attrs.update(set(op[op_mode]['request']['attributes']))
if op_mode in op and 'reply' in op[op_mode]:
rsp_attrs.update(set(op[op_mode]['reply']['attributes']))
if 'event' in op:
rsp_attrs.update(set(op['event']['attributes']))
if op['attribute-set'] not in self.root_sets:
self.root_sets[op['attribute-set']] = {'request': req_attrs, 'reply': rsp_attrs}
@@ -922,14 +923,6 @@ class Family(SpecFamily):
child.request |= struct.request
child.reply |= struct.reply
def _load_all_notify(self):
for op_name, op in self.ops.items():
if not op:
continue
if 'notify' in op:
self.all_notify[op_name] = op['notify']['cmds']
def _load_global_policy(self):
global_set = set()
attr_set_name = None
@@ -968,21 +961,14 @@ class Family(SpecFamily):
self.hooks[when][op_mode]['set'].add(name)
self.hooks[when][op_mode]['list'].append(name)
def has_notifications(self):
for op in self.ops.values():
if 'notify' in op or 'event' in op:
return True
return False
class RenderInfo:
def __init__(self, cw, family, ku_space, op, op_name, op_mode, attr_set=None):
def __init__(self, cw, family, ku_space, op, op_mode, attr_set=None):
self.family = family
self.nl = cw.nlib
self.ku_space = ku_space
self.op = op
self.op_name = op_name
self.op_mode = op_mode
self.op = op
# 'do' and 'dump' response parsing is identical
self.type_consistent = True
@@ -997,13 +983,15 @@ class RenderInfo:
self.attr_set = op['attribute-set']
if op:
self.type_name = c_lower(op_name)
self.type_name = c_lower(op.name)
else:
self.type_name = c_lower(attr_set)
self.cw = cw
self.struct = dict()
if op_mode == 'notify':
op_mode = 'do'
for op_dir in ['request', 'reply']:
if op and op_dir in op[op_mode]:
self.struct[op_dir] = Struct(family, self.attr_set,
@@ -1017,6 +1005,7 @@ class CodeWriter:
self.nlib = nlib
self._nl = False
self._block_end = False
self._silent_block = False
self._ind = 0
self._out = out_file
@@ -1025,11 +1014,18 @@ class CodeWriter:
def _is_cond(cls, line):
return line.startswith('if') or line.startswith('while') or line.startswith('for')
def p(self, line, add_ind=0, eat_nl=False):
def p(self, line, add_ind=0):
if self._block_end:
self._block_end = False
if line.startswith('else'):
line = '} ' + line
else:
self._out.write('\t' * self._ind + '}\n')
if self._nl:
if not eat_nl:
self._out.write('\n')
self._out.write('\n')
self._nl = False
ind = self._ind
if line[-1] == ':':
ind -= 1
@@ -1053,7 +1049,14 @@ class CodeWriter:
if line and line[0] not in {';', ','}:
line = ' ' + line
self._ind -= 1
self.p('}' + line, eat_nl=True)
self._nl = False
if not line:
# Delay printing closing bracket in case "else" comes next
if self._block_end:
self._out.write('\t' * (self._ind + 1) + '}\n')
self._block_end = True
else:
self.p('}' + line)
def write_doc_line(self, doc, indent=True):
words = doc.split()
@@ -1172,7 +1175,40 @@ op_mode_to_wrapper = {
}
_C_KW = {
'do'
'auto',
'bool',
'break',
'case',
'char',
'const',
'continue',
'default',
'do',
'double',
'else',
'enum',
'extern',
'float',
'for',
'goto',
'if',
'inline',
'int',
'long',
'register',
'return',
'short',
'signed',
'sizeof',
'static',
'struct',
'switch',
'typedef',
'union',
'unsigned',
'void',
'volatile',
'while'
}
@@ -1370,6 +1406,8 @@ def _multi_parse(ri, struct, init_lines, local_vars):
ri.cw.nl()
ri.cw.block_start(line=iter_line)
ri.cw.p('unsigned int type = mnl_attr_get_type(attr);')
ri.cw.nl()
first = True
for _, arg in struct.member_list():
@@ -1760,70 +1798,6 @@ def print_ntf_type_free(ri):
ri.cw.nl()
def print_ntf_parse_prototype(family, cw, suffix=';'):
cw.write_func_prot('struct ynl_ntf_base_type *', f"{family['name']}_ntf_parse",
['struct ynl_sock *ys'], suffix=suffix)
def print_ntf_type_parse(family, cw, ku_mode):
print_ntf_parse_prototype(family, cw, suffix='')
cw.block_start()
cw.write_func_lvar(['struct genlmsghdr *genlh;',
'struct nlmsghdr *nlh;',
'struct ynl_parse_arg yarg = { .ys = ys, };',
'struct ynl_ntf_base_type *rsp;',
'int len, err;',
'mnl_cb_t parse;'])
cw.p('len = mnl_socket_recvfrom(ys->sock, ys->rx_buf, MNL_SOCKET_BUFFER_SIZE);')
cw.p('if (len < (ssize_t)(sizeof(*nlh) + sizeof(*genlh)))')
cw.p('return NULL;')
cw.nl()
cw.p('nlh = (struct nlmsghdr *)ys->rx_buf;')
cw.p('genlh = mnl_nlmsg_get_payload(nlh);')
cw.nl()
cw.block_start(line='switch (genlh->cmd)')
for ntf_op in sorted(family.all_notify.keys()):
op = family.ops[ntf_op]
ri = RenderInfo(cw, family, ku_mode, op, ntf_op, "notify")
for ntf in op['notify']['cmds']:
cw.p(f"case {ntf.enum_name}:")
cw.p(f"rsp = calloc(1, sizeof({type_name(ri, 'notify')}));")
cw.p(f"parse = {op_prefix(ri, 'reply', deref=True)}_parse;")
cw.p(f"yarg.rsp_policy = &{ri.struct['reply'].render_name}_nest;")
cw.p(f"rsp->free = (void *){op_prefix(ri, 'notify')}_free;")
cw.p('break;')
for op_name, op in family.ops.items():
if 'event' not in op:
continue
ri = RenderInfo(cw, family, ku_mode, op, op_name, "event")
cw.p(f"case {op.enum_name}:")
cw.p(f"rsp = calloc(1, sizeof({type_name(ri, 'event')}));")
cw.p(f"parse = {op_prefix(ri, 'reply', deref=True)}_parse;")
cw.p(f"yarg.rsp_policy = &{ri.struct['reply'].render_name}_nest;")
cw.p(f"rsp->free = (void *){op_prefix(ri, 'notify')}_free;")
cw.p('break;')
cw.p('default:')
cw.p('ynl_error_unknown_notification(ys, genlh->cmd);')
cw.p('return NULL;')
cw.block_end()
cw.nl()
cw.p('yarg.data = rsp->data;')
cw.nl()
cw.p(f"err = {cw.nlib.parse_cb_run('parse', '&yarg', True)};")
cw.p('if (err < 0)')
cw.p('goto err_free;')
cw.nl()
cw.p('rsp->family = nlh->nlmsg_type;')
cw.p('rsp->cmd = genlh->cmd;')
cw.p('return rsp;')
cw.nl()
cw.p('err_free:')
cw.p('free(rsp);')
cw.p('return NULL;')
cw.block_end()
cw.nl()
def print_req_policy_fwd(cw, struct, ri=None, terminate=True):
if terminate and ri and kernel_can_gen_family_struct(struct.family):
return
@@ -2223,25 +2197,28 @@ def render_user_family(family, cw, prototype):
cw.p(f'extern {symbol};')
return
ntf = family.has_notifications()
if ntf:
if family.ntfs:
cw.block_start(line=f"static const struct ynl_ntf_info {family['name']}_ntf_info[] = ")
for ntf_op in sorted(family.all_notify.keys()):
op = family.ops[ntf_op]
ri = RenderInfo(cw, family, "user", op, ntf_op, "notify")
for ntf in op['notify']['cmds']:
_render_user_ntf_entry(ri, ntf)
for ntf_op_name, ntf_op in family.ntfs.items():
if 'notify' in ntf_op:
op = family.ops[ntf_op['notify']]
ri = RenderInfo(cw, family, "user", op, "notify")
elif 'event' in ntf_op:
ri = RenderInfo(cw, family, "user", ntf_op, "event")
else:
raise Exception('Invalid notification ' + ntf_op_name)
_render_user_ntf_entry(ri, ntf_op)
for op_name, op in family.ops.items():
if 'event' not in op:
continue
ri = RenderInfo(cw, family, "user", op, op_name, "event")
ri = RenderInfo(cw, family, "user", op, "event")
_render_user_ntf_entry(ri, op)
cw.block_end(line=";")
cw.nl()
cw.block_start(f'{symbol} = ')
cw.p(f'.name\t\t= "{family.name}",')
if ntf:
if family.ntfs:
cw.p(f".ntf_info\t= {family['name']}_ntf_info,")
cw.p(f".ntf_info_size\t= MNL_ARRAY_SIZE({family['name']}_ntf_info),")
cw.block_end(line=';')
@@ -2323,8 +2300,8 @@ def main():
headers = ['uapi/' + parsed.uapi_header]
else:
cw.p('#include <stdlib.h>')
cw.p('#include <string.h>')
if args.header:
cw.p('#include <string.h>')
cw.p('#include <linux/types.h>')
else:
cw.p(f'#include "{parsed.name}-user.h"')
@@ -2339,9 +2316,6 @@ def main():
if args.mode == "user":
if not args.header:
cw.p("#include <stdlib.h>")
cw.p("#include <stdio.h>")
cw.p("#include <string.h>")
cw.p("#include <libmnl/libmnl.h>")
cw.p("#include <linux/genetlink.h>")
cw.nl()
@@ -2374,7 +2348,7 @@ def main():
if parsed.kernel_policy in {'per-op', 'split'}:
for op_name, op in parsed.ops.items():
if 'do' in op and 'event' not in op:
ri = RenderInfo(cw, parsed, args.mode, op, op_name, "do")
ri = RenderInfo(cw, parsed, args.mode, op, "do")
print_req_policy_fwd(cw, ri.struct['request'], ri=ri)
cw.nl()
@@ -2403,7 +2377,7 @@ def main():
for op_mode in ['do', 'dump']:
if op_mode in op and 'request' in op[op_mode]:
cw.p(f"/* {op.enum_name} - {op_mode} */")
ri = RenderInfo(cw, parsed, args.mode, op, op_name, op_mode)
ri = RenderInfo(cw, parsed, args.mode, op, op_mode)
print_req_policy(cw, ri.struct['request'], ri=ri)
cw.nl()
@@ -2423,7 +2397,7 @@ def main():
cw.p('/* Common nested types */')
for attr_set, struct in parsed.pure_nested_structs.items():
ri = RenderInfo(cw, parsed, args.mode, "", "", "", attr_set)
ri = RenderInfo(cw, parsed, args.mode, "", "", attr_set)
print_type_full(ri, struct)
for op_name, op in parsed.ops.items():
@@ -2431,7 +2405,7 @@ def main():
if 'do' in op and 'event' not in op:
cw.p(f"/* {op.enum_name} - do */")
ri = RenderInfo(cw, parsed, args.mode, op, op_name, "do")
ri = RenderInfo(cw, parsed, args.mode, op, "do")
print_req_type(ri)
print_req_type_helpers(ri)
cw.nl()
@@ -2443,7 +2417,7 @@ def main():
if 'dump' in op:
cw.p(f"/* {op.enum_name} - dump */")
ri = RenderInfo(cw, parsed, args.mode, op, op_name, 'dump')
ri = RenderInfo(cw, parsed, args.mode, op, 'dump')
if 'request' in op['dump']:
print_req_type(ri)
print_req_type_helpers(ri)
@@ -2453,23 +2427,20 @@ def main():
print_dump_prototype(ri)
cw.nl()
if 'notify' in op:
if op.has_ntf:
cw.p(f"/* {op.enum_name} - notify */")
ri = RenderInfo(cw, parsed, args.mode, op, op_name, 'notify')
ri = RenderInfo(cw, parsed, args.mode, op, 'notify')
if not ri.type_consistent:
raise Exception(f'Only notifications with consistent types supported ({op.name})')
print_wrapped_type(ri)
for op_name, op in parsed.ntfs.items():
if 'event' in op:
ri = RenderInfo(cw, parsed, args.mode, op, op_name, 'event')
ri = RenderInfo(cw, parsed, args.mode, op, 'event')
cw.p(f"/* {op.enum_name} - event */")
print_rsp_type(ri)
cw.nl()
print_wrapped_type(ri)
if parsed.has_notifications():
cw.p('/* --------------- Common notification parsing --------------- */')
print_ntf_parse_prototype(parsed, cw)
cw.nl()
else:
cw.p('/* Enums */')
@@ -2490,7 +2461,7 @@ def main():
cw.p('/* Common nested types */')
for attr_set, struct in parsed.pure_nested_structs.items():
ri = RenderInfo(cw, parsed, args.mode, "", "", "", attr_set)
ri = RenderInfo(cw, parsed, args.mode, "", "", attr_set)
free_rsp_nested(ri, struct)
if struct.request:
@@ -2502,7 +2473,7 @@ def main():
cw.p(f"/* ============== {op.enum_name} ============== */")
if 'do' in op and 'event' not in op:
cw.p(f"/* {op.enum_name} - do */")
ri = RenderInfo(cw, parsed, args.mode, op, op_name, "do")
ri = RenderInfo(cw, parsed, args.mode, op, "do")
print_req_free(ri)
print_rsp_free(ri)
parse_rsp_msg(ri)
@@ -2511,33 +2482,29 @@ def main():
if 'dump' in op:
cw.p(f"/* {op.enum_name} - dump */")
ri = RenderInfo(cw, parsed, args.mode, op, op_name, "dump")
ri = RenderInfo(cw, parsed, args.mode, op, "dump")
if not ri.type_consistent:
parse_rsp_msg(ri, deref=True)
print_dump_type_free(ri)
print_dump(ri)
cw.nl()
if 'notify' in op:
if op.has_ntf:
cw.p(f"/* {op.enum_name} - notify */")
ri = RenderInfo(cw, parsed, args.mode, op, op_name, 'notify')
ri = RenderInfo(cw, parsed, args.mode, op, 'notify')
if not ri.type_consistent:
raise Exception(f'Only notifications with consistent types supported ({op.name})')
print_ntf_type_free(ri)
for op_name, op in parsed.ntfs.items():
if 'event' in op:
cw.p(f"/* {op.enum_name} - event */")
ri = RenderInfo(cw, parsed, args.mode, op, op_name, "do")
ri = RenderInfo(cw, parsed, args.mode, op, "do")
parse_rsp_msg(ri)
ri = RenderInfo(cw, parsed, args.mode, op, op_name, "event")
ri = RenderInfo(cw, parsed, args.mode, op, "event")
print_ntf_type_free(ri)
if parsed.has_notifications():
cw.p('/* --------------- Common notification parsing --------------- */')
print_ntf_type_parse(parsed, cw, args.mode)
cw.nl()
render_user_family(parsed, cw, False)