Thomas Gleixner | de6cc65 | 2019-05-27 08:55:02 +0200 | [diff] [blame] | 1 | // SPDX-License-Identifier: GPL-2.0-or-later |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2 | /* |
| 3 | * linux/drivers/net/netconsole.c |
| 4 | * |
| 5 | * Copyright (C) 2001 Ingo Molnar <mingo@redhat.com> |
| 6 | * |
| 7 | * This file contains the implementation of an IRQ-safe, crash-safe |
| 8 | * kernel console implementation that outputs kernel messages to the |
| 9 | * network. |
| 10 | * |
| 11 | * Modification history: |
| 12 | * |
| 13 | * 2001-09-17 started by Ingo Molnar. |
| 14 | * 2003-08-11 2.6 port by Matt Mackall |
| 15 | * simplified options |
| 16 | * generic card hooks |
| 17 | * works non-modular |
| 18 | * 2003-09-07 rewritten with netpoll api |
| 19 | */ |
| 20 | |
| 21 | /**************************************************************** |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 22 | * |
| 23 | ****************************************************************/ |
| 24 | |
Joe Perches | 22ded57 | 2013-10-28 12:53:21 -0700 | [diff] [blame] | 25 | #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt |
| 26 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 27 | #include <linux/mm.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 28 | #include <linux/init.h> |
| 29 | #include <linux/module.h> |
Tejun Heo | 5a0e3ad | 2010-03-24 17:04:11 +0900 | [diff] [blame] | 30 | #include <linux/slab.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 31 | #include <linux/console.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 32 | #include <linux/moduleparam.h> |
Andy Shevchenko | 4cd5773 | 2013-06-04 19:46:26 +0300 | [diff] [blame] | 33 | #include <linux/kernel.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 34 | #include <linux/string.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 35 | #include <linux/netpoll.h> |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 36 | #include <linux/inet.h> |
| 37 | #include <linux/configfs.h> |
Joe Perches | 1667c94 | 2015-03-02 19:54:50 -0800 | [diff] [blame] | 38 | #include <linux/etherdevice.h> |
Breno Leitao | c62c0a1 | 2023-07-14 04:13:29 -0700 | [diff] [blame] | 39 | #include <linux/utsname.h> |
Breno Leitao | 9771469 | 2024-08-08 05:25:11 -0700 | [diff] [blame] | 40 | #include <linux/rtnetlink.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 41 | |
Breno Leitao | 10a6545 | 2024-08-02 01:07:23 -0700 | [diff] [blame] | 42 | MODULE_AUTHOR("Matt Mackall <mpm@selenic.com>"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 43 | MODULE_DESCRIPTION("Console driver for network interfaces"); |
| 44 | MODULE_LICENSE("GPL"); |
| 45 | |
Matthew Wood | 2b395358 | 2024-03-07 16:25:24 -0800 | [diff] [blame] | 46 | #define MAX_PARAM_LENGTH 256 |
Matthew Wood | 8a6d5fe | 2024-02-04 15:27:36 -0800 | [diff] [blame] | 47 | #define MAX_USERDATA_ENTRY_LENGTH 256 |
Matthew Wood | 2b395358 | 2024-03-07 16:25:24 -0800 | [diff] [blame] | 48 | #define MAX_USERDATA_VALUE_LENGTH 200 |
| 49 | /* The number 3 comes from userdata entry format characters (' ', '=', '\n') */ |
| 50 | #define MAX_USERDATA_NAME_LENGTH (MAX_USERDATA_ENTRY_LENGTH - \ |
| 51 | MAX_USERDATA_VALUE_LENGTH - 3) |
Matthew Wood | 8a6d5fe | 2024-02-04 15:27:36 -0800 | [diff] [blame] | 52 | #define MAX_USERDATA_ITEMS 16 |
Matthew Wood | 2b395358 | 2024-03-07 16:25:24 -0800 | [diff] [blame] | 53 | #define MAX_PRINT_CHUNK 1000 |
Satyam Sharma | d39badf | 2007-08-10 15:27:24 -0700 | [diff] [blame] | 54 | |
| 55 | static char config[MAX_PARAM_LENGTH]; |
| 56 | module_param_string(netconsole, config, MAX_PARAM_LENGTH, 0); |
Niels de Vos | 61a2d07 | 2008-07-31 00:07:23 -0700 | [diff] [blame] | 57 | MODULE_PARM_DESC(netconsole, " netconsole=[src-port]@[src-ip]/[dev],[tgt-port]@<tgt-ip>/[tgt-macaddr]"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 58 | |
Matthew Wood | 602ad3b | 2024-02-04 15:27:32 -0800 | [diff] [blame] | 59 | static bool oops_only; |
Amerigo Wang | c1a60851 | 2012-11-08 03:42:38 +0000 | [diff] [blame] | 60 | module_param(oops_only, bool, 0600); |
| 61 | MODULE_PARM_DESC(oops_only, "Only log oops messages"); |
| 62 | |
Breno Leitao | 131eeb4 | 2023-10-12 04:13:59 -0700 | [diff] [blame] | 63 | #define NETCONSOLE_PARAM_TARGET_PREFIX "cmdline" |
| 64 | |
Satyam Sharma | d2b6088 | 2007-08-10 15:29:47 -0700 | [diff] [blame] | 65 | #ifndef MODULE |
| 66 | static int __init option_setup(char *opt) |
| 67 | { |
Wolfram Sang | fb3ceec | 2022-08-30 22:14:52 +0200 | [diff] [blame] | 68 | strscpy(config, opt, MAX_PARAM_LENGTH); |
Satyam Sharma | d2b6088 | 2007-08-10 15:29:47 -0700 | [diff] [blame] | 69 | return 1; |
| 70 | } |
| 71 | __setup("netconsole=", option_setup); |
| 72 | #endif /* MODULE */ |
| 73 | |
Satyam Sharma | b5427c2 | 2007-08-10 15:33:40 -0700 | [diff] [blame] | 74 | /* Linked list of all configured targets */ |
| 75 | static LIST_HEAD(target_list); |
Breno Leitao | 9771469 | 2024-08-08 05:25:11 -0700 | [diff] [blame] | 76 | /* target_cleanup_list is used to track targets that need to be cleaned outside |
| 77 | * of target_list_lock. It should be cleaned in the same function it is |
| 78 | * populated. |
| 79 | */ |
| 80 | static LIST_HEAD(target_cleanup_list); |
Satyam Sharma | b5427c2 | 2007-08-10 15:33:40 -0700 | [diff] [blame] | 81 | |
| 82 | /* This needs to be a spinlock because write_msg() cannot sleep */ |
| 83 | static DEFINE_SPINLOCK(target_list_lock); |
Breno Leitao | 9771469 | 2024-08-08 05:25:11 -0700 | [diff] [blame] | 84 | /* This needs to be a mutex because netpoll_cleanup might sleep */ |
| 85 | static DEFINE_MUTEX(target_cleanup_list_lock); |
Satyam Sharma | b5427c2 | 2007-08-10 15:33:40 -0700 | [diff] [blame] | 86 | |
Tejun Heo | e2f15f9 | 2015-06-25 15:01:41 -0700 | [diff] [blame] | 87 | /* |
| 88 | * Console driver for extended netconsoles. Registered on the first use to |
| 89 | * avoid unnecessarily enabling ext message formatting. |
| 90 | */ |
| 91 | static struct console netconsole_ext; |
| 92 | |
Satyam Sharma | df180e3 | 2007-08-10 15:32:14 -0700 | [diff] [blame] | 93 | /** |
| 94 | * struct netconsole_target - Represents a configured netconsole target. |
Satyam Sharma | b5427c2 | 2007-08-10 15:33:40 -0700 | [diff] [blame] | 95 | * @list: Links this target into the target_list. |
Matthew Wood | bd9c69a | 2024-02-04 15:27:33 -0800 | [diff] [blame] | 96 | * @group: Links us into the configfs subsystem hierarchy. |
Matthew Wood | 8a6d5fe | 2024-02-04 15:27:36 -0800 | [diff] [blame] | 97 | * @userdata_group: Links to the userdata configfs hierarchy |
Matthew Wood | df03f83 | 2024-02-04 15:27:37 -0800 | [diff] [blame] | 98 | * @userdata_complete: Cached, formatted string of append |
| 99 | * @userdata_length: String length of userdata_complete |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 100 | * @enabled: On / off knob to enable / disable target. |
| 101 | * Visible from userspace (read-write). |
| 102 | * We maintain a strict 1:1 correspondence between this and |
| 103 | * whether the corresponding netpoll is active or inactive. |
| 104 | * Also, other parameters of a target may be modified at |
| 105 | * runtime only when it is disabled (enabled == 0). |
Lee Jones | a8eb1a0 | 2020-11-02 11:45:10 +0000 | [diff] [blame] | 106 | * @extended: Denotes whether console is extended or not. |
Breno Leitao | c62c0a1 | 2023-07-14 04:13:29 -0700 | [diff] [blame] | 107 | * @release: Denotes whether kernel release version should be prepended |
| 108 | * to the message. Depends on extended console. |
Satyam Sharma | df180e3 | 2007-08-10 15:32:14 -0700 | [diff] [blame] | 109 | * @np: The netpoll structure for this target. |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 110 | * Contains the other userspace visible parameters: |
| 111 | * dev_name (read-write) |
| 112 | * local_port (read-write) |
| 113 | * remote_port (read-write) |
| 114 | * local_ip (read-write) |
| 115 | * remote_ip (read-write) |
| 116 | * local_mac (read-only) |
| 117 | * remote_mac (read-write) |
Satyam Sharma | df180e3 | 2007-08-10 15:32:14 -0700 | [diff] [blame] | 118 | */ |
| 119 | struct netconsole_target { |
Satyam Sharma | b5427c2 | 2007-08-10 15:33:40 -0700 | [diff] [blame] | 120 | struct list_head list; |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 121 | #ifdef CONFIG_NETCONSOLE_DYNAMIC |
Matthew Wood | bd9c69a | 2024-02-04 15:27:33 -0800 | [diff] [blame] | 122 | struct config_group group; |
Matthew Wood | 8a6d5fe | 2024-02-04 15:27:36 -0800 | [diff] [blame] | 123 | struct config_group userdata_group; |
Matthew Wood | df03f83 | 2024-02-04 15:27:37 -0800 | [diff] [blame] | 124 | char userdata_complete[MAX_USERDATA_ENTRY_LENGTH * MAX_USERDATA_ITEMS]; |
| 125 | size_t userdata_length; |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 126 | #endif |
Tejun Heo | 698cf1c | 2015-06-25 15:01:36 -0700 | [diff] [blame] | 127 | bool enabled; |
Tejun Heo | e2f15f9 | 2015-06-25 15:01:41 -0700 | [diff] [blame] | 128 | bool extended; |
Breno Leitao | c62c0a1 | 2023-07-14 04:13:29 -0700 | [diff] [blame] | 129 | bool release; |
Satyam Sharma | df180e3 | 2007-08-10 15:32:14 -0700 | [diff] [blame] | 130 | struct netpoll np; |
| 131 | }; |
| 132 | |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 133 | #ifdef CONFIG_NETCONSOLE_DYNAMIC |
| 134 | |
| 135 | static struct configfs_subsystem netconsole_subsys; |
Tejun Heo | 369e5a8 | 2015-06-25 15:01:38 -0700 | [diff] [blame] | 136 | static DEFINE_MUTEX(dynamic_netconsole_mutex); |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 137 | |
| 138 | static int __init dynamic_netconsole_init(void) |
| 139 | { |
| 140 | config_group_init(&netconsole_subsys.su_group); |
| 141 | mutex_init(&netconsole_subsys.su_mutex); |
| 142 | return configfs_register_subsystem(&netconsole_subsys); |
| 143 | } |
| 144 | |
| 145 | static void __exit dynamic_netconsole_exit(void) |
| 146 | { |
| 147 | configfs_unregister_subsystem(&netconsole_subsys); |
| 148 | } |
| 149 | |
| 150 | /* |
| 151 | * Targets that were created by parsing the boot/module option string |
| 152 | * do not exist in the configfs hierarchy (and have NULL names) and will |
| 153 | * never go away, so make these a no-op for them. |
| 154 | */ |
| 155 | static void netconsole_target_get(struct netconsole_target *nt) |
| 156 | { |
Matthew Wood | bd9c69a | 2024-02-04 15:27:33 -0800 | [diff] [blame] | 157 | if (config_item_name(&nt->group.cg_item)) |
| 158 | config_group_get(&nt->group); |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 159 | } |
| 160 | |
| 161 | static void netconsole_target_put(struct netconsole_target *nt) |
| 162 | { |
Matthew Wood | bd9c69a | 2024-02-04 15:27:33 -0800 | [diff] [blame] | 163 | if (config_item_name(&nt->group.cg_item)) |
| 164 | config_group_put(&nt->group); |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 165 | } |
| 166 | |
| 167 | #else /* !CONFIG_NETCONSOLE_DYNAMIC */ |
| 168 | |
| 169 | static int __init dynamic_netconsole_init(void) |
| 170 | { |
| 171 | return 0; |
| 172 | } |
| 173 | |
| 174 | static void __exit dynamic_netconsole_exit(void) |
| 175 | { |
| 176 | } |
| 177 | |
| 178 | /* |
| 179 | * No danger of targets going away from under us when dynamic |
| 180 | * reconfigurability is off. |
| 181 | */ |
| 182 | static void netconsole_target_get(struct netconsole_target *nt) |
| 183 | { |
| 184 | } |
| 185 | |
| 186 | static void netconsole_target_put(struct netconsole_target *nt) |
| 187 | { |
| 188 | } |
| 189 | |
Breno Leitao | 131eeb4 | 2023-10-12 04:13:59 -0700 | [diff] [blame] | 190 | static void populate_configfs_item(struct netconsole_target *nt, |
| 191 | int cmdline_count) |
| 192 | { |
| 193 | } |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 194 | #endif /* CONFIG_NETCONSOLE_DYNAMIC */ |
| 195 | |
Breno Leitao | b0a9e2c | 2023-08-11 02:31:57 -0700 | [diff] [blame] | 196 | /* Allocate and initialize with defaults. |
| 197 | * Note that these targets get their config_item fields zeroed-out. |
| 198 | */ |
| 199 | static struct netconsole_target *alloc_and_init(void) |
Satyam Sharma | b5427c2 | 2007-08-10 15:33:40 -0700 | [diff] [blame] | 200 | { |
Satyam Sharma | b5427c2 | 2007-08-10 15:33:40 -0700 | [diff] [blame] | 201 | struct netconsole_target *nt; |
| 202 | |
Satyam Sharma | b5427c2 | 2007-08-10 15:33:40 -0700 | [diff] [blame] | 203 | nt = kzalloc(sizeof(*nt), GFP_KERNEL); |
Joe Perches | e404dec | 2012-01-29 12:56:23 +0000 | [diff] [blame] | 204 | if (!nt) |
Breno Leitao | b0a9e2c | 2023-08-11 02:31:57 -0700 | [diff] [blame] | 205 | return nt; |
Satyam Sharma | b5427c2 | 2007-08-10 15:33:40 -0700 | [diff] [blame] | 206 | |
Breno Leitao | fad361a | 2023-08-11 02:31:58 -0700 | [diff] [blame] | 207 | if (IS_ENABLED(CONFIG_NETCONSOLE_EXTENDED_LOG)) |
| 208 | nt->extended = true; |
| 209 | if (IS_ENABLED(CONFIG_NETCONSOLE_PREPEND_RELEASE)) |
| 210 | nt->release = true; |
| 211 | |
Satyam Sharma | b5427c2 | 2007-08-10 15:33:40 -0700 | [diff] [blame] | 212 | nt->np.name = "netconsole"; |
Wolfram Sang | fb3ceec | 2022-08-30 22:14:52 +0200 | [diff] [blame] | 213 | strscpy(nt->np.dev_name, "eth0", IFNAMSIZ); |
Satyam Sharma | b5427c2 | 2007-08-10 15:33:40 -0700 | [diff] [blame] | 214 | nt->np.local_port = 6665; |
| 215 | nt->np.remote_port = 6666; |
Joe Perches | 1667c94 | 2015-03-02 19:54:50 -0800 | [diff] [blame] | 216 | eth_broadcast_addr(nt->np.remote_mac); |
Satyam Sharma | b5427c2 | 2007-08-10 15:33:40 -0700 | [diff] [blame] | 217 | |
Breno Leitao | b0a9e2c | 2023-08-11 02:31:57 -0700 | [diff] [blame] | 218 | return nt; |
| 219 | } |
| 220 | |
Breno Leitao | 9771469 | 2024-08-08 05:25:11 -0700 | [diff] [blame] | 221 | /* Clean up every target in the cleanup_list and move the clean targets back to |
| 222 | * the main target_list. |
| 223 | */ |
| 224 | static void netconsole_process_cleanups_core(void) |
| 225 | { |
| 226 | struct netconsole_target *nt, *tmp; |
| 227 | unsigned long flags; |
| 228 | |
| 229 | /* The cleanup needs RTNL locked */ |
| 230 | ASSERT_RTNL(); |
| 231 | |
| 232 | mutex_lock(&target_cleanup_list_lock); |
| 233 | list_for_each_entry_safe(nt, tmp, &target_cleanup_list, list) { |
| 234 | /* all entries in the cleanup_list needs to be disabled */ |
| 235 | WARN_ON_ONCE(nt->enabled); |
| 236 | do_netpoll_cleanup(&nt->np); |
| 237 | /* moved the cleaned target to target_list. Need to hold both |
| 238 | * locks |
| 239 | */ |
| 240 | spin_lock_irqsave(&target_list_lock, flags); |
| 241 | list_move(&nt->list, &target_list); |
| 242 | spin_unlock_irqrestore(&target_list_lock, flags); |
| 243 | } |
| 244 | WARN_ON_ONCE(!list_empty(&target_cleanup_list)); |
| 245 | mutex_unlock(&target_cleanup_list_lock); |
| 246 | } |
| 247 | |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 248 | #ifdef CONFIG_NETCONSOLE_DYNAMIC |
| 249 | |
| 250 | /* |
| 251 | * Our subsystem hierarchy is: |
| 252 | * |
| 253 | * /sys/kernel/config/netconsole/ |
| 254 | * | |
| 255 | * <target>/ |
| 256 | * | enabled |
Breno Leitao | c62c0a1 | 2023-07-14 04:13:29 -0700 | [diff] [blame] | 257 | * | release |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 258 | * | dev_name |
| 259 | * | local_port |
| 260 | * | remote_port |
| 261 | * | local_ip |
| 262 | * | remote_ip |
| 263 | * | local_mac |
| 264 | * | remote_mac |
Matthew Wood | 8a6d5fe | 2024-02-04 15:27:36 -0800 | [diff] [blame] | 265 | * | userdata/ |
| 266 | * | <key>/ |
| 267 | * | value |
| 268 | * | ... |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 269 | * | |
| 270 | * <target>/... |
| 271 | */ |
| 272 | |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 273 | static struct netconsole_target *to_target(struct config_item *item) |
| 274 | { |
Matthew Wood | bd9c69a | 2024-02-04 15:27:33 -0800 | [diff] [blame] | 275 | struct config_group *cfg_group; |
| 276 | |
| 277 | cfg_group = to_config_group(item); |
| 278 | if (!cfg_group) |
| 279 | return NULL; |
| 280 | return container_of(to_config_group(item), |
| 281 | struct netconsole_target, group); |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 282 | } |
| 283 | |
Breno Leitao | 9771469 | 2024-08-08 05:25:11 -0700 | [diff] [blame] | 284 | /* Do the list cleanup with the rtnl lock hold. rtnl lock is necessary because |
| 285 | * netdev might be cleaned-up by calling __netpoll_cleanup(), |
| 286 | */ |
| 287 | static void netconsole_process_cleanups(void) |
| 288 | { |
| 289 | /* rtnl lock is called here, because it has precedence over |
| 290 | * target_cleanup_list_lock mutex and target_cleanup_list |
| 291 | */ |
| 292 | rtnl_lock(); |
| 293 | netconsole_process_cleanups_core(); |
| 294 | rtnl_unlock(); |
| 295 | } |
| 296 | |
Matthew Wood | ae001dc | 2024-02-04 15:27:34 -0800 | [diff] [blame] | 297 | /* Get rid of possible trailing newline, returning the new length */ |
| 298 | static void trim_newline(char *s, size_t maxlen) |
| 299 | { |
| 300 | size_t len; |
| 301 | |
| 302 | len = strnlen(s, maxlen); |
| 303 | if (s[len - 1] == '\n') |
| 304 | s[len - 1] = '\0'; |
| 305 | } |
| 306 | |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 307 | /* |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 308 | * Attribute operations for netconsole_target. |
| 309 | */ |
| 310 | |
Christoph Hellwig | ea9ed9c | 2015-10-03 15:32:56 +0200 | [diff] [blame] | 311 | static ssize_t enabled_show(struct config_item *item, char *buf) |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 312 | { |
Breno Leitao | 9f64b6e | 2023-07-21 02:21:44 -0700 | [diff] [blame] | 313 | return sysfs_emit(buf, "%d\n", to_target(item)->enabled); |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 314 | } |
| 315 | |
Christoph Hellwig | ea9ed9c | 2015-10-03 15:32:56 +0200 | [diff] [blame] | 316 | static ssize_t extended_show(struct config_item *item, char *buf) |
Tejun Heo | e2f15f9 | 2015-06-25 15:01:41 -0700 | [diff] [blame] | 317 | { |
Breno Leitao | 9f64b6e | 2023-07-21 02:21:44 -0700 | [diff] [blame] | 318 | return sysfs_emit(buf, "%d\n", to_target(item)->extended); |
Tejun Heo | e2f15f9 | 2015-06-25 15:01:41 -0700 | [diff] [blame] | 319 | } |
| 320 | |
Breno Leitao | c62c0a1 | 2023-07-14 04:13:29 -0700 | [diff] [blame] | 321 | static ssize_t release_show(struct config_item *item, char *buf) |
| 322 | { |
Breno Leitao | 9f64b6e | 2023-07-21 02:21:44 -0700 | [diff] [blame] | 323 | return sysfs_emit(buf, "%d\n", to_target(item)->release); |
Breno Leitao | c62c0a1 | 2023-07-14 04:13:29 -0700 | [diff] [blame] | 324 | } |
| 325 | |
Christoph Hellwig | ea9ed9c | 2015-10-03 15:32:56 +0200 | [diff] [blame] | 326 | static ssize_t dev_name_show(struct config_item *item, char *buf) |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 327 | { |
Breno Leitao | 9f64b6e | 2023-07-21 02:21:44 -0700 | [diff] [blame] | 328 | return sysfs_emit(buf, "%s\n", to_target(item)->np.dev_name); |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 329 | } |
| 330 | |
Christoph Hellwig | ea9ed9c | 2015-10-03 15:32:56 +0200 | [diff] [blame] | 331 | static ssize_t local_port_show(struct config_item *item, char *buf) |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 332 | { |
Breno Leitao | 9f64b6e | 2023-07-21 02:21:44 -0700 | [diff] [blame] | 333 | return sysfs_emit(buf, "%d\n", to_target(item)->np.local_port); |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 334 | } |
| 335 | |
Christoph Hellwig | ea9ed9c | 2015-10-03 15:32:56 +0200 | [diff] [blame] | 336 | static ssize_t remote_port_show(struct config_item *item, char *buf) |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 337 | { |
Breno Leitao | 9f64b6e | 2023-07-21 02:21:44 -0700 | [diff] [blame] | 338 | return sysfs_emit(buf, "%d\n", to_target(item)->np.remote_port); |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 339 | } |
| 340 | |
Christoph Hellwig | ea9ed9c | 2015-10-03 15:32:56 +0200 | [diff] [blame] | 341 | static ssize_t local_ip_show(struct config_item *item, char *buf) |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 342 | { |
Christoph Hellwig | ea9ed9c | 2015-10-03 15:32:56 +0200 | [diff] [blame] | 343 | struct netconsole_target *nt = to_target(item); |
| 344 | |
Cong Wang | b3d936f3 | 2013-01-07 20:52:41 +0000 | [diff] [blame] | 345 | if (nt->np.ipv6) |
Breno Leitao | 9f64b6e | 2023-07-21 02:21:44 -0700 | [diff] [blame] | 346 | return sysfs_emit(buf, "%pI6c\n", &nt->np.local_ip.in6); |
Cong Wang | b3d936f3 | 2013-01-07 20:52:41 +0000 | [diff] [blame] | 347 | else |
Breno Leitao | 9f64b6e | 2023-07-21 02:21:44 -0700 | [diff] [blame] | 348 | return sysfs_emit(buf, "%pI4\n", &nt->np.local_ip); |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 349 | } |
| 350 | |
Christoph Hellwig | ea9ed9c | 2015-10-03 15:32:56 +0200 | [diff] [blame] | 351 | static ssize_t remote_ip_show(struct config_item *item, char *buf) |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 352 | { |
Christoph Hellwig | ea9ed9c | 2015-10-03 15:32:56 +0200 | [diff] [blame] | 353 | struct netconsole_target *nt = to_target(item); |
| 354 | |
Cong Wang | b3d936f3 | 2013-01-07 20:52:41 +0000 | [diff] [blame] | 355 | if (nt->np.ipv6) |
Breno Leitao | 9f64b6e | 2023-07-21 02:21:44 -0700 | [diff] [blame] | 356 | return sysfs_emit(buf, "%pI6c\n", &nt->np.remote_ip.in6); |
Cong Wang | b3d936f3 | 2013-01-07 20:52:41 +0000 | [diff] [blame] | 357 | else |
Breno Leitao | 9f64b6e | 2023-07-21 02:21:44 -0700 | [diff] [blame] | 358 | return sysfs_emit(buf, "%pI4\n", &nt->np.remote_ip); |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 359 | } |
| 360 | |
Christoph Hellwig | ea9ed9c | 2015-10-03 15:32:56 +0200 | [diff] [blame] | 361 | static ssize_t local_mac_show(struct config_item *item, char *buf) |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 362 | { |
Christoph Hellwig | ea9ed9c | 2015-10-03 15:32:56 +0200 | [diff] [blame] | 363 | struct net_device *dev = to_target(item)->np.dev; |
Johannes Berg | e174961 | 2008-10-27 15:59:26 -0700 | [diff] [blame] | 364 | static const u8 bcast[ETH_ALEN] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }; |
Stephen Hemminger | 0953864 | 2007-11-19 19:23:29 -0800 | [diff] [blame] | 365 | |
Breno Leitao | 9f64b6e | 2023-07-21 02:21:44 -0700 | [diff] [blame] | 366 | return sysfs_emit(buf, "%pM\n", dev ? dev->dev_addr : bcast); |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 367 | } |
| 368 | |
Christoph Hellwig | ea9ed9c | 2015-10-03 15:32:56 +0200 | [diff] [blame] | 369 | static ssize_t remote_mac_show(struct config_item *item, char *buf) |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 370 | { |
Breno Leitao | 9f64b6e | 2023-07-21 02:21:44 -0700 | [diff] [blame] | 371 | return sysfs_emit(buf, "%pM\n", to_target(item)->np.remote_mac); |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 372 | } |
| 373 | |
| 374 | /* |
| 375 | * This one is special -- targets created through the configfs interface |
| 376 | * are not enabled (and the corresponding netpoll activated) by default. |
| 377 | * The user is expected to set the desired parameters first (which |
| 378 | * would enable him to dynamically add new netpoll targets for new |
| 379 | * network interfaces as and when they come up). |
| 380 | */ |
Christoph Hellwig | ea9ed9c | 2015-10-03 15:32:56 +0200 | [diff] [blame] | 381 | static ssize_t enabled_store(struct config_item *item, |
| 382 | const char *buf, size_t count) |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 383 | { |
Christoph Hellwig | ea9ed9c | 2015-10-03 15:32:56 +0200 | [diff] [blame] | 384 | struct netconsole_target *nt = to_target(item); |
Nikolay Aleksandrov | 45e526e | 2013-10-23 15:04:49 +0200 | [diff] [blame] | 385 | unsigned long flags; |
Breno Leitao | 004a04b | 2023-07-21 02:21:45 -0700 | [diff] [blame] | 386 | bool enabled; |
Breno Leitao | 5c4a39e | 2024-08-08 05:25:09 -0700 | [diff] [blame] | 387 | ssize_t ret; |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 388 | |
Christoph Hellwig | ea9ed9c | 2015-10-03 15:32:56 +0200 | [diff] [blame] | 389 | mutex_lock(&dynamic_netconsole_mutex); |
Breno Leitao | 5c4a39e | 2024-08-08 05:25:09 -0700 | [diff] [blame] | 390 | ret = kstrtobool(buf, &enabled); |
| 391 | if (ret) |
Christoph Hellwig | ea9ed9c | 2015-10-03 15:32:56 +0200 | [diff] [blame] | 392 | goto out_unlock; |
| 393 | |
Breno Leitao | 5c4a39e | 2024-08-08 05:25:09 -0700 | [diff] [blame] | 394 | ret = -EINVAL; |
Breno Leitao | a9359e8 | 2024-07-09 07:43:59 -0700 | [diff] [blame] | 395 | if (enabled == nt->enabled) { |
Joe Perches | 22ded57 | 2013-10-28 12:53:21 -0700 | [diff] [blame] | 396 | pr_info("network logging has already %s\n", |
| 397 | nt->enabled ? "started" : "stopped"); |
Christoph Hellwig | ea9ed9c | 2015-10-03 15:32:56 +0200 | [diff] [blame] | 398 | goto out_unlock; |
Gao feng | d512348 | 2011-10-11 16:08:11 +0000 | [diff] [blame] | 399 | } |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 400 | |
Tejun Heo | 698cf1c | 2015-06-25 15:01:36 -0700 | [diff] [blame] | 401 | if (enabled) { /* true */ |
Breno Leitao | c62c0a1 | 2023-07-14 04:13:29 -0700 | [diff] [blame] | 402 | if (nt->release && !nt->extended) { |
| 403 | pr_err("Not enabling netconsole. Release feature requires extended log message"); |
| 404 | goto out_unlock; |
| 405 | } |
| 406 | |
John Ogness | 2c6b4b7 | 2022-11-16 17:27:43 +0106 | [diff] [blame] | 407 | if (nt->extended && !console_is_registered(&netconsole_ext)) |
Tejun Heo | e2f15f9 | 2015-06-25 15:01:41 -0700 | [diff] [blame] | 408 | register_console(&netconsole_ext); |
Tejun Heo | e2f15f9 | 2015-06-25 15:01:41 -0700 | [diff] [blame] | 409 | |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 410 | /* |
| 411 | * Skip netpoll_parse_options() -- all the attributes are |
| 412 | * already configured via configfs. Just print them out. |
| 413 | */ |
| 414 | netpoll_print_options(&nt->np); |
| 415 | |
Breno Leitao | 5c4a39e | 2024-08-08 05:25:09 -0700 | [diff] [blame] | 416 | ret = netpoll_setup(&nt->np); |
| 417 | if (ret) |
Christoph Hellwig | ea9ed9c | 2015-10-03 15:32:56 +0200 | [diff] [blame] | 418 | goto out_unlock; |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 419 | |
Breno Leitao | 0066623 | 2024-07-09 07:44:00 -0700 | [diff] [blame] | 420 | nt->enabled = true; |
Joe Perches | 4a6a97e | 2017-06-12 16:39:51 -0700 | [diff] [blame] | 421 | pr_info("network logging started\n"); |
Tejun Heo | 698cf1c | 2015-06-25 15:01:36 -0700 | [diff] [blame] | 422 | } else { /* false */ |
Nikolay Aleksandrov | 45e526e | 2013-10-23 15:04:49 +0200 | [diff] [blame] | 423 | /* We need to disable the netconsole before cleaning it up |
| 424 | * otherwise we might end up in write_msg() with |
Tejun Heo | 698cf1c | 2015-06-25 15:01:36 -0700 | [diff] [blame] | 425 | * nt->np.dev == NULL and nt->enabled == true |
Nikolay Aleksandrov | 45e526e | 2013-10-23 15:04:49 +0200 | [diff] [blame] | 426 | */ |
Breno Leitao | 9771469 | 2024-08-08 05:25:11 -0700 | [diff] [blame] | 427 | mutex_lock(&target_cleanup_list_lock); |
Nikolay Aleksandrov | 45e526e | 2013-10-23 15:04:49 +0200 | [diff] [blame] | 428 | spin_lock_irqsave(&target_list_lock, flags); |
Tejun Heo | 698cf1c | 2015-06-25 15:01:36 -0700 | [diff] [blame] | 429 | nt->enabled = false; |
Breno Leitao | 9771469 | 2024-08-08 05:25:11 -0700 | [diff] [blame] | 430 | /* Remove the target from the list, while holding |
| 431 | * target_list_lock |
| 432 | */ |
| 433 | list_move(&nt->list, &target_cleanup_list); |
Nikolay Aleksandrov | 45e526e | 2013-10-23 15:04:49 +0200 | [diff] [blame] | 434 | spin_unlock_irqrestore(&target_list_lock, flags); |
Breno Leitao | 9771469 | 2024-08-08 05:25:11 -0700 | [diff] [blame] | 435 | mutex_unlock(&target_cleanup_list_lock); |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 436 | } |
| 437 | |
Breno Leitao | f2ab4c1 | 2024-08-08 05:25:10 -0700 | [diff] [blame] | 438 | ret = strnlen(buf, count); |
Breno Leitao | 9771469 | 2024-08-08 05:25:11 -0700 | [diff] [blame] | 439 | /* Deferred cleanup */ |
| 440 | netconsole_process_cleanups(); |
Christoph Hellwig | ea9ed9c | 2015-10-03 15:32:56 +0200 | [diff] [blame] | 441 | out_unlock: |
| 442 | mutex_unlock(&dynamic_netconsole_mutex); |
Breno Leitao | 5c4a39e | 2024-08-08 05:25:09 -0700 | [diff] [blame] | 443 | return ret; |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 444 | } |
| 445 | |
Breno Leitao | c62c0a1 | 2023-07-14 04:13:29 -0700 | [diff] [blame] | 446 | static ssize_t release_store(struct config_item *item, const char *buf, |
| 447 | size_t count) |
| 448 | { |
| 449 | struct netconsole_target *nt = to_target(item); |
Breno Leitao | 004a04b | 2023-07-21 02:21:45 -0700 | [diff] [blame] | 450 | bool release; |
Breno Leitao | 5c4a39e | 2024-08-08 05:25:09 -0700 | [diff] [blame] | 451 | ssize_t ret; |
Breno Leitao | c62c0a1 | 2023-07-14 04:13:29 -0700 | [diff] [blame] | 452 | |
| 453 | mutex_lock(&dynamic_netconsole_mutex); |
| 454 | if (nt->enabled) { |
| 455 | pr_err("target (%s) is enabled, disable to update parameters\n", |
Matthew Wood | bd9c69a | 2024-02-04 15:27:33 -0800 | [diff] [blame] | 456 | config_item_name(&nt->group.cg_item)); |
Breno Leitao | 5c4a39e | 2024-08-08 05:25:09 -0700 | [diff] [blame] | 457 | ret = -EINVAL; |
Breno Leitao | c62c0a1 | 2023-07-14 04:13:29 -0700 | [diff] [blame] | 458 | goto out_unlock; |
| 459 | } |
| 460 | |
Breno Leitao | 5c4a39e | 2024-08-08 05:25:09 -0700 | [diff] [blame] | 461 | ret = kstrtobool(buf, &release); |
| 462 | if (ret) |
Breno Leitao | c62c0a1 | 2023-07-14 04:13:29 -0700 | [diff] [blame] | 463 | goto out_unlock; |
Breno Leitao | c62c0a1 | 2023-07-14 04:13:29 -0700 | [diff] [blame] | 464 | |
| 465 | nt->release = release; |
| 466 | |
Breno Leitao | f2ab4c1 | 2024-08-08 05:25:10 -0700 | [diff] [blame] | 467 | ret = strnlen(buf, count); |
Breno Leitao | c62c0a1 | 2023-07-14 04:13:29 -0700 | [diff] [blame] | 468 | out_unlock: |
| 469 | mutex_unlock(&dynamic_netconsole_mutex); |
Breno Leitao | 5c4a39e | 2024-08-08 05:25:09 -0700 | [diff] [blame] | 470 | return ret; |
Breno Leitao | c62c0a1 | 2023-07-14 04:13:29 -0700 | [diff] [blame] | 471 | } |
| 472 | |
Christoph Hellwig | ea9ed9c | 2015-10-03 15:32:56 +0200 | [diff] [blame] | 473 | static ssize_t extended_store(struct config_item *item, const char *buf, |
| 474 | size_t count) |
Tejun Heo | e2f15f9 | 2015-06-25 15:01:41 -0700 | [diff] [blame] | 475 | { |
Christoph Hellwig | ea9ed9c | 2015-10-03 15:32:56 +0200 | [diff] [blame] | 476 | struct netconsole_target *nt = to_target(item); |
Breno Leitao | 004a04b | 2023-07-21 02:21:45 -0700 | [diff] [blame] | 477 | bool extended; |
Breno Leitao | 5c4a39e | 2024-08-08 05:25:09 -0700 | [diff] [blame] | 478 | ssize_t ret; |
Tejun Heo | e2f15f9 | 2015-06-25 15:01:41 -0700 | [diff] [blame] | 479 | |
Christoph Hellwig | ea9ed9c | 2015-10-03 15:32:56 +0200 | [diff] [blame] | 480 | mutex_lock(&dynamic_netconsole_mutex); |
Tejun Heo | e2f15f9 | 2015-06-25 15:01:41 -0700 | [diff] [blame] | 481 | if (nt->enabled) { |
| 482 | pr_err("target (%s) is enabled, disable to update parameters\n", |
Matthew Wood | bd9c69a | 2024-02-04 15:27:33 -0800 | [diff] [blame] | 483 | config_item_name(&nt->group.cg_item)); |
Breno Leitao | 5c4a39e | 2024-08-08 05:25:09 -0700 | [diff] [blame] | 484 | ret = -EINVAL; |
Christoph Hellwig | ea9ed9c | 2015-10-03 15:32:56 +0200 | [diff] [blame] | 485 | goto out_unlock; |
Tejun Heo | e2f15f9 | 2015-06-25 15:01:41 -0700 | [diff] [blame] | 486 | } |
| 487 | |
Breno Leitao | 5c4a39e | 2024-08-08 05:25:09 -0700 | [diff] [blame] | 488 | ret = kstrtobool(buf, &extended); |
| 489 | if (ret) |
Christoph Hellwig | ea9ed9c | 2015-10-03 15:32:56 +0200 | [diff] [blame] | 490 | goto out_unlock; |
Tejun Heo | e2f15f9 | 2015-06-25 15:01:41 -0700 | [diff] [blame] | 491 | |
| 492 | nt->extended = extended; |
Breno Leitao | f2ab4c1 | 2024-08-08 05:25:10 -0700 | [diff] [blame] | 493 | ret = strnlen(buf, count); |
Christoph Hellwig | ea9ed9c | 2015-10-03 15:32:56 +0200 | [diff] [blame] | 494 | out_unlock: |
| 495 | mutex_unlock(&dynamic_netconsole_mutex); |
Breno Leitao | 5c4a39e | 2024-08-08 05:25:09 -0700 | [diff] [blame] | 496 | return ret; |
Tejun Heo | e2f15f9 | 2015-06-25 15:01:41 -0700 | [diff] [blame] | 497 | } |
| 498 | |
Christoph Hellwig | ea9ed9c | 2015-10-03 15:32:56 +0200 | [diff] [blame] | 499 | static ssize_t dev_name_store(struct config_item *item, const char *buf, |
| 500 | size_t count) |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 501 | { |
Christoph Hellwig | ea9ed9c | 2015-10-03 15:32:56 +0200 | [diff] [blame] | 502 | struct netconsole_target *nt = to_target(item); |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 503 | |
Christoph Hellwig | ea9ed9c | 2015-10-03 15:32:56 +0200 | [diff] [blame] | 504 | mutex_lock(&dynamic_netconsole_mutex); |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 505 | if (nt->enabled) { |
Joe Perches | 22ded57 | 2013-10-28 12:53:21 -0700 | [diff] [blame] | 506 | pr_err("target (%s) is enabled, disable to update parameters\n", |
Matthew Wood | bd9c69a | 2024-02-04 15:27:33 -0800 | [diff] [blame] | 507 | config_item_name(&nt->group.cg_item)); |
Christoph Hellwig | ea9ed9c | 2015-10-03 15:32:56 +0200 | [diff] [blame] | 508 | mutex_unlock(&dynamic_netconsole_mutex); |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 509 | return -EINVAL; |
| 510 | } |
| 511 | |
Wolfram Sang | fb3ceec | 2022-08-30 22:14:52 +0200 | [diff] [blame] | 512 | strscpy(nt->np.dev_name, buf, IFNAMSIZ); |
Matthew Wood | ae001dc | 2024-02-04 15:27:34 -0800 | [diff] [blame] | 513 | trim_newline(nt->np.dev_name, IFNAMSIZ); |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 514 | |
Christoph Hellwig | ea9ed9c | 2015-10-03 15:32:56 +0200 | [diff] [blame] | 515 | mutex_unlock(&dynamic_netconsole_mutex); |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 516 | return strnlen(buf, count); |
| 517 | } |
| 518 | |
Christoph Hellwig | ea9ed9c | 2015-10-03 15:32:56 +0200 | [diff] [blame] | 519 | static ssize_t local_port_store(struct config_item *item, const char *buf, |
| 520 | size_t count) |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 521 | { |
Christoph Hellwig | ea9ed9c | 2015-10-03 15:32:56 +0200 | [diff] [blame] | 522 | struct netconsole_target *nt = to_target(item); |
Breno Leitao | 5c4a39e | 2024-08-08 05:25:09 -0700 | [diff] [blame] | 523 | ssize_t ret = -EINVAL; |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 524 | |
Christoph Hellwig | ea9ed9c | 2015-10-03 15:32:56 +0200 | [diff] [blame] | 525 | mutex_lock(&dynamic_netconsole_mutex); |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 526 | if (nt->enabled) { |
Joe Perches | 22ded57 | 2013-10-28 12:53:21 -0700 | [diff] [blame] | 527 | pr_err("target (%s) is enabled, disable to update parameters\n", |
Matthew Wood | bd9c69a | 2024-02-04 15:27:33 -0800 | [diff] [blame] | 528 | config_item_name(&nt->group.cg_item)); |
Christoph Hellwig | ea9ed9c | 2015-10-03 15:32:56 +0200 | [diff] [blame] | 529 | goto out_unlock; |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 530 | } |
| 531 | |
Breno Leitao | 5c4a39e | 2024-08-08 05:25:09 -0700 | [diff] [blame] | 532 | ret = kstrtou16(buf, 10, &nt->np.local_port); |
| 533 | if (ret < 0) |
Christoph Hellwig | ea9ed9c | 2015-10-03 15:32:56 +0200 | [diff] [blame] | 534 | goto out_unlock; |
Breno Leitao | f2ab4c1 | 2024-08-08 05:25:10 -0700 | [diff] [blame] | 535 | ret = strnlen(buf, count); |
Christoph Hellwig | ea9ed9c | 2015-10-03 15:32:56 +0200 | [diff] [blame] | 536 | out_unlock: |
| 537 | mutex_unlock(&dynamic_netconsole_mutex); |
Breno Leitao | 5c4a39e | 2024-08-08 05:25:09 -0700 | [diff] [blame] | 538 | return ret; |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 539 | } |
| 540 | |
Christoph Hellwig | ea9ed9c | 2015-10-03 15:32:56 +0200 | [diff] [blame] | 541 | static ssize_t remote_port_store(struct config_item *item, |
| 542 | const char *buf, size_t count) |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 543 | { |
Christoph Hellwig | ea9ed9c | 2015-10-03 15:32:56 +0200 | [diff] [blame] | 544 | struct netconsole_target *nt = to_target(item); |
Breno Leitao | 5c4a39e | 2024-08-08 05:25:09 -0700 | [diff] [blame] | 545 | ssize_t ret = -EINVAL; |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 546 | |
Christoph Hellwig | ea9ed9c | 2015-10-03 15:32:56 +0200 | [diff] [blame] | 547 | mutex_lock(&dynamic_netconsole_mutex); |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 548 | if (nt->enabled) { |
Joe Perches | 22ded57 | 2013-10-28 12:53:21 -0700 | [diff] [blame] | 549 | pr_err("target (%s) is enabled, disable to update parameters\n", |
Matthew Wood | bd9c69a | 2024-02-04 15:27:33 -0800 | [diff] [blame] | 550 | config_item_name(&nt->group.cg_item)); |
Christoph Hellwig | ea9ed9c | 2015-10-03 15:32:56 +0200 | [diff] [blame] | 551 | goto out_unlock; |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 552 | } |
| 553 | |
Breno Leitao | 5c4a39e | 2024-08-08 05:25:09 -0700 | [diff] [blame] | 554 | ret = kstrtou16(buf, 10, &nt->np.remote_port); |
| 555 | if (ret < 0) |
Christoph Hellwig | ea9ed9c | 2015-10-03 15:32:56 +0200 | [diff] [blame] | 556 | goto out_unlock; |
Breno Leitao | f2ab4c1 | 2024-08-08 05:25:10 -0700 | [diff] [blame] | 557 | ret = strnlen(buf, count); |
Christoph Hellwig | ea9ed9c | 2015-10-03 15:32:56 +0200 | [diff] [blame] | 558 | out_unlock: |
| 559 | mutex_unlock(&dynamic_netconsole_mutex); |
Breno Leitao | 5c4a39e | 2024-08-08 05:25:09 -0700 | [diff] [blame] | 560 | return ret; |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 561 | } |
| 562 | |
Christoph Hellwig | ea9ed9c | 2015-10-03 15:32:56 +0200 | [diff] [blame] | 563 | static ssize_t local_ip_store(struct config_item *item, const char *buf, |
| 564 | size_t count) |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 565 | { |
Christoph Hellwig | ea9ed9c | 2015-10-03 15:32:56 +0200 | [diff] [blame] | 566 | struct netconsole_target *nt = to_target(item); |
Breno Leitao | f2ab4c1 | 2024-08-08 05:25:10 -0700 | [diff] [blame] | 567 | ssize_t ret = -EINVAL; |
Christoph Hellwig | ea9ed9c | 2015-10-03 15:32:56 +0200 | [diff] [blame] | 568 | |
| 569 | mutex_lock(&dynamic_netconsole_mutex); |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 570 | if (nt->enabled) { |
Joe Perches | 22ded57 | 2013-10-28 12:53:21 -0700 | [diff] [blame] | 571 | pr_err("target (%s) is enabled, disable to update parameters\n", |
Matthew Wood | bd9c69a | 2024-02-04 15:27:33 -0800 | [diff] [blame] | 572 | config_item_name(&nt->group.cg_item)); |
Christoph Hellwig | ea9ed9c | 2015-10-03 15:32:56 +0200 | [diff] [blame] | 573 | goto out_unlock; |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 574 | } |
| 575 | |
Cong Wang | b3d936f3 | 2013-01-07 20:52:41 +0000 | [diff] [blame] | 576 | if (strnchr(buf, count, ':')) { |
| 577 | const char *end; |
Matthew Wood | 602ad3b | 2024-02-04 15:27:32 -0800 | [diff] [blame] | 578 | |
Cong Wang | b3d936f3 | 2013-01-07 20:52:41 +0000 | [diff] [blame] | 579 | if (in6_pton(buf, count, nt->np.local_ip.in6.s6_addr, -1, &end) > 0) { |
| 580 | if (*end && *end != '\n') { |
Joe Perches | 22ded57 | 2013-10-28 12:53:21 -0700 | [diff] [blame] | 581 | pr_err("invalid IPv6 address at: <%c>\n", *end); |
Christoph Hellwig | ea9ed9c | 2015-10-03 15:32:56 +0200 | [diff] [blame] | 582 | goto out_unlock; |
Cong Wang | b3d936f3 | 2013-01-07 20:52:41 +0000 | [diff] [blame] | 583 | } |
| 584 | nt->np.ipv6 = true; |
| 585 | } else |
Christoph Hellwig | ea9ed9c | 2015-10-03 15:32:56 +0200 | [diff] [blame] | 586 | goto out_unlock; |
Cong Wang | b3d936f3 | 2013-01-07 20:52:41 +0000 | [diff] [blame] | 587 | } else { |
Matthew Wood | 602ad3b | 2024-02-04 15:27:32 -0800 | [diff] [blame] | 588 | if (!nt->np.ipv6) |
Cong Wang | b3d936f3 | 2013-01-07 20:52:41 +0000 | [diff] [blame] | 589 | nt->np.local_ip.ip = in_aton(buf); |
Matthew Wood | 602ad3b | 2024-02-04 15:27:32 -0800 | [diff] [blame] | 590 | else |
Christoph Hellwig | ea9ed9c | 2015-10-03 15:32:56 +0200 | [diff] [blame] | 591 | goto out_unlock; |
Cong Wang | b3d936f3 | 2013-01-07 20:52:41 +0000 | [diff] [blame] | 592 | } |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 593 | |
Breno Leitao | f2ab4c1 | 2024-08-08 05:25:10 -0700 | [diff] [blame] | 594 | ret = strnlen(buf, count); |
Christoph Hellwig | ea9ed9c | 2015-10-03 15:32:56 +0200 | [diff] [blame] | 595 | out_unlock: |
| 596 | mutex_unlock(&dynamic_netconsole_mutex); |
Breno Leitao | f2ab4c1 | 2024-08-08 05:25:10 -0700 | [diff] [blame] | 597 | return ret; |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 598 | } |
| 599 | |
Christoph Hellwig | ea9ed9c | 2015-10-03 15:32:56 +0200 | [diff] [blame] | 600 | static ssize_t remote_ip_store(struct config_item *item, const char *buf, |
| 601 | size_t count) |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 602 | { |
Christoph Hellwig | ea9ed9c | 2015-10-03 15:32:56 +0200 | [diff] [blame] | 603 | struct netconsole_target *nt = to_target(item); |
Breno Leitao | f2ab4c1 | 2024-08-08 05:25:10 -0700 | [diff] [blame] | 604 | ssize_t ret = -EINVAL; |
Christoph Hellwig | ea9ed9c | 2015-10-03 15:32:56 +0200 | [diff] [blame] | 605 | |
| 606 | mutex_lock(&dynamic_netconsole_mutex); |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 607 | if (nt->enabled) { |
Joe Perches | 22ded57 | 2013-10-28 12:53:21 -0700 | [diff] [blame] | 608 | pr_err("target (%s) is enabled, disable to update parameters\n", |
Matthew Wood | bd9c69a | 2024-02-04 15:27:33 -0800 | [diff] [blame] | 609 | config_item_name(&nt->group.cg_item)); |
Christoph Hellwig | ea9ed9c | 2015-10-03 15:32:56 +0200 | [diff] [blame] | 610 | goto out_unlock; |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 611 | } |
| 612 | |
Cong Wang | b3d936f3 | 2013-01-07 20:52:41 +0000 | [diff] [blame] | 613 | if (strnchr(buf, count, ':')) { |
| 614 | const char *end; |
Matthew Wood | 602ad3b | 2024-02-04 15:27:32 -0800 | [diff] [blame] | 615 | |
Cong Wang | b3d936f3 | 2013-01-07 20:52:41 +0000 | [diff] [blame] | 616 | if (in6_pton(buf, count, nt->np.remote_ip.in6.s6_addr, -1, &end) > 0) { |
| 617 | if (*end && *end != '\n') { |
Joe Perches | 22ded57 | 2013-10-28 12:53:21 -0700 | [diff] [blame] | 618 | pr_err("invalid IPv6 address at: <%c>\n", *end); |
Christoph Hellwig | ea9ed9c | 2015-10-03 15:32:56 +0200 | [diff] [blame] | 619 | goto out_unlock; |
Cong Wang | b3d936f3 | 2013-01-07 20:52:41 +0000 | [diff] [blame] | 620 | } |
| 621 | nt->np.ipv6 = true; |
| 622 | } else |
Christoph Hellwig | ea9ed9c | 2015-10-03 15:32:56 +0200 | [diff] [blame] | 623 | goto out_unlock; |
Cong Wang | b3d936f3 | 2013-01-07 20:52:41 +0000 | [diff] [blame] | 624 | } else { |
Matthew Wood | 602ad3b | 2024-02-04 15:27:32 -0800 | [diff] [blame] | 625 | if (!nt->np.ipv6) |
Cong Wang | b3d936f3 | 2013-01-07 20:52:41 +0000 | [diff] [blame] | 626 | nt->np.remote_ip.ip = in_aton(buf); |
Matthew Wood | 602ad3b | 2024-02-04 15:27:32 -0800 | [diff] [blame] | 627 | else |
Christoph Hellwig | ea9ed9c | 2015-10-03 15:32:56 +0200 | [diff] [blame] | 628 | goto out_unlock; |
Cong Wang | b3d936f3 | 2013-01-07 20:52:41 +0000 | [diff] [blame] | 629 | } |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 630 | |
Breno Leitao | f2ab4c1 | 2024-08-08 05:25:10 -0700 | [diff] [blame] | 631 | ret = strnlen(buf, count); |
Christoph Hellwig | ea9ed9c | 2015-10-03 15:32:56 +0200 | [diff] [blame] | 632 | out_unlock: |
| 633 | mutex_unlock(&dynamic_netconsole_mutex); |
Breno Leitao | f2ab4c1 | 2024-08-08 05:25:10 -0700 | [diff] [blame] | 634 | return ret; |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 635 | } |
| 636 | |
Christoph Hellwig | ea9ed9c | 2015-10-03 15:32:56 +0200 | [diff] [blame] | 637 | static ssize_t remote_mac_store(struct config_item *item, const char *buf, |
| 638 | size_t count) |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 639 | { |
Christoph Hellwig | ea9ed9c | 2015-10-03 15:32:56 +0200 | [diff] [blame] | 640 | struct netconsole_target *nt = to_target(item); |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 641 | u8 remote_mac[ETH_ALEN]; |
Breno Leitao | f2ab4c1 | 2024-08-08 05:25:10 -0700 | [diff] [blame] | 642 | ssize_t ret = -EINVAL; |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 643 | |
Christoph Hellwig | ea9ed9c | 2015-10-03 15:32:56 +0200 | [diff] [blame] | 644 | mutex_lock(&dynamic_netconsole_mutex); |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 645 | if (nt->enabled) { |
Joe Perches | 22ded57 | 2013-10-28 12:53:21 -0700 | [diff] [blame] | 646 | pr_err("target (%s) is enabled, disable to update parameters\n", |
Matthew Wood | bd9c69a | 2024-02-04 15:27:33 -0800 | [diff] [blame] | 647 | config_item_name(&nt->group.cg_item)); |
Christoph Hellwig | ea9ed9c | 2015-10-03 15:32:56 +0200 | [diff] [blame] | 648 | goto out_unlock; |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 649 | } |
| 650 | |
Alexey Dobriyan | 4940fc8 | 2011-05-07 23:00:07 +0000 | [diff] [blame] | 651 | if (!mac_pton(buf, remote_mac)) |
Christoph Hellwig | ea9ed9c | 2015-10-03 15:32:56 +0200 | [diff] [blame] | 652 | goto out_unlock; |
Alexey Dobriyan | 4940fc8 | 2011-05-07 23:00:07 +0000 | [diff] [blame] | 653 | if (buf[3 * ETH_ALEN - 1] && buf[3 * ETH_ALEN - 1] != '\n') |
Christoph Hellwig | ea9ed9c | 2015-10-03 15:32:56 +0200 | [diff] [blame] | 654 | goto out_unlock; |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 655 | memcpy(nt->np.remote_mac, remote_mac, ETH_ALEN); |
| 656 | |
Breno Leitao | f2ab4c1 | 2024-08-08 05:25:10 -0700 | [diff] [blame] | 657 | ret = strnlen(buf, count); |
Christoph Hellwig | ea9ed9c | 2015-10-03 15:32:56 +0200 | [diff] [blame] | 658 | out_unlock: |
| 659 | mutex_unlock(&dynamic_netconsole_mutex); |
Breno Leitao | f2ab4c1 | 2024-08-08 05:25:10 -0700 | [diff] [blame] | 660 | return ret; |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 661 | } |
| 662 | |
Matthew Wood | 8a6d5fe | 2024-02-04 15:27:36 -0800 | [diff] [blame] | 663 | struct userdatum { |
| 664 | struct config_item item; |
| 665 | char value[MAX_USERDATA_VALUE_LENGTH]; |
| 666 | }; |
| 667 | |
| 668 | static struct userdatum *to_userdatum(struct config_item *item) |
| 669 | { |
| 670 | return container_of(item, struct userdatum, item); |
| 671 | } |
| 672 | |
| 673 | struct userdata { |
| 674 | struct config_group group; |
| 675 | }; |
| 676 | |
| 677 | static struct userdata *to_userdata(struct config_item *item) |
| 678 | { |
| 679 | return container_of(to_config_group(item), struct userdata, group); |
| 680 | } |
| 681 | |
| 682 | static struct netconsole_target *userdata_to_target(struct userdata *ud) |
| 683 | { |
| 684 | struct config_group *netconsole_group; |
| 685 | |
| 686 | netconsole_group = to_config_group(ud->group.cg_item.ci_parent); |
| 687 | return to_target(&netconsole_group->cg_item); |
| 688 | } |
| 689 | |
| 690 | static ssize_t userdatum_value_show(struct config_item *item, char *buf) |
| 691 | { |
| 692 | return sysfs_emit(buf, "%s\n", &(to_userdatum(item)->value[0])); |
| 693 | } |
| 694 | |
Matthew Wood | df03f83 | 2024-02-04 15:27:37 -0800 | [diff] [blame] | 695 | static void update_userdata(struct netconsole_target *nt) |
| 696 | { |
| 697 | int complete_idx = 0, child_count = 0; |
| 698 | struct list_head *entry; |
| 699 | |
| 700 | /* Clear the current string in case the last userdatum was deleted */ |
| 701 | nt->userdata_length = 0; |
| 702 | nt->userdata_complete[0] = 0; |
| 703 | |
| 704 | list_for_each(entry, &nt->userdata_group.cg_children) { |
| 705 | struct userdatum *udm_item; |
| 706 | struct config_item *item; |
| 707 | |
| 708 | if (child_count >= MAX_USERDATA_ITEMS) |
| 709 | break; |
| 710 | child_count++; |
| 711 | |
| 712 | item = container_of(entry, struct config_item, ci_entry); |
| 713 | udm_item = to_userdatum(item); |
| 714 | |
| 715 | /* Skip userdata with no value set */ |
| 716 | if (strnlen(udm_item->value, MAX_USERDATA_VALUE_LENGTH) == 0) |
| 717 | continue; |
| 718 | |
| 719 | /* This doesn't overflow userdata_complete since it will write |
| 720 | * one entry length (1/MAX_USERDATA_ITEMS long), entry count is |
| 721 | * checked to not exceed MAX items with child_count above |
| 722 | */ |
| 723 | complete_idx += scnprintf(&nt->userdata_complete[complete_idx], |
Matthew Wood | 2b395358 | 2024-03-07 16:25:24 -0800 | [diff] [blame] | 724 | MAX_USERDATA_ENTRY_LENGTH, " %s=%s\n", |
Matthew Wood | df03f83 | 2024-02-04 15:27:37 -0800 | [diff] [blame] | 725 | item->ci_name, udm_item->value); |
| 726 | } |
| 727 | nt->userdata_length = strnlen(nt->userdata_complete, |
| 728 | sizeof(nt->userdata_complete)); |
| 729 | } |
| 730 | |
Matthew Wood | 8a6d5fe | 2024-02-04 15:27:36 -0800 | [diff] [blame] | 731 | static ssize_t userdatum_value_store(struct config_item *item, const char *buf, |
| 732 | size_t count) |
| 733 | { |
| 734 | struct userdatum *udm = to_userdatum(item); |
Matthew Wood | df03f83 | 2024-02-04 15:27:37 -0800 | [diff] [blame] | 735 | struct netconsole_target *nt; |
| 736 | struct userdata *ud; |
Breno Leitao | e0a2b7e | 2024-08-08 05:25:08 -0700 | [diff] [blame] | 737 | ssize_t ret; |
Matthew Wood | 8a6d5fe | 2024-02-04 15:27:36 -0800 | [diff] [blame] | 738 | |
| 739 | if (count > MAX_USERDATA_VALUE_LENGTH) |
| 740 | return -EMSGSIZE; |
| 741 | |
| 742 | mutex_lock(&dynamic_netconsole_mutex); |
| 743 | |
| 744 | ret = strscpy(udm->value, buf, sizeof(udm->value)); |
| 745 | if (ret < 0) |
| 746 | goto out_unlock; |
| 747 | trim_newline(udm->value, sizeof(udm->value)); |
| 748 | |
Matthew Wood | df03f83 | 2024-02-04 15:27:37 -0800 | [diff] [blame] | 749 | ud = to_userdata(item->ci_parent); |
| 750 | nt = userdata_to_target(ud); |
| 751 | update_userdata(nt); |
Breno Leitao | f2ab4c1 | 2024-08-08 05:25:10 -0700 | [diff] [blame] | 752 | ret = count; |
Matthew Wood | 8a6d5fe | 2024-02-04 15:27:36 -0800 | [diff] [blame] | 753 | out_unlock: |
| 754 | mutex_unlock(&dynamic_netconsole_mutex); |
| 755 | return ret; |
| 756 | } |
| 757 | |
| 758 | CONFIGFS_ATTR(userdatum_, value); |
| 759 | |
| 760 | static struct configfs_attribute *userdatum_attrs[] = { |
| 761 | &userdatum_attr_value, |
| 762 | NULL, |
| 763 | }; |
| 764 | |
| 765 | static void userdatum_release(struct config_item *item) |
| 766 | { |
| 767 | kfree(to_userdatum(item)); |
| 768 | } |
| 769 | |
| 770 | static struct configfs_item_operations userdatum_ops = { |
| 771 | .release = userdatum_release, |
| 772 | }; |
| 773 | |
| 774 | static const struct config_item_type userdatum_type = { |
| 775 | .ct_item_ops = &userdatum_ops, |
| 776 | .ct_attrs = userdatum_attrs, |
| 777 | .ct_owner = THIS_MODULE, |
| 778 | }; |
| 779 | |
| 780 | static struct config_item *userdatum_make_item(struct config_group *group, |
| 781 | const char *name) |
| 782 | { |
| 783 | struct netconsole_target *nt; |
| 784 | struct userdatum *udm; |
| 785 | struct userdata *ud; |
| 786 | size_t child_count; |
| 787 | |
| 788 | if (strlen(name) > MAX_USERDATA_NAME_LENGTH) |
| 789 | return ERR_PTR(-ENAMETOOLONG); |
| 790 | |
| 791 | ud = to_userdata(&group->cg_item); |
| 792 | nt = userdata_to_target(ud); |
| 793 | child_count = list_count_nodes(&nt->userdata_group.cg_children); |
| 794 | if (child_count >= MAX_USERDATA_ITEMS) |
| 795 | return ERR_PTR(-ENOSPC); |
| 796 | |
| 797 | udm = kzalloc(sizeof(*udm), GFP_KERNEL); |
| 798 | if (!udm) |
| 799 | return ERR_PTR(-ENOMEM); |
| 800 | |
| 801 | config_item_init_type_name(&udm->item, name, &userdatum_type); |
| 802 | return &udm->item; |
| 803 | } |
| 804 | |
Matthew Wood | df03f83 | 2024-02-04 15:27:37 -0800 | [diff] [blame] | 805 | static void userdatum_drop(struct config_group *group, struct config_item *item) |
| 806 | { |
| 807 | struct netconsole_target *nt; |
| 808 | struct userdata *ud; |
| 809 | |
| 810 | ud = to_userdata(&group->cg_item); |
| 811 | nt = userdata_to_target(ud); |
| 812 | |
| 813 | mutex_lock(&dynamic_netconsole_mutex); |
| 814 | update_userdata(nt); |
| 815 | config_item_put(item); |
| 816 | mutex_unlock(&dynamic_netconsole_mutex); |
| 817 | } |
| 818 | |
Matthew Wood | 8a6d5fe | 2024-02-04 15:27:36 -0800 | [diff] [blame] | 819 | static struct configfs_attribute *userdata_attrs[] = { |
| 820 | NULL, |
| 821 | }; |
| 822 | |
| 823 | static struct configfs_group_operations userdata_ops = { |
| 824 | .make_item = userdatum_make_item, |
Matthew Wood | df03f83 | 2024-02-04 15:27:37 -0800 | [diff] [blame] | 825 | .drop_item = userdatum_drop, |
Matthew Wood | 8a6d5fe | 2024-02-04 15:27:36 -0800 | [diff] [blame] | 826 | }; |
| 827 | |
Christophe JAILLET | ed4290f | 2024-08-10 23:39:04 +0200 | [diff] [blame] | 828 | static const struct config_item_type userdata_type = { |
Matthew Wood | 8a6d5fe | 2024-02-04 15:27:36 -0800 | [diff] [blame] | 829 | .ct_item_ops = &userdatum_ops, |
| 830 | .ct_group_ops = &userdata_ops, |
| 831 | .ct_attrs = userdata_attrs, |
| 832 | .ct_owner = THIS_MODULE, |
| 833 | }; |
| 834 | |
Christoph Hellwig | ea9ed9c | 2015-10-03 15:32:56 +0200 | [diff] [blame] | 835 | CONFIGFS_ATTR(, enabled); |
| 836 | CONFIGFS_ATTR(, extended); |
| 837 | CONFIGFS_ATTR(, dev_name); |
| 838 | CONFIGFS_ATTR(, local_port); |
| 839 | CONFIGFS_ATTR(, remote_port); |
| 840 | CONFIGFS_ATTR(, local_ip); |
| 841 | CONFIGFS_ATTR(, remote_ip); |
| 842 | CONFIGFS_ATTR_RO(, local_mac); |
| 843 | CONFIGFS_ATTR(, remote_mac); |
Breno Leitao | c62c0a1 | 2023-07-14 04:13:29 -0700 | [diff] [blame] | 844 | CONFIGFS_ATTR(, release); |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 845 | |
| 846 | static struct configfs_attribute *netconsole_target_attrs[] = { |
Christoph Hellwig | ea9ed9c | 2015-10-03 15:32:56 +0200 | [diff] [blame] | 847 | &attr_enabled, |
| 848 | &attr_extended, |
Breno Leitao | c62c0a1 | 2023-07-14 04:13:29 -0700 | [diff] [blame] | 849 | &attr_release, |
Christoph Hellwig | ea9ed9c | 2015-10-03 15:32:56 +0200 | [diff] [blame] | 850 | &attr_dev_name, |
| 851 | &attr_local_port, |
| 852 | &attr_remote_port, |
| 853 | &attr_local_ip, |
| 854 | &attr_remote_ip, |
| 855 | &attr_local_mac, |
| 856 | &attr_remote_mac, |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 857 | NULL, |
| 858 | }; |
| 859 | |
| 860 | /* |
| 861 | * Item operations and type for netconsole_target. |
| 862 | */ |
| 863 | |
| 864 | static void netconsole_target_release(struct config_item *item) |
| 865 | { |
| 866 | kfree(to_target(item)); |
| 867 | } |
| 868 | |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 869 | static struct configfs_item_operations netconsole_target_item_ops = { |
| 870 | .release = netconsole_target_release, |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 871 | }; |
| 872 | |
Bhumika Goyal | 0d4a440 | 2017-10-16 17:18:52 +0200 | [diff] [blame] | 873 | static const struct config_item_type netconsole_target_type = { |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 874 | .ct_attrs = netconsole_target_attrs, |
| 875 | .ct_item_ops = &netconsole_target_item_ops, |
| 876 | .ct_owner = THIS_MODULE, |
| 877 | }; |
| 878 | |
Matthew Wood | 8a6d5fe | 2024-02-04 15:27:36 -0800 | [diff] [blame] | 879 | static void init_target_config_group(struct netconsole_target *nt, |
| 880 | const char *name) |
| 881 | { |
| 882 | config_group_init_type_name(&nt->group, name, &netconsole_target_type); |
| 883 | config_group_init_type_name(&nt->userdata_group, "userdata", |
| 884 | &userdata_type); |
| 885 | configfs_add_default_group(&nt->userdata_group, &nt->group); |
| 886 | } |
| 887 | |
Breno Leitao | 5fbd6cd | 2023-10-12 04:14:00 -0700 | [diff] [blame] | 888 | static struct netconsole_target *find_cmdline_target(const char *name) |
| 889 | { |
| 890 | struct netconsole_target *nt, *ret = NULL; |
| 891 | unsigned long flags; |
| 892 | |
| 893 | spin_lock_irqsave(&target_list_lock, flags); |
| 894 | list_for_each_entry(nt, &target_list, list) { |
Matthew Wood | bd9c69a | 2024-02-04 15:27:33 -0800 | [diff] [blame] | 895 | if (!strcmp(nt->group.cg_item.ci_name, name)) { |
Breno Leitao | 5fbd6cd | 2023-10-12 04:14:00 -0700 | [diff] [blame] | 896 | ret = nt; |
| 897 | break; |
| 898 | } |
| 899 | } |
| 900 | spin_unlock_irqrestore(&target_list_lock, flags); |
| 901 | |
| 902 | return ret; |
| 903 | } |
| 904 | |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 905 | /* |
| 906 | * Group operations and type for netconsole_subsys. |
| 907 | */ |
| 908 | |
Matthew Wood | bd9c69a | 2024-02-04 15:27:33 -0800 | [diff] [blame] | 909 | static struct config_group *make_netconsole_target(struct config_group *group, |
| 910 | const char *name) |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 911 | { |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 912 | struct netconsole_target *nt; |
Breno Leitao | b0a9e2c | 2023-08-11 02:31:57 -0700 | [diff] [blame] | 913 | unsigned long flags; |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 914 | |
Breno Leitao | 5fbd6cd | 2023-10-12 04:14:00 -0700 | [diff] [blame] | 915 | /* Checking if a target by this name was created at boot time. If so, |
| 916 | * attach a configfs entry to that target. This enables dynamic |
| 917 | * control. |
| 918 | */ |
| 919 | if (!strncmp(name, NETCONSOLE_PARAM_TARGET_PREFIX, |
| 920 | strlen(NETCONSOLE_PARAM_TARGET_PREFIX))) { |
| 921 | nt = find_cmdline_target(name); |
Matthew Wood | 8a6d5fe | 2024-02-04 15:27:36 -0800 | [diff] [blame] | 922 | if (nt) { |
| 923 | init_target_config_group(nt, name); |
Matthew Wood | bd9c69a | 2024-02-04 15:27:33 -0800 | [diff] [blame] | 924 | return &nt->group; |
Matthew Wood | 8a6d5fe | 2024-02-04 15:27:36 -0800 | [diff] [blame] | 925 | } |
Breno Leitao | 5fbd6cd | 2023-10-12 04:14:00 -0700 | [diff] [blame] | 926 | } |
| 927 | |
Breno Leitao | b0a9e2c | 2023-08-11 02:31:57 -0700 | [diff] [blame] | 928 | nt = alloc_and_init(); |
Joe Perches | e404dec | 2012-01-29 12:56:23 +0000 | [diff] [blame] | 929 | if (!nt) |
Joel Becker | a6795e9 | 2008-07-17 15:21:29 -0700 | [diff] [blame] | 930 | return ERR_PTR(-ENOMEM); |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 931 | |
Matthew Wood | 8a6d5fe | 2024-02-04 15:27:36 -0800 | [diff] [blame] | 932 | /* Initialize the config_group member */ |
| 933 | init_target_config_group(nt, name); |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 934 | |
| 935 | /* Adding, but it is disabled */ |
| 936 | spin_lock_irqsave(&target_list_lock, flags); |
| 937 | list_add(&nt->list, &target_list); |
| 938 | spin_unlock_irqrestore(&target_list_lock, flags); |
| 939 | |
Matthew Wood | bd9c69a | 2024-02-04 15:27:33 -0800 | [diff] [blame] | 940 | return &nt->group; |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 941 | } |
| 942 | |
| 943 | static void drop_netconsole_target(struct config_group *group, |
| 944 | struct config_item *item) |
| 945 | { |
| 946 | unsigned long flags; |
| 947 | struct netconsole_target *nt = to_target(item); |
| 948 | |
| 949 | spin_lock_irqsave(&target_list_lock, flags); |
| 950 | list_del(&nt->list); |
| 951 | spin_unlock_irqrestore(&target_list_lock, flags); |
| 952 | |
| 953 | /* |
| 954 | * The target may have never been enabled, or was manually disabled |
| 955 | * before being removed so netpoll may have already been cleaned up. |
| 956 | */ |
| 957 | if (nt->enabled) |
| 958 | netpoll_cleanup(&nt->np); |
| 959 | |
Matthew Wood | bd9c69a | 2024-02-04 15:27:33 -0800 | [diff] [blame] | 960 | config_item_put(&nt->group.cg_item); |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 961 | } |
| 962 | |
| 963 | static struct configfs_group_operations netconsole_subsys_group_ops = { |
Matthew Wood | bd9c69a | 2024-02-04 15:27:33 -0800 | [diff] [blame] | 964 | .make_group = make_netconsole_target, |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 965 | .drop_item = drop_netconsole_target, |
| 966 | }; |
| 967 | |
Bhumika Goyal | 0d4a440 | 2017-10-16 17:18:52 +0200 | [diff] [blame] | 968 | static const struct config_item_type netconsole_subsys_type = { |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 969 | .ct_group_ops = &netconsole_subsys_group_ops, |
| 970 | .ct_owner = THIS_MODULE, |
| 971 | }; |
| 972 | |
| 973 | /* The netconsole configfs subsystem */ |
| 974 | static struct configfs_subsystem netconsole_subsys = { |
| 975 | .su_group = { |
| 976 | .cg_item = { |
| 977 | .ci_namebuf = "netconsole", |
| 978 | .ci_type = &netconsole_subsys_type, |
| 979 | }, |
| 980 | }, |
| 981 | }; |
| 982 | |
Breno Leitao | 131eeb4 | 2023-10-12 04:13:59 -0700 | [diff] [blame] | 983 | static void populate_configfs_item(struct netconsole_target *nt, |
| 984 | int cmdline_count) |
| 985 | { |
| 986 | char target_name[16]; |
| 987 | |
| 988 | snprintf(target_name, sizeof(target_name), "%s%d", |
| 989 | NETCONSOLE_PARAM_TARGET_PREFIX, cmdline_count); |
Matthew Wood | 8a6d5fe | 2024-02-04 15:27:36 -0800 | [diff] [blame] | 990 | init_target_config_group(nt, target_name); |
Breno Leitao | 131eeb4 | 2023-10-12 04:13:59 -0700 | [diff] [blame] | 991 | } |
| 992 | |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 993 | #endif /* CONFIG_NETCONSOLE_DYNAMIC */ |
| 994 | |
Satyam Sharma | 17951f3 | 2007-08-10 15:33:01 -0700 | [diff] [blame] | 995 | /* Handle network interface device notifications */ |
| 996 | static int netconsole_netdev_event(struct notifier_block *this, |
Jiri Pirko | 351638e | 2013-05-28 01:30:21 +0000 | [diff] [blame] | 997 | unsigned long event, void *ptr) |
Satyam Sharma | 17951f3 | 2007-08-10 15:33:01 -0700 | [diff] [blame] | 998 | { |
Satyam Sharma | b5427c2 | 2007-08-10 15:33:40 -0700 | [diff] [blame] | 999 | unsigned long flags; |
Breno Leitao | 9771469 | 2024-08-08 05:25:11 -0700 | [diff] [blame] | 1000 | struct netconsole_target *nt, *tmp; |
Jiri Pirko | 351638e | 2013-05-28 01:30:21 +0000 | [diff] [blame] | 1001 | struct net_device *dev = netdev_notifier_info_to_dev(ptr); |
Ferenc Wagner | 141dfba | 2011-01-06 05:11:19 +0000 | [diff] [blame] | 1002 | bool stopped = false; |
Satyam Sharma | 17951f3 | 2007-08-10 15:33:01 -0700 | [diff] [blame] | 1003 | |
WANG Cong | 0e34e93 | 2010-05-06 00:47:21 -0700 | [diff] [blame] | 1004 | if (!(event == NETDEV_CHANGENAME || event == NETDEV_UNREGISTER || |
Amerigo Wang | daf9209 | 2011-05-19 21:39:12 +0000 | [diff] [blame] | 1005 | event == NETDEV_RELEASE || event == NETDEV_JOIN)) |
Satyam Sharma | b5427c2 | 2007-08-10 15:33:40 -0700 | [diff] [blame] | 1006 | goto done; |
Satyam Sharma | 17951f3 | 2007-08-10 15:33:01 -0700 | [diff] [blame] | 1007 | |
Breno Leitao | 9771469 | 2024-08-08 05:25:11 -0700 | [diff] [blame] | 1008 | mutex_lock(&target_cleanup_list_lock); |
Satyam Sharma | b5427c2 | 2007-08-10 15:33:40 -0700 | [diff] [blame] | 1009 | spin_lock_irqsave(&target_list_lock, flags); |
Breno Leitao | 9771469 | 2024-08-08 05:25:11 -0700 | [diff] [blame] | 1010 | list_for_each_entry_safe(nt, tmp, &target_list, list) { |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 1011 | netconsole_target_get(nt); |
Satyam Sharma | b5427c2 | 2007-08-10 15:33:40 -0700 | [diff] [blame] | 1012 | if (nt->np.dev == dev) { |
| 1013 | switch (event) { |
Satyam Sharma | b5427c2 | 2007-08-10 15:33:40 -0700 | [diff] [blame] | 1014 | case NETDEV_CHANGENAME: |
Wolfram Sang | fb3ceec | 2022-08-30 22:14:52 +0200 | [diff] [blame] | 1015 | strscpy(nt->np.dev_name, dev->name, IFNAMSIZ); |
Satyam Sharma | b5427c2 | 2007-08-10 15:33:40 -0700 | [diff] [blame] | 1016 | break; |
Amerigo Wang | daf9209 | 2011-05-19 21:39:12 +0000 | [diff] [blame] | 1017 | case NETDEV_RELEASE: |
Amerigo Wang | 8d8fc29 | 2011-05-19 21:39:10 +0000 | [diff] [blame] | 1018 | case NETDEV_JOIN: |
Bruno Prémont | 2382b15 | 2009-04-29 20:45:17 +0000 | [diff] [blame] | 1019 | case NETDEV_UNREGISTER: |
Breno Leitao | 97d9fba | 2024-07-12 07:34:15 -0700 | [diff] [blame] | 1020 | nt->enabled = false; |
Breno Leitao | 9771469 | 2024-08-08 05:25:11 -0700 | [diff] [blame] | 1021 | list_move(&nt->list, &target_cleanup_list); |
Ferenc Wagner | 141dfba | 2011-01-06 05:11:19 +0000 | [diff] [blame] | 1022 | stopped = true; |
Satyam Sharma | b5427c2 | 2007-08-10 15:33:40 -0700 | [diff] [blame] | 1023 | } |
Satyam Sharma | 17951f3 | 2007-08-10 15:33:01 -0700 | [diff] [blame] | 1024 | } |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 1025 | netconsole_target_put(nt); |
Satyam Sharma | 17951f3 | 2007-08-10 15:33:01 -0700 | [diff] [blame] | 1026 | } |
Satyam Sharma | b5427c2 | 2007-08-10 15:33:40 -0700 | [diff] [blame] | 1027 | spin_unlock_irqrestore(&target_list_lock, flags); |
Breno Leitao | 9771469 | 2024-08-08 05:25:11 -0700 | [diff] [blame] | 1028 | mutex_unlock(&target_cleanup_list_lock); |
| 1029 | |
Amerigo Wang | 8d8fc29 | 2011-05-19 21:39:10 +0000 | [diff] [blame] | 1030 | if (stopped) { |
Joe Perches | 22ded57 | 2013-10-28 12:53:21 -0700 | [diff] [blame] | 1031 | const char *msg = "had an event"; |
Matthew Wood | 602ad3b | 2024-02-04 15:27:32 -0800 | [diff] [blame] | 1032 | |
Amerigo Wang | 8d8fc29 | 2011-05-19 21:39:10 +0000 | [diff] [blame] | 1033 | switch (event) { |
| 1034 | case NETDEV_UNREGISTER: |
Joe Perches | 22ded57 | 2013-10-28 12:53:21 -0700 | [diff] [blame] | 1035 | msg = "unregistered"; |
Amerigo Wang | 8d8fc29 | 2011-05-19 21:39:10 +0000 | [diff] [blame] | 1036 | break; |
Amerigo Wang | daf9209 | 2011-05-19 21:39:12 +0000 | [diff] [blame] | 1037 | case NETDEV_RELEASE: |
Joe Perches | 22ded57 | 2013-10-28 12:53:21 -0700 | [diff] [blame] | 1038 | msg = "released slaves"; |
Amerigo Wang | 8d8fc29 | 2011-05-19 21:39:10 +0000 | [diff] [blame] | 1039 | break; |
| 1040 | case NETDEV_JOIN: |
Joe Perches | 22ded57 | 2013-10-28 12:53:21 -0700 | [diff] [blame] | 1041 | msg = "is joining a master device"; |
Amerigo Wang | 8d8fc29 | 2011-05-19 21:39:10 +0000 | [diff] [blame] | 1042 | break; |
| 1043 | } |
Joe Perches | 22ded57 | 2013-10-28 12:53:21 -0700 | [diff] [blame] | 1044 | pr_info("network logging stopped on interface %s as it %s\n", |
| 1045 | dev->name, msg); |
Amerigo Wang | 8d8fc29 | 2011-05-19 21:39:10 +0000 | [diff] [blame] | 1046 | } |
Satyam Sharma | 17951f3 | 2007-08-10 15:33:01 -0700 | [diff] [blame] | 1047 | |
Breno Leitao | 9771469 | 2024-08-08 05:25:11 -0700 | [diff] [blame] | 1048 | /* Process target_cleanup_list entries. By the end, target_cleanup_list |
| 1049 | * should be empty |
| 1050 | */ |
| 1051 | netconsole_process_cleanups_core(); |
| 1052 | |
Satyam Sharma | b5427c2 | 2007-08-10 15:33:40 -0700 | [diff] [blame] | 1053 | done: |
Satyam Sharma | 17951f3 | 2007-08-10 15:33:01 -0700 | [diff] [blame] | 1054 | return NOTIFY_DONE; |
| 1055 | } |
| 1056 | |
| 1057 | static struct notifier_block netconsole_netdev_notifier = { |
| 1058 | .notifier_call = netconsole_netdev_event, |
| 1059 | }; |
| 1060 | |
Tejun Heo | e2f15f9 | 2015-06-25 15:01:41 -0700 | [diff] [blame] | 1061 | /** |
| 1062 | * send_ext_msg_udp - send extended log message to target |
| 1063 | * @nt: target to send message to |
| 1064 | * @msg: extended log message to send |
| 1065 | * @msg_len: length of message |
| 1066 | * |
| 1067 | * Transfer extended log @msg to @nt. If @msg is longer than |
| 1068 | * MAX_PRINT_CHUNK, it'll be split and transmitted in multiple chunks with |
| 1069 | * ncfrag header field added to identify them. |
| 1070 | */ |
| 1071 | static void send_ext_msg_udp(struct netconsole_target *nt, const char *msg, |
| 1072 | int msg_len) |
| 1073 | { |
| 1074 | static char buf[MAX_PRINT_CHUNK]; /* protected by target_list_lock */ |
| 1075 | const char *header, *body; |
| 1076 | int offset = 0; |
| 1077 | int header_len, body_len; |
Breno Leitao | c62c0a1 | 2023-07-14 04:13:29 -0700 | [diff] [blame] | 1078 | const char *msg_ready = msg; |
| 1079 | const char *release; |
| 1080 | int release_len = 0; |
Matthew Wood | b4ab4f2 | 2024-02-04 15:27:38 -0800 | [diff] [blame] | 1081 | int userdata_len = 0; |
| 1082 | char *userdata = NULL; |
| 1083 | |
| 1084 | #ifdef CONFIG_NETCONSOLE_DYNAMIC |
| 1085 | userdata = nt->userdata_complete; |
| 1086 | userdata_len = nt->userdata_length; |
| 1087 | #endif |
Tejun Heo | e2f15f9 | 2015-06-25 15:01:41 -0700 | [diff] [blame] | 1088 | |
Breno Leitao | c62c0a1 | 2023-07-14 04:13:29 -0700 | [diff] [blame] | 1089 | if (nt->release) { |
| 1090 | release = init_utsname()->release; |
| 1091 | release_len = strlen(release) + 1; |
| 1092 | } |
| 1093 | |
Matthew Wood | b4ab4f2 | 2024-02-04 15:27:38 -0800 | [diff] [blame] | 1094 | if (msg_len + release_len + userdata_len <= MAX_PRINT_CHUNK) { |
Breno Leitao | c62c0a1 | 2023-07-14 04:13:29 -0700 | [diff] [blame] | 1095 | /* No fragmentation needed */ |
| 1096 | if (nt->release) { |
| 1097 | scnprintf(buf, MAX_PRINT_CHUNK, "%s,%s", release, msg); |
| 1098 | msg_len += release_len; |
Matthew Wood | b4ab4f2 | 2024-02-04 15:27:38 -0800 | [diff] [blame] | 1099 | } else { |
| 1100 | memcpy(buf, msg, msg_len); |
Breno Leitao | c62c0a1 | 2023-07-14 04:13:29 -0700 | [diff] [blame] | 1101 | } |
Matthew Wood | b4ab4f2 | 2024-02-04 15:27:38 -0800 | [diff] [blame] | 1102 | |
| 1103 | if (userdata) |
| 1104 | msg_len += scnprintf(&buf[msg_len], |
| 1105 | MAX_PRINT_CHUNK - msg_len, |
| 1106 | "%s", userdata); |
| 1107 | |
| 1108 | msg_ready = buf; |
Breno Leitao | c62c0a1 | 2023-07-14 04:13:29 -0700 | [diff] [blame] | 1109 | netpoll_send_udp(&nt->np, msg_ready, msg_len); |
Tejun Heo | e2f15f9 | 2015-06-25 15:01:41 -0700 | [diff] [blame] | 1110 | return; |
| 1111 | } |
| 1112 | |
| 1113 | /* need to insert extra header fields, detect header and body */ |
| 1114 | header = msg; |
| 1115 | body = memchr(msg, ';', msg_len); |
| 1116 | if (WARN_ON_ONCE(!body)) |
| 1117 | return; |
| 1118 | |
| 1119 | header_len = body - header; |
| 1120 | body_len = msg_len - header_len - 1; |
| 1121 | body++; |
| 1122 | |
| 1123 | /* |
| 1124 | * Transfer multiple chunks with the following extra header. |
| 1125 | * "ncfrag=<byte-offset>/<total-bytes>" |
| 1126 | */ |
Breno Leitao | c62c0a1 | 2023-07-14 04:13:29 -0700 | [diff] [blame] | 1127 | if (nt->release) |
| 1128 | scnprintf(buf, MAX_PRINT_CHUNK, "%s,", release); |
| 1129 | memcpy(buf + release_len, header, header_len); |
| 1130 | header_len += release_len; |
Tejun Heo | e2f15f9 | 2015-06-25 15:01:41 -0700 | [diff] [blame] | 1131 | |
Matthew Wood | 1ec9daf | 2024-02-04 15:27:39 -0800 | [diff] [blame] | 1132 | while (offset < body_len + userdata_len) { |
Tejun Heo | e2f15f9 | 2015-06-25 15:01:41 -0700 | [diff] [blame] | 1133 | int this_header = header_len; |
Matthew Wood | 1ec9daf | 2024-02-04 15:27:39 -0800 | [diff] [blame] | 1134 | int this_offset = 0; |
| 1135 | int this_chunk = 0; |
Tejun Heo | e2f15f9 | 2015-06-25 15:01:41 -0700 | [diff] [blame] | 1136 | |
| 1137 | this_header += scnprintf(buf + this_header, |
| 1138 | sizeof(buf) - this_header, |
Matthew Wood | 1ec9daf | 2024-02-04 15:27:39 -0800 | [diff] [blame] | 1139 | ",ncfrag=%d/%d;", offset, |
| 1140 | body_len + userdata_len); |
Tejun Heo | e2f15f9 | 2015-06-25 15:01:41 -0700 | [diff] [blame] | 1141 | |
Matthew Wood | 1ec9daf | 2024-02-04 15:27:39 -0800 | [diff] [blame] | 1142 | /* Not all body data has been written yet */ |
| 1143 | if (offset < body_len) { |
| 1144 | this_chunk = min(body_len - offset, |
| 1145 | MAX_PRINT_CHUNK - this_header); |
| 1146 | if (WARN_ON_ONCE(this_chunk <= 0)) |
| 1147 | return; |
| 1148 | memcpy(buf + this_header, body + offset, this_chunk); |
| 1149 | this_offset += this_chunk; |
| 1150 | } |
| 1151 | /* Body is fully written and there is pending userdata to write, |
| 1152 | * append userdata in this chunk |
| 1153 | */ |
| 1154 | if (offset + this_offset >= body_len && |
| 1155 | offset + this_offset < userdata_len + body_len) { |
| 1156 | int sent_userdata = (offset + this_offset) - body_len; |
| 1157 | int preceding_bytes = this_chunk + this_header; |
Tejun Heo | e2f15f9 | 2015-06-25 15:01:41 -0700 | [diff] [blame] | 1158 | |
Matthew Wood | 1ec9daf | 2024-02-04 15:27:39 -0800 | [diff] [blame] | 1159 | if (WARN_ON_ONCE(sent_userdata < 0)) |
| 1160 | return; |
Tejun Heo | e2f15f9 | 2015-06-25 15:01:41 -0700 | [diff] [blame] | 1161 | |
Matthew Wood | 1ec9daf | 2024-02-04 15:27:39 -0800 | [diff] [blame] | 1162 | this_chunk = min(userdata_len - sent_userdata, |
| 1163 | MAX_PRINT_CHUNK - preceding_bytes); |
Breno Leitao | d94785b | 2024-10-08 02:43:24 -0700 | [diff] [blame] | 1164 | if (WARN_ON_ONCE(this_chunk < 0)) |
| 1165 | /* this_chunk could be zero if all the previous |
| 1166 | * message used all the buffer. This is not a |
| 1167 | * problem, userdata will be sent in the next |
| 1168 | * iteration |
| 1169 | */ |
Matthew Wood | 1ec9daf | 2024-02-04 15:27:39 -0800 | [diff] [blame] | 1170 | return; |
Breno Leitao | d94785b | 2024-10-08 02:43:24 -0700 | [diff] [blame] | 1171 | |
Matthew Wood | 1ec9daf | 2024-02-04 15:27:39 -0800 | [diff] [blame] | 1172 | memcpy(buf + this_header + this_offset, |
| 1173 | userdata + sent_userdata, |
| 1174 | this_chunk); |
| 1175 | this_offset += this_chunk; |
| 1176 | } |
Tejun Heo | e2f15f9 | 2015-06-25 15:01:41 -0700 | [diff] [blame] | 1177 | |
Matthew Wood | 1ec9daf | 2024-02-04 15:27:39 -0800 | [diff] [blame] | 1178 | netpoll_send_udp(&nt->np, buf, this_header + this_offset); |
| 1179 | offset += this_offset; |
Tejun Heo | e2f15f9 | 2015-06-25 15:01:41 -0700 | [diff] [blame] | 1180 | } |
| 1181 | } |
| 1182 | |
| 1183 | static void write_ext_msg(struct console *con, const char *msg, |
| 1184 | unsigned int len) |
| 1185 | { |
| 1186 | struct netconsole_target *nt; |
| 1187 | unsigned long flags; |
| 1188 | |
| 1189 | if ((oops_only && !oops_in_progress) || list_empty(&target_list)) |
| 1190 | return; |
| 1191 | |
| 1192 | spin_lock_irqsave(&target_list_lock, flags); |
| 1193 | list_for_each_entry(nt, &target_list, list) |
| 1194 | if (nt->extended && nt->enabled && netif_running(nt->np.dev)) |
| 1195 | send_ext_msg_udp(nt, msg, len); |
| 1196 | spin_unlock_irqrestore(&target_list_lock, flags); |
| 1197 | } |
| 1198 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1199 | static void write_msg(struct console *con, const char *msg, unsigned int len) |
| 1200 | { |
| 1201 | int frag, left; |
| 1202 | unsigned long flags; |
Satyam Sharma | b5427c2 | 2007-08-10 15:33:40 -0700 | [diff] [blame] | 1203 | struct netconsole_target *nt; |
| 1204 | const char *tmp; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1205 | |
Amerigo Wang | c1a60851 | 2012-11-08 03:42:38 +0000 | [diff] [blame] | 1206 | if (oops_only && !oops_in_progress) |
| 1207 | return; |
Satyam Sharma | b5427c2 | 2007-08-10 15:33:40 -0700 | [diff] [blame] | 1208 | /* Avoid taking lock and disabling interrupts unnecessarily */ |
| 1209 | if (list_empty(&target_list)) |
| 1210 | return; |
| 1211 | |
| 1212 | spin_lock_irqsave(&target_list_lock, flags); |
| 1213 | list_for_each_entry(nt, &target_list, list) { |
Tejun Heo | e2f15f9 | 2015-06-25 15:01:41 -0700 | [diff] [blame] | 1214 | if (!nt->extended && nt->enabled && netif_running(nt->np.dev)) { |
Satyam Sharma | b5427c2 | 2007-08-10 15:33:40 -0700 | [diff] [blame] | 1215 | /* |
| 1216 | * We nest this inside the for-each-target loop above |
| 1217 | * so that we're able to get as much logging out to |
| 1218 | * at least one target if we die inside here, instead |
| 1219 | * of unnecessarily keeping all targets in lock-step. |
| 1220 | */ |
| 1221 | tmp = msg; |
| 1222 | for (left = len; left;) { |
| 1223 | frag = min(left, MAX_PRINT_CHUNK); |
| 1224 | netpoll_send_udp(&nt->np, tmp, frag); |
| 1225 | tmp += frag; |
| 1226 | left -= frag; |
| 1227 | } |
Satyam Sharma | 0cc120be | 2007-08-10 15:30:31 -0700 | [diff] [blame] | 1228 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1229 | } |
Satyam Sharma | b5427c2 | 2007-08-10 15:33:40 -0700 | [diff] [blame] | 1230 | spin_unlock_irqrestore(&target_list_lock, flags); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1231 | } |
| 1232 | |
Breno Leitao | 28856ab | 2023-10-12 04:13:58 -0700 | [diff] [blame] | 1233 | /* Allocate new target (from boot/module param) and setup netpoll for it */ |
Breno Leitao | 131eeb4 | 2023-10-12 04:13:59 -0700 | [diff] [blame] | 1234 | static struct netconsole_target *alloc_param_target(char *target_config, |
| 1235 | int cmdline_count) |
Breno Leitao | 28856ab | 2023-10-12 04:13:58 -0700 | [diff] [blame] | 1236 | { |
| 1237 | struct netconsole_target *nt; |
| 1238 | int err; |
| 1239 | |
| 1240 | nt = alloc_and_init(); |
| 1241 | if (!nt) { |
| 1242 | err = -ENOMEM; |
| 1243 | goto fail; |
| 1244 | } |
| 1245 | |
| 1246 | if (*target_config == '+') { |
| 1247 | nt->extended = true; |
| 1248 | target_config++; |
| 1249 | } |
| 1250 | |
| 1251 | if (*target_config == 'r') { |
| 1252 | if (!nt->extended) { |
| 1253 | pr_err("Netconsole configuration error. Release feature requires extended log message"); |
| 1254 | err = -EINVAL; |
| 1255 | goto fail; |
| 1256 | } |
| 1257 | nt->release = true; |
| 1258 | target_config++; |
| 1259 | } |
| 1260 | |
| 1261 | /* Parse parameters and setup netpoll */ |
| 1262 | err = netpoll_parse_options(&nt->np, target_config); |
| 1263 | if (err) |
| 1264 | goto fail; |
| 1265 | |
| 1266 | err = netpoll_setup(&nt->np); |
Breno Leitao | 908ee29 | 2024-08-22 04:10:48 -0700 | [diff] [blame] | 1267 | if (err) { |
| 1268 | pr_err("Not enabling netconsole for %s%d. Netpoll setup failed\n", |
| 1269 | NETCONSOLE_PARAM_TARGET_PREFIX, cmdline_count); |
| 1270 | if (!IS_ENABLED(CONFIG_NETCONSOLE_DYNAMIC)) |
| 1271 | /* only fail if dynamic reconfiguration is set, |
| 1272 | * otherwise, keep the target in the list, but disabled. |
| 1273 | */ |
| 1274 | goto fail; |
| 1275 | } else { |
| 1276 | nt->enabled = true; |
| 1277 | } |
Breno Leitao | 131eeb4 | 2023-10-12 04:13:59 -0700 | [diff] [blame] | 1278 | populate_configfs_item(nt, cmdline_count); |
Breno Leitao | 28856ab | 2023-10-12 04:13:58 -0700 | [diff] [blame] | 1279 | |
| 1280 | return nt; |
| 1281 | |
| 1282 | fail: |
| 1283 | kfree(nt); |
| 1284 | return ERR_PTR(err); |
| 1285 | } |
| 1286 | |
| 1287 | /* Cleanup netpoll for given target (from boot/module param) and free it */ |
| 1288 | static void free_param_target(struct netconsole_target *nt) |
| 1289 | { |
| 1290 | netpoll_cleanup(&nt->np); |
| 1291 | kfree(nt); |
| 1292 | } |
| 1293 | |
Tejun Heo | e2f15f9 | 2015-06-25 15:01:41 -0700 | [diff] [blame] | 1294 | static struct console netconsole_ext = { |
| 1295 | .name = "netcon_ext", |
John Ogness | 2c6b4b7 | 2022-11-16 17:27:43 +0106 | [diff] [blame] | 1296 | .flags = CON_ENABLED | CON_EXTENDED, |
Tejun Heo | e2f15f9 | 2015-06-25 15:01:41 -0700 | [diff] [blame] | 1297 | .write = write_ext_msg, |
| 1298 | }; |
| 1299 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1300 | static struct console netconsole = { |
Satyam Sharma | d39badf | 2007-08-10 15:27:24 -0700 | [diff] [blame] | 1301 | .name = "netcon", |
Michael Ellerman | 0517dee | 2008-04-15 00:49:04 -0700 | [diff] [blame] | 1302 | .flags = CON_ENABLED, |
Satyam Sharma | d39badf | 2007-08-10 15:27:24 -0700 | [diff] [blame] | 1303 | .write = write_msg, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1304 | }; |
| 1305 | |
Satyam Sharma | d39badf | 2007-08-10 15:27:24 -0700 | [diff] [blame] | 1306 | static int __init init_netconsole(void) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1307 | { |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 1308 | int err; |
Satyam Sharma | b5427c2 | 2007-08-10 15:33:40 -0700 | [diff] [blame] | 1309 | struct netconsole_target *nt, *tmp; |
Breno Leitao | 131eeb4 | 2023-10-12 04:13:59 -0700 | [diff] [blame] | 1310 | unsigned int count = 0; |
John Ogness | 2c6b4b7 | 2022-11-16 17:27:43 +0106 | [diff] [blame] | 1311 | bool extended = false; |
Satyam Sharma | b5427c2 | 2007-08-10 15:33:40 -0700 | [diff] [blame] | 1312 | unsigned long flags; |
| 1313 | char *target_config; |
| 1314 | char *input = config; |
Stephen Hemminger | b41848b | 2006-10-26 15:46:52 -0700 | [diff] [blame] | 1315 | |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 1316 | if (strnlen(input, MAX_PARAM_LENGTH)) { |
| 1317 | while ((target_config = strsep(&input, ";"))) { |
Breno Leitao | 131eeb4 | 2023-10-12 04:13:59 -0700 | [diff] [blame] | 1318 | nt = alloc_param_target(target_config, count); |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 1319 | if (IS_ERR(nt)) { |
Breno Leitao | c339067 | 2024-05-28 01:42:24 -0700 | [diff] [blame] | 1320 | if (IS_ENABLED(CONFIG_NETCONSOLE_DYNAMIC)) |
| 1321 | continue; |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 1322 | err = PTR_ERR(nt); |
| 1323 | goto fail; |
| 1324 | } |
Michael Ellerman | 0517dee | 2008-04-15 00:49:04 -0700 | [diff] [blame] | 1325 | /* Dump existing printks when we register */ |
John Ogness | 2c6b4b7 | 2022-11-16 17:27:43 +0106 | [diff] [blame] | 1326 | if (nt->extended) { |
| 1327 | extended = true; |
| 1328 | netconsole_ext.flags |= CON_PRINTBUFFER; |
| 1329 | } else { |
Tejun Heo | e2f15f9 | 2015-06-25 15:01:41 -0700 | [diff] [blame] | 1330 | netconsole.flags |= CON_PRINTBUFFER; |
John Ogness | 2c6b4b7 | 2022-11-16 17:27:43 +0106 | [diff] [blame] | 1331 | } |
Michael Ellerman | 0517dee | 2008-04-15 00:49:04 -0700 | [diff] [blame] | 1332 | |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 1333 | spin_lock_irqsave(&target_list_lock, flags); |
| 1334 | list_add(&nt->list, &target_list); |
| 1335 | spin_unlock_irqrestore(&target_list_lock, flags); |
Breno Leitao | 131eeb4 | 2023-10-12 04:13:59 -0700 | [diff] [blame] | 1336 | count++; |
Satyam Sharma | b5427c2 | 2007-08-10 15:33:40 -0700 | [diff] [blame] | 1337 | } |
Satyam Sharma | b5427c2 | 2007-08-10 15:33:40 -0700 | [diff] [blame] | 1338 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1339 | |
Satyam Sharma | 17951f3 | 2007-08-10 15:33:01 -0700 | [diff] [blame] | 1340 | err = register_netdevice_notifier(&netconsole_netdev_notifier); |
| 1341 | if (err) |
Satyam Sharma | b5427c2 | 2007-08-10 15:33:40 -0700 | [diff] [blame] | 1342 | goto fail; |
Satyam Sharma | 17951f3 | 2007-08-10 15:33:01 -0700 | [diff] [blame] | 1343 | |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 1344 | err = dynamic_netconsole_init(); |
| 1345 | if (err) |
| 1346 | goto undonotifier; |
| 1347 | |
John Ogness | 2c6b4b7 | 2022-11-16 17:27:43 +0106 | [diff] [blame] | 1348 | if (extended) |
Tejun Heo | e2f15f9 | 2015-06-25 15:01:41 -0700 | [diff] [blame] | 1349 | register_console(&netconsole_ext); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1350 | register_console(&netconsole); |
Joe Perches | 22ded57 | 2013-10-28 12:53:21 -0700 | [diff] [blame] | 1351 | pr_info("network logging started\n"); |
Satyam Sharma | d39badf | 2007-08-10 15:27:24 -0700 | [diff] [blame] | 1352 | |
Satyam Sharma | d39badf | 2007-08-10 15:27:24 -0700 | [diff] [blame] | 1353 | return err; |
Satyam Sharma | b5427c2 | 2007-08-10 15:33:40 -0700 | [diff] [blame] | 1354 | |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 1355 | undonotifier: |
| 1356 | unregister_netdevice_notifier(&netconsole_netdev_notifier); |
| 1357 | |
Satyam Sharma | b5427c2 | 2007-08-10 15:33:40 -0700 | [diff] [blame] | 1358 | fail: |
Joe Perches | 22ded57 | 2013-10-28 12:53:21 -0700 | [diff] [blame] | 1359 | pr_err("cleaning up\n"); |
Satyam Sharma | b5427c2 | 2007-08-10 15:33:40 -0700 | [diff] [blame] | 1360 | |
| 1361 | /* |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 1362 | * Remove all targets and destroy them (only targets created |
| 1363 | * from the boot/module option exist here). Skipping the list |
Satyam Sharma | b5427c2 | 2007-08-10 15:33:40 -0700 | [diff] [blame] | 1364 | * lock is safe here, and netpoll_cleanup() will sleep. |
| 1365 | */ |
| 1366 | list_for_each_entry_safe(nt, tmp, &target_list, list) { |
| 1367 | list_del(&nt->list); |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 1368 | free_param_target(nt); |
Satyam Sharma | b5427c2 | 2007-08-10 15:33:40 -0700 | [diff] [blame] | 1369 | } |
| 1370 | |
| 1371 | return err; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1372 | } |
| 1373 | |
Satyam Sharma | d39badf | 2007-08-10 15:27:24 -0700 | [diff] [blame] | 1374 | static void __exit cleanup_netconsole(void) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1375 | { |
Satyam Sharma | b5427c2 | 2007-08-10 15:33:40 -0700 | [diff] [blame] | 1376 | struct netconsole_target *nt, *tmp; |
Satyam Sharma | df180e3 | 2007-08-10 15:32:14 -0700 | [diff] [blame] | 1377 | |
John Ogness | 2c6b4b7 | 2022-11-16 17:27:43 +0106 | [diff] [blame] | 1378 | if (console_is_registered(&netconsole_ext)) |
| 1379 | unregister_console(&netconsole_ext); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1380 | unregister_console(&netconsole); |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 1381 | dynamic_netconsole_exit(); |
Satyam Sharma | 17951f3 | 2007-08-10 15:33:01 -0700 | [diff] [blame] | 1382 | unregister_netdevice_notifier(&netconsole_netdev_notifier); |
Satyam Sharma | b5427c2 | 2007-08-10 15:33:40 -0700 | [diff] [blame] | 1383 | |
| 1384 | /* |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 1385 | * Targets created via configfs pin references on our module |
| 1386 | * and would first be rmdir(2)'ed from userspace. We reach |
| 1387 | * here only when they are already destroyed, and only those |
| 1388 | * created from the boot/module option are left, so remove and |
| 1389 | * destroy them. Skipping the list lock is safe here, and |
| 1390 | * netpoll_cleanup() will sleep. |
Satyam Sharma | b5427c2 | 2007-08-10 15:33:40 -0700 | [diff] [blame] | 1391 | */ |
| 1392 | list_for_each_entry_safe(nt, tmp, &target_list, list) { |
| 1393 | list_del(&nt->list); |
Satyam Sharma | 0bcc181 | 2007-08-10 15:35:05 -0700 | [diff] [blame] | 1394 | free_param_target(nt); |
Satyam Sharma | b5427c2 | 2007-08-10 15:33:40 -0700 | [diff] [blame] | 1395 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1396 | } |
| 1397 | |
Lin Ming | 97c7de0 | 2011-09-20 15:45:07 -0400 | [diff] [blame] | 1398 | /* |
| 1399 | * Use late_initcall to ensure netconsole is |
| 1400 | * initialized after network device driver if built-in. |
| 1401 | * |
| 1402 | * late_initcall() and module_init() are identical if built as module. |
| 1403 | */ |
| 1404 | late_initcall(init_netconsole); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1405 | module_exit(cleanup_netconsole); |