Commit | Line | Data |
---|---|---|
de6cc651 | 1 | // SPDX-License-Identifier: GPL-2.0-or-later |
1da177e4 LT |
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 | /**************************************************************** | |
1da177e4 LT |
22 | * |
23 | ****************************************************************/ | |
24 | ||
22ded577 JP |
25 | #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt |
26 | ||
1da177e4 | 27 | #include <linux/mm.h> |
1da177e4 LT |
28 | #include <linux/init.h> |
29 | #include <linux/module.h> | |
5a0e3ad6 | 30 | #include <linux/slab.h> |
1da177e4 | 31 | #include <linux/console.h> |
1da177e4 | 32 | #include <linux/moduleparam.h> |
4cd5773a | 33 | #include <linux/kernel.h> |
1da177e4 | 34 | #include <linux/string.h> |
1da177e4 | 35 | #include <linux/netpoll.h> |
0bcc1816 SS |
36 | #include <linux/inet.h> |
37 | #include <linux/configfs.h> | |
1667c942 | 38 | #include <linux/etherdevice.h> |
1da177e4 LT |
39 | |
40 | MODULE_AUTHOR("Maintainer: Matt Mackall <mpm@selenic.com>"); | |
41 | MODULE_DESCRIPTION("Console driver for network interfaces"); | |
42 | MODULE_LICENSE("GPL"); | |
43 | ||
d39badf0 SS |
44 | #define MAX_PARAM_LENGTH 256 |
45 | #define MAX_PRINT_CHUNK 1000 | |
46 | ||
47 | static char config[MAX_PARAM_LENGTH]; | |
48 | module_param_string(netconsole, config, MAX_PARAM_LENGTH, 0); | |
61a2d07d | 49 | MODULE_PARM_DESC(netconsole, " netconsole=[src-port]@[src-ip]/[dev],[tgt-port]@<tgt-ip>/[tgt-macaddr]"); |
1da177e4 | 50 | |
c1a60851 AW |
51 | static bool oops_only = false; |
52 | module_param(oops_only, bool, 0600); | |
53 | MODULE_PARM_DESC(oops_only, "Only log oops messages"); | |
54 | ||
d2b60881 SS |
55 | #ifndef MODULE |
56 | static int __init option_setup(char *opt) | |
57 | { | |
58 | strlcpy(config, opt, MAX_PARAM_LENGTH); | |
59 | return 1; | |
60 | } | |
61 | __setup("netconsole=", option_setup); | |
62 | #endif /* MODULE */ | |
63 | ||
b5427c27 SS |
64 | /* Linked list of all configured targets */ |
65 | static LIST_HEAD(target_list); | |
66 | ||
67 | /* This needs to be a spinlock because write_msg() cannot sleep */ | |
68 | static DEFINE_SPINLOCK(target_list_lock); | |
69 | ||
e2f15f9a TH |
70 | /* |
71 | * Console driver for extended netconsoles. Registered on the first use to | |
72 | * avoid unnecessarily enabling ext message formatting. | |
73 | */ | |
74 | static struct console netconsole_ext; | |
75 | ||
df180e36 SS |
76 | /** |
77 | * struct netconsole_target - Represents a configured netconsole target. | |
b5427c27 | 78 | * @list: Links this target into the target_list. |
0bcc1816 SS |
79 | * @item: Links us into the configfs subsystem hierarchy. |
80 | * @enabled: On / off knob to enable / disable target. | |
81 | * Visible from userspace (read-write). | |
82 | * We maintain a strict 1:1 correspondence between this and | |
83 | * whether the corresponding netpoll is active or inactive. | |
84 | * Also, other parameters of a target may be modified at | |
85 | * runtime only when it is disabled (enabled == 0). | |
df180e36 | 86 | * @np: The netpoll structure for this target. |
0bcc1816 SS |
87 | * Contains the other userspace visible parameters: |
88 | * dev_name (read-write) | |
89 | * local_port (read-write) | |
90 | * remote_port (read-write) | |
91 | * local_ip (read-write) | |
92 | * remote_ip (read-write) | |
93 | * local_mac (read-only) | |
94 | * remote_mac (read-write) | |
df180e36 SS |
95 | */ |
96 | struct netconsole_target { | |
b5427c27 | 97 | struct list_head list; |
0bcc1816 SS |
98 | #ifdef CONFIG_NETCONSOLE_DYNAMIC |
99 | struct config_item item; | |
100 | #endif | |
698cf1c6 | 101 | bool enabled; |
e2f15f9a | 102 | bool extended; |
df180e36 SS |
103 | struct netpoll np; |
104 | }; | |
105 | ||
0bcc1816 SS |
106 | #ifdef CONFIG_NETCONSOLE_DYNAMIC |
107 | ||
108 | static struct configfs_subsystem netconsole_subsys; | |
369e5a88 | 109 | static DEFINE_MUTEX(dynamic_netconsole_mutex); |
0bcc1816 SS |
110 | |
111 | static int __init dynamic_netconsole_init(void) | |
112 | { | |
113 | config_group_init(&netconsole_subsys.su_group); | |
114 | mutex_init(&netconsole_subsys.su_mutex); | |
115 | return configfs_register_subsystem(&netconsole_subsys); | |
116 | } | |
117 | ||
118 | static void __exit dynamic_netconsole_exit(void) | |
119 | { | |
120 | configfs_unregister_subsystem(&netconsole_subsys); | |
121 | } | |
122 | ||
123 | /* | |
124 | * Targets that were created by parsing the boot/module option string | |
125 | * do not exist in the configfs hierarchy (and have NULL names) and will | |
126 | * never go away, so make these a no-op for them. | |
127 | */ | |
128 | static void netconsole_target_get(struct netconsole_target *nt) | |
129 | { | |
130 | if (config_item_name(&nt->item)) | |
131 | config_item_get(&nt->item); | |
132 | } | |
133 | ||
134 | static void netconsole_target_put(struct netconsole_target *nt) | |
135 | { | |
136 | if (config_item_name(&nt->item)) | |
137 | config_item_put(&nt->item); | |
138 | } | |
139 | ||
140 | #else /* !CONFIG_NETCONSOLE_DYNAMIC */ | |
141 | ||
142 | static int __init dynamic_netconsole_init(void) | |
143 | { | |
144 | return 0; | |
145 | } | |
146 | ||
147 | static void __exit dynamic_netconsole_exit(void) | |
148 | { | |
149 | } | |
150 | ||
151 | /* | |
152 | * No danger of targets going away from under us when dynamic | |
153 | * reconfigurability is off. | |
154 | */ | |
155 | static void netconsole_target_get(struct netconsole_target *nt) | |
156 | { | |
157 | } | |
158 | ||
159 | static void netconsole_target_put(struct netconsole_target *nt) | |
160 | { | |
161 | } | |
162 | ||
163 | #endif /* CONFIG_NETCONSOLE_DYNAMIC */ | |
164 | ||
165 | /* Allocate new target (from boot/module param) and setup netpoll for it */ | |
166 | static struct netconsole_target *alloc_param_target(char *target_config) | |
b5427c27 SS |
167 | { |
168 | int err = -ENOMEM; | |
169 | struct netconsole_target *nt; | |
170 | ||
0bcc1816 SS |
171 | /* |
172 | * Allocate and initialize with defaults. | |
173 | * Note that these targets get their config_item fields zeroed-out. | |
174 | */ | |
b5427c27 | 175 | nt = kzalloc(sizeof(*nt), GFP_KERNEL); |
e404decb | 176 | if (!nt) |
b5427c27 | 177 | goto fail; |
b5427c27 SS |
178 | |
179 | nt->np.name = "netconsole"; | |
180 | strlcpy(nt->np.dev_name, "eth0", IFNAMSIZ); | |
181 | nt->np.local_port = 6665; | |
182 | nt->np.remote_port = 6666; | |
1667c942 | 183 | eth_broadcast_addr(nt->np.remote_mac); |
b5427c27 | 184 | |
e2f15f9a TH |
185 | if (*target_config == '+') { |
186 | nt->extended = true; | |
187 | target_config++; | |
188 | } | |
189 | ||
b5427c27 SS |
190 | /* Parse parameters and setup netpoll */ |
191 | err = netpoll_parse_options(&nt->np, target_config); | |
192 | if (err) | |
193 | goto fail; | |
194 | ||
195 | err = netpoll_setup(&nt->np); | |
196 | if (err) | |
197 | goto fail; | |
198 | ||
698cf1c6 | 199 | nt->enabled = true; |
0bcc1816 | 200 | |
b5427c27 SS |
201 | return nt; |
202 | ||
203 | fail: | |
204 | kfree(nt); | |
205 | return ERR_PTR(err); | |
206 | } | |
207 | ||
0bcc1816 SS |
208 | /* Cleanup netpoll for given target (from boot/module param) and free it */ |
209 | static void free_param_target(struct netconsole_target *nt) | |
b5427c27 SS |
210 | { |
211 | netpoll_cleanup(&nt->np); | |
212 | kfree(nt); | |
213 | } | |
1da177e4 | 214 | |
0bcc1816 SS |
215 | #ifdef CONFIG_NETCONSOLE_DYNAMIC |
216 | ||
217 | /* | |
218 | * Our subsystem hierarchy is: | |
219 | * | |
220 | * /sys/kernel/config/netconsole/ | |
221 | * | | |
222 | * <target>/ | |
223 | * | enabled | |
224 | * | dev_name | |
225 | * | local_port | |
226 | * | remote_port | |
227 | * | local_ip | |
228 | * | remote_ip | |
229 | * | local_mac | |
230 | * | remote_mac | |
231 | * | | |
232 | * <target>/... | |
233 | */ | |
234 | ||
0bcc1816 SS |
235 | static struct netconsole_target *to_target(struct config_item *item) |
236 | { | |
237 | return item ? | |
238 | container_of(item, struct netconsole_target, item) : | |
239 | NULL; | |
240 | } | |
241 | ||
0bcc1816 SS |
242 | /* |
243 | * Attribute operations for netconsole_target. | |
244 | */ | |
245 | ||
ea9ed9cf | 246 | static ssize_t enabled_show(struct config_item *item, char *buf) |
0bcc1816 | 247 | { |
ea9ed9cf | 248 | return snprintf(buf, PAGE_SIZE, "%d\n", to_target(item)->enabled); |
0bcc1816 SS |
249 | } |
250 | ||
ea9ed9cf | 251 | static ssize_t extended_show(struct config_item *item, char *buf) |
e2f15f9a | 252 | { |
ea9ed9cf | 253 | return snprintf(buf, PAGE_SIZE, "%d\n", to_target(item)->extended); |
e2f15f9a TH |
254 | } |
255 | ||
ea9ed9cf | 256 | static ssize_t dev_name_show(struct config_item *item, char *buf) |
0bcc1816 | 257 | { |
ea9ed9cf | 258 | return snprintf(buf, PAGE_SIZE, "%s\n", to_target(item)->np.dev_name); |
0bcc1816 SS |
259 | } |
260 | ||
ea9ed9cf | 261 | static ssize_t local_port_show(struct config_item *item, char *buf) |
0bcc1816 | 262 | { |
ea9ed9cf | 263 | return snprintf(buf, PAGE_SIZE, "%d\n", to_target(item)->np.local_port); |
0bcc1816 SS |
264 | } |
265 | ||
ea9ed9cf | 266 | static ssize_t remote_port_show(struct config_item *item, char *buf) |
0bcc1816 | 267 | { |
ea9ed9cf | 268 | return snprintf(buf, PAGE_SIZE, "%d\n", to_target(item)->np.remote_port); |
0bcc1816 SS |
269 | } |
270 | ||
ea9ed9cf | 271 | static ssize_t local_ip_show(struct config_item *item, char *buf) |
0bcc1816 | 272 | { |
ea9ed9cf CH |
273 | struct netconsole_target *nt = to_target(item); |
274 | ||
b3d936f3 CW |
275 | if (nt->np.ipv6) |
276 | return snprintf(buf, PAGE_SIZE, "%pI6c\n", &nt->np.local_ip.in6); | |
277 | else | |
b7394d24 | 278 | return snprintf(buf, PAGE_SIZE, "%pI4\n", &nt->np.local_ip); |
0bcc1816 SS |
279 | } |
280 | ||
ea9ed9cf | 281 | static ssize_t remote_ip_show(struct config_item *item, char *buf) |
0bcc1816 | 282 | { |
ea9ed9cf CH |
283 | struct netconsole_target *nt = to_target(item); |
284 | ||
b3d936f3 CW |
285 | if (nt->np.ipv6) |
286 | return snprintf(buf, PAGE_SIZE, "%pI6c\n", &nt->np.remote_ip.in6); | |
287 | else | |
b7394d24 | 288 | return snprintf(buf, PAGE_SIZE, "%pI4\n", &nt->np.remote_ip); |
0bcc1816 SS |
289 | } |
290 | ||
ea9ed9cf | 291 | static ssize_t local_mac_show(struct config_item *item, char *buf) |
0bcc1816 | 292 | { |
ea9ed9cf | 293 | struct net_device *dev = to_target(item)->np.dev; |
e174961c | 294 | static const u8 bcast[ETH_ALEN] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }; |
09538641 | 295 | |
e174961c | 296 | return snprintf(buf, PAGE_SIZE, "%pM\n", dev ? dev->dev_addr : bcast); |
0bcc1816 SS |
297 | } |
298 | ||
ea9ed9cf | 299 | static ssize_t remote_mac_show(struct config_item *item, char *buf) |
0bcc1816 | 300 | { |
ea9ed9cf | 301 | return snprintf(buf, PAGE_SIZE, "%pM\n", to_target(item)->np.remote_mac); |
0bcc1816 SS |
302 | } |
303 | ||
304 | /* | |
305 | * This one is special -- targets created through the configfs interface | |
306 | * are not enabled (and the corresponding netpoll activated) by default. | |
307 | * The user is expected to set the desired parameters first (which | |
308 | * would enable him to dynamically add new netpoll targets for new | |
309 | * network interfaces as and when they come up). | |
310 | */ | |
ea9ed9cf CH |
311 | static ssize_t enabled_store(struct config_item *item, |
312 | const char *buf, size_t count) | |
0bcc1816 | 313 | { |
ea9ed9cf | 314 | struct netconsole_target *nt = to_target(item); |
45e526e8 | 315 | unsigned long flags; |
99f823f9 | 316 | int enabled; |
0bcc1816 | 317 | int err; |
0bcc1816 | 318 | |
ea9ed9cf | 319 | mutex_lock(&dynamic_netconsole_mutex); |
99f823f9 AD |
320 | err = kstrtoint(buf, 10, &enabled); |
321 | if (err < 0) | |
ea9ed9cf CH |
322 | goto out_unlock; |
323 | ||
324 | err = -EINVAL; | |
99f823f9 | 325 | if (enabled < 0 || enabled > 1) |
ea9ed9cf | 326 | goto out_unlock; |
698cf1c6 | 327 | if ((bool)enabled == nt->enabled) { |
22ded577 JP |
328 | pr_info("network logging has already %s\n", |
329 | nt->enabled ? "started" : "stopped"); | |
ea9ed9cf | 330 | goto out_unlock; |
d5123480 | 331 | } |
0bcc1816 | 332 | |
698cf1c6 | 333 | if (enabled) { /* true */ |
e2f15f9a TH |
334 | if (nt->extended && !(netconsole_ext.flags & CON_ENABLED)) { |
335 | netconsole_ext.flags |= CON_ENABLED; | |
336 | register_console(&netconsole_ext); | |
337 | } | |
338 | ||
0bcc1816 SS |
339 | /* |
340 | * Skip netpoll_parse_options() -- all the attributes are | |
341 | * already configured via configfs. Just print them out. | |
342 | */ | |
343 | netpoll_print_options(&nt->np); | |
344 | ||
345 | err = netpoll_setup(&nt->np); | |
c7c6effd | 346 | if (err) |
ea9ed9cf | 347 | goto out_unlock; |
0bcc1816 | 348 | |
4a6a97e2 | 349 | pr_info("network logging started\n"); |
698cf1c6 | 350 | } else { /* false */ |
45e526e8 NA |
351 | /* We need to disable the netconsole before cleaning it up |
352 | * otherwise we might end up in write_msg() with | |
698cf1c6 | 353 | * nt->np.dev == NULL and nt->enabled == true |
45e526e8 NA |
354 | */ |
355 | spin_lock_irqsave(&target_list_lock, flags); | |
698cf1c6 | 356 | nt->enabled = false; |
45e526e8 | 357 | spin_unlock_irqrestore(&target_list_lock, flags); |
0bcc1816 SS |
358 | netpoll_cleanup(&nt->np); |
359 | } | |
360 | ||
361 | nt->enabled = enabled; | |
362 | ||
ea9ed9cf | 363 | mutex_unlock(&dynamic_netconsole_mutex); |
0bcc1816 | 364 | return strnlen(buf, count); |
ea9ed9cf CH |
365 | out_unlock: |
366 | mutex_unlock(&dynamic_netconsole_mutex); | |
367 | return err; | |
0bcc1816 SS |
368 | } |
369 | ||
ea9ed9cf CH |
370 | static ssize_t extended_store(struct config_item *item, const char *buf, |
371 | size_t count) | |
e2f15f9a | 372 | { |
ea9ed9cf | 373 | struct netconsole_target *nt = to_target(item); |
e2f15f9a TH |
374 | int extended; |
375 | int err; | |
376 | ||
ea9ed9cf | 377 | mutex_lock(&dynamic_netconsole_mutex); |
e2f15f9a TH |
378 | if (nt->enabled) { |
379 | pr_err("target (%s) is enabled, disable to update parameters\n", | |
380 | config_item_name(&nt->item)); | |
ea9ed9cf CH |
381 | err = -EINVAL; |
382 | goto out_unlock; | |
e2f15f9a TH |
383 | } |
384 | ||
385 | err = kstrtoint(buf, 10, &extended); | |
386 | if (err < 0) | |
ea9ed9cf CH |
387 | goto out_unlock; |
388 | if (extended < 0 || extended > 1) { | |
389 | err = -EINVAL; | |
390 | goto out_unlock; | |
391 | } | |
e2f15f9a TH |
392 | |
393 | nt->extended = extended; | |
394 | ||
ea9ed9cf | 395 | mutex_unlock(&dynamic_netconsole_mutex); |
e2f15f9a | 396 | return strnlen(buf, count); |
ea9ed9cf CH |
397 | out_unlock: |
398 | mutex_unlock(&dynamic_netconsole_mutex); | |
399 | return err; | |
e2f15f9a TH |
400 | } |
401 | ||
ea9ed9cf CH |
402 | static ssize_t dev_name_store(struct config_item *item, const char *buf, |
403 | size_t count) | |
0bcc1816 | 404 | { |
ea9ed9cf | 405 | struct netconsole_target *nt = to_target(item); |
0bcc1816 SS |
406 | size_t len; |
407 | ||
ea9ed9cf | 408 | mutex_lock(&dynamic_netconsole_mutex); |
0bcc1816 | 409 | if (nt->enabled) { |
22ded577 JP |
410 | pr_err("target (%s) is enabled, disable to update parameters\n", |
411 | config_item_name(&nt->item)); | |
ea9ed9cf | 412 | mutex_unlock(&dynamic_netconsole_mutex); |
0bcc1816 SS |
413 | return -EINVAL; |
414 | } | |
415 | ||
416 | strlcpy(nt->np.dev_name, buf, IFNAMSIZ); | |
417 | ||
418 | /* Get rid of possible trailing newline from echo(1) */ | |
419 | len = strnlen(nt->np.dev_name, IFNAMSIZ); | |
420 | if (nt->np.dev_name[len - 1] == '\n') | |
421 | nt->np.dev_name[len - 1] = '\0'; | |
422 | ||
ea9ed9cf | 423 | mutex_unlock(&dynamic_netconsole_mutex); |
0bcc1816 SS |
424 | return strnlen(buf, count); |
425 | } | |
426 | ||
ea9ed9cf CH |
427 | static ssize_t local_port_store(struct config_item *item, const char *buf, |
428 | size_t count) | |
0bcc1816 | 429 | { |
ea9ed9cf CH |
430 | struct netconsole_target *nt = to_target(item); |
431 | int rv = -EINVAL; | |
0bcc1816 | 432 | |
ea9ed9cf | 433 | mutex_lock(&dynamic_netconsole_mutex); |
0bcc1816 | 434 | if (nt->enabled) { |
22ded577 JP |
435 | pr_err("target (%s) is enabled, disable to update parameters\n", |
436 | config_item_name(&nt->item)); | |
ea9ed9cf | 437 | goto out_unlock; |
0bcc1816 SS |
438 | } |
439 | ||
99f823f9 AD |
440 | rv = kstrtou16(buf, 10, &nt->np.local_port); |
441 | if (rv < 0) | |
ea9ed9cf CH |
442 | goto out_unlock; |
443 | mutex_unlock(&dynamic_netconsole_mutex); | |
0bcc1816 | 444 | return strnlen(buf, count); |
ea9ed9cf CH |
445 | out_unlock: |
446 | mutex_unlock(&dynamic_netconsole_mutex); | |
447 | return rv; | |
0bcc1816 SS |
448 | } |
449 | ||
ea9ed9cf CH |
450 | static ssize_t remote_port_store(struct config_item *item, |
451 | const char *buf, size_t count) | |
0bcc1816 | 452 | { |
ea9ed9cf CH |
453 | struct netconsole_target *nt = to_target(item); |
454 | int rv = -EINVAL; | |
0bcc1816 | 455 | |
ea9ed9cf | 456 | mutex_lock(&dynamic_netconsole_mutex); |
0bcc1816 | 457 | if (nt->enabled) { |
22ded577 JP |
458 | pr_err("target (%s) is enabled, disable to update parameters\n", |
459 | config_item_name(&nt->item)); | |
ea9ed9cf | 460 | goto out_unlock; |
0bcc1816 SS |
461 | } |
462 | ||
99f823f9 AD |
463 | rv = kstrtou16(buf, 10, &nt->np.remote_port); |
464 | if (rv < 0) | |
ea9ed9cf CH |
465 | goto out_unlock; |
466 | mutex_unlock(&dynamic_netconsole_mutex); | |
0bcc1816 | 467 | return strnlen(buf, count); |
ea9ed9cf CH |
468 | out_unlock: |
469 | mutex_unlock(&dynamic_netconsole_mutex); | |
470 | return rv; | |
0bcc1816 SS |
471 | } |
472 | ||
ea9ed9cf CH |
473 | static ssize_t local_ip_store(struct config_item *item, const char *buf, |
474 | size_t count) | |
0bcc1816 | 475 | { |
ea9ed9cf CH |
476 | struct netconsole_target *nt = to_target(item); |
477 | ||
478 | mutex_lock(&dynamic_netconsole_mutex); | |
0bcc1816 | 479 | if (nt->enabled) { |
22ded577 JP |
480 | pr_err("target (%s) is enabled, disable to update parameters\n", |
481 | config_item_name(&nt->item)); | |
ea9ed9cf | 482 | goto out_unlock; |
0bcc1816 SS |
483 | } |
484 | ||
b3d936f3 CW |
485 | if (strnchr(buf, count, ':')) { |
486 | const char *end; | |
487 | if (in6_pton(buf, count, nt->np.local_ip.in6.s6_addr, -1, &end) > 0) { | |
488 | if (*end && *end != '\n') { | |
22ded577 | 489 | pr_err("invalid IPv6 address at: <%c>\n", *end); |
ea9ed9cf | 490 | goto out_unlock; |
b3d936f3 CW |
491 | } |
492 | nt->np.ipv6 = true; | |
493 | } else | |
ea9ed9cf | 494 | goto out_unlock; |
b3d936f3 CW |
495 | } else { |
496 | if (!nt->np.ipv6) { | |
497 | nt->np.local_ip.ip = in_aton(buf); | |
498 | } else | |
ea9ed9cf | 499 | goto out_unlock; |
b3d936f3 | 500 | } |
0bcc1816 | 501 | |
ea9ed9cf | 502 | mutex_unlock(&dynamic_netconsole_mutex); |
0bcc1816 | 503 | return strnlen(buf, count); |
ea9ed9cf CH |
504 | out_unlock: |
505 | mutex_unlock(&dynamic_netconsole_mutex); | |
506 | return -EINVAL; | |
0bcc1816 SS |
507 | } |
508 | ||
ea9ed9cf CH |
509 | static ssize_t remote_ip_store(struct config_item *item, const char *buf, |
510 | size_t count) | |
0bcc1816 | 511 | { |
ea9ed9cf CH |
512 | struct netconsole_target *nt = to_target(item); |
513 | ||
514 | mutex_lock(&dynamic_netconsole_mutex); | |
0bcc1816 | 515 | if (nt->enabled) { |
22ded577 JP |
516 | pr_err("target (%s) is enabled, disable to update parameters\n", |
517 | config_item_name(&nt->item)); | |
ea9ed9cf | 518 | goto out_unlock; |
0bcc1816 SS |
519 | } |
520 | ||
b3d936f3 CW |
521 | if (strnchr(buf, count, ':')) { |
522 | const char *end; | |
523 | if (in6_pton(buf, count, nt->np.remote_ip.in6.s6_addr, -1, &end) > 0) { | |
524 | if (*end && *end != '\n') { | |
22ded577 | 525 | pr_err("invalid IPv6 address at: <%c>\n", *end); |
ea9ed9cf | 526 | goto out_unlock; |
b3d936f3 CW |
527 | } |
528 | nt->np.ipv6 = true; | |
529 | } else | |
ea9ed9cf | 530 | goto out_unlock; |
b3d936f3 CW |
531 | } else { |
532 | if (!nt->np.ipv6) { | |
533 | nt->np.remote_ip.ip = in_aton(buf); | |
534 | } else | |
ea9ed9cf | 535 | goto out_unlock; |
b3d936f3 | 536 | } |
0bcc1816 | 537 | |
ea9ed9cf | 538 | mutex_unlock(&dynamic_netconsole_mutex); |
0bcc1816 | 539 | return strnlen(buf, count); |
ea9ed9cf CH |
540 | out_unlock: |
541 | mutex_unlock(&dynamic_netconsole_mutex); | |
542 | return -EINVAL; | |
0bcc1816 SS |
543 | } |
544 | ||
ea9ed9cf CH |
545 | static ssize_t remote_mac_store(struct config_item *item, const char *buf, |
546 | size_t count) | |
0bcc1816 | 547 | { |
ea9ed9cf | 548 | struct netconsole_target *nt = to_target(item); |
0bcc1816 | 549 | u8 remote_mac[ETH_ALEN]; |
0bcc1816 | 550 | |
ea9ed9cf | 551 | mutex_lock(&dynamic_netconsole_mutex); |
0bcc1816 | 552 | if (nt->enabled) { |
22ded577 JP |
553 | pr_err("target (%s) is enabled, disable to update parameters\n", |
554 | config_item_name(&nt->item)); | |
ea9ed9cf | 555 | goto out_unlock; |
0bcc1816 SS |
556 | } |
557 | ||
4940fc88 | 558 | if (!mac_pton(buf, remote_mac)) |
ea9ed9cf | 559 | goto out_unlock; |
4940fc88 | 560 | if (buf[3 * ETH_ALEN - 1] && buf[3 * ETH_ALEN - 1] != '\n') |
ea9ed9cf | 561 | goto out_unlock; |
0bcc1816 SS |
562 | memcpy(nt->np.remote_mac, remote_mac, ETH_ALEN); |
563 | ||
ea9ed9cf | 564 | mutex_unlock(&dynamic_netconsole_mutex); |
0bcc1816 | 565 | return strnlen(buf, count); |
ea9ed9cf CH |
566 | out_unlock: |
567 | mutex_unlock(&dynamic_netconsole_mutex); | |
568 | return -EINVAL; | |
0bcc1816 SS |
569 | } |
570 | ||
ea9ed9cf CH |
571 | CONFIGFS_ATTR(, enabled); |
572 | CONFIGFS_ATTR(, extended); | |
573 | CONFIGFS_ATTR(, dev_name); | |
574 | CONFIGFS_ATTR(, local_port); | |
575 | CONFIGFS_ATTR(, remote_port); | |
576 | CONFIGFS_ATTR(, local_ip); | |
577 | CONFIGFS_ATTR(, remote_ip); | |
578 | CONFIGFS_ATTR_RO(, local_mac); | |
579 | CONFIGFS_ATTR(, remote_mac); | |
0bcc1816 SS |
580 | |
581 | static struct configfs_attribute *netconsole_target_attrs[] = { | |
ea9ed9cf CH |
582 | &attr_enabled, |
583 | &attr_extended, | |
584 | &attr_dev_name, | |
585 | &attr_local_port, | |
586 | &attr_remote_port, | |
587 | &attr_local_ip, | |
588 | &attr_remote_ip, | |
589 | &attr_local_mac, | |
590 | &attr_remote_mac, | |
0bcc1816 SS |
591 | NULL, |
592 | }; | |
593 | ||
594 | /* | |
595 | * Item operations and type for netconsole_target. | |
596 | */ | |
597 | ||
598 | static void netconsole_target_release(struct config_item *item) | |
599 | { | |
600 | kfree(to_target(item)); | |
601 | } | |
602 | ||
0bcc1816 SS |
603 | static struct configfs_item_operations netconsole_target_item_ops = { |
604 | .release = netconsole_target_release, | |
0bcc1816 SS |
605 | }; |
606 | ||
0d4a4406 | 607 | static const struct config_item_type netconsole_target_type = { |
0bcc1816 SS |
608 | .ct_attrs = netconsole_target_attrs, |
609 | .ct_item_ops = &netconsole_target_item_ops, | |
610 | .ct_owner = THIS_MODULE, | |
611 | }; | |
612 | ||
613 | /* | |
614 | * Group operations and type for netconsole_subsys. | |
615 | */ | |
616 | ||
f89ab861 JB |
617 | static struct config_item *make_netconsole_target(struct config_group *group, |
618 | const char *name) | |
0bcc1816 SS |
619 | { |
620 | unsigned long flags; | |
621 | struct netconsole_target *nt; | |
622 | ||
623 | /* | |
624 | * Allocate and initialize with defaults. | |
698cf1c6 | 625 | * Target is disabled at creation (!enabled). |
0bcc1816 SS |
626 | */ |
627 | nt = kzalloc(sizeof(*nt), GFP_KERNEL); | |
e404decb | 628 | if (!nt) |
a6795e9e | 629 | return ERR_PTR(-ENOMEM); |
0bcc1816 SS |
630 | |
631 | nt->np.name = "netconsole"; | |
632 | strlcpy(nt->np.dev_name, "eth0", IFNAMSIZ); | |
633 | nt->np.local_port = 6665; | |
634 | nt->np.remote_port = 6666; | |
1667c942 | 635 | eth_broadcast_addr(nt->np.remote_mac); |
0bcc1816 SS |
636 | |
637 | /* Initialize the config_item member */ | |
638 | config_item_init_type_name(&nt->item, name, &netconsole_target_type); | |
639 | ||
640 | /* Adding, but it is disabled */ | |
641 | spin_lock_irqsave(&target_list_lock, flags); | |
642 | list_add(&nt->list, &target_list); | |
643 | spin_unlock_irqrestore(&target_list_lock, flags); | |
644 | ||
f89ab861 | 645 | return &nt->item; |
0bcc1816 SS |
646 | } |
647 | ||
648 | static void drop_netconsole_target(struct config_group *group, | |
649 | struct config_item *item) | |
650 | { | |
651 | unsigned long flags; | |
652 | struct netconsole_target *nt = to_target(item); | |
653 | ||
654 | spin_lock_irqsave(&target_list_lock, flags); | |
655 | list_del(&nt->list); | |
656 | spin_unlock_irqrestore(&target_list_lock, flags); | |
657 | ||
658 | /* | |
659 | * The target may have never been enabled, or was manually disabled | |
660 | * before being removed so netpoll may have already been cleaned up. | |
661 | */ | |
662 | if (nt->enabled) | |
663 | netpoll_cleanup(&nt->np); | |
664 | ||
665 | config_item_put(&nt->item); | |
666 | } | |
667 | ||
668 | static struct configfs_group_operations netconsole_subsys_group_ops = { | |
669 | .make_item = make_netconsole_target, | |
670 | .drop_item = drop_netconsole_target, | |
671 | }; | |
672 | ||
0d4a4406 | 673 | static const struct config_item_type netconsole_subsys_type = { |
0bcc1816 SS |
674 | .ct_group_ops = &netconsole_subsys_group_ops, |
675 | .ct_owner = THIS_MODULE, | |
676 | }; | |
677 | ||
678 | /* The netconsole configfs subsystem */ | |
679 | static struct configfs_subsystem netconsole_subsys = { | |
680 | .su_group = { | |
681 | .cg_item = { | |
682 | .ci_namebuf = "netconsole", | |
683 | .ci_type = &netconsole_subsys_type, | |
684 | }, | |
685 | }, | |
686 | }; | |
687 | ||
688 | #endif /* CONFIG_NETCONSOLE_DYNAMIC */ | |
689 | ||
17951f34 SS |
690 | /* Handle network interface device notifications */ |
691 | static int netconsole_netdev_event(struct notifier_block *this, | |
351638e7 | 692 | unsigned long event, void *ptr) |
17951f34 | 693 | { |
b5427c27 SS |
694 | unsigned long flags; |
695 | struct netconsole_target *nt; | |
351638e7 | 696 | struct net_device *dev = netdev_notifier_info_to_dev(ptr); |
141dfba3 | 697 | bool stopped = false; |
17951f34 | 698 | |
0e34e931 | 699 | if (!(event == NETDEV_CHANGENAME || event == NETDEV_UNREGISTER || |
daf9209b | 700 | event == NETDEV_RELEASE || event == NETDEV_JOIN)) |
b5427c27 SS |
701 | goto done; |
702 | ||
703 | spin_lock_irqsave(&target_list_lock, flags); | |
3f315bef | 704 | restart: |
b5427c27 | 705 | list_for_each_entry(nt, &target_list, list) { |
0bcc1816 | 706 | netconsole_target_get(nt); |
b5427c27 SS |
707 | if (nt->np.dev == dev) { |
708 | switch (event) { | |
b5427c27 SS |
709 | case NETDEV_CHANGENAME: |
710 | strlcpy(nt->np.dev_name, dev->name, IFNAMSIZ); | |
711 | break; | |
daf9209b | 712 | case NETDEV_RELEASE: |
8d8fc29d | 713 | case NETDEV_JOIN: |
2382b15b | 714 | case NETDEV_UNREGISTER: |
c71380ff | 715 | /* rtnl_lock already held |
3f315bef | 716 | * we might sleep in __netpoll_cleanup() |
3b410a31 | 717 | */ |
3f315bef | 718 | spin_unlock_irqrestore(&target_list_lock, flags); |
7a163bfb | 719 | |
3f315bef | 720 | __netpoll_cleanup(&nt->np); |
7a163bfb | 721 | |
3f315bef VF |
722 | spin_lock_irqsave(&target_list_lock, flags); |
723 | dev_put(nt->np.dev); | |
724 | nt->np.dev = NULL; | |
698cf1c6 | 725 | nt->enabled = false; |
141dfba3 | 726 | stopped = true; |
3f315bef VF |
727 | netconsole_target_put(nt); |
728 | goto restart; | |
b5427c27 | 729 | } |
17951f34 | 730 | } |
0bcc1816 | 731 | netconsole_target_put(nt); |
17951f34 | 732 | } |
b5427c27 | 733 | spin_unlock_irqrestore(&target_list_lock, flags); |
8d8fc29d | 734 | if (stopped) { |
22ded577 | 735 | const char *msg = "had an event"; |
8d8fc29d AW |
736 | switch (event) { |
737 | case NETDEV_UNREGISTER: | |
22ded577 | 738 | msg = "unregistered"; |
8d8fc29d | 739 | break; |
daf9209b | 740 | case NETDEV_RELEASE: |
22ded577 | 741 | msg = "released slaves"; |
8d8fc29d AW |
742 | break; |
743 | case NETDEV_JOIN: | |
22ded577 | 744 | msg = "is joining a master device"; |
8d8fc29d AW |
745 | break; |
746 | } | |
22ded577 JP |
747 | pr_info("network logging stopped on interface %s as it %s\n", |
748 | dev->name, msg); | |
8d8fc29d | 749 | } |
17951f34 | 750 | |
b5427c27 | 751 | done: |
17951f34 SS |
752 | return NOTIFY_DONE; |
753 | } | |
754 | ||
755 | static struct notifier_block netconsole_netdev_notifier = { | |
756 | .notifier_call = netconsole_netdev_event, | |
757 | }; | |
758 | ||
e2f15f9a TH |
759 | /** |
760 | * send_ext_msg_udp - send extended log message to target | |
761 | * @nt: target to send message to | |
762 | * @msg: extended log message to send | |
763 | * @msg_len: length of message | |
764 | * | |
765 | * Transfer extended log @msg to @nt. If @msg is longer than | |
766 | * MAX_PRINT_CHUNK, it'll be split and transmitted in multiple chunks with | |
767 | * ncfrag header field added to identify them. | |
768 | */ | |
769 | static void send_ext_msg_udp(struct netconsole_target *nt, const char *msg, | |
770 | int msg_len) | |
771 | { | |
772 | static char buf[MAX_PRINT_CHUNK]; /* protected by target_list_lock */ | |
773 | const char *header, *body; | |
774 | int offset = 0; | |
775 | int header_len, body_len; | |
776 | ||
777 | if (msg_len <= MAX_PRINT_CHUNK) { | |
778 | netpoll_send_udp(&nt->np, msg, msg_len); | |
779 | return; | |
780 | } | |
781 | ||
782 | /* need to insert extra header fields, detect header and body */ | |
783 | header = msg; | |
784 | body = memchr(msg, ';', msg_len); | |
785 | if (WARN_ON_ONCE(!body)) | |
786 | return; | |
787 | ||
788 | header_len = body - header; | |
789 | body_len = msg_len - header_len - 1; | |
790 | body++; | |
791 | ||
792 | /* | |
793 | * Transfer multiple chunks with the following extra header. | |
794 | * "ncfrag=<byte-offset>/<total-bytes>" | |
795 | */ | |
796 | memcpy(buf, header, header_len); | |
797 | ||
798 | while (offset < body_len) { | |
799 | int this_header = header_len; | |
800 | int this_chunk; | |
801 | ||
802 | this_header += scnprintf(buf + this_header, | |
803 | sizeof(buf) - this_header, | |
804 | ",ncfrag=%d/%d;", offset, body_len); | |
805 | ||
806 | this_chunk = min(body_len - offset, | |
807 | MAX_PRINT_CHUNK - this_header); | |
808 | if (WARN_ON_ONCE(this_chunk <= 0)) | |
809 | return; | |
810 | ||
811 | memcpy(buf + this_header, body + offset, this_chunk); | |
812 | ||
813 | netpoll_send_udp(&nt->np, buf, this_header + this_chunk); | |
814 | ||
815 | offset += this_chunk; | |
816 | } | |
817 | } | |
818 | ||
819 | static void write_ext_msg(struct console *con, const char *msg, | |
820 | unsigned int len) | |
821 | { | |
822 | struct netconsole_target *nt; | |
823 | unsigned long flags; | |
824 | ||
825 | if ((oops_only && !oops_in_progress) || list_empty(&target_list)) | |
826 | return; | |
827 | ||
828 | spin_lock_irqsave(&target_list_lock, flags); | |
829 | list_for_each_entry(nt, &target_list, list) | |
830 | if (nt->extended && nt->enabled && netif_running(nt->np.dev)) | |
831 | send_ext_msg_udp(nt, msg, len); | |
832 | spin_unlock_irqrestore(&target_list_lock, flags); | |
833 | } | |
834 | ||
1da177e4 LT |
835 | static void write_msg(struct console *con, const char *msg, unsigned int len) |
836 | { | |
837 | int frag, left; | |
838 | unsigned long flags; | |
b5427c27 SS |
839 | struct netconsole_target *nt; |
840 | const char *tmp; | |
841 | ||
c1a60851 AW |
842 | if (oops_only && !oops_in_progress) |
843 | return; | |
b5427c27 SS |
844 | /* Avoid taking lock and disabling interrupts unnecessarily */ |
845 | if (list_empty(&target_list)) | |
846 | return; | |
847 | ||
848 | spin_lock_irqsave(&target_list_lock, flags); | |
849 | list_for_each_entry(nt, &target_list, list) { | |
e2f15f9a | 850 | if (!nt->extended && nt->enabled && netif_running(nt->np.dev)) { |
b5427c27 SS |
851 | /* |
852 | * We nest this inside the for-each-target loop above | |
853 | * so that we're able to get as much logging out to | |
854 | * at least one target if we die inside here, instead | |
855 | * of unnecessarily keeping all targets in lock-step. | |
856 | */ | |
857 | tmp = msg; | |
858 | for (left = len; left;) { | |
859 | frag = min(left, MAX_PRINT_CHUNK); | |
860 | netpoll_send_udp(&nt->np, tmp, frag); | |
861 | tmp += frag; | |
862 | left -= frag; | |
863 | } | |
0cc120be | 864 | } |
1da177e4 | 865 | } |
b5427c27 | 866 | spin_unlock_irqrestore(&target_list_lock, flags); |
1da177e4 LT |
867 | } |
868 | ||
e2f15f9a TH |
869 | static struct console netconsole_ext = { |
870 | .name = "netcon_ext", | |
871 | .flags = CON_EXTENDED, /* starts disabled, registered on first use */ | |
872 | .write = write_ext_msg, | |
873 | }; | |
874 | ||
1da177e4 | 875 | static struct console netconsole = { |
d39badf0 | 876 | .name = "netcon", |
0517deed | 877 | .flags = CON_ENABLED, |
d39badf0 | 878 | .write = write_msg, |
1da177e4 LT |
879 | }; |
880 | ||
d39badf0 | 881 | static int __init init_netconsole(void) |
1da177e4 | 882 | { |
0bcc1816 | 883 | int err; |
b5427c27 SS |
884 | struct netconsole_target *nt, *tmp; |
885 | unsigned long flags; | |
886 | char *target_config; | |
887 | char *input = config; | |
b41848b6 | 888 | |
0bcc1816 SS |
889 | if (strnlen(input, MAX_PARAM_LENGTH)) { |
890 | while ((target_config = strsep(&input, ";"))) { | |
891 | nt = alloc_param_target(target_config); | |
892 | if (IS_ERR(nt)) { | |
893 | err = PTR_ERR(nt); | |
894 | goto fail; | |
895 | } | |
0517deed | 896 | /* Dump existing printks when we register */ |
e2f15f9a TH |
897 | if (nt->extended) |
898 | netconsole_ext.flags |= CON_PRINTBUFFER | | |
899 | CON_ENABLED; | |
900 | else | |
901 | netconsole.flags |= CON_PRINTBUFFER; | |
0517deed | 902 | |
0bcc1816 SS |
903 | spin_lock_irqsave(&target_list_lock, flags); |
904 | list_add(&nt->list, &target_list); | |
905 | spin_unlock_irqrestore(&target_list_lock, flags); | |
b5427c27 | 906 | } |
b5427c27 | 907 | } |
1da177e4 | 908 | |
17951f34 SS |
909 | err = register_netdevice_notifier(&netconsole_netdev_notifier); |
910 | if (err) | |
b5427c27 | 911 | goto fail; |
17951f34 | 912 | |
0bcc1816 SS |
913 | err = dynamic_netconsole_init(); |
914 | if (err) | |
915 | goto undonotifier; | |
916 | ||
e2f15f9a TH |
917 | if (netconsole_ext.flags & CON_ENABLED) |
918 | register_console(&netconsole_ext); | |
1da177e4 | 919 | register_console(&netconsole); |
22ded577 | 920 | pr_info("network logging started\n"); |
d39badf0 | 921 | |
d39badf0 | 922 | return err; |
b5427c27 | 923 | |
0bcc1816 SS |
924 | undonotifier: |
925 | unregister_netdevice_notifier(&netconsole_netdev_notifier); | |
926 | ||
b5427c27 | 927 | fail: |
22ded577 | 928 | pr_err("cleaning up\n"); |
b5427c27 SS |
929 | |
930 | /* | |
0bcc1816 SS |
931 | * Remove all targets and destroy them (only targets created |
932 | * from the boot/module option exist here). Skipping the list | |
b5427c27 SS |
933 | * lock is safe here, and netpoll_cleanup() will sleep. |
934 | */ | |
935 | list_for_each_entry_safe(nt, tmp, &target_list, list) { | |
936 | list_del(&nt->list); | |
0bcc1816 | 937 | free_param_target(nt); |
b5427c27 SS |
938 | } |
939 | ||
940 | return err; | |
1da177e4 LT |
941 | } |
942 | ||
d39badf0 | 943 | static void __exit cleanup_netconsole(void) |
1da177e4 | 944 | { |
b5427c27 | 945 | struct netconsole_target *nt, *tmp; |
df180e36 | 946 | |
e2f15f9a | 947 | unregister_console(&netconsole_ext); |
1da177e4 | 948 | unregister_console(&netconsole); |
0bcc1816 | 949 | dynamic_netconsole_exit(); |
17951f34 | 950 | unregister_netdevice_notifier(&netconsole_netdev_notifier); |
b5427c27 SS |
951 | |
952 | /* | |
0bcc1816 SS |
953 | * Targets created via configfs pin references on our module |
954 | * and would first be rmdir(2)'ed from userspace. We reach | |
955 | * here only when they are already destroyed, and only those | |
956 | * created from the boot/module option are left, so remove and | |
957 | * destroy them. Skipping the list lock is safe here, and | |
958 | * netpoll_cleanup() will sleep. | |
b5427c27 SS |
959 | */ |
960 | list_for_each_entry_safe(nt, tmp, &target_list, list) { | |
961 | list_del(&nt->list); | |
0bcc1816 | 962 | free_param_target(nt); |
b5427c27 | 963 | } |
1da177e4 LT |
964 | } |
965 | ||
97c7de05 LM |
966 | /* |
967 | * Use late_initcall to ensure netconsole is | |
968 | * initialized after network device driver if built-in. | |
969 | * | |
970 | * late_initcall() and module_init() are identical if built as module. | |
971 | */ | |
972 | late_initcall(init_netconsole); | |
1da177e4 | 973 | module_exit(cleanup_netconsole); |