netconsole: Dynamic allocation of userdata buffer

The userdata buffer in struct netconsole_target is currently statically
allocated with a size of MAX_USERDATA_ITEMS * MAX_EXTRADATA_ENTRY_LEN
(16 * 256 = 4096 bytes). This wastes memory when userdata entries are
not used or when only a few entries are configured, which is common in
typical usage scenarios. It also forces us to keep MAX_USERDATA_ITEMS
small to limit the memory wasted.

Change the userdata buffer from a static array to a dynamically
allocated pointer. The buffer is now allocated on-demand in
update_userdata() whenever userdata entries are added, modified, or
removed via configfs. The implementation calculates the exact size
needed for all current userdata entries, allocates a new buffer of that
size, formats the entries into it, and atomically swaps it with the old
buffer.

This approach provides several benefits:
- Memory efficiency: Targets with no userdata use zero bytes instead of
  4KB, and targets with userdata only allocate what they need;
- Scalability: Makes it practical to increase MAX_USERDATA_ITEMS to a
  much larger value without imposing a fixed memory cost on every
  target;
- No hot-path overhead: Allocation occurs during configuration (write to
  configfs), not during message transmission

If memory allocation fails during userdata update, -ENOMEM is returned
to userspace through the configfs attribute write operation.

The sysdata buffer remains statically allocated since it has a smaller
fixed size (MAX_SYSDATA_ITEMS * MAX_EXTRADATA_ENTRY_LEN = 4 * 256 = 1024
bytes) and its content length is less predictable.

Signed-off-by: Gustavo Luiz Duarte <gustavold@gmail.com>
Reviewed-by: Breno Leitao <leitao@debian.org>
Link: https://patch.msgid.link/20251119-netconsole_dynamic_extradata-v3-3-497ac3191707@meta.com
Signed-off-by: Jakub Kicinski <kuba@kernel.org>

diff --git a/drivers/net/netconsole.c b/drivers/net/netconsole.c
index 1bd811714322003e3d70060f93b1b2ccaeba2b3d..0b350f82d91560840dfbbf97fcef3455b431cd7b 100644 (file)
--- a/drivers/net/netconsole.c
+++ b/drivers/net/netconsole.c
@@ -155,7 +155,7 @@ struct netconsole_target {
 #ifdef CONFIG_NETCONSOLE_DYNAMIC
        struct config_group     group;
        struct config_group     userdata_group;
-       char                    userdata[MAX_EXTRADATA_ENTRY_LEN * MAX_USERDATA_ITEMS];
+       char                    *userdata;
        size_t                  userdata_length;
        char                    sysdata[MAX_EXTRADATA_ENTRY_LEN * MAX_SYSDATA_ITEMS];
 
@@ -875,45 +875,77 @@ static ssize_t userdatum_value_show(struct config_item *item, char *buf)
        return sysfs_emit(buf, "%s\n", &(to_userdatum(item)->value[0]));
 }
 
-static void update_userdata(struct netconsole_target *nt)
+/* Navigate configfs and calculate the lentgh of the formatted string
+ * representing userdata.
+ * Must be called holding netconsole_subsys.su_mutex
+ */
+static int calc_userdata_len(struct netconsole_target *nt)
 {
+       struct userdatum *udm_item;
+       struct config_item *item;
        struct list_head *entry;
-       int child_count = 0;
-       unsigned long flags;
+       int len = 0;
 
-       spin_lock_irqsave(&target_list_lock, flags);
+       list_for_each(entry, &nt->userdata_group.cg_children) {
+               item = container_of(entry, struct config_item, ci_entry);
+               udm_item = to_userdatum(item);
+               /* Skip userdata with no value set */
+               if (udm_item->value[0]) {
+                       len += snprintf(NULL, 0, " %s=%s\n", item->ci_name,
+                                       udm_item->value);
+               }
+       }
+       return len;
+}
 
-       /* Clear the current string in case the last userdatum was deleted */
-       nt->userdata_length = 0;
-       nt->userdata[0] = 0;
+static int update_userdata(struct netconsole_target *nt)
+{
+       struct userdatum *udm_item;
+       struct config_item *item;
+       struct list_head *entry;
+       char *old_buf = NULL;
+       char *new_buf = NULL;
+       unsigned long flags;
+       int offset = 0;
+       int len;
 
-       list_for_each(entry, &nt->userdata_group.cg_children) {
-               struct userdatum *udm_item;
-               struct config_item *item;
+       /* Calculate required buffer size */
+       len = calc_userdata_len(nt);
 
-               if (child_count >= MAX_USERDATA_ITEMS) {
-                       spin_unlock_irqrestore(&target_list_lock, flags);
-                       WARN_ON_ONCE(1);
-                       return;
-               }
-               child_count++;
+       if (WARN_ON_ONCE(len > MAX_EXTRADATA_ENTRY_LEN * MAX_USERDATA_ITEMS))
+               return -ENOSPC;
+
+       /* Allocate new buffer */
+       if (len) {
+               new_buf = kmalloc(len + 1, GFP_KERNEL);
+               if (!new_buf)
+                       return -ENOMEM;
+       }
 
+       /* Write userdata to new buffer */
+       list_for_each(entry, &nt->userdata_group.cg_children) {
                item = container_of(entry, struct config_item, ci_entry);
                udm_item = to_userdatum(item);
-
                /* Skip userdata with no value set */
-               if (strnlen(udm_item->value, MAX_EXTRADATA_VALUE_LEN) == 0)
-                       continue;
-
-               /* This doesn't overflow userdata since it will write
-                * one entry length (1/MAX_USERDATA_ITEMS long), entry count is
-                * checked to not exceed MAX items with child_count above
-                */
-               nt->userdata_length += scnprintf(&nt->userdata[nt->userdata_length],
-                                                MAX_EXTRADATA_ENTRY_LEN, " %s=%s\n",
-                                                item->ci_name, udm_item->value);
+               if (udm_item->value[0]) {
+                       offset += scnprintf(&new_buf[offset], len + 1 - offset,
+                                           " %s=%s\n", item->ci_name,
+                                           udm_item->value);
+               }
        }
+
+       WARN_ON_ONCE(offset != len);
+
+       /* Switch to new buffer and free old buffer */
+       spin_lock_irqsave(&target_list_lock, flags);
+       old_buf = nt->userdata;
+       nt->userdata = new_buf;
+       nt->userdata_length = offset;
        spin_unlock_irqrestore(&target_list_lock, flags);
+
+       kfree(old_buf);
+
+       return 0;
 }
 
 static ssize_t userdatum_value_store(struct config_item *item, const char *buf,
@@ -937,7 +969,9 @@ static ssize_t userdatum_value_store(struct config_item *item, const char *buf,
 
        ud = to_userdata(item->ci_parent);
        nt = userdata_to_target(ud);
-       update_userdata(nt);
+       ret = update_userdata(nt);
+       if (ret < 0)
+               goto out_unlock;
        ret = count;
 out_unlock:
        mutex_unlock(&dynamic_netconsole_mutex);
@@ -1193,7 +1227,10 @@ static struct configfs_attribute *netconsole_target_attrs[] = {
 
 static void netconsole_target_release(struct config_item *item)
 {
-       kfree(to_target(item));
+       struct netconsole_target *nt = to_target(item);
+
+       kfree(nt->userdata);
+       kfree(nt);
 }
 
 static struct configfs_item_operations netconsole_target_item_ops = {
@@ -1874,6 +1911,9 @@ fail:
 static void free_param_target(struct netconsole_target *nt)
 {
        netpoll_cleanup(&nt->np);
+#ifdef CONFIG_NETCONSOLE_DYNAMIC
+       kfree(nt->userdata);
+#endif
        kfree(nt);
 }