blob: de20928f740211a55fe288cd83230a026237c8b5 [file] [log] [blame]
Thomas Gleixnerde6cc652019-05-27 08:55:02 +02001// SPDX-License-Identifier: GPL-2.0-or-later
Linus Torvalds1da177e2005-04-16 15:20:36 -07002/*
3 * linux/drivers/net/netconsole.c
4 *
5 * Copyright (C) 2001 Ingo Molnar <mingo@redhat.com>
6 *
7 * This file contains the implementation of an IRQ-safe, crash-safe
8 * kernel console implementation that outputs kernel messages to the
9 * network.
10 *
11 * Modification history:
12 *
13 * 2001-09-17 started by Ingo Molnar.
14 * 2003-08-11 2.6 port by Matt Mackall
15 * simplified options
16 * generic card hooks
17 * works non-modular
18 * 2003-09-07 rewritten with netpoll api
19 */
20
21/****************************************************************
Linus Torvalds1da177e2005-04-16 15:20:36 -070022 *
23 ****************************************************************/
24
Joe Perches22ded572013-10-28 12:53:21 -070025#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
26
Linus Torvalds1da177e2005-04-16 15:20:36 -070027#include <linux/mm.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070028#include <linux/init.h>
29#include <linux/module.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090030#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070031#include <linux/console.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070032#include <linux/moduleparam.h>
Andy Shevchenko4cd57732013-06-04 19:46:26 +030033#include <linux/kernel.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070034#include <linux/string.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070035#include <linux/netpoll.h>
Satyam Sharma0bcc1812007-08-10 15:35:05 -070036#include <linux/inet.h>
37#include <linux/configfs.h>
Joe Perches1667c942015-03-02 19:54:50 -080038#include <linux/etherdevice.h>
Breno Leitaoc62c0a12023-07-14 04:13:29 -070039#include <linux/utsname.h>
Breno Leitao97714692024-08-08 05:25:11 -070040#include <linux/rtnetlink.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070041
Breno Leitao10a65452024-08-02 01:07:23 -070042MODULE_AUTHOR("Matt Mackall <mpm@selenic.com>");
Linus Torvalds1da177e2005-04-16 15:20:36 -070043MODULE_DESCRIPTION("Console driver for network interfaces");
44MODULE_LICENSE("GPL");
45
Matthew Wood2b3953582024-03-07 16:25:24 -080046#define MAX_PARAM_LENGTH 256
Matthew Wood8a6d5fe2024-02-04 15:27:36 -080047#define MAX_USERDATA_ENTRY_LENGTH 256
Matthew Wood2b3953582024-03-07 16:25:24 -080048#define MAX_USERDATA_VALUE_LENGTH 200
49/* The number 3 comes from userdata entry format characters (' ', '=', '\n') */
50#define MAX_USERDATA_NAME_LENGTH (MAX_USERDATA_ENTRY_LENGTH - \
51 MAX_USERDATA_VALUE_LENGTH - 3)
Matthew Wood8a6d5fe2024-02-04 15:27:36 -080052#define MAX_USERDATA_ITEMS 16
Matthew Wood2b3953582024-03-07 16:25:24 -080053#define MAX_PRINT_CHUNK 1000
Satyam Sharmad39badf2007-08-10 15:27:24 -070054
55static char config[MAX_PARAM_LENGTH];
56module_param_string(netconsole, config, MAX_PARAM_LENGTH, 0);
Niels de Vos61a2d072008-07-31 00:07:23 -070057MODULE_PARM_DESC(netconsole, " netconsole=[src-port]@[src-ip]/[dev],[tgt-port]@<tgt-ip>/[tgt-macaddr]");
Linus Torvalds1da177e2005-04-16 15:20:36 -070058
Matthew Wood602ad3b2024-02-04 15:27:32 -080059static bool oops_only;
Amerigo Wangc1a608512012-11-08 03:42:38 +000060module_param(oops_only, bool, 0600);
61MODULE_PARM_DESC(oops_only, "Only log oops messages");
62
Breno Leitao131eeb42023-10-12 04:13:59 -070063#define NETCONSOLE_PARAM_TARGET_PREFIX "cmdline"
64
Satyam Sharmad2b60882007-08-10 15:29:47 -070065#ifndef MODULE
66static int __init option_setup(char *opt)
67{
Wolfram Sangfb3ceec2022-08-30 22:14:52 +020068 strscpy(config, opt, MAX_PARAM_LENGTH);
Satyam Sharmad2b60882007-08-10 15:29:47 -070069 return 1;
70}
71__setup("netconsole=", option_setup);
72#endif /* MODULE */
73
Satyam Sharmab5427c22007-08-10 15:33:40 -070074/* Linked list of all configured targets */
75static LIST_HEAD(target_list);
Breno Leitao97714692024-08-08 05:25:11 -070076/* 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);
Satyam Sharmab5427c22007-08-10 15:33:40 -070081
82/* This needs to be a spinlock because write_msg() cannot sleep */
83static DEFINE_SPINLOCK(target_list_lock);
Breno Leitao97714692024-08-08 05:25:11 -070084/* This needs to be a mutex because netpoll_cleanup might sleep */
85static DEFINE_MUTEX(target_cleanup_list_lock);
Satyam Sharmab5427c22007-08-10 15:33:40 -070086
Tejun Heoe2f15f92015-06-25 15:01:41 -070087/*
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
Satyam Sharmadf180e32007-08-10 15:32:14 -070093/**
94 * struct netconsole_target - Represents a configured netconsole target.
Satyam Sharmab5427c22007-08-10 15:33:40 -070095 * @list: Links this target into the target_list.
Matthew Woodbd9c69a2024-02-04 15:27:33 -080096 * @group: Links us into the configfs subsystem hierarchy.
Matthew Wood8a6d5fe2024-02-04 15:27:36 -080097 * @userdata_group: Links to the userdata configfs hierarchy
Matthew Wooddf03f832024-02-04 15:27:37 -080098 * @userdata_complete: Cached, formatted string of append
99 * @userdata_length: String length of userdata_complete
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700100 * @enabled: On / off knob to enable / disable target.
101 * Visible from userspace (read-write).
102 * We maintain a strict 1:1 correspondence between this and
103 * whether the corresponding netpoll is active or inactive.
104 * Also, other parameters of a target may be modified at
105 * runtime only when it is disabled (enabled == 0).
Lee Jonesa8eb1a02020-11-02 11:45:10 +0000106 * @extended: Denotes whether console is extended or not.
Breno Leitaoc62c0a12023-07-14 04:13:29 -0700107 * @release: Denotes whether kernel release version should be prepended
108 * to the message. Depends on extended console.
Satyam Sharmadf180e32007-08-10 15:32:14 -0700109 * @np: The netpoll structure for this target.
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700110 * Contains the other userspace visible parameters:
111 * dev_name (read-write)
112 * local_port (read-write)
113 * remote_port (read-write)
114 * local_ip (read-write)
115 * remote_ip (read-write)
116 * local_mac (read-only)
117 * remote_mac (read-write)
Satyam Sharmadf180e32007-08-10 15:32:14 -0700118 */
119struct netconsole_target {
Satyam Sharmab5427c22007-08-10 15:33:40 -0700120 struct list_head list;
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700121#ifdef CONFIG_NETCONSOLE_DYNAMIC
Matthew Woodbd9c69a2024-02-04 15:27:33 -0800122 struct config_group group;
Matthew Wood8a6d5fe2024-02-04 15:27:36 -0800123 struct config_group userdata_group;
Matthew Wooddf03f832024-02-04 15:27:37 -0800124 char userdata_complete[MAX_USERDATA_ENTRY_LENGTH * MAX_USERDATA_ITEMS];
125 size_t userdata_length;
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700126#endif
Tejun Heo698cf1c2015-06-25 15:01:36 -0700127 bool enabled;
Tejun Heoe2f15f92015-06-25 15:01:41 -0700128 bool extended;
Breno Leitaoc62c0a12023-07-14 04:13:29 -0700129 bool release;
Satyam Sharmadf180e32007-08-10 15:32:14 -0700130 struct netpoll np;
131};
132
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700133#ifdef CONFIG_NETCONSOLE_DYNAMIC
134
135static struct configfs_subsystem netconsole_subsys;
Tejun Heo369e5a82015-06-25 15:01:38 -0700136static DEFINE_MUTEX(dynamic_netconsole_mutex);
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700137
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{
Matthew Woodbd9c69a2024-02-04 15:27:33 -0800157 if (config_item_name(&nt->group.cg_item))
158 config_group_get(&nt->group);
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700159}
160
161static void netconsole_target_put(struct netconsole_target *nt)
162{
Matthew Woodbd9c69a2024-02-04 15:27:33 -0800163 if (config_item_name(&nt->group.cg_item))
164 config_group_put(&nt->group);
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700165}
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
Breno Leitao131eeb42023-10-12 04:13:59 -0700190static void populate_configfs_item(struct netconsole_target *nt,
191 int cmdline_count)
192{
193}
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700194#endif /* CONFIG_NETCONSOLE_DYNAMIC */
195
Breno Leitaob0a9e2c2023-08-11 02:31:57 -0700196/* 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)
Satyam Sharmab5427c22007-08-10 15:33:40 -0700200{
Satyam Sharmab5427c22007-08-10 15:33:40 -0700201 struct netconsole_target *nt;
202
Satyam Sharmab5427c22007-08-10 15:33:40 -0700203 nt = kzalloc(sizeof(*nt), GFP_KERNEL);
Joe Perchese404dec2012-01-29 12:56:23 +0000204 if (!nt)
Breno Leitaob0a9e2c2023-08-11 02:31:57 -0700205 return nt;
Satyam Sharmab5427c22007-08-10 15:33:40 -0700206
Breno Leitaofad361a2023-08-11 02:31:58 -0700207 if (IS_ENABLED(CONFIG_NETCONSOLE_EXTENDED_LOG))
208 nt->extended = true;
209 if (IS_ENABLED(CONFIG_NETCONSOLE_PREPEND_RELEASE))
210 nt->release = true;
211
Satyam Sharmab5427c22007-08-10 15:33:40 -0700212 nt->np.name = "netconsole";
Wolfram Sangfb3ceec2022-08-30 22:14:52 +0200213 strscpy(nt->np.dev_name, "eth0", IFNAMSIZ);
Satyam Sharmab5427c22007-08-10 15:33:40 -0700214 nt->np.local_port = 6665;
215 nt->np.remote_port = 6666;
Joe Perches1667c942015-03-02 19:54:50 -0800216 eth_broadcast_addr(nt->np.remote_mac);
Satyam Sharmab5427c22007-08-10 15:33:40 -0700217
Breno Leitaob0a9e2c2023-08-11 02:31:57 -0700218 return nt;
219}
220
Breno Leitao97714692024-08-08 05:25:11 -0700221/* 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
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700248#ifdef CONFIG_NETCONSOLE_DYNAMIC
249
250/*
251 * Our subsystem hierarchy is:
252 *
253 * /sys/kernel/config/netconsole/
254 * |
255 * <target>/
256 * | enabled
Breno Leitaoc62c0a12023-07-14 04:13:29 -0700257 * | release
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700258 * | dev_name
259 * | local_port
260 * | remote_port
261 * | local_ip
262 * | remote_ip
263 * | local_mac
264 * | remote_mac
Matthew Wood8a6d5fe2024-02-04 15:27:36 -0800265 * | userdata/
266 * | <key>/
267 * | value
268 * | ...
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700269 * |
270 * <target>/...
271 */
272
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700273static struct netconsole_target *to_target(struct config_item *item)
274{
Matthew Woodbd9c69a2024-02-04 15:27:33 -0800275 struct config_group *cfg_group;
276
277 cfg_group = to_config_group(item);
278 if (!cfg_group)
279 return NULL;
280 return container_of(to_config_group(item),
281 struct netconsole_target, group);
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700282}
283
Breno Leitao97714692024-08-08 05:25:11 -0700284/* 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
Matthew Woodae001dc2024-02-04 15:27:34 -0800297/* 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
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700307/*
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700308 * Attribute operations for netconsole_target.
309 */
310
Christoph Hellwigea9ed9c2015-10-03 15:32:56 +0200311static ssize_t enabled_show(struct config_item *item, char *buf)
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700312{
Breno Leitao9f64b6e2023-07-21 02:21:44 -0700313 return sysfs_emit(buf, "%d\n", to_target(item)->enabled);
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700314}
315
Christoph Hellwigea9ed9c2015-10-03 15:32:56 +0200316static ssize_t extended_show(struct config_item *item, char *buf)
Tejun Heoe2f15f92015-06-25 15:01:41 -0700317{
Breno Leitao9f64b6e2023-07-21 02:21:44 -0700318 return sysfs_emit(buf, "%d\n", to_target(item)->extended);
Tejun Heoe2f15f92015-06-25 15:01:41 -0700319}
320
Breno Leitaoc62c0a12023-07-14 04:13:29 -0700321static ssize_t release_show(struct config_item *item, char *buf)
322{
Breno Leitao9f64b6e2023-07-21 02:21:44 -0700323 return sysfs_emit(buf, "%d\n", to_target(item)->release);
Breno Leitaoc62c0a12023-07-14 04:13:29 -0700324}
325
Christoph Hellwigea9ed9c2015-10-03 15:32:56 +0200326static ssize_t dev_name_show(struct config_item *item, char *buf)
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700327{
Breno Leitao9f64b6e2023-07-21 02:21:44 -0700328 return sysfs_emit(buf, "%s\n", to_target(item)->np.dev_name);
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700329}
330
Christoph Hellwigea9ed9c2015-10-03 15:32:56 +0200331static ssize_t local_port_show(struct config_item *item, char *buf)
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700332{
Breno Leitao9f64b6e2023-07-21 02:21:44 -0700333 return sysfs_emit(buf, "%d\n", to_target(item)->np.local_port);
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700334}
335
Christoph Hellwigea9ed9c2015-10-03 15:32:56 +0200336static ssize_t remote_port_show(struct config_item *item, char *buf)
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700337{
Breno Leitao9f64b6e2023-07-21 02:21:44 -0700338 return sysfs_emit(buf, "%d\n", to_target(item)->np.remote_port);
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700339}
340
Christoph Hellwigea9ed9c2015-10-03 15:32:56 +0200341static ssize_t local_ip_show(struct config_item *item, char *buf)
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700342{
Christoph Hellwigea9ed9c2015-10-03 15:32:56 +0200343 struct netconsole_target *nt = to_target(item);
344
Cong Wangb3d936f32013-01-07 20:52:41 +0000345 if (nt->np.ipv6)
Breno Leitao9f64b6e2023-07-21 02:21:44 -0700346 return sysfs_emit(buf, "%pI6c\n", &nt->np.local_ip.in6);
Cong Wangb3d936f32013-01-07 20:52:41 +0000347 else
Breno Leitao9f64b6e2023-07-21 02:21:44 -0700348 return sysfs_emit(buf, "%pI4\n", &nt->np.local_ip);
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700349}
350
Christoph Hellwigea9ed9c2015-10-03 15:32:56 +0200351static ssize_t remote_ip_show(struct config_item *item, char *buf)
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700352{
Christoph Hellwigea9ed9c2015-10-03 15:32:56 +0200353 struct netconsole_target *nt = to_target(item);
354
Cong Wangb3d936f32013-01-07 20:52:41 +0000355 if (nt->np.ipv6)
Breno Leitao9f64b6e2023-07-21 02:21:44 -0700356 return sysfs_emit(buf, "%pI6c\n", &nt->np.remote_ip.in6);
Cong Wangb3d936f32013-01-07 20:52:41 +0000357 else
Breno Leitao9f64b6e2023-07-21 02:21:44 -0700358 return sysfs_emit(buf, "%pI4\n", &nt->np.remote_ip);
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700359}
360
Christoph Hellwigea9ed9c2015-10-03 15:32:56 +0200361static ssize_t local_mac_show(struct config_item *item, char *buf)
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700362{
Christoph Hellwigea9ed9c2015-10-03 15:32:56 +0200363 struct net_device *dev = to_target(item)->np.dev;
Johannes Berge1749612008-10-27 15:59:26 -0700364 static const u8 bcast[ETH_ALEN] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
Stephen Hemminger09538642007-11-19 19:23:29 -0800365
Breno Leitao9f64b6e2023-07-21 02:21:44 -0700366 return sysfs_emit(buf, "%pM\n", dev ? dev->dev_addr : bcast);
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700367}
368
Christoph Hellwigea9ed9c2015-10-03 15:32:56 +0200369static ssize_t remote_mac_show(struct config_item *item, char *buf)
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700370{
Breno Leitao9f64b6e2023-07-21 02:21:44 -0700371 return sysfs_emit(buf, "%pM\n", to_target(item)->np.remote_mac);
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700372}
373
374/*
375 * This one is special -- targets created through the configfs interface
376 * are not enabled (and the corresponding netpoll activated) by default.
377 * The user is expected to set the desired parameters first (which
378 * would enable him to dynamically add new netpoll targets for new
379 * network interfaces as and when they come up).
380 */
Christoph Hellwigea9ed9c2015-10-03 15:32:56 +0200381static ssize_t enabled_store(struct config_item *item,
382 const char *buf, size_t count)
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700383{
Christoph Hellwigea9ed9c2015-10-03 15:32:56 +0200384 struct netconsole_target *nt = to_target(item);
Nikolay Aleksandrov45e526e2013-10-23 15:04:49 +0200385 unsigned long flags;
Breno Leitao004a04b2023-07-21 02:21:45 -0700386 bool enabled;
Breno Leitao5c4a39e2024-08-08 05:25:09 -0700387 ssize_t ret;
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700388
Christoph Hellwigea9ed9c2015-10-03 15:32:56 +0200389 mutex_lock(&dynamic_netconsole_mutex);
Breno Leitao5c4a39e2024-08-08 05:25:09 -0700390 ret = kstrtobool(buf, &enabled);
391 if (ret)
Christoph Hellwigea9ed9c2015-10-03 15:32:56 +0200392 goto out_unlock;
393
Breno Leitao5c4a39e2024-08-08 05:25:09 -0700394 ret = -EINVAL;
Breno Leitaoa9359e82024-07-09 07:43:59 -0700395 if (enabled == nt->enabled) {
Joe Perches22ded572013-10-28 12:53:21 -0700396 pr_info("network logging has already %s\n",
397 nt->enabled ? "started" : "stopped");
Christoph Hellwigea9ed9c2015-10-03 15:32:56 +0200398 goto out_unlock;
Gao fengd5123482011-10-11 16:08:11 +0000399 }
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700400
Tejun Heo698cf1c2015-06-25 15:01:36 -0700401 if (enabled) { /* true */
Breno Leitaoc62c0a12023-07-14 04:13:29 -0700402 if (nt->release && !nt->extended) {
403 pr_err("Not enabling netconsole. Release feature requires extended log message");
404 goto out_unlock;
405 }
406
John Ogness2c6b4b72022-11-16 17:27:43 +0106407 if (nt->extended && !console_is_registered(&netconsole_ext))
Tejun Heoe2f15f92015-06-25 15:01:41 -0700408 register_console(&netconsole_ext);
Tejun Heoe2f15f92015-06-25 15:01:41 -0700409
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700410 /*
411 * Skip netpoll_parse_options() -- all the attributes are
412 * already configured via configfs. Just print them out.
413 */
414 netpoll_print_options(&nt->np);
415
Breno Leitao5c4a39e2024-08-08 05:25:09 -0700416 ret = netpoll_setup(&nt->np);
417 if (ret)
Christoph Hellwigea9ed9c2015-10-03 15:32:56 +0200418 goto out_unlock;
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700419
Breno Leitao00666232024-07-09 07:44:00 -0700420 nt->enabled = true;
Joe Perches4a6a97e2017-06-12 16:39:51 -0700421 pr_info("network logging started\n");
Tejun Heo698cf1c2015-06-25 15:01:36 -0700422 } else { /* false */
Nikolay Aleksandrov45e526e2013-10-23 15:04:49 +0200423 /* We need to disable the netconsole before cleaning it up
424 * otherwise we might end up in write_msg() with
Tejun Heo698cf1c2015-06-25 15:01:36 -0700425 * nt->np.dev == NULL and nt->enabled == true
Nikolay Aleksandrov45e526e2013-10-23 15:04:49 +0200426 */
Breno Leitao97714692024-08-08 05:25:11 -0700427 mutex_lock(&target_cleanup_list_lock);
Nikolay Aleksandrov45e526e2013-10-23 15:04:49 +0200428 spin_lock_irqsave(&target_list_lock, flags);
Tejun Heo698cf1c2015-06-25 15:01:36 -0700429 nt->enabled = false;
Breno Leitao97714692024-08-08 05:25:11 -0700430 /* Remove the target from the list, while holding
431 * target_list_lock
432 */
433 list_move(&nt->list, &target_cleanup_list);
Nikolay Aleksandrov45e526e2013-10-23 15:04:49 +0200434 spin_unlock_irqrestore(&target_list_lock, flags);
Breno Leitao97714692024-08-08 05:25:11 -0700435 mutex_unlock(&target_cleanup_list_lock);
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700436 }
437
Breno Leitaof2ab4c12024-08-08 05:25:10 -0700438 ret = strnlen(buf, count);
Breno Leitao97714692024-08-08 05:25:11 -0700439 /* Deferred cleanup */
440 netconsole_process_cleanups();
Christoph Hellwigea9ed9c2015-10-03 15:32:56 +0200441out_unlock:
442 mutex_unlock(&dynamic_netconsole_mutex);
Breno Leitao5c4a39e2024-08-08 05:25:09 -0700443 return ret;
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700444}
445
Breno Leitaoc62c0a12023-07-14 04:13:29 -0700446static ssize_t release_store(struct config_item *item, const char *buf,
447 size_t count)
448{
449 struct netconsole_target *nt = to_target(item);
Breno Leitao004a04b2023-07-21 02:21:45 -0700450 bool release;
Breno Leitao5c4a39e2024-08-08 05:25:09 -0700451 ssize_t ret;
Breno Leitaoc62c0a12023-07-14 04:13:29 -0700452
453 mutex_lock(&dynamic_netconsole_mutex);
454 if (nt->enabled) {
455 pr_err("target (%s) is enabled, disable to update parameters\n",
Matthew Woodbd9c69a2024-02-04 15:27:33 -0800456 config_item_name(&nt->group.cg_item));
Breno Leitao5c4a39e2024-08-08 05:25:09 -0700457 ret = -EINVAL;
Breno Leitaoc62c0a12023-07-14 04:13:29 -0700458 goto out_unlock;
459 }
460
Breno Leitao5c4a39e2024-08-08 05:25:09 -0700461 ret = kstrtobool(buf, &release);
462 if (ret)
Breno Leitaoc62c0a12023-07-14 04:13:29 -0700463 goto out_unlock;
Breno Leitaoc62c0a12023-07-14 04:13:29 -0700464
465 nt->release = release;
466
Breno Leitaof2ab4c12024-08-08 05:25:10 -0700467 ret = strnlen(buf, count);
Breno Leitaoc62c0a12023-07-14 04:13:29 -0700468out_unlock:
469 mutex_unlock(&dynamic_netconsole_mutex);
Breno Leitao5c4a39e2024-08-08 05:25:09 -0700470 return ret;
Breno Leitaoc62c0a12023-07-14 04:13:29 -0700471}
472
Christoph Hellwigea9ed9c2015-10-03 15:32:56 +0200473static ssize_t extended_store(struct config_item *item, const char *buf,
474 size_t count)
Tejun Heoe2f15f92015-06-25 15:01:41 -0700475{
Christoph Hellwigea9ed9c2015-10-03 15:32:56 +0200476 struct netconsole_target *nt = to_target(item);
Breno Leitao004a04b2023-07-21 02:21:45 -0700477 bool extended;
Breno Leitao5c4a39e2024-08-08 05:25:09 -0700478 ssize_t ret;
Tejun Heoe2f15f92015-06-25 15:01:41 -0700479
Christoph Hellwigea9ed9c2015-10-03 15:32:56 +0200480 mutex_lock(&dynamic_netconsole_mutex);
Tejun Heoe2f15f92015-06-25 15:01:41 -0700481 if (nt->enabled) {
482 pr_err("target (%s) is enabled, disable to update parameters\n",
Matthew Woodbd9c69a2024-02-04 15:27:33 -0800483 config_item_name(&nt->group.cg_item));
Breno Leitao5c4a39e2024-08-08 05:25:09 -0700484 ret = -EINVAL;
Christoph Hellwigea9ed9c2015-10-03 15:32:56 +0200485 goto out_unlock;
Tejun Heoe2f15f92015-06-25 15:01:41 -0700486 }
487
Breno Leitao5c4a39e2024-08-08 05:25:09 -0700488 ret = kstrtobool(buf, &extended);
489 if (ret)
Christoph Hellwigea9ed9c2015-10-03 15:32:56 +0200490 goto out_unlock;
Tejun Heoe2f15f92015-06-25 15:01:41 -0700491
492 nt->extended = extended;
Breno Leitaof2ab4c12024-08-08 05:25:10 -0700493 ret = strnlen(buf, count);
Christoph Hellwigea9ed9c2015-10-03 15:32:56 +0200494out_unlock:
495 mutex_unlock(&dynamic_netconsole_mutex);
Breno Leitao5c4a39e2024-08-08 05:25:09 -0700496 return ret;
Tejun Heoe2f15f92015-06-25 15:01:41 -0700497}
498
Christoph Hellwigea9ed9c2015-10-03 15:32:56 +0200499static ssize_t dev_name_store(struct config_item *item, const char *buf,
500 size_t count)
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700501{
Christoph Hellwigea9ed9c2015-10-03 15:32:56 +0200502 struct netconsole_target *nt = to_target(item);
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700503
Christoph Hellwigea9ed9c2015-10-03 15:32:56 +0200504 mutex_lock(&dynamic_netconsole_mutex);
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700505 if (nt->enabled) {
Joe Perches22ded572013-10-28 12:53:21 -0700506 pr_err("target (%s) is enabled, disable to update parameters\n",
Matthew Woodbd9c69a2024-02-04 15:27:33 -0800507 config_item_name(&nt->group.cg_item));
Christoph Hellwigea9ed9c2015-10-03 15:32:56 +0200508 mutex_unlock(&dynamic_netconsole_mutex);
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700509 return -EINVAL;
510 }
511
Wolfram Sangfb3ceec2022-08-30 22:14:52 +0200512 strscpy(nt->np.dev_name, buf, IFNAMSIZ);
Matthew Woodae001dc2024-02-04 15:27:34 -0800513 trim_newline(nt->np.dev_name, IFNAMSIZ);
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700514
Christoph Hellwigea9ed9c2015-10-03 15:32:56 +0200515 mutex_unlock(&dynamic_netconsole_mutex);
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700516 return strnlen(buf, count);
517}
518
Christoph Hellwigea9ed9c2015-10-03 15:32:56 +0200519static ssize_t local_port_store(struct config_item *item, const char *buf,
520 size_t count)
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700521{
Christoph Hellwigea9ed9c2015-10-03 15:32:56 +0200522 struct netconsole_target *nt = to_target(item);
Breno Leitao5c4a39e2024-08-08 05:25:09 -0700523 ssize_t ret = -EINVAL;
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700524
Christoph Hellwigea9ed9c2015-10-03 15:32:56 +0200525 mutex_lock(&dynamic_netconsole_mutex);
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700526 if (nt->enabled) {
Joe Perches22ded572013-10-28 12:53:21 -0700527 pr_err("target (%s) is enabled, disable to update parameters\n",
Matthew Woodbd9c69a2024-02-04 15:27:33 -0800528 config_item_name(&nt->group.cg_item));
Christoph Hellwigea9ed9c2015-10-03 15:32:56 +0200529 goto out_unlock;
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700530 }
531
Breno Leitao5c4a39e2024-08-08 05:25:09 -0700532 ret = kstrtou16(buf, 10, &nt->np.local_port);
533 if (ret < 0)
Christoph Hellwigea9ed9c2015-10-03 15:32:56 +0200534 goto out_unlock;
Breno Leitaof2ab4c12024-08-08 05:25:10 -0700535 ret = strnlen(buf, count);
Christoph Hellwigea9ed9c2015-10-03 15:32:56 +0200536out_unlock:
537 mutex_unlock(&dynamic_netconsole_mutex);
Breno Leitao5c4a39e2024-08-08 05:25:09 -0700538 return ret;
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700539}
540
Christoph Hellwigea9ed9c2015-10-03 15:32:56 +0200541static ssize_t remote_port_store(struct config_item *item,
542 const char *buf, size_t count)
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700543{
Christoph Hellwigea9ed9c2015-10-03 15:32:56 +0200544 struct netconsole_target *nt = to_target(item);
Breno Leitao5c4a39e2024-08-08 05:25:09 -0700545 ssize_t ret = -EINVAL;
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700546
Christoph Hellwigea9ed9c2015-10-03 15:32:56 +0200547 mutex_lock(&dynamic_netconsole_mutex);
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700548 if (nt->enabled) {
Joe Perches22ded572013-10-28 12:53:21 -0700549 pr_err("target (%s) is enabled, disable to update parameters\n",
Matthew Woodbd9c69a2024-02-04 15:27:33 -0800550 config_item_name(&nt->group.cg_item));
Christoph Hellwigea9ed9c2015-10-03 15:32:56 +0200551 goto out_unlock;
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700552 }
553
Breno Leitao5c4a39e2024-08-08 05:25:09 -0700554 ret = kstrtou16(buf, 10, &nt->np.remote_port);
555 if (ret < 0)
Christoph Hellwigea9ed9c2015-10-03 15:32:56 +0200556 goto out_unlock;
Breno Leitaof2ab4c12024-08-08 05:25:10 -0700557 ret = strnlen(buf, count);
Christoph Hellwigea9ed9c2015-10-03 15:32:56 +0200558out_unlock:
559 mutex_unlock(&dynamic_netconsole_mutex);
Breno Leitao5c4a39e2024-08-08 05:25:09 -0700560 return ret;
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700561}
562
Christoph Hellwigea9ed9c2015-10-03 15:32:56 +0200563static ssize_t local_ip_store(struct config_item *item, const char *buf,
564 size_t count)
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700565{
Christoph Hellwigea9ed9c2015-10-03 15:32:56 +0200566 struct netconsole_target *nt = to_target(item);
Breno Leitaof2ab4c12024-08-08 05:25:10 -0700567 ssize_t ret = -EINVAL;
Christoph Hellwigea9ed9c2015-10-03 15:32:56 +0200568
569 mutex_lock(&dynamic_netconsole_mutex);
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700570 if (nt->enabled) {
Joe Perches22ded572013-10-28 12:53:21 -0700571 pr_err("target (%s) is enabled, disable to update parameters\n",
Matthew Woodbd9c69a2024-02-04 15:27:33 -0800572 config_item_name(&nt->group.cg_item));
Christoph Hellwigea9ed9c2015-10-03 15:32:56 +0200573 goto out_unlock;
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700574 }
575
Cong Wangb3d936f32013-01-07 20:52:41 +0000576 if (strnchr(buf, count, ':')) {
577 const char *end;
Matthew Wood602ad3b2024-02-04 15:27:32 -0800578
Cong Wangb3d936f32013-01-07 20:52:41 +0000579 if (in6_pton(buf, count, nt->np.local_ip.in6.s6_addr, -1, &end) > 0) {
580 if (*end && *end != '\n') {
Joe Perches22ded572013-10-28 12:53:21 -0700581 pr_err("invalid IPv6 address at: <%c>\n", *end);
Christoph Hellwigea9ed9c2015-10-03 15:32:56 +0200582 goto out_unlock;
Cong Wangb3d936f32013-01-07 20:52:41 +0000583 }
584 nt->np.ipv6 = true;
585 } else
Christoph Hellwigea9ed9c2015-10-03 15:32:56 +0200586 goto out_unlock;
Cong Wangb3d936f32013-01-07 20:52:41 +0000587 } else {
Matthew Wood602ad3b2024-02-04 15:27:32 -0800588 if (!nt->np.ipv6)
Cong Wangb3d936f32013-01-07 20:52:41 +0000589 nt->np.local_ip.ip = in_aton(buf);
Matthew Wood602ad3b2024-02-04 15:27:32 -0800590 else
Christoph Hellwigea9ed9c2015-10-03 15:32:56 +0200591 goto out_unlock;
Cong Wangb3d936f32013-01-07 20:52:41 +0000592 }
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700593
Breno Leitaof2ab4c12024-08-08 05:25:10 -0700594 ret = strnlen(buf, count);
Christoph Hellwigea9ed9c2015-10-03 15:32:56 +0200595out_unlock:
596 mutex_unlock(&dynamic_netconsole_mutex);
Breno Leitaof2ab4c12024-08-08 05:25:10 -0700597 return ret;
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700598}
599
Christoph Hellwigea9ed9c2015-10-03 15:32:56 +0200600static ssize_t remote_ip_store(struct config_item *item, const char *buf,
601 size_t count)
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700602{
Christoph Hellwigea9ed9c2015-10-03 15:32:56 +0200603 struct netconsole_target *nt = to_target(item);
Breno Leitaof2ab4c12024-08-08 05:25:10 -0700604 ssize_t ret = -EINVAL;
Christoph Hellwigea9ed9c2015-10-03 15:32:56 +0200605
606 mutex_lock(&dynamic_netconsole_mutex);
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700607 if (nt->enabled) {
Joe Perches22ded572013-10-28 12:53:21 -0700608 pr_err("target (%s) is enabled, disable to update parameters\n",
Matthew Woodbd9c69a2024-02-04 15:27:33 -0800609 config_item_name(&nt->group.cg_item));
Christoph Hellwigea9ed9c2015-10-03 15:32:56 +0200610 goto out_unlock;
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700611 }
612
Cong Wangb3d936f32013-01-07 20:52:41 +0000613 if (strnchr(buf, count, ':')) {
614 const char *end;
Matthew Wood602ad3b2024-02-04 15:27:32 -0800615
Cong Wangb3d936f32013-01-07 20:52:41 +0000616 if (in6_pton(buf, count, nt->np.remote_ip.in6.s6_addr, -1, &end) > 0) {
617 if (*end && *end != '\n') {
Joe Perches22ded572013-10-28 12:53:21 -0700618 pr_err("invalid IPv6 address at: <%c>\n", *end);
Christoph Hellwigea9ed9c2015-10-03 15:32:56 +0200619 goto out_unlock;
Cong Wangb3d936f32013-01-07 20:52:41 +0000620 }
621 nt->np.ipv6 = true;
622 } else
Christoph Hellwigea9ed9c2015-10-03 15:32:56 +0200623 goto out_unlock;
Cong Wangb3d936f32013-01-07 20:52:41 +0000624 } else {
Matthew Wood602ad3b2024-02-04 15:27:32 -0800625 if (!nt->np.ipv6)
Cong Wangb3d936f32013-01-07 20:52:41 +0000626 nt->np.remote_ip.ip = in_aton(buf);
Matthew Wood602ad3b2024-02-04 15:27:32 -0800627 else
Christoph Hellwigea9ed9c2015-10-03 15:32:56 +0200628 goto out_unlock;
Cong Wangb3d936f32013-01-07 20:52:41 +0000629 }
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700630
Breno Leitaof2ab4c12024-08-08 05:25:10 -0700631 ret = strnlen(buf, count);
Christoph Hellwigea9ed9c2015-10-03 15:32:56 +0200632out_unlock:
633 mutex_unlock(&dynamic_netconsole_mutex);
Breno Leitaof2ab4c12024-08-08 05:25:10 -0700634 return ret;
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700635}
636
Christoph Hellwigea9ed9c2015-10-03 15:32:56 +0200637static ssize_t remote_mac_store(struct config_item *item, const char *buf,
638 size_t count)
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700639{
Christoph Hellwigea9ed9c2015-10-03 15:32:56 +0200640 struct netconsole_target *nt = to_target(item);
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700641 u8 remote_mac[ETH_ALEN];
Breno Leitaof2ab4c12024-08-08 05:25:10 -0700642 ssize_t ret = -EINVAL;
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700643
Christoph Hellwigea9ed9c2015-10-03 15:32:56 +0200644 mutex_lock(&dynamic_netconsole_mutex);
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700645 if (nt->enabled) {
Joe Perches22ded572013-10-28 12:53:21 -0700646 pr_err("target (%s) is enabled, disable to update parameters\n",
Matthew Woodbd9c69a2024-02-04 15:27:33 -0800647 config_item_name(&nt->group.cg_item));
Christoph Hellwigea9ed9c2015-10-03 15:32:56 +0200648 goto out_unlock;
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700649 }
650
Alexey Dobriyan4940fc82011-05-07 23:00:07 +0000651 if (!mac_pton(buf, remote_mac))
Christoph Hellwigea9ed9c2015-10-03 15:32:56 +0200652 goto out_unlock;
Alexey Dobriyan4940fc82011-05-07 23:00:07 +0000653 if (buf[3 * ETH_ALEN - 1] && buf[3 * ETH_ALEN - 1] != '\n')
Christoph Hellwigea9ed9c2015-10-03 15:32:56 +0200654 goto out_unlock;
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700655 memcpy(nt->np.remote_mac, remote_mac, ETH_ALEN);
656
Breno Leitaof2ab4c12024-08-08 05:25:10 -0700657 ret = strnlen(buf, count);
Christoph Hellwigea9ed9c2015-10-03 15:32:56 +0200658out_unlock:
659 mutex_unlock(&dynamic_netconsole_mutex);
Breno Leitaof2ab4c12024-08-08 05:25:10 -0700660 return ret;
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700661}
662
Matthew Wood8a6d5fe2024-02-04 15:27:36 -0800663struct 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
Matthew Wooddf03f832024-02-04 15:27:37 -0800695static void update_userdata(struct netconsole_target *nt)
696{
697 int complete_idx = 0, child_count = 0;
698 struct list_head *entry;
699
700 /* Clear the current string in case the last userdatum was deleted */
701 nt->userdata_length = 0;
702 nt->userdata_complete[0] = 0;
703
704 list_for_each(entry, &nt->userdata_group.cg_children) {
705 struct userdatum *udm_item;
706 struct config_item *item;
707
708 if (child_count >= MAX_USERDATA_ITEMS)
709 break;
710 child_count++;
711
712 item = container_of(entry, struct config_item, ci_entry);
713 udm_item = to_userdatum(item);
714
715 /* Skip userdata with no value set */
716 if (strnlen(udm_item->value, MAX_USERDATA_VALUE_LENGTH) == 0)
717 continue;
718
719 /* This doesn't overflow userdata_complete since it will write
720 * one entry length (1/MAX_USERDATA_ITEMS long), entry count is
721 * checked to not exceed MAX items with child_count above
722 */
723 complete_idx += scnprintf(&nt->userdata_complete[complete_idx],
Matthew Wood2b3953582024-03-07 16:25:24 -0800724 MAX_USERDATA_ENTRY_LENGTH, " %s=%s\n",
Matthew Wooddf03f832024-02-04 15:27:37 -0800725 item->ci_name, udm_item->value);
726 }
727 nt->userdata_length = strnlen(nt->userdata_complete,
728 sizeof(nt->userdata_complete));
729}
730
Matthew Wood8a6d5fe2024-02-04 15:27:36 -0800731static ssize_t userdatum_value_store(struct config_item *item, const char *buf,
732 size_t count)
733{
734 struct userdatum *udm = to_userdatum(item);
Matthew Wooddf03f832024-02-04 15:27:37 -0800735 struct netconsole_target *nt;
736 struct userdata *ud;
Breno Leitaoe0a2b7e2024-08-08 05:25:08 -0700737 ssize_t ret;
Matthew Wood8a6d5fe2024-02-04 15:27:36 -0800738
739 if (count > MAX_USERDATA_VALUE_LENGTH)
740 return -EMSGSIZE;
741
742 mutex_lock(&dynamic_netconsole_mutex);
743
744 ret = strscpy(udm->value, buf, sizeof(udm->value));
745 if (ret < 0)
746 goto out_unlock;
747 trim_newline(udm->value, sizeof(udm->value));
748
Matthew Wooddf03f832024-02-04 15:27:37 -0800749 ud = to_userdata(item->ci_parent);
750 nt = userdata_to_target(ud);
751 update_userdata(nt);
Breno Leitaof2ab4c12024-08-08 05:25:10 -0700752 ret = count;
Matthew Wood8a6d5fe2024-02-04 15:27:36 -0800753out_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
Matthew Wooddf03f832024-02-04 15:27:37 -0800805static void userdatum_drop(struct config_group *group, struct config_item *item)
806{
807 struct netconsole_target *nt;
808 struct userdata *ud;
809
810 ud = to_userdata(&group->cg_item);
811 nt = userdata_to_target(ud);
812
813 mutex_lock(&dynamic_netconsole_mutex);
814 update_userdata(nt);
815 config_item_put(item);
816 mutex_unlock(&dynamic_netconsole_mutex);
817}
818
Matthew Wood8a6d5fe2024-02-04 15:27:36 -0800819static struct configfs_attribute *userdata_attrs[] = {
820 NULL,
821};
822
823static struct configfs_group_operations userdata_ops = {
824 .make_item = userdatum_make_item,
Matthew Wooddf03f832024-02-04 15:27:37 -0800825 .drop_item = userdatum_drop,
Matthew Wood8a6d5fe2024-02-04 15:27:36 -0800826};
827
Christophe JAILLETed4290f2024-08-10 23:39:04 +0200828static const struct config_item_type userdata_type = {
Matthew Wood8a6d5fe2024-02-04 15:27:36 -0800829 .ct_item_ops = &userdatum_ops,
830 .ct_group_ops = &userdata_ops,
831 .ct_attrs = userdata_attrs,
832 .ct_owner = THIS_MODULE,
833};
834
Christoph Hellwigea9ed9c2015-10-03 15:32:56 +0200835CONFIGFS_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);
Breno Leitaoc62c0a12023-07-14 04:13:29 -0700844CONFIGFS_ATTR(, release);
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700845
846static struct configfs_attribute *netconsole_target_attrs[] = {
Christoph Hellwigea9ed9c2015-10-03 15:32:56 +0200847 &attr_enabled,
848 &attr_extended,
Breno Leitaoc62c0a12023-07-14 04:13:29 -0700849 &attr_release,
Christoph Hellwigea9ed9c2015-10-03 15:32:56 +0200850 &attr_dev_name,
851 &attr_local_port,
852 &attr_remote_port,
853 &attr_local_ip,
854 &attr_remote_ip,
855 &attr_local_mac,
856 &attr_remote_mac,
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700857 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
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700869static struct configfs_item_operations netconsole_target_item_ops = {
870 .release = netconsole_target_release,
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700871};
872
Bhumika Goyal0d4a4402017-10-16 17:18:52 +0200873static const struct config_item_type netconsole_target_type = {
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700874 .ct_attrs = netconsole_target_attrs,
875 .ct_item_ops = &netconsole_target_item_ops,
876 .ct_owner = THIS_MODULE,
877};
878
Matthew Wood8a6d5fe2024-02-04 15:27:36 -0800879static void init_target_config_group(struct netconsole_target *nt,
880 const char *name)
881{
882 config_group_init_type_name(&nt->group, name, &netconsole_target_type);
883 config_group_init_type_name(&nt->userdata_group, "userdata",
884 &userdata_type);
885 configfs_add_default_group(&nt->userdata_group, &nt->group);
886}
887
Breno Leitao5fbd6cd2023-10-12 04:14:00 -0700888static struct netconsole_target *find_cmdline_target(const char *name)
889{
890 struct netconsole_target *nt, *ret = NULL;
891 unsigned long flags;
892
893 spin_lock_irqsave(&target_list_lock, flags);
894 list_for_each_entry(nt, &target_list, list) {
Matthew Woodbd9c69a2024-02-04 15:27:33 -0800895 if (!strcmp(nt->group.cg_item.ci_name, name)) {
Breno Leitao5fbd6cd2023-10-12 04:14:00 -0700896 ret = nt;
897 break;
898 }
899 }
900 spin_unlock_irqrestore(&target_list_lock, flags);
901
902 return ret;
903}
904
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700905/*
906 * Group operations and type for netconsole_subsys.
907 */
908
Matthew Woodbd9c69a2024-02-04 15:27:33 -0800909static struct config_group *make_netconsole_target(struct config_group *group,
910 const char *name)
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700911{
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700912 struct netconsole_target *nt;
Breno Leitaob0a9e2c2023-08-11 02:31:57 -0700913 unsigned long flags;
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700914
Breno Leitao5fbd6cd2023-10-12 04:14:00 -0700915 /* Checking if a target by this name was created at boot time. If so,
916 * attach a configfs entry to that target. This enables dynamic
917 * control.
918 */
919 if (!strncmp(name, NETCONSOLE_PARAM_TARGET_PREFIX,
920 strlen(NETCONSOLE_PARAM_TARGET_PREFIX))) {
921 nt = find_cmdline_target(name);
Matthew Wood8a6d5fe2024-02-04 15:27:36 -0800922 if (nt) {
923 init_target_config_group(nt, name);
Matthew Woodbd9c69a2024-02-04 15:27:33 -0800924 return &nt->group;
Matthew Wood8a6d5fe2024-02-04 15:27:36 -0800925 }
Breno Leitao5fbd6cd2023-10-12 04:14:00 -0700926 }
927
Breno Leitaob0a9e2c2023-08-11 02:31:57 -0700928 nt = alloc_and_init();
Joe Perchese404dec2012-01-29 12:56:23 +0000929 if (!nt)
Joel Beckera6795e92008-07-17 15:21:29 -0700930 return ERR_PTR(-ENOMEM);
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700931
Matthew Wood8a6d5fe2024-02-04 15:27:36 -0800932 /* Initialize the config_group member */
933 init_target_config_group(nt, name);
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700934
935 /* Adding, but it is disabled */
936 spin_lock_irqsave(&target_list_lock, flags);
937 list_add(&nt->list, &target_list);
938 spin_unlock_irqrestore(&target_list_lock, flags);
939
Matthew Woodbd9c69a2024-02-04 15:27:33 -0800940 return &nt->group;
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700941}
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
Matthew Woodbd9c69a2024-02-04 15:27:33 -0800960 config_item_put(&nt->group.cg_item);
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700961}
962
963static struct configfs_group_operations netconsole_subsys_group_ops = {
Matthew Woodbd9c69a2024-02-04 15:27:33 -0800964 .make_group = make_netconsole_target,
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700965 .drop_item = drop_netconsole_target,
966};
967
Bhumika Goyal0d4a4402017-10-16 17:18:52 +0200968static const struct config_item_type netconsole_subsys_type = {
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700969 .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
Breno Leitao131eeb42023-10-12 04:13:59 -0700983static void populate_configfs_item(struct netconsole_target *nt,
984 int cmdline_count)
985{
986 char target_name[16];
987
988 snprintf(target_name, sizeof(target_name), "%s%d",
989 NETCONSOLE_PARAM_TARGET_PREFIX, cmdline_count);
Matthew Wood8a6d5fe2024-02-04 15:27:36 -0800990 init_target_config_group(nt, target_name);
Breno Leitao131eeb42023-10-12 04:13:59 -0700991}
992
Satyam Sharma0bcc1812007-08-10 15:35:05 -0700993#endif /* CONFIG_NETCONSOLE_DYNAMIC */
994
Satyam Sharma17951f32007-08-10 15:33:01 -0700995/* Handle network interface device notifications */
996static int netconsole_netdev_event(struct notifier_block *this,
Jiri Pirko351638e2013-05-28 01:30:21 +0000997 unsigned long event, void *ptr)
Satyam Sharma17951f32007-08-10 15:33:01 -0700998{
Satyam Sharmab5427c22007-08-10 15:33:40 -0700999 unsigned long flags;
Breno Leitao97714692024-08-08 05:25:11 -07001000 struct netconsole_target *nt, *tmp;
Jiri Pirko351638e2013-05-28 01:30:21 +00001001 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
Ferenc Wagner141dfba2011-01-06 05:11:19 +00001002 bool stopped = false;
Satyam Sharma17951f32007-08-10 15:33:01 -07001003
WANG Cong0e34e932010-05-06 00:47:21 -07001004 if (!(event == NETDEV_CHANGENAME || event == NETDEV_UNREGISTER ||
Amerigo Wangdaf92092011-05-19 21:39:12 +00001005 event == NETDEV_RELEASE || event == NETDEV_JOIN))
Satyam Sharmab5427c22007-08-10 15:33:40 -07001006 goto done;
Satyam Sharma17951f32007-08-10 15:33:01 -07001007
Breno Leitao97714692024-08-08 05:25:11 -07001008 mutex_lock(&target_cleanup_list_lock);
Satyam Sharmab5427c22007-08-10 15:33:40 -07001009 spin_lock_irqsave(&target_list_lock, flags);
Breno Leitao97714692024-08-08 05:25:11 -07001010 list_for_each_entry_safe(nt, tmp, &target_list, list) {
Satyam Sharma0bcc1812007-08-10 15:35:05 -07001011 netconsole_target_get(nt);
Satyam Sharmab5427c22007-08-10 15:33:40 -07001012 if (nt->np.dev == dev) {
1013 switch (event) {
Satyam Sharmab5427c22007-08-10 15:33:40 -07001014 case NETDEV_CHANGENAME:
Wolfram Sangfb3ceec2022-08-30 22:14:52 +02001015 strscpy(nt->np.dev_name, dev->name, IFNAMSIZ);
Satyam Sharmab5427c22007-08-10 15:33:40 -07001016 break;
Amerigo Wangdaf92092011-05-19 21:39:12 +00001017 case NETDEV_RELEASE:
Amerigo Wang8d8fc292011-05-19 21:39:10 +00001018 case NETDEV_JOIN:
Bruno Prémont2382b152009-04-29 20:45:17 +00001019 case NETDEV_UNREGISTER:
Breno Leitao97d9fba2024-07-12 07:34:15 -07001020 nt->enabled = false;
Breno Leitao97714692024-08-08 05:25:11 -07001021 list_move(&nt->list, &target_cleanup_list);
Ferenc Wagner141dfba2011-01-06 05:11:19 +00001022 stopped = true;
Satyam Sharmab5427c22007-08-10 15:33:40 -07001023 }
Satyam Sharma17951f32007-08-10 15:33:01 -07001024 }
Satyam Sharma0bcc1812007-08-10 15:35:05 -07001025 netconsole_target_put(nt);
Satyam Sharma17951f32007-08-10 15:33:01 -07001026 }
Satyam Sharmab5427c22007-08-10 15:33:40 -07001027 spin_unlock_irqrestore(&target_list_lock, flags);
Breno Leitao97714692024-08-08 05:25:11 -07001028 mutex_unlock(&target_cleanup_list_lock);
1029
Amerigo Wang8d8fc292011-05-19 21:39:10 +00001030 if (stopped) {
Joe Perches22ded572013-10-28 12:53:21 -07001031 const char *msg = "had an event";
Matthew Wood602ad3b2024-02-04 15:27:32 -08001032
Amerigo Wang8d8fc292011-05-19 21:39:10 +00001033 switch (event) {
1034 case NETDEV_UNREGISTER:
Joe Perches22ded572013-10-28 12:53:21 -07001035 msg = "unregistered";
Amerigo Wang8d8fc292011-05-19 21:39:10 +00001036 break;
Amerigo Wangdaf92092011-05-19 21:39:12 +00001037 case NETDEV_RELEASE:
Joe Perches22ded572013-10-28 12:53:21 -07001038 msg = "released slaves";
Amerigo Wang8d8fc292011-05-19 21:39:10 +00001039 break;
1040 case NETDEV_JOIN:
Joe Perches22ded572013-10-28 12:53:21 -07001041 msg = "is joining a master device";
Amerigo Wang8d8fc292011-05-19 21:39:10 +00001042 break;
1043 }
Joe Perches22ded572013-10-28 12:53:21 -07001044 pr_info("network logging stopped on interface %s as it %s\n",
1045 dev->name, msg);
Amerigo Wang8d8fc292011-05-19 21:39:10 +00001046 }
Satyam Sharma17951f32007-08-10 15:33:01 -07001047
Breno Leitao97714692024-08-08 05:25:11 -07001048 /* Process target_cleanup_list entries. By the end, target_cleanup_list
1049 * should be empty
1050 */
1051 netconsole_process_cleanups_core();
1052
Satyam Sharmab5427c22007-08-10 15:33:40 -07001053done:
Satyam Sharma17951f32007-08-10 15:33:01 -07001054 return NOTIFY_DONE;
1055}
1056
1057static struct notifier_block netconsole_netdev_notifier = {
1058 .notifier_call = netconsole_netdev_event,
1059};
1060
Tejun Heoe2f15f92015-06-25 15:01:41 -07001061/**
1062 * send_ext_msg_udp - send extended log message to target
1063 * @nt: target to send message to
1064 * @msg: extended log message to send
1065 * @msg_len: length of message
1066 *
1067 * Transfer extended log @msg to @nt. If @msg is longer than
1068 * MAX_PRINT_CHUNK, it'll be split and transmitted in multiple chunks with
1069 * ncfrag header field added to identify them.
1070 */
1071static void send_ext_msg_udp(struct netconsole_target *nt, const char *msg,
1072 int msg_len)
1073{
1074 static char buf[MAX_PRINT_CHUNK]; /* protected by target_list_lock */
1075 const char *header, *body;
1076 int offset = 0;
1077 int header_len, body_len;
Breno Leitaoc62c0a12023-07-14 04:13:29 -07001078 const char *msg_ready = msg;
1079 const char *release;
1080 int release_len = 0;
Matthew Woodb4ab4f22024-02-04 15:27:38 -08001081 int userdata_len = 0;
1082 char *userdata = NULL;
1083
1084#ifdef CONFIG_NETCONSOLE_DYNAMIC
1085 userdata = nt->userdata_complete;
1086 userdata_len = nt->userdata_length;
1087#endif
Tejun Heoe2f15f92015-06-25 15:01:41 -07001088
Breno Leitaoc62c0a12023-07-14 04:13:29 -07001089 if (nt->release) {
1090 release = init_utsname()->release;
1091 release_len = strlen(release) + 1;
1092 }
1093
Matthew Woodb4ab4f22024-02-04 15:27:38 -08001094 if (msg_len + release_len + userdata_len <= MAX_PRINT_CHUNK) {
Breno Leitaoc62c0a12023-07-14 04:13:29 -07001095 /* No fragmentation needed */
1096 if (nt->release) {
1097 scnprintf(buf, MAX_PRINT_CHUNK, "%s,%s", release, msg);
1098 msg_len += release_len;
Matthew Woodb4ab4f22024-02-04 15:27:38 -08001099 } else {
1100 memcpy(buf, msg, msg_len);
Breno Leitaoc62c0a12023-07-14 04:13:29 -07001101 }
Matthew Woodb4ab4f22024-02-04 15:27:38 -08001102
1103 if (userdata)
1104 msg_len += scnprintf(&buf[msg_len],
1105 MAX_PRINT_CHUNK - msg_len,
1106 "%s", userdata);
1107
1108 msg_ready = buf;
Breno Leitaoc62c0a12023-07-14 04:13:29 -07001109 netpoll_send_udp(&nt->np, msg_ready, msg_len);
Tejun Heoe2f15f92015-06-25 15:01:41 -07001110 return;
1111 }
1112
1113 /* need to insert extra header fields, detect header and body */
1114 header = msg;
1115 body = memchr(msg, ';', msg_len);
1116 if (WARN_ON_ONCE(!body))
1117 return;
1118
1119 header_len = body - header;
1120 body_len = msg_len - header_len - 1;
1121 body++;
1122
1123 /*
1124 * Transfer multiple chunks with the following extra header.
1125 * "ncfrag=<byte-offset>/<total-bytes>"
1126 */
Breno Leitaoc62c0a12023-07-14 04:13:29 -07001127 if (nt->release)
1128 scnprintf(buf, MAX_PRINT_CHUNK, "%s,", release);
1129 memcpy(buf + release_len, header, header_len);
1130 header_len += release_len;
Tejun Heoe2f15f92015-06-25 15:01:41 -07001131
Matthew Wood1ec9daf2024-02-04 15:27:39 -08001132 while (offset < body_len + userdata_len) {
Tejun Heoe2f15f92015-06-25 15:01:41 -07001133 int this_header = header_len;
Matthew Wood1ec9daf2024-02-04 15:27:39 -08001134 int this_offset = 0;
1135 int this_chunk = 0;
Tejun Heoe2f15f92015-06-25 15:01:41 -07001136
1137 this_header += scnprintf(buf + this_header,
1138 sizeof(buf) - this_header,
Matthew Wood1ec9daf2024-02-04 15:27:39 -08001139 ",ncfrag=%d/%d;", offset,
1140 body_len + userdata_len);
Tejun Heoe2f15f92015-06-25 15:01:41 -07001141
Matthew Wood1ec9daf2024-02-04 15:27:39 -08001142 /* Not all body data has been written yet */
1143 if (offset < body_len) {
1144 this_chunk = min(body_len - offset,
1145 MAX_PRINT_CHUNK - this_header);
1146 if (WARN_ON_ONCE(this_chunk <= 0))
1147 return;
1148 memcpy(buf + this_header, body + offset, this_chunk);
1149 this_offset += this_chunk;
1150 }
1151 /* Body is fully written and there is pending userdata to write,
1152 * append userdata in this chunk
1153 */
1154 if (offset + this_offset >= body_len &&
1155 offset + this_offset < userdata_len + body_len) {
1156 int sent_userdata = (offset + this_offset) - body_len;
1157 int preceding_bytes = this_chunk + this_header;
Tejun Heoe2f15f92015-06-25 15:01:41 -07001158
Matthew Wood1ec9daf2024-02-04 15:27:39 -08001159 if (WARN_ON_ONCE(sent_userdata < 0))
1160 return;
Tejun Heoe2f15f92015-06-25 15:01:41 -07001161
Matthew Wood1ec9daf2024-02-04 15:27:39 -08001162 this_chunk = min(userdata_len - sent_userdata,
1163 MAX_PRINT_CHUNK - preceding_bytes);
Breno Leitaod94785b2024-10-08 02:43:24 -07001164 if (WARN_ON_ONCE(this_chunk < 0))
1165 /* this_chunk could be zero if all the previous
1166 * message used all the buffer. This is not a
1167 * problem, userdata will be sent in the next
1168 * iteration
1169 */
Matthew Wood1ec9daf2024-02-04 15:27:39 -08001170 return;
Breno Leitaod94785b2024-10-08 02:43:24 -07001171
Matthew Wood1ec9daf2024-02-04 15:27:39 -08001172 memcpy(buf + this_header + this_offset,
1173 userdata + sent_userdata,
1174 this_chunk);
1175 this_offset += this_chunk;
1176 }
Tejun Heoe2f15f92015-06-25 15:01:41 -07001177
Matthew Wood1ec9daf2024-02-04 15:27:39 -08001178 netpoll_send_udp(&nt->np, buf, this_header + this_offset);
1179 offset += this_offset;
Tejun Heoe2f15f92015-06-25 15:01:41 -07001180 }
1181}
1182
1183static void write_ext_msg(struct console *con, const char *msg,
1184 unsigned int len)
1185{
1186 struct netconsole_target *nt;
1187 unsigned long flags;
1188
1189 if ((oops_only && !oops_in_progress) || list_empty(&target_list))
1190 return;
1191
1192 spin_lock_irqsave(&target_list_lock, flags);
1193 list_for_each_entry(nt, &target_list, list)
1194 if (nt->extended && nt->enabled && netif_running(nt->np.dev))
1195 send_ext_msg_udp(nt, msg, len);
1196 spin_unlock_irqrestore(&target_list_lock, flags);
1197}
1198
Linus Torvalds1da177e2005-04-16 15:20:36 -07001199static void write_msg(struct console *con, const char *msg, unsigned int len)
1200{
1201 int frag, left;
1202 unsigned long flags;
Satyam Sharmab5427c22007-08-10 15:33:40 -07001203 struct netconsole_target *nt;
1204 const char *tmp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001205
Amerigo Wangc1a608512012-11-08 03:42:38 +00001206 if (oops_only && !oops_in_progress)
1207 return;
Satyam Sharmab5427c22007-08-10 15:33:40 -07001208 /* Avoid taking lock and disabling interrupts unnecessarily */
1209 if (list_empty(&target_list))
1210 return;
1211
1212 spin_lock_irqsave(&target_list_lock, flags);
1213 list_for_each_entry(nt, &target_list, list) {
Tejun Heoe2f15f92015-06-25 15:01:41 -07001214 if (!nt->extended && nt->enabled && netif_running(nt->np.dev)) {
Satyam Sharmab5427c22007-08-10 15:33:40 -07001215 /*
1216 * We nest this inside the for-each-target loop above
1217 * so that we're able to get as much logging out to
1218 * at least one target if we die inside here, instead
1219 * of unnecessarily keeping all targets in lock-step.
1220 */
1221 tmp = msg;
1222 for (left = len; left;) {
1223 frag = min(left, MAX_PRINT_CHUNK);
1224 netpoll_send_udp(&nt->np, tmp, frag);
1225 tmp += frag;
1226 left -= frag;
1227 }
Satyam Sharma0cc120be2007-08-10 15:30:31 -07001228 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001229 }
Satyam Sharmab5427c22007-08-10 15:33:40 -07001230 spin_unlock_irqrestore(&target_list_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001231}
1232
Breno Leitao28856ab2023-10-12 04:13:58 -07001233/* Allocate new target (from boot/module param) and setup netpoll for it */
Breno Leitao131eeb42023-10-12 04:13:59 -07001234static struct netconsole_target *alloc_param_target(char *target_config,
1235 int cmdline_count)
Breno Leitao28856ab2023-10-12 04:13:58 -07001236{
1237 struct netconsole_target *nt;
1238 int err;
1239
1240 nt = alloc_and_init();
1241 if (!nt) {
1242 err = -ENOMEM;
1243 goto fail;
1244 }
1245
1246 if (*target_config == '+') {
1247 nt->extended = true;
1248 target_config++;
1249 }
1250
1251 if (*target_config == 'r') {
1252 if (!nt->extended) {
1253 pr_err("Netconsole configuration error. Release feature requires extended log message");
1254 err = -EINVAL;
1255 goto fail;
1256 }
1257 nt->release = true;
1258 target_config++;
1259 }
1260
1261 /* Parse parameters and setup netpoll */
1262 err = netpoll_parse_options(&nt->np, target_config);
1263 if (err)
1264 goto fail;
1265
1266 err = netpoll_setup(&nt->np);
Breno Leitao908ee292024-08-22 04:10:48 -07001267 if (err) {
1268 pr_err("Not enabling netconsole for %s%d. Netpoll setup failed\n",
1269 NETCONSOLE_PARAM_TARGET_PREFIX, cmdline_count);
1270 if (!IS_ENABLED(CONFIG_NETCONSOLE_DYNAMIC))
1271 /* only fail if dynamic reconfiguration is set,
1272 * otherwise, keep the target in the list, but disabled.
1273 */
1274 goto fail;
1275 } else {
1276 nt->enabled = true;
1277 }
Breno Leitao131eeb42023-10-12 04:13:59 -07001278 populate_configfs_item(nt, cmdline_count);
Breno Leitao28856ab2023-10-12 04:13:58 -07001279
1280 return nt;
1281
1282fail:
1283 kfree(nt);
1284 return ERR_PTR(err);
1285}
1286
1287/* Cleanup netpoll for given target (from boot/module param) and free it */
1288static void free_param_target(struct netconsole_target *nt)
1289{
1290 netpoll_cleanup(&nt->np);
1291 kfree(nt);
1292}
1293
Tejun Heoe2f15f92015-06-25 15:01:41 -07001294static struct console netconsole_ext = {
1295 .name = "netcon_ext",
John Ogness2c6b4b72022-11-16 17:27:43 +01061296 .flags = CON_ENABLED | CON_EXTENDED,
Tejun Heoe2f15f92015-06-25 15:01:41 -07001297 .write = write_ext_msg,
1298};
1299
Linus Torvalds1da177e2005-04-16 15:20:36 -07001300static struct console netconsole = {
Satyam Sharmad39badf2007-08-10 15:27:24 -07001301 .name = "netcon",
Michael Ellerman0517dee2008-04-15 00:49:04 -07001302 .flags = CON_ENABLED,
Satyam Sharmad39badf2007-08-10 15:27:24 -07001303 .write = write_msg,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001304};
1305
Satyam Sharmad39badf2007-08-10 15:27:24 -07001306static int __init init_netconsole(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001307{
Satyam Sharma0bcc1812007-08-10 15:35:05 -07001308 int err;
Satyam Sharmab5427c22007-08-10 15:33:40 -07001309 struct netconsole_target *nt, *tmp;
Breno Leitao131eeb42023-10-12 04:13:59 -07001310 unsigned int count = 0;
John Ogness2c6b4b72022-11-16 17:27:43 +01061311 bool extended = false;
Satyam Sharmab5427c22007-08-10 15:33:40 -07001312 unsigned long flags;
1313 char *target_config;
1314 char *input = config;
Stephen Hemmingerb41848b2006-10-26 15:46:52 -07001315
Satyam Sharma0bcc1812007-08-10 15:35:05 -07001316 if (strnlen(input, MAX_PARAM_LENGTH)) {
1317 while ((target_config = strsep(&input, ";"))) {
Breno Leitao131eeb42023-10-12 04:13:59 -07001318 nt = alloc_param_target(target_config, count);
Satyam Sharma0bcc1812007-08-10 15:35:05 -07001319 if (IS_ERR(nt)) {
Breno Leitaoc3390672024-05-28 01:42:24 -07001320 if (IS_ENABLED(CONFIG_NETCONSOLE_DYNAMIC))
1321 continue;
Satyam Sharma0bcc1812007-08-10 15:35:05 -07001322 err = PTR_ERR(nt);
1323 goto fail;
1324 }
Michael Ellerman0517dee2008-04-15 00:49:04 -07001325 /* Dump existing printks when we register */
John Ogness2c6b4b72022-11-16 17:27:43 +01061326 if (nt->extended) {
1327 extended = true;
1328 netconsole_ext.flags |= CON_PRINTBUFFER;
1329 } else {
Tejun Heoe2f15f92015-06-25 15:01:41 -07001330 netconsole.flags |= CON_PRINTBUFFER;
John Ogness2c6b4b72022-11-16 17:27:43 +01061331 }
Michael Ellerman0517dee2008-04-15 00:49:04 -07001332
Satyam Sharma0bcc1812007-08-10 15:35:05 -07001333 spin_lock_irqsave(&target_list_lock, flags);
1334 list_add(&nt->list, &target_list);
1335 spin_unlock_irqrestore(&target_list_lock, flags);
Breno Leitao131eeb42023-10-12 04:13:59 -07001336 count++;
Satyam Sharmab5427c22007-08-10 15:33:40 -07001337 }
Satyam Sharmab5427c22007-08-10 15:33:40 -07001338 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001339
Satyam Sharma17951f32007-08-10 15:33:01 -07001340 err = register_netdevice_notifier(&netconsole_netdev_notifier);
1341 if (err)
Satyam Sharmab5427c22007-08-10 15:33:40 -07001342 goto fail;
Satyam Sharma17951f32007-08-10 15:33:01 -07001343
Satyam Sharma0bcc1812007-08-10 15:35:05 -07001344 err = dynamic_netconsole_init();
1345 if (err)
1346 goto undonotifier;
1347
John Ogness2c6b4b72022-11-16 17:27:43 +01061348 if (extended)
Tejun Heoe2f15f92015-06-25 15:01:41 -07001349 register_console(&netconsole_ext);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001350 register_console(&netconsole);
Joe Perches22ded572013-10-28 12:53:21 -07001351 pr_info("network logging started\n");
Satyam Sharmad39badf2007-08-10 15:27:24 -07001352
Satyam Sharmad39badf2007-08-10 15:27:24 -07001353 return err;
Satyam Sharmab5427c22007-08-10 15:33:40 -07001354
Satyam Sharma0bcc1812007-08-10 15:35:05 -07001355undonotifier:
1356 unregister_netdevice_notifier(&netconsole_netdev_notifier);
1357
Satyam Sharmab5427c22007-08-10 15:33:40 -07001358fail:
Joe Perches22ded572013-10-28 12:53:21 -07001359 pr_err("cleaning up\n");
Satyam Sharmab5427c22007-08-10 15:33:40 -07001360
1361 /*
Satyam Sharma0bcc1812007-08-10 15:35:05 -07001362 * Remove all targets and destroy them (only targets created
1363 * from the boot/module option exist here). Skipping the list
Satyam Sharmab5427c22007-08-10 15:33:40 -07001364 * lock is safe here, and netpoll_cleanup() will sleep.
1365 */
1366 list_for_each_entry_safe(nt, tmp, &target_list, list) {
1367 list_del(&nt->list);
Satyam Sharma0bcc1812007-08-10 15:35:05 -07001368 free_param_target(nt);
Satyam Sharmab5427c22007-08-10 15:33:40 -07001369 }
1370
1371 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001372}
1373
Satyam Sharmad39badf2007-08-10 15:27:24 -07001374static void __exit cleanup_netconsole(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001375{
Satyam Sharmab5427c22007-08-10 15:33:40 -07001376 struct netconsole_target *nt, *tmp;
Satyam Sharmadf180e32007-08-10 15:32:14 -07001377
John Ogness2c6b4b72022-11-16 17:27:43 +01061378 if (console_is_registered(&netconsole_ext))
1379 unregister_console(&netconsole_ext);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001380 unregister_console(&netconsole);
Satyam Sharma0bcc1812007-08-10 15:35:05 -07001381 dynamic_netconsole_exit();
Satyam Sharma17951f32007-08-10 15:33:01 -07001382 unregister_netdevice_notifier(&netconsole_netdev_notifier);
Satyam Sharmab5427c22007-08-10 15:33:40 -07001383
1384 /*
Satyam Sharma0bcc1812007-08-10 15:35:05 -07001385 * Targets created via configfs pin references on our module
1386 * and would first be rmdir(2)'ed from userspace. We reach
1387 * here only when they are already destroyed, and only those
1388 * created from the boot/module option are left, so remove and
1389 * destroy them. Skipping the list lock is safe here, and
1390 * netpoll_cleanup() will sleep.
Satyam Sharmab5427c22007-08-10 15:33:40 -07001391 */
1392 list_for_each_entry_safe(nt, tmp, &target_list, list) {
1393 list_del(&nt->list);
Satyam Sharma0bcc1812007-08-10 15:35:05 -07001394 free_param_target(nt);
Satyam Sharmab5427c22007-08-10 15:33:40 -07001395 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001396}
1397
Lin Ming97c7de02011-09-20 15:45:07 -04001398/*
1399 * Use late_initcall to ensure netconsole is
1400 * initialized after network device driver if built-in.
1401 *
1402 * late_initcall() and module_init() are identical if built as module.
1403 */
1404late_initcall(init_netconsole);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001405module_exit(cleanup_netconsole);