devlink: Add devlink formatted message (fmsg) API

Devlink fmsg is a mechanism to pass descriptors between drivers and
devlink, in json-like format. The API allows the driver to add nested
attributes such as object, object pair and value array, in addition to
attributes such as name and value.

Driver can use this API to fill the fmsg context in a format which will be
translated by the devlink to the netlink message later.
There is no memory allocation in advance (other than the initial list
head), and it dynamically allocates messages descriptors and add them to
the list on the fly.

When it needs to send the data using SKBs to the netlink layer, it
fragments the data between different SKBs. In order to do this
fragmentation, it uses virtual nests attributes, to avoid actual
nesting use which cannot be divided between different SKBs.

Signed-off-by: Eran Ben Elisha <eranbe@mellanox.com>
Reviewed-by: Moshe Shemesh <moshe@mellanox.com>
Acked-by: Jiri Pirko <jiri@mellanox.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

diff --git a/include/net/devlink.h b/include/net/devlink.h
index 74d992a68a06493ddbf1471d300c908afcceb5ec..7c5722e816aaf589e1066ae04d81828c75b3bff3 100644 (file)
--- a/include/net/devlink.h
+++ b/include/net/devlink.h
@@ -448,6 +448,8 @@ struct devlink_info_req;
 
 typedef void devlink_snapshot_data_dest_t(const void *data);
 
+struct devlink_fmsg;
+
 struct devlink_ops {
        int (*reload)(struct devlink *devlink, struct netlink_ext_ack *extack);
        int (*port_type_set)(struct devlink_port *devlink_port,
@@ -639,6 +641,37 @@ int devlink_info_version_running_put(struct devlink_info_req *req,
                                     const char *version_name,
                                     const char *version_value);
 
+int devlink_fmsg_obj_nest_start(struct devlink_fmsg *fmsg);
+int devlink_fmsg_obj_nest_end(struct devlink_fmsg *fmsg);
+
+int devlink_fmsg_pair_nest_start(struct devlink_fmsg *fmsg, const char *name);
+int devlink_fmsg_pair_nest_end(struct devlink_fmsg *fmsg);
+
+int devlink_fmsg_arr_pair_nest_start(struct devlink_fmsg *fmsg,
+                                    const char *name);
+int devlink_fmsg_arr_pair_nest_end(struct devlink_fmsg *fmsg);
+
+int devlink_fmsg_bool_put(struct devlink_fmsg *fmsg, bool value);
+int devlink_fmsg_u8_put(struct devlink_fmsg *fmsg, u8 value);
+int devlink_fmsg_u32_put(struct devlink_fmsg *fmsg, u32 value);
+int devlink_fmsg_u64_put(struct devlink_fmsg *fmsg, u64 value);
+int devlink_fmsg_string_put(struct devlink_fmsg *fmsg, const char *value);
+int devlink_fmsg_binary_put(struct devlink_fmsg *fmsg, const void *value,
+                           u16 value_len);
+
+int devlink_fmsg_bool_pair_put(struct devlink_fmsg *fmsg, const char *name,
+                              bool value);
+int devlink_fmsg_u8_pair_put(struct devlink_fmsg *fmsg, const char *name,
+                            u8 value);
+int devlink_fmsg_u32_pair_put(struct devlink_fmsg *fmsg, const char *name,
+                             u32 value);
+int devlink_fmsg_u64_pair_put(struct devlink_fmsg *fmsg, const char *name,
+                             u64 value);
+int devlink_fmsg_string_pair_put(struct devlink_fmsg *fmsg, const char *name,
+                                const char *value);
+int devlink_fmsg_binary_pair_put(struct devlink_fmsg *fmsg, const char *name,
+                                const void *value, u16 value_len);
+
 #else
 
 static inline struct devlink *devlink_alloc(const struct devlink_ops *ops,
@@ -971,6 +1004,122 @@ devlink_info_version_running_put(struct devlink_info_req *req,
 {
        return 0;
 }
+
+static inline int
+devlink_fmsg_obj_nest_start(struct devlink_fmsg *fmsg)
+{
+       return 0;
+}
+
+static inline int
+devlink_fmsg_obj_nest_end(struct devlink_fmsg *fmsg)
+{
+       return 0;
+}
+
+static inline int
+devlink_fmsg_pair_nest_start(struct devlink_fmsg *fmsg, const char *name)
+{
+       return 0;
+}
+
+static inline int
+devlink_fmsg_pair_nest_end(struct devlink_fmsg *fmsg)
+{
+       return 0;
+}
+
+static inline int
+devlink_fmsg_arr_pair_nest_start(struct devlink_fmsg *fmsg,
+                                const char *name)
+{
+       return 0;
+}
+
+static inline int
+devlink_fmsg_arr_pair_nest_end(struct devlink_fmsg *fmsg)
+{
+       return 0;
+}
+
+static inline int
+devlink_fmsg_bool_put(struct devlink_fmsg *fmsg, bool value)
+{
+       return 0;
+}
+
+static inline int
+devlink_fmsg_u8_put(struct devlink_fmsg *fmsg, u8 value)
+{
+       return 0;
+}
+
+static inline int
+devlink_fmsg_u32_put(struct devlink_fmsg *fmsg, u32 value)
+{
+       return 0;
+}
+
+static inline int
+devlink_fmsg_u64_put(struct devlink_fmsg *fmsg, u64 value)
+{
+       return 0;
+}
+
+static inline int
+devlink_fmsg_string_put(struct devlink_fmsg *fmsg, const char *value)
+{
+       return 0;
+}
+
+static inline int
+devlink_fmsg_binary_put(struct devlink_fmsg *fmsg, const void *value,
+                       u16 value_len)
+{
+       return 0;
+}
+
+static inline int
+devlink_fmsg_bool_pair_put(struct devlink_fmsg *fmsg, const char *name,
+                          bool value)
+{
+       return 0;
+}
+
+static inline int
+devlink_fmsg_u8_pair_put(struct devlink_fmsg *fmsg, const char *name,
+                        u8 value)
+{
+       return 0;
+}
+
+static inline int
+devlink_fmsg_u32_pair_put(struct devlink_fmsg *fmsg, const char *name,
+                         u32 value)
+{
+       return 0;
+}
+
+static inline int
+devlink_fmsg_u64_pair_put(struct devlink_fmsg *fmsg, const char *name,
+                         u64 value)
+{
+       return 0;
+}
+
+static inline int
+devlink_fmsg_string_pair_put(struct devlink_fmsg *fmsg, const char *name,
+                            const char *value)
+{
+       return 0;
+}
+
+static inline int
+devlink_fmsg_binary_pair_put(struct devlink_fmsg *fmsg, const char *name,
+                            const void *value, u16 value_len)
+{
+       return 0;
+}
 #endif
 
 #if IS_REACHABLE(CONFIG_NET_DEVLINK)

diff --git a/include/uapi/linux/devlink.h b/include/uapi/linux/devlink.h
index 054b2d1a45376a24bdf11add8e8baa0fe5fa4de5..076692209a9b6283986a4acc09cf5a70320765bc 100644 (file)
--- a/include/uapi/linux/devlink.h
+++ b/include/uapi/linux/devlink.h
@@ -302,6 +302,14 @@ enum devlink_attr {
 
        DEVLINK_ATTR_SB_POOL_CELL_SIZE,         /* u32 */
 
+       DEVLINK_ATTR_FMSG,                      /* nested */
+       DEVLINK_ATTR_FMSG_OBJ_NEST_START,       /* flag */
+       DEVLINK_ATTR_FMSG_PAIR_NEST_START,      /* flag */
+       DEVLINK_ATTR_FMSG_ARR_NEST_START,       /* flag */
+       DEVLINK_ATTR_FMSG_NEST_END,             /* flag */
+       DEVLINK_ATTR_FMSG_OBJ_NAME,             /* string */
+       DEVLINK_ATTR_FMSG_OBJ_VALUE_TYPE,       /* u8 */
+       DEVLINK_ATTR_FMSG_OBJ_VALUE_DATA,       /* dynamic */
        /* add new attributes above here, update the policy in devlink.c */
 
        __DEVLINK_ATTR_MAX,

diff --git a/net/core/devlink.c b/net/core/devlink.c
index cd0d393bc62d89694c99625459607ea040546687..03883697fcf0abad6483b9c71178ab545f63bfba 100644 (file)
--- a/net/core/devlink.c
+++ b/net/core/devlink.c
@@ -3879,6 +3879,489 @@ static int devlink_nl_cmd_info_get_dumpit(struct sk_buff *msg,
        return msg->len;
 }
 
+struct devlink_fmsg_item {
+       struct list_head list;
+       int attrtype;
+       u8 nla_type;
+       u16 len;
+       int value[0];
+};
+
+struct devlink_fmsg {
+       struct list_head item_list;
+};
+
+static struct devlink_fmsg *devlink_fmsg_alloc(void)
+{
+       struct devlink_fmsg *fmsg;
+
+       fmsg = kzalloc(sizeof(*fmsg), GFP_KERNEL);
+       if (!fmsg)
+               return NULL;
+
+       INIT_LIST_HEAD(&fmsg->item_list);
+
+       return fmsg;
+}
+
+static void devlink_fmsg_free(struct devlink_fmsg *fmsg)
+{
+       struct devlink_fmsg_item *item, *tmp;
+
+       list_for_each_entry_safe(item, tmp, &fmsg->item_list, list) {
+               list_del(&item->list);
+               kfree(item);
+       }
+       kfree(fmsg);
+}
+
+static int devlink_fmsg_nest_common(struct devlink_fmsg *fmsg,
+                                   int attrtype)
+{
+       struct devlink_fmsg_item *item;
+
+       item = kzalloc(sizeof(*item), GFP_KERNEL);
+       if (!item)
+               return -ENOMEM;
+
+       item->attrtype = attrtype;
+       list_add_tail(&item->list, &fmsg->item_list);
+
+       return 0;
+}
+
+int devlink_fmsg_obj_nest_start(struct devlink_fmsg *fmsg)
+{
+       return devlink_fmsg_nest_common(fmsg, DEVLINK_ATTR_FMSG_OBJ_NEST_START);
+}
+EXPORT_SYMBOL_GPL(devlink_fmsg_obj_nest_start);
+
+static int devlink_fmsg_nest_end(struct devlink_fmsg *fmsg)
+{
+       return devlink_fmsg_nest_common(fmsg, DEVLINK_ATTR_FMSG_NEST_END);
+}
+
+int devlink_fmsg_obj_nest_end(struct devlink_fmsg *fmsg)
+{
+       return devlink_fmsg_nest_end(fmsg);
+}
+EXPORT_SYMBOL_GPL(devlink_fmsg_obj_nest_end);
+
+#define DEVLINK_FMSG_MAX_SIZE (GENLMSG_DEFAULT_SIZE - GENL_HDRLEN - NLA_HDRLEN)
+
+static int devlink_fmsg_put_name(struct devlink_fmsg *fmsg, const char *name)
+{
+       struct devlink_fmsg_item *item;
+
+       if (strlen(name) + 1 > DEVLINK_FMSG_MAX_SIZE)
+               return -EMSGSIZE;
+
+       item = kzalloc(sizeof(*item) + strlen(name) + 1, GFP_KERNEL);
+       if (!item)
+               return -ENOMEM;
+
+       item->nla_type = NLA_NUL_STRING;
+       item->len = strlen(name) + 1;
+       item->attrtype = DEVLINK_ATTR_FMSG_OBJ_NAME;
+       memcpy(&item->value, name, item->len);
+       list_add_tail(&item->list, &fmsg->item_list);
+
+       return 0;
+}
+
+int devlink_fmsg_pair_nest_start(struct devlink_fmsg *fmsg, const char *name)
+{
+       int err;
+
+       err = devlink_fmsg_nest_common(fmsg, DEVLINK_ATTR_FMSG_PAIR_NEST_START);
+       if (err)
+               return err;
+
+       err = devlink_fmsg_put_name(fmsg, name);
+       if (err)
+               return err;
+
+       return 0;
+}
+EXPORT_SYMBOL_GPL(devlink_fmsg_pair_nest_start);
+
+int devlink_fmsg_pair_nest_end(struct devlink_fmsg *fmsg)
+{
+       return devlink_fmsg_nest_end(fmsg);
+}
+EXPORT_SYMBOL_GPL(devlink_fmsg_pair_nest_end);
+
+int devlink_fmsg_arr_pair_nest_start(struct devlink_fmsg *fmsg,
+                                    const char *name)
+{
+       int err;
+
+       err = devlink_fmsg_pair_nest_start(fmsg, name);
+       if (err)
+               return err;
+
+       err = devlink_fmsg_nest_common(fmsg, DEVLINK_ATTR_FMSG_ARR_NEST_START);
+       if (err)
+               return err;
+
+       return 0;
+}
+EXPORT_SYMBOL_GPL(devlink_fmsg_arr_pair_nest_start);
+
+int devlink_fmsg_arr_pair_nest_end(struct devlink_fmsg *fmsg)
+{
+       int err;
+
+       err = devlink_fmsg_nest_end(fmsg);
+       if (err)
+               return err;
+
+       err = devlink_fmsg_nest_end(fmsg);
+       if (err)
+               return err;
+
+       return 0;
+}
+EXPORT_SYMBOL_GPL(devlink_fmsg_arr_pair_nest_end);
+
+static int devlink_fmsg_put_value(struct devlink_fmsg *fmsg,
+                                 const void *value, u16 value_len,
+                                 u8 value_nla_type)
+{
+       struct devlink_fmsg_item *item;
+
+       if (value_len > DEVLINK_FMSG_MAX_SIZE)
+               return -EMSGSIZE;
+
+       item = kzalloc(sizeof(*item) + value_len, GFP_KERNEL);
+       if (!item)
+               return -ENOMEM;
+
+       item->nla_type = value_nla_type;
+       item->len = value_len;
+       item->attrtype = DEVLINK_ATTR_FMSG_OBJ_VALUE_DATA;
+       memcpy(&item->value, value, item->len);
+       list_add_tail(&item->list, &fmsg->item_list);
+
+       return 0;
+}
+
+int devlink_fmsg_bool_put(struct devlink_fmsg *fmsg, bool value)
+{
+       return devlink_fmsg_put_value(fmsg, &value, sizeof(value), NLA_FLAG);
+}
+EXPORT_SYMBOL_GPL(devlink_fmsg_bool_put);
+
+int devlink_fmsg_u8_put(struct devlink_fmsg *fmsg, u8 value)
+{
+       return devlink_fmsg_put_value(fmsg, &value, sizeof(value), NLA_U8);
+}
+EXPORT_SYMBOL_GPL(devlink_fmsg_u8_put);
+
+int devlink_fmsg_u32_put(struct devlink_fmsg *fmsg, u32 value)
+{
+       return devlink_fmsg_put_value(fmsg, &value, sizeof(value), NLA_U32);
+}
+EXPORT_SYMBOL_GPL(devlink_fmsg_u32_put);
+
+int devlink_fmsg_u64_put(struct devlink_fmsg *fmsg, u64 value)
+{
+       return devlink_fmsg_put_value(fmsg, &value, sizeof(value), NLA_U64);
+}
+EXPORT_SYMBOL_GPL(devlink_fmsg_u64_put);
+
+int devlink_fmsg_string_put(struct devlink_fmsg *fmsg, const char *value)
+{
+       return devlink_fmsg_put_value(fmsg, value, strlen(value) + 1,
+                                     NLA_NUL_STRING);
+}
+EXPORT_SYMBOL_GPL(devlink_fmsg_string_put);
+
+int devlink_fmsg_binary_put(struct devlink_fmsg *fmsg, const void *value,
+                           u16 value_len)
+{
+       return devlink_fmsg_put_value(fmsg, value, value_len, NLA_BINARY);
+}
+EXPORT_SYMBOL_GPL(devlink_fmsg_binary_put);
+
+int devlink_fmsg_bool_pair_put(struct devlink_fmsg *fmsg, const char *name,
+                              bool value)
+{
+       int err;
+
+       err = devlink_fmsg_pair_nest_start(fmsg, name);
+       if (err)
+               return err;
+
+       err = devlink_fmsg_bool_put(fmsg, value);
+       if (err)
+               return err;
+
+       err = devlink_fmsg_pair_nest_end(fmsg);
+       if (err)
+               return err;
+
+       return 0;
+}
+EXPORT_SYMBOL_GPL(devlink_fmsg_bool_pair_put);
+
+int devlink_fmsg_u8_pair_put(struct devlink_fmsg *fmsg, const char *name,
+                            u8 value)
+{
+       int err;
+
+       err = devlink_fmsg_pair_nest_start(fmsg, name);
+       if (err)
+               return err;
+
+       err = devlink_fmsg_u8_put(fmsg, value);
+       if (err)
+               return err;
+
+       err = devlink_fmsg_pair_nest_end(fmsg);
+       if (err)
+               return err;
+
+       return 0;
+}
+EXPORT_SYMBOL_GPL(devlink_fmsg_u8_pair_put);
+
+int devlink_fmsg_u32_pair_put(struct devlink_fmsg *fmsg, const char *name,
+                             u32 value)
+{
+       int err;
+
+       err = devlink_fmsg_pair_nest_start(fmsg, name);
+       if (err)
+               return err;
+
+       err = devlink_fmsg_u32_put(fmsg, value);
+       if (err)
+               return err;
+
+       err = devlink_fmsg_pair_nest_end(fmsg);
+       if (err)
+               return err;
+
+       return 0;
+}
+EXPORT_SYMBOL_GPL(devlink_fmsg_u32_pair_put);
+
+int devlink_fmsg_u64_pair_put(struct devlink_fmsg *fmsg, const char *name,
+                             u64 value)
+{
+       int err;
+
+       err = devlink_fmsg_pair_nest_start(fmsg, name);
+       if (err)
+               return err;
+
+       err = devlink_fmsg_u64_put(fmsg, value);
+       if (err)
+               return err;
+
+       err = devlink_fmsg_pair_nest_end(fmsg);
+       if (err)
+               return err;
+
+       return 0;
+}
+EXPORT_SYMBOL_GPL(devlink_fmsg_u64_pair_put);
+
+int devlink_fmsg_string_pair_put(struct devlink_fmsg *fmsg, const char *name,
+                                const char *value)
+{
+       int err;
+
+       err = devlink_fmsg_pair_nest_start(fmsg, name);
+       if (err)
+               return err;
+
+       err = devlink_fmsg_string_put(fmsg, value);
+       if (err)
+               return err;
+
+       err = devlink_fmsg_pair_nest_end(fmsg);
+       if (err)
+               return err;
+
+       return 0;
+}
+EXPORT_SYMBOL_GPL(devlink_fmsg_string_pair_put);
+
+int devlink_fmsg_binary_pair_put(struct devlink_fmsg *fmsg, const char *name,
+                                const void *value, u16 value_len)
+{
+       int err;
+
+       err = devlink_fmsg_pair_nest_start(fmsg, name);
+       if (err)
+               return err;
+
+       err = devlink_fmsg_binary_put(fmsg, value, value_len);
+       if (err)
+               return err;
+
+       err = devlink_fmsg_pair_nest_end(fmsg);
+       if (err)
+               return err;
+
+       return 0;
+}
+EXPORT_SYMBOL_GPL(devlink_fmsg_binary_pair_put);
+
+static int
+devlink_fmsg_item_fill_type(struct devlink_fmsg_item *msg, struct sk_buff *skb)
+{
+       switch (msg->nla_type) {
+       case NLA_FLAG:
+       case NLA_U8:
+       case NLA_U32:
+       case NLA_U64:
+       case NLA_NUL_STRING:
+       case NLA_BINARY:
+               return nla_put_u8(skb, DEVLINK_ATTR_FMSG_OBJ_VALUE_TYPE,
+                                 msg->nla_type);
+       default:
+               return -EINVAL;
+       }
+}
+
+static int
+devlink_fmsg_item_fill_data(struct devlink_fmsg_item *msg, struct sk_buff *skb)
+{
+       int attrtype = DEVLINK_ATTR_FMSG_OBJ_VALUE_DATA;
+       u8 tmp;
+
+       switch (msg->nla_type) {
+       case NLA_FLAG:
+               /* Always provide flag data, regardless of its value */
+               tmp = *(bool *) msg->value;
+
+               return nla_put_u8(skb, attrtype, tmp);
+       case NLA_U8:
+               return nla_put_u8(skb, attrtype, *(u8 *) msg->value);
+       case NLA_U32:
+               return nla_put_u32(skb, attrtype, *(u32 *) msg->value);
+       case NLA_U64:
+               return nla_put_u64_64bit(skb, attrtype, *(u64 *) msg->value,
+                                        DEVLINK_ATTR_PAD);
+       case NLA_NUL_STRING:
+               return nla_put_string(skb, attrtype, (char *) &msg->value);
+       case NLA_BINARY:
+               return nla_put(skb, attrtype, msg->len, (void *) &msg->value);
+       default:
+               return -EINVAL;
+       }
+}
+
+static int
+devlink_fmsg_prepare_skb(struct devlink_fmsg *fmsg, struct sk_buff *skb,
+                        int *start)
+{
+       struct devlink_fmsg_item *item;
+       struct nlattr *fmsg_nlattr;
+       int i = 0;
+       int err;
+
+       fmsg_nlattr = nla_nest_start(skb, DEVLINK_ATTR_FMSG);
+       if (!fmsg_nlattr)
+               return -EMSGSIZE;
+
+       list_for_each_entry(item, &fmsg->item_list, list) {
+               if (i < *start) {
+                       i++;
+                       continue;
+               }
+
+               switch (item->attrtype) {
+               case DEVLINK_ATTR_FMSG_OBJ_NEST_START:
+               case DEVLINK_ATTR_FMSG_PAIR_NEST_START:
+               case DEVLINK_ATTR_FMSG_ARR_NEST_START:
+               case DEVLINK_ATTR_FMSG_NEST_END:
+                       err = nla_put_flag(skb, item->attrtype);
+                       break;
+               case DEVLINK_ATTR_FMSG_OBJ_VALUE_DATA:
+                       err = devlink_fmsg_item_fill_type(item, skb);
+                       if (err)
+                               break;
+                       err = devlink_fmsg_item_fill_data(item, skb);
+                       break;
+               case DEVLINK_ATTR_FMSG_OBJ_NAME:
+                       err = nla_put_string(skb, item->attrtype,
+                                            (char *) &item->value);
+                       break;
+               default:
+                       err = -EINVAL;
+                       break;
+               }
+               if (!err)
+                       *start = ++i;
+               else
+                       break;
+       }
+
+       nla_nest_end(skb, fmsg_nlattr);
+       return err;
+}
+
+static int devlink_fmsg_snd(struct devlink_fmsg *fmsg,
+                           struct genl_info *info,
+                           enum devlink_command cmd, int flags)
+{
+       struct nlmsghdr *nlh;
+       struct sk_buff *skb;
+       bool last = false;
+       int index = 0;
+       void *hdr;
+       int err;
+
+       while (!last) {
+               int tmp_index = index;
+
+               skb = genlmsg_new(GENLMSG_DEFAULT_SIZE, GFP_KERNEL);
+               if (!skb)
+                       return -ENOMEM;
+
+               hdr = genlmsg_put(skb, info->snd_portid, info->snd_seq,
+                                 &devlink_nl_family, flags | NLM_F_MULTI, cmd);
+               if (!hdr) {
+                       err = -EMSGSIZE;
+                       goto nla_put_failure;
+               }
+
+               err = devlink_fmsg_prepare_skb(fmsg, skb, &index);
+               if (!err)
+                       last = true;
+               else if (err != -EMSGSIZE || tmp_index == index)
+                       goto nla_put_failure;
+
+               genlmsg_end(skb, hdr);
+               err = genlmsg_reply(skb, info);
+               if (err)
+                       return err;
+       }
+
+       skb = genlmsg_new(GENLMSG_DEFAULT_SIZE, GFP_KERNEL);
+       if (!skb)
+               return -ENOMEM;
+       nlh = nlmsg_put(skb, info->snd_portid, info->snd_seq,
+                       NLMSG_DONE, 0, flags | NLM_F_MULTI);
+       if (!nlh) {
+               err = -EMSGSIZE;
+               goto nla_put_failure;
+       }
+       err = genlmsg_reply(skb, info);
+       if (err)
+               return err;
+
+       return 0;
+
+nla_put_failure:
+       nlmsg_free(skb);
+       return err;
+}
+
 static const struct nla_policy devlink_nl_policy[DEVLINK_ATTR_MAX + 1] = {
        [DEVLINK_ATTR_BUS_NAME] = { .type = NLA_NUL_STRING },
        [DEVLINK_ATTR_DEV_NAME] = { .type = NLA_NUL_STRING },