Linux Audio

Check our new training course

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