blob: 15731d1db918c32f6dc341800155340c0e62a7a2 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * linux/drivers/net/netconsole.c
3 *
4 * Copyright (C) 2001 Ingo Molnar <mingo@redhat.com>
5 *
6 * This file contains the implementation of an IRQ-safe, crash-safe
7 * kernel console implementation that outputs kernel messages to the
8 * network.
9 *
10 * Modification history:
11 *
12 * 2001-09-17 started by Ingo Molnar.
13 * 2003-08-11 2.6 port by Matt Mackall
14 * simplified options
15 * generic card hooks
16 * works non-modular
17 * 2003-09-07 rewritten with netpoll api
18 */
19
20/****************************************************************
21 * This program is free software; you can redistribute it and/or modify
22 * it under the terms of the GNU General Public License as published by
23 * the Free Software Foundation; either version 2, or (at your option)
24 * any later version.
25 *
26 * This program is distributed in the hope that it will be useful,
27 * but WITHOUT ANY WARRANTY; without even the implied warranty of
28 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
29 * GNU General Public License for more details.
30 *
31 * You should have received a copy of the GNU General Public License
32 * along with this program; if not, write to the Free Software
33 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
34 *
35 ****************************************************************/
36
Joe Perches22ded572013-10-28 12:53:21 -070037#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
38
Linus Torvalds1da177e2005-04-16 15:20:36 -070039#include <linux/mm.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070040#include <linux/init.h>
41#include <linux/module.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090042#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070043#include <linux/console.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070044#include <linux/moduleparam.h>
Andy Shevchenko4cd57732013-06-04 19:46:26 +030045#include <linux/kernel.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070046#include <linux/string.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070047#include <linux/netpoll.h>
Satyam Sharma0bcc1812007-08-10 15:35:05 -070048#include <linux/inet.h>
49#include <linux/configfs.h>
Joe Perches1667c942015-03-02 19:54:50 -080050#include <linux/etherdevice.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070051
52MODULE_AUTHOR("Maintainer: Matt Mackall <mpm@selenic.com>");
53MODULE_DESCRIPTION("Console driver for network interfaces");
54MODULE_LICENSE("GPL");
55
Satyam Sharmad39badf2007-08-10 15:27:24 -070056#define MAX_PARAM_LENGTH 256
57#define MAX_PRINT_CHUNK 1000
58
59static char config[MAX_PARAM_LENGTH];
60module_param_string(netconsole, config, MAX_PARAM_LENGTH, 0);
Niels de Vos61a2d072008-07-31 00:07:23 -070061MODULE_PARM_DESC(netconsole, " netconsole=[src-port]@[src-ip]/[dev],[tgt-port]@<tgt-ip>/[tgt-macaddr]");
Linus Torvalds1da177e2005-04-16 15:20:36 -070062
Amerigo Wangc1a60852012-11-08 03:42:38 +000063static bool oops_only = false;
64module_param(oops_only, bool, 0600);
65MODULE_PARM_DESC(oops_only, "Only log oops messages");
66
Satyam Sharmad2b60882007-08-10 15:29:47 -070067#ifndef MODULE
68static int __init option_setup(char *opt)
69{
70 strlcpy(config, opt, MAX_PARAM_LENGTH);
71 return 1;
72}
73__setup("netconsole=", option_setup);
74#endif /* MODULE */
75
Satyam Sharmab5427c22007-08-10 15:33:40 -070076/* Linked list of all configured targets */
77static LIST_HEAD(target_list);
78
79/* This needs to be a spinlock because write_msg() cannot sleep */
80static DEFINE_SPINLOCK(target_list_lock);
81
Satyam Sharmadf180e32007-08-10 15:32:14 -070082/**
83 * struct netconsole_target - Represents a configured netconsole target.
Satyam Sharmab5427c22007-08-10 15:33:40 -070084 * @list: Links this target into the target_list.
Satyam Sharma0bcc1812007-08-10 15:35:05 -070085 * @item: Links us into the configfs subsystem hierarchy.
86 * @enabled: On / off knob to enable / disable target.
87 * Visible from userspace (read-write).
88 * We maintain a strict 1:1 correspondence between this and
89 * whether the corresponding netpoll is active or inactive.
90 * Also, other parameters of a target may be modified at
91 * runtime only when it is disabled (enabled == 0).
Satyam Sharmadf180e32007-08-10 15:32:14 -070092 * @np: The netpoll structure for this target.
Satyam Sharma0bcc1812007-08-10 15:35:05 -070093 * Contains the other userspace visible parameters:
94 * dev_name (read-write)
95 * local_port (read-write)
96 * remote_port (read-write)
97 * local_ip (read-write)
98 * remote_ip (read-write)
99 * local_mac (read-only)
100 * remote_mac (read-write)
Satyam Sharmadf180e32007-08-10 15:32:14 -0700101 */
102struct netconsole_target {
Satyam Sharmab5427c22007-08-10 15:33:40 -0700103 struct list_head list;
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700104#ifdef CONFIG_NETCONSOLE_DYNAMIC
105 struct config_item item;
106#endif
107 int enabled;
Dan Aloni7a163bf2013-08-30 13:59:46 +0300108 struct mutex mutex;
Satyam Sharmadf180e32007-08-10 15:32:14 -0700109 struct netpoll np;
110};
111
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700112#ifdef CONFIG_NETCONSOLE_DYNAMIC
113
114static struct configfs_subsystem netconsole_subsys;
115
116static int __init dynamic_netconsole_init(void)
117{
118 config_group_init(&netconsole_subsys.su_group);
119 mutex_init(&netconsole_subsys.su_mutex);
120 return configfs_register_subsystem(&netconsole_subsys);
121}
122
123static void __exit dynamic_netconsole_exit(void)
124{
125 configfs_unregister_subsystem(&netconsole_subsys);
126}
127
128/*
129 * Targets that were created by parsing the boot/module option string
130 * do not exist in the configfs hierarchy (and have NULL names) and will
131 * never go away, so make these a no-op for them.
132 */
133static void netconsole_target_get(struct netconsole_target *nt)
134{
135 if (config_item_name(&nt->item))
136 config_item_get(&nt->item);
137}
138
139static void netconsole_target_put(struct netconsole_target *nt)
140{
141 if (config_item_name(&nt->item))
142 config_item_put(&nt->item);
143}
144
145#else /* !CONFIG_NETCONSOLE_DYNAMIC */
146
147static int __init dynamic_netconsole_init(void)
148{
149 return 0;
150}
151
152static void __exit dynamic_netconsole_exit(void)
153{
154}
155
156/*
157 * No danger of targets going away from under us when dynamic
158 * reconfigurability is off.
159 */
160static void netconsole_target_get(struct netconsole_target *nt)
161{
162}
163
164static void netconsole_target_put(struct netconsole_target *nt)
165{
166}
167
168#endif /* CONFIG_NETCONSOLE_DYNAMIC */
169
170/* Allocate new target (from boot/module param) and setup netpoll for it */
171static struct netconsole_target *alloc_param_target(char *target_config)
Satyam Sharmab5427c22007-08-10 15:33:40 -0700172{
173 int err = -ENOMEM;
174 struct netconsole_target *nt;
175
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700176 /*
177 * Allocate and initialize with defaults.
178 * Note that these targets get their config_item fields zeroed-out.
179 */
Satyam Sharmab5427c22007-08-10 15:33:40 -0700180 nt = kzalloc(sizeof(*nt), GFP_KERNEL);
Joe Perchese404dec2012-01-29 12:56:23 +0000181 if (!nt)
Satyam Sharmab5427c22007-08-10 15:33:40 -0700182 goto fail;
Satyam Sharmab5427c22007-08-10 15:33:40 -0700183
184 nt->np.name = "netconsole";
185 strlcpy(nt->np.dev_name, "eth0", IFNAMSIZ);
186 nt->np.local_port = 6665;
187 nt->np.remote_port = 6666;
Dan Aloni7a163bf2013-08-30 13:59:46 +0300188 mutex_init(&nt->mutex);
Joe Perches1667c942015-03-02 19:54:50 -0800189 eth_broadcast_addr(nt->np.remote_mac);
Satyam Sharmab5427c22007-08-10 15:33:40 -0700190
191 /* Parse parameters and setup netpoll */
192 err = netpoll_parse_options(&nt->np, target_config);
193 if (err)
194 goto fail;
195
196 err = netpoll_setup(&nt->np);
197 if (err)
198 goto fail;
199
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700200 nt->enabled = 1;
201
Satyam Sharmab5427c22007-08-10 15:33:40 -0700202 return nt;
203
204fail:
205 kfree(nt);
206 return ERR_PTR(err);
207}
208
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700209/* Cleanup netpoll for given target (from boot/module param) and free it */
210static void free_param_target(struct netconsole_target *nt)
Satyam Sharmab5427c22007-08-10 15:33:40 -0700211{
212 netpoll_cleanup(&nt->np);
213 kfree(nt);
214}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700216#ifdef CONFIG_NETCONSOLE_DYNAMIC
217
218/*
219 * Our subsystem hierarchy is:
220 *
221 * /sys/kernel/config/netconsole/
222 * |
223 * <target>/
224 * | enabled
225 * | dev_name
226 * | local_port
227 * | remote_port
228 * | local_ip
229 * | remote_ip
230 * | local_mac
231 * | remote_mac
232 * |
233 * <target>/...
234 */
235
236struct netconsole_target_attr {
237 struct configfs_attribute attr;
238 ssize_t (*show)(struct netconsole_target *nt,
239 char *buf);
240 ssize_t (*store)(struct netconsole_target *nt,
241 const char *buf,
242 size_t count);
243};
244
245static struct netconsole_target *to_target(struct config_item *item)
246{
247 return item ?
248 container_of(item, struct netconsole_target, item) :
249 NULL;
250}
251
252/*
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700253 * Attribute operations for netconsole_target.
254 */
255
256static ssize_t show_enabled(struct netconsole_target *nt, char *buf)
257{
258 return snprintf(buf, PAGE_SIZE, "%d\n", nt->enabled);
259}
260
261static ssize_t show_dev_name(struct netconsole_target *nt, char *buf)
262{
263 return snprintf(buf, PAGE_SIZE, "%s\n", nt->np.dev_name);
264}
265
266static ssize_t show_local_port(struct netconsole_target *nt, char *buf)
267{
268 return snprintf(buf, PAGE_SIZE, "%d\n", nt->np.local_port);
269}
270
271static ssize_t show_remote_port(struct netconsole_target *nt, char *buf)
272{
273 return snprintf(buf, PAGE_SIZE, "%d\n", nt->np.remote_port);
274}
275
276static ssize_t show_local_ip(struct netconsole_target *nt, char *buf)
277{
Cong Wangb3d936f2013-01-07 20:52:41 +0000278 if (nt->np.ipv6)
279 return snprintf(buf, PAGE_SIZE, "%pI6c\n", &nt->np.local_ip.in6);
280 else
Cong Wangb7394d22013-01-07 20:52:39 +0000281 return snprintf(buf, PAGE_SIZE, "%pI4\n", &nt->np.local_ip);
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700282}
283
284static ssize_t show_remote_ip(struct netconsole_target *nt, char *buf)
285{
Cong Wangb3d936f2013-01-07 20:52:41 +0000286 if (nt->np.ipv6)
287 return snprintf(buf, PAGE_SIZE, "%pI6c\n", &nt->np.remote_ip.in6);
288 else
Cong Wangb7394d22013-01-07 20:52:39 +0000289 return snprintf(buf, PAGE_SIZE, "%pI4\n", &nt->np.remote_ip);
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700290}
291
292static ssize_t show_local_mac(struct netconsole_target *nt, char *buf)
293{
Stephen Hemminger09538642007-11-19 19:23:29 -0800294 struct net_device *dev = nt->np.dev;
Johannes Berge1749612008-10-27 15:59:26 -0700295 static const u8 bcast[ETH_ALEN] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
Stephen Hemminger09538642007-11-19 19:23:29 -0800296
Johannes Berge1749612008-10-27 15:59:26 -0700297 return snprintf(buf, PAGE_SIZE, "%pM\n", dev ? dev->dev_addr : bcast);
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700298}
299
300static ssize_t show_remote_mac(struct netconsole_target *nt, char *buf)
301{
Johannes Berge1749612008-10-27 15:59:26 -0700302 return snprintf(buf, PAGE_SIZE, "%pM\n", nt->np.remote_mac);
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700303}
304
305/*
306 * This one is special -- targets created through the configfs interface
307 * are not enabled (and the corresponding netpoll activated) by default.
308 * The user is expected to set the desired parameters first (which
309 * would enable him to dynamically add new netpoll targets for new
310 * network interfaces as and when they come up).
311 */
312static ssize_t store_enabled(struct netconsole_target *nt,
313 const char *buf,
314 size_t count)
315{
Nikolay Aleksandrov45e526e2013-10-23 15:04:49 +0200316 unsigned long flags;
Alexey Dobriyan99f823f2011-05-07 20:33:13 +0000317 int enabled;
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700318 int err;
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700319
Alexey Dobriyan99f823f2011-05-07 20:33:13 +0000320 err = kstrtoint(buf, 10, &enabled);
321 if (err < 0)
322 return err;
323 if (enabled < 0 || enabled > 1)
324 return -EINVAL;
Gao fengd5123482011-10-11 16:08:11 +0000325 if (enabled == nt->enabled) {
Joe Perches22ded572013-10-28 12:53:21 -0700326 pr_info("network logging has already %s\n",
327 nt->enabled ? "started" : "stopped");
Gao fengd5123482011-10-11 16:08:11 +0000328 return -EINVAL;
329 }
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700330
331 if (enabled) { /* 1 */
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700332 /*
333 * Skip netpoll_parse_options() -- all the attributes are
334 * already configured via configfs. Just print them out.
335 */
336 netpoll_print_options(&nt->np);
337
338 err = netpoll_setup(&nt->np);
Nikolay Aleksandrovc7c6eff2013-10-24 12:09:24 +0200339 if (err)
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700340 return err;
341
David S. Miller394efd12013-11-04 13:48:30 -0500342 pr_info("netconsole: network logging started\n");
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700343 } else { /* 0 */
Nikolay Aleksandrov45e526e2013-10-23 15:04:49 +0200344 /* We need to disable the netconsole before cleaning it up
345 * otherwise we might end up in write_msg() with
346 * nt->np.dev == NULL and nt->enabled == 1
347 */
348 spin_lock_irqsave(&target_list_lock, flags);
349 nt->enabled = 0;
350 spin_unlock_irqrestore(&target_list_lock, flags);
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700351 netpoll_cleanup(&nt->np);
352 }
353
354 nt->enabled = enabled;
355
356 return strnlen(buf, count);
357}
358
359static ssize_t store_dev_name(struct netconsole_target *nt,
360 const char *buf,
361 size_t count)
362{
363 size_t len;
364
365 if (nt->enabled) {
Joe Perches22ded572013-10-28 12:53:21 -0700366 pr_err("target (%s) is enabled, disable to update parameters\n",
367 config_item_name(&nt->item));
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700368 return -EINVAL;
369 }
370
371 strlcpy(nt->np.dev_name, buf, IFNAMSIZ);
372
373 /* Get rid of possible trailing newline from echo(1) */
374 len = strnlen(nt->np.dev_name, IFNAMSIZ);
375 if (nt->np.dev_name[len - 1] == '\n')
376 nt->np.dev_name[len - 1] = '\0';
377
378 return strnlen(buf, count);
379}
380
381static ssize_t store_local_port(struct netconsole_target *nt,
382 const char *buf,
383 size_t count)
384{
Alexey Dobriyan99f823f2011-05-07 20:33:13 +0000385 int rv;
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700386
387 if (nt->enabled) {
Joe Perches22ded572013-10-28 12:53:21 -0700388 pr_err("target (%s) is enabled, disable to update parameters\n",
389 config_item_name(&nt->item));
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700390 return -EINVAL;
391 }
392
Alexey Dobriyan99f823f2011-05-07 20:33:13 +0000393 rv = kstrtou16(buf, 10, &nt->np.local_port);
394 if (rv < 0)
395 return rv;
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700396 return strnlen(buf, count);
397}
398
399static ssize_t store_remote_port(struct netconsole_target *nt,
400 const char *buf,
401 size_t count)
402{
Alexey Dobriyan99f823f2011-05-07 20:33:13 +0000403 int rv;
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700404
405 if (nt->enabled) {
Joe Perches22ded572013-10-28 12:53:21 -0700406 pr_err("target (%s) is enabled, disable to update parameters\n",
407 config_item_name(&nt->item));
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700408 return -EINVAL;
409 }
410
Alexey Dobriyan99f823f2011-05-07 20:33:13 +0000411 rv = kstrtou16(buf, 10, &nt->np.remote_port);
412 if (rv < 0)
413 return rv;
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700414 return strnlen(buf, count);
415}
416
417static ssize_t store_local_ip(struct netconsole_target *nt,
418 const char *buf,
419 size_t count)
420{
421 if (nt->enabled) {
Joe Perches22ded572013-10-28 12:53:21 -0700422 pr_err("target (%s) is enabled, disable to update parameters\n",
423 config_item_name(&nt->item));
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700424 return -EINVAL;
425 }
426
Cong Wangb3d936f2013-01-07 20:52:41 +0000427 if (strnchr(buf, count, ':')) {
428 const char *end;
429 if (in6_pton(buf, count, nt->np.local_ip.in6.s6_addr, -1, &end) > 0) {
430 if (*end && *end != '\n') {
Joe Perches22ded572013-10-28 12:53:21 -0700431 pr_err("invalid IPv6 address at: <%c>\n", *end);
Cong Wangb3d936f2013-01-07 20:52:41 +0000432 return -EINVAL;
433 }
434 nt->np.ipv6 = true;
435 } else
436 return -EINVAL;
437 } else {
438 if (!nt->np.ipv6) {
439 nt->np.local_ip.ip = in_aton(buf);
440 } else
441 return -EINVAL;
442 }
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700443
444 return strnlen(buf, count);
445}
446
447static ssize_t store_remote_ip(struct netconsole_target *nt,
448 const char *buf,
449 size_t count)
450{
451 if (nt->enabled) {
Joe Perches22ded572013-10-28 12:53:21 -0700452 pr_err("target (%s) is enabled, disable to update parameters\n",
453 config_item_name(&nt->item));
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700454 return -EINVAL;
455 }
456
Cong Wangb3d936f2013-01-07 20:52:41 +0000457 if (strnchr(buf, count, ':')) {
458 const char *end;
459 if (in6_pton(buf, count, nt->np.remote_ip.in6.s6_addr, -1, &end) > 0) {
460 if (*end && *end != '\n') {
Joe Perches22ded572013-10-28 12:53:21 -0700461 pr_err("invalid IPv6 address at: <%c>\n", *end);
Cong Wangb3d936f2013-01-07 20:52:41 +0000462 return -EINVAL;
463 }
464 nt->np.ipv6 = true;
465 } else
466 return -EINVAL;
467 } else {
468 if (!nt->np.ipv6) {
469 nt->np.remote_ip.ip = in_aton(buf);
470 } else
471 return -EINVAL;
472 }
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700473
474 return strnlen(buf, count);
475}
476
477static ssize_t store_remote_mac(struct netconsole_target *nt,
478 const char *buf,
479 size_t count)
480{
481 u8 remote_mac[ETH_ALEN];
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700482
483 if (nt->enabled) {
Joe Perches22ded572013-10-28 12:53:21 -0700484 pr_err("target (%s) is enabled, disable to update parameters\n",
485 config_item_name(&nt->item));
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700486 return -EINVAL;
487 }
488
Alexey Dobriyan4940fc82011-05-07 23:00:07 +0000489 if (!mac_pton(buf, remote_mac))
490 return -EINVAL;
491 if (buf[3 * ETH_ALEN - 1] && buf[3 * ETH_ALEN - 1] != '\n')
492 return -EINVAL;
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700493 memcpy(nt->np.remote_mac, remote_mac, ETH_ALEN);
494
495 return strnlen(buf, count);
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700496}
497
498/*
499 * Attribute definitions for netconsole_target.
500 */
501
502#define NETCONSOLE_TARGET_ATTR_RO(_name) \
503static struct netconsole_target_attr netconsole_target_##_name = \
504 __CONFIGFS_ATTR(_name, S_IRUGO, show_##_name, NULL)
505
506#define NETCONSOLE_TARGET_ATTR_RW(_name) \
507static struct netconsole_target_attr netconsole_target_##_name = \
508 __CONFIGFS_ATTR(_name, S_IRUGO | S_IWUSR, show_##_name, store_##_name)
509
510NETCONSOLE_TARGET_ATTR_RW(enabled);
511NETCONSOLE_TARGET_ATTR_RW(dev_name);
512NETCONSOLE_TARGET_ATTR_RW(local_port);
513NETCONSOLE_TARGET_ATTR_RW(remote_port);
514NETCONSOLE_TARGET_ATTR_RW(local_ip);
515NETCONSOLE_TARGET_ATTR_RW(remote_ip);
516NETCONSOLE_TARGET_ATTR_RO(local_mac);
517NETCONSOLE_TARGET_ATTR_RW(remote_mac);
518
519static struct configfs_attribute *netconsole_target_attrs[] = {
520 &netconsole_target_enabled.attr,
521 &netconsole_target_dev_name.attr,
522 &netconsole_target_local_port.attr,
523 &netconsole_target_remote_port.attr,
524 &netconsole_target_local_ip.attr,
525 &netconsole_target_remote_ip.attr,
526 &netconsole_target_local_mac.attr,
527 &netconsole_target_remote_mac.attr,
528 NULL,
529};
530
531/*
532 * Item operations and type for netconsole_target.
533 */
534
535static void netconsole_target_release(struct config_item *item)
536{
537 kfree(to_target(item));
538}
539
540static ssize_t netconsole_target_attr_show(struct config_item *item,
541 struct configfs_attribute *attr,
542 char *buf)
543{
544 ssize_t ret = -EINVAL;
545 struct netconsole_target *nt = to_target(item);
546 struct netconsole_target_attr *na =
547 container_of(attr, struct netconsole_target_attr, attr);
548
549 if (na->show)
550 ret = na->show(nt, buf);
551
552 return ret;
553}
554
555static ssize_t netconsole_target_attr_store(struct config_item *item,
556 struct configfs_attribute *attr,
557 const char *buf,
558 size_t count)
559{
560 ssize_t ret = -EINVAL;
561 struct netconsole_target *nt = to_target(item);
562 struct netconsole_target_attr *na =
563 container_of(attr, struct netconsole_target_attr, attr);
564
Nikolay Aleksandrovc7c6eff2013-10-24 12:09:24 +0200565 mutex_lock(&nt->mutex);
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700566 if (na->store)
567 ret = na->store(nt, buf, count);
Nikolay Aleksandrovc7c6eff2013-10-24 12:09:24 +0200568 mutex_unlock(&nt->mutex);
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700569
570 return ret;
571}
572
573static struct configfs_item_operations netconsole_target_item_ops = {
574 .release = netconsole_target_release,
575 .show_attribute = netconsole_target_attr_show,
576 .store_attribute = netconsole_target_attr_store,
577};
578
579static struct config_item_type netconsole_target_type = {
580 .ct_attrs = netconsole_target_attrs,
581 .ct_item_ops = &netconsole_target_item_ops,
582 .ct_owner = THIS_MODULE,
583};
584
585/*
586 * Group operations and type for netconsole_subsys.
587 */
588
Joel Beckerf89ab862008-07-17 14:53:48 -0700589static struct config_item *make_netconsole_target(struct config_group *group,
590 const char *name)
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700591{
592 unsigned long flags;
593 struct netconsole_target *nt;
594
595 /*
596 * Allocate and initialize with defaults.
597 * Target is disabled at creation (enabled == 0).
598 */
599 nt = kzalloc(sizeof(*nt), GFP_KERNEL);
Joe Perchese404dec2012-01-29 12:56:23 +0000600 if (!nt)
Joel Beckera6795e92008-07-17 15:21:29 -0700601 return ERR_PTR(-ENOMEM);
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700602
603 nt->np.name = "netconsole";
604 strlcpy(nt->np.dev_name, "eth0", IFNAMSIZ);
605 nt->np.local_port = 6665;
606 nt->np.remote_port = 6666;
Dan Aloni7a163bf2013-08-30 13:59:46 +0300607 mutex_init(&nt->mutex);
Joe Perches1667c942015-03-02 19:54:50 -0800608 eth_broadcast_addr(nt->np.remote_mac);
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700609
610 /* Initialize the config_item member */
611 config_item_init_type_name(&nt->item, name, &netconsole_target_type);
612
613 /* Adding, but it is disabled */
614 spin_lock_irqsave(&target_list_lock, flags);
615 list_add(&nt->list, &target_list);
616 spin_unlock_irqrestore(&target_list_lock, flags);
617
Joel Beckerf89ab862008-07-17 14:53:48 -0700618 return &nt->item;
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700619}
620
621static void drop_netconsole_target(struct config_group *group,
622 struct config_item *item)
623{
624 unsigned long flags;
625 struct netconsole_target *nt = to_target(item);
626
627 spin_lock_irqsave(&target_list_lock, flags);
628 list_del(&nt->list);
629 spin_unlock_irqrestore(&target_list_lock, flags);
630
631 /*
632 * The target may have never been enabled, or was manually disabled
633 * before being removed so netpoll may have already been cleaned up.
634 */
635 if (nt->enabled)
636 netpoll_cleanup(&nt->np);
637
638 config_item_put(&nt->item);
639}
640
641static struct configfs_group_operations netconsole_subsys_group_ops = {
642 .make_item = make_netconsole_target,
643 .drop_item = drop_netconsole_target,
644};
645
646static struct config_item_type netconsole_subsys_type = {
647 .ct_group_ops = &netconsole_subsys_group_ops,
648 .ct_owner = THIS_MODULE,
649};
650
651/* The netconsole configfs subsystem */
652static struct configfs_subsystem netconsole_subsys = {
653 .su_group = {
654 .cg_item = {
655 .ci_namebuf = "netconsole",
656 .ci_type = &netconsole_subsys_type,
657 },
658 },
659};
660
661#endif /* CONFIG_NETCONSOLE_DYNAMIC */
662
Satyam Sharma17951f32007-08-10 15:33:01 -0700663/* Handle network interface device notifications */
664static int netconsole_netdev_event(struct notifier_block *this,
Jiri Pirko351638e2013-05-28 01:30:21 +0000665 unsigned long event, void *ptr)
Satyam Sharma17951f32007-08-10 15:33:01 -0700666{
Satyam Sharmab5427c22007-08-10 15:33:40 -0700667 unsigned long flags;
668 struct netconsole_target *nt;
Jiri Pirko351638e2013-05-28 01:30:21 +0000669 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
Ferenc Wagner141dfba2011-01-06 05:11:19 +0000670 bool stopped = false;
Satyam Sharma17951f32007-08-10 15:33:01 -0700671
WANG Cong0e34e932010-05-06 00:47:21 -0700672 if (!(event == NETDEV_CHANGENAME || event == NETDEV_UNREGISTER ||
Amerigo Wangdaf92092011-05-19 21:39:12 +0000673 event == NETDEV_RELEASE || event == NETDEV_JOIN))
Satyam Sharmab5427c22007-08-10 15:33:40 -0700674 goto done;
Satyam Sharma17951f32007-08-10 15:33:01 -0700675
Satyam Sharmab5427c22007-08-10 15:33:40 -0700676 spin_lock_irqsave(&target_list_lock, flags);
Veaceslav Falico3f315be2013-03-11 00:21:48 +0000677restart:
Satyam Sharmab5427c22007-08-10 15:33:40 -0700678 list_for_each_entry(nt, &target_list, list) {
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700679 netconsole_target_get(nt);
Satyam Sharmab5427c22007-08-10 15:33:40 -0700680 if (nt->np.dev == dev) {
681 switch (event) {
Satyam Sharmab5427c22007-08-10 15:33:40 -0700682 case NETDEV_CHANGENAME:
683 strlcpy(nt->np.dev_name, dev->name, IFNAMSIZ);
684 break;
Amerigo Wangdaf92092011-05-19 21:39:12 +0000685 case NETDEV_RELEASE:
Amerigo Wang8d8fc292011-05-19 21:39:10 +0000686 case NETDEV_JOIN:
Bruno Prémont2382b152009-04-29 20:45:17 +0000687 case NETDEV_UNREGISTER:
Nikolay Aleksandrovc71380f2013-09-19 15:02:36 +0200688 /* rtnl_lock already held
Veaceslav Falico3f315be2013-03-11 00:21:48 +0000689 * we might sleep in __netpoll_cleanup()
Neil Horman3b410a32010-10-13 16:01:52 +0000690 */
Veaceslav Falico3f315be2013-03-11 00:21:48 +0000691 spin_unlock_irqrestore(&target_list_lock, flags);
Dan Aloni7a163bf2013-08-30 13:59:46 +0300692
Veaceslav Falico3f315be2013-03-11 00:21:48 +0000693 __netpoll_cleanup(&nt->np);
Dan Aloni7a163bf2013-08-30 13:59:46 +0300694
Veaceslav Falico3f315be2013-03-11 00:21:48 +0000695 spin_lock_irqsave(&target_list_lock, flags);
696 dev_put(nt->np.dev);
697 nt->np.dev = NULL;
Bruno Prémont2382b152009-04-29 20:45:17 +0000698 nt->enabled = 0;
Ferenc Wagner141dfba2011-01-06 05:11:19 +0000699 stopped = true;
Veaceslav Falico3f315be2013-03-11 00:21:48 +0000700 netconsole_target_put(nt);
701 goto restart;
Satyam Sharmab5427c22007-08-10 15:33:40 -0700702 }
Satyam Sharma17951f32007-08-10 15:33:01 -0700703 }
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700704 netconsole_target_put(nt);
Satyam Sharma17951f32007-08-10 15:33:01 -0700705 }
Satyam Sharmab5427c22007-08-10 15:33:40 -0700706 spin_unlock_irqrestore(&target_list_lock, flags);
Amerigo Wang8d8fc292011-05-19 21:39:10 +0000707 if (stopped) {
Joe Perches22ded572013-10-28 12:53:21 -0700708 const char *msg = "had an event";
Amerigo Wang8d8fc292011-05-19 21:39:10 +0000709 switch (event) {
710 case NETDEV_UNREGISTER:
Joe Perches22ded572013-10-28 12:53:21 -0700711 msg = "unregistered";
Amerigo Wang8d8fc292011-05-19 21:39:10 +0000712 break;
Amerigo Wangdaf92092011-05-19 21:39:12 +0000713 case NETDEV_RELEASE:
Joe Perches22ded572013-10-28 12:53:21 -0700714 msg = "released slaves";
Amerigo Wang8d8fc292011-05-19 21:39:10 +0000715 break;
716 case NETDEV_JOIN:
Joe Perches22ded572013-10-28 12:53:21 -0700717 msg = "is joining a master device";
Amerigo Wang8d8fc292011-05-19 21:39:10 +0000718 break;
719 }
Joe Perches22ded572013-10-28 12:53:21 -0700720 pr_info("network logging stopped on interface %s as it %s\n",
721 dev->name, msg);
Amerigo Wang8d8fc292011-05-19 21:39:10 +0000722 }
Satyam Sharma17951f32007-08-10 15:33:01 -0700723
Satyam Sharmab5427c22007-08-10 15:33:40 -0700724done:
Satyam Sharma17951f32007-08-10 15:33:01 -0700725 return NOTIFY_DONE;
726}
727
728static struct notifier_block netconsole_netdev_notifier = {
729 .notifier_call = netconsole_netdev_event,
730};
731
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732static void write_msg(struct console *con, const char *msg, unsigned int len)
733{
734 int frag, left;
735 unsigned long flags;
Satyam Sharmab5427c22007-08-10 15:33:40 -0700736 struct netconsole_target *nt;
737 const char *tmp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700738
Amerigo Wangc1a60852012-11-08 03:42:38 +0000739 if (oops_only && !oops_in_progress)
740 return;
Satyam Sharmab5427c22007-08-10 15:33:40 -0700741 /* Avoid taking lock and disabling interrupts unnecessarily */
742 if (list_empty(&target_list))
743 return;
744
745 spin_lock_irqsave(&target_list_lock, flags);
746 list_for_each_entry(nt, &target_list, list) {
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700747 netconsole_target_get(nt);
748 if (nt->enabled && netif_running(nt->np.dev)) {
Satyam Sharmab5427c22007-08-10 15:33:40 -0700749 /*
750 * We nest this inside the for-each-target loop above
751 * so that we're able to get as much logging out to
752 * at least one target if we die inside here, instead
753 * of unnecessarily keeping all targets in lock-step.
754 */
755 tmp = msg;
756 for (left = len; left;) {
757 frag = min(left, MAX_PRINT_CHUNK);
758 netpoll_send_udp(&nt->np, tmp, frag);
759 tmp += frag;
760 left -= frag;
761 }
Satyam Sharma0cc120be2007-08-10 15:30:31 -0700762 }
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700763 netconsole_target_put(nt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764 }
Satyam Sharmab5427c22007-08-10 15:33:40 -0700765 spin_unlock_irqrestore(&target_list_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700766}
767
768static struct console netconsole = {
Satyam Sharmad39badf2007-08-10 15:27:24 -0700769 .name = "netcon",
Michael Ellerman0517dee2008-04-15 00:49:04 -0700770 .flags = CON_ENABLED,
Satyam Sharmad39badf2007-08-10 15:27:24 -0700771 .write = write_msg,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700772};
773
Satyam Sharmad39badf2007-08-10 15:27:24 -0700774static int __init init_netconsole(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700775{
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700776 int err;
Satyam Sharmab5427c22007-08-10 15:33:40 -0700777 struct netconsole_target *nt, *tmp;
778 unsigned long flags;
779 char *target_config;
780 char *input = config;
Stephen Hemmingerb41848b2006-10-26 15:46:52 -0700781
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700782 if (strnlen(input, MAX_PARAM_LENGTH)) {
783 while ((target_config = strsep(&input, ";"))) {
784 nt = alloc_param_target(target_config);
785 if (IS_ERR(nt)) {
786 err = PTR_ERR(nt);
787 goto fail;
788 }
Michael Ellerman0517dee2008-04-15 00:49:04 -0700789 /* Dump existing printks when we register */
790 netconsole.flags |= CON_PRINTBUFFER;
791
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700792 spin_lock_irqsave(&target_list_lock, flags);
793 list_add(&nt->list, &target_list);
794 spin_unlock_irqrestore(&target_list_lock, flags);
Satyam Sharmab5427c22007-08-10 15:33:40 -0700795 }
Satyam Sharmab5427c22007-08-10 15:33:40 -0700796 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700797
Satyam Sharma17951f32007-08-10 15:33:01 -0700798 err = register_netdevice_notifier(&netconsole_netdev_notifier);
799 if (err)
Satyam Sharmab5427c22007-08-10 15:33:40 -0700800 goto fail;
Satyam Sharma17951f32007-08-10 15:33:01 -0700801
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700802 err = dynamic_netconsole_init();
803 if (err)
804 goto undonotifier;
805
Linus Torvalds1da177e2005-04-16 15:20:36 -0700806 register_console(&netconsole);
Joe Perches22ded572013-10-28 12:53:21 -0700807 pr_info("network logging started\n");
Satyam Sharmad39badf2007-08-10 15:27:24 -0700808
Satyam Sharmad39badf2007-08-10 15:27:24 -0700809 return err;
Satyam Sharmab5427c22007-08-10 15:33:40 -0700810
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700811undonotifier:
812 unregister_netdevice_notifier(&netconsole_netdev_notifier);
813
Satyam Sharmab5427c22007-08-10 15:33:40 -0700814fail:
Joe Perches22ded572013-10-28 12:53:21 -0700815 pr_err("cleaning up\n");
Satyam Sharmab5427c22007-08-10 15:33:40 -0700816
817 /*
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700818 * Remove all targets and destroy them (only targets created
819 * from the boot/module option exist here). Skipping the list
Satyam Sharmab5427c22007-08-10 15:33:40 -0700820 * lock is safe here, and netpoll_cleanup() will sleep.
821 */
822 list_for_each_entry_safe(nt, tmp, &target_list, list) {
823 list_del(&nt->list);
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700824 free_param_target(nt);
Satyam Sharmab5427c22007-08-10 15:33:40 -0700825 }
826
827 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700828}
829
Satyam Sharmad39badf2007-08-10 15:27:24 -0700830static void __exit cleanup_netconsole(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700831{
Satyam Sharmab5427c22007-08-10 15:33:40 -0700832 struct netconsole_target *nt, *tmp;
Satyam Sharmadf180e32007-08-10 15:32:14 -0700833
Linus Torvalds1da177e2005-04-16 15:20:36 -0700834 unregister_console(&netconsole);
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700835 dynamic_netconsole_exit();
Satyam Sharma17951f32007-08-10 15:33:01 -0700836 unregister_netdevice_notifier(&netconsole_netdev_notifier);
Satyam Sharmab5427c22007-08-10 15:33:40 -0700837
838 /*
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700839 * Targets created via configfs pin references on our module
840 * and would first be rmdir(2)'ed from userspace. We reach
841 * here only when they are already destroyed, and only those
842 * created from the boot/module option are left, so remove and
843 * destroy them. Skipping the list lock is safe here, and
844 * netpoll_cleanup() will sleep.
Satyam Sharmab5427c22007-08-10 15:33:40 -0700845 */
846 list_for_each_entry_safe(nt, tmp, &target_list, list) {
847 list_del(&nt->list);
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700848 free_param_target(nt);
Satyam Sharmab5427c22007-08-10 15:33:40 -0700849 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700850}
851
Lin Ming97c7de02011-09-20 15:45:07 -0400852/*
853 * Use late_initcall to ensure netconsole is
854 * initialized after network device driver if built-in.
855 *
856 * late_initcall() and module_init() are identical if built as module.
857 */
858late_initcall(init_netconsole);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700859module_exit(cleanup_netconsole);