drivers/net: Convert unbounded kzalloc calls to kcalloc
[linux-2.6.git] / drivers / net / netconsole.c
1 /*
2  *  linux/drivers/net/netconsole.c
3  *
4  *  Copyright (C) 2001  Ingo Molnar <mingo@redhat.com>
5  *
6  *  This file contains the implementation of an IRQ-safe, crash-safe
7  *  kernel console implementation that outputs kernel messages to the
8  *  network.
9  *
10  * Modification history:
11  *
12  * 2001-09-17    started by Ingo Molnar.
13  * 2003-08-11    2.6 port by Matt Mackall
14  *               simplified options
15  *               generic card hooks
16  *               works non-modular
17  * 2003-09-07    rewritten with netpoll api
18  */
19
20 /****************************************************************
21  *      This program is free software; you can redistribute it and/or modify
22  *      it under the terms of the GNU General Public License as published by
23  *      the Free Software Foundation; either version 2, or (at your option)
24  *      any later version.
25  *
26  *      This program is distributed in the hope that it will be useful,
27  *      but WITHOUT ANY WARRANTY; without even the implied warranty of
28  *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
29  *      GNU General Public License for more details.
30  *
31  *      You should have received a copy of the GNU General Public License
32  *      along with this program; if not, write to the Free Software
33  *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
34  *
35  ****************************************************************/
36
37 #include <linux/mm.h>
38 #include <linux/init.h>
39 #include <linux/module.h>
40 #include <linux/slab.h>
41 #include <linux/console.h>
42 #include <linux/moduleparam.h>
43 #include <linux/string.h>
44 #include <linux/netpoll.h>
45 #include <linux/inet.h>
46 #include <linux/configfs.h>
47
48 MODULE_AUTHOR("Maintainer: Matt Mackall <mpm@selenic.com>");
49 MODULE_DESCRIPTION("Console driver for network interfaces");
50 MODULE_LICENSE("GPL");
51
52 #define MAX_PARAM_LENGTH        256
53 #define MAX_PRINT_CHUNK         1000
54
55 static char config[MAX_PARAM_LENGTH];
56 module_param_string(netconsole, config, MAX_PARAM_LENGTH, 0);
57 MODULE_PARM_DESC(netconsole, " netconsole=[src-port]@[src-ip]/[dev],[tgt-port]@<tgt-ip>/[tgt-macaddr]");
58
59 #ifndef MODULE
60 static int __init option_setup(char *opt)
61 {
62         strlcpy(config, opt, MAX_PARAM_LENGTH);
63         return 1;
64 }
65 __setup("netconsole=", option_setup);
66 #endif  /* MODULE */
67
68 /* Linked list of all configured targets */
69 static LIST_HEAD(target_list);
70
71 /* This needs to be a spinlock because write_msg() cannot sleep */
72 static DEFINE_SPINLOCK(target_list_lock);
73
74 /**
75  * struct netconsole_target - Represents a configured netconsole target.
76  * @list:       Links this target into the target_list.
77  * @item:       Links us into the configfs subsystem hierarchy.
78  * @enabled:    On / off knob to enable / disable target.
79  *              Visible from userspace (read-write).
80  *              We maintain a strict 1:1 correspondence between this and
81  *              whether the corresponding netpoll is active or inactive.
82  *              Also, other parameters of a target may be modified at
83  *              runtime only when it is disabled (enabled == 0).
84  * @np:         The netpoll structure for this target.
85  *              Contains the other userspace visible parameters:
86  *              dev_name        (read-write)
87  *              local_port      (read-write)
88  *              remote_port     (read-write)
89  *              local_ip        (read-write)
90  *              remote_ip       (read-write)
91  *              local_mac       (read-only)
92  *              remote_mac      (read-write)
93  */
94 struct netconsole_target {
95         struct list_head        list;
96 #ifdef  CONFIG_NETCONSOLE_DYNAMIC
97         struct config_item      item;
98 #endif
99         int                     enabled;
100         struct netpoll          np;
101 };
102
103 #ifdef  CONFIG_NETCONSOLE_DYNAMIC
104
105 static struct configfs_subsystem netconsole_subsys;
106
107 static int __init dynamic_netconsole_init(void)
108 {
109         config_group_init(&netconsole_subsys.su_group);
110         mutex_init(&netconsole_subsys.su_mutex);
111         return configfs_register_subsystem(&netconsole_subsys);
112 }
113
114 static void __exit dynamic_netconsole_exit(void)
115 {
116         configfs_unregister_subsystem(&netconsole_subsys);
117 }
118
119 /*
120  * Targets that were created by parsing the boot/module option string
121  * do not exist in the configfs hierarchy (and have NULL names) and will
122  * never go away, so make these a no-op for them.
123  */
124 static void netconsole_target_get(struct netconsole_target *nt)
125 {
126         if (config_item_name(&nt->item))
127                 config_item_get(&nt->item);
128 }
129
130 static void netconsole_target_put(struct netconsole_target *nt)
131 {
132         if (config_item_name(&nt->item))
133                 config_item_put(&nt->item);
134 }
135
136 #else   /* !CONFIG_NETCONSOLE_DYNAMIC */
137
138 static int __init dynamic_netconsole_init(void)
139 {
140         return 0;
141 }
142
143 static void __exit dynamic_netconsole_exit(void)
144 {
145 }
146
147 /*
148  * No danger of targets going away from under us when dynamic
149  * reconfigurability is off.
150  */
151 static void netconsole_target_get(struct netconsole_target *nt)
152 {
153 }
154
155 static void netconsole_target_put(struct netconsole_target *nt)
156 {
157 }
158
159 #endif  /* CONFIG_NETCONSOLE_DYNAMIC */
160
161 /* Allocate new target (from boot/module param) and setup netpoll for it */
162 static struct netconsole_target *alloc_param_target(char *target_config)
163 {
164         int err = -ENOMEM;
165         struct netconsole_target *nt;
166
167         /*
168          * Allocate and initialize with defaults.
169          * Note that these targets get their config_item fields zeroed-out.
170          */
171         nt = kzalloc(sizeof(*nt), GFP_KERNEL);
172         if (!nt) {
173                 printk(KERN_ERR "netconsole: failed to allocate memory\n");
174                 goto fail;
175         }
176
177         nt->np.name = "netconsole";
178         strlcpy(nt->np.dev_name, "eth0", IFNAMSIZ);
179         nt->np.local_port = 6665;
180         nt->np.remote_port = 6666;
181         memset(nt->np.remote_mac, 0xff, ETH_ALEN);
182
183         /* Parse parameters and setup netpoll */
184         err = netpoll_parse_options(&nt->np, target_config);
185         if (err)
186                 goto fail;
187
188         err = netpoll_setup(&nt->np);
189         if (err)
190                 goto fail;
191
192         nt->enabled = 1;
193
194         return nt;
195
196 fail:
197         kfree(nt);
198         return ERR_PTR(err);
199 }
200
201 /* Cleanup netpoll for given target (from boot/module param) and free it */
202 static void free_param_target(struct netconsole_target *nt)
203 {
204         netpoll_cleanup(&nt->np);
205         kfree(nt);
206 }
207
208 #ifdef  CONFIG_NETCONSOLE_DYNAMIC
209
210 /*
211  * Our subsystem hierarchy is:
212  *
213  * /sys/kernel/config/netconsole/
214  *                              |
215  *                              <target>/
216  *                              |       enabled
217  *                              |       dev_name
218  *                              |       local_port
219  *                              |       remote_port
220  *                              |       local_ip
221  *                              |       remote_ip
222  *                              |       local_mac
223  *                              |       remote_mac
224  *                              |
225  *                              <target>/...
226  */
227
228 struct netconsole_target_attr {
229         struct configfs_attribute       attr;
230         ssize_t                         (*show)(struct netconsole_target *nt,
231                                                 char *buf);
232         ssize_t                         (*store)(struct netconsole_target *nt,
233                                                  const char *buf,
234                                                  size_t count);
235 };
236
237 static struct netconsole_target *to_target(struct config_item *item)
238 {
239         return item ?
240                 container_of(item, struct netconsole_target, item) :
241                 NULL;
242 }
243
244 /*
245  * Wrapper over simple_strtol (base 10) with sanity and range checking.
246  * We return (signed) long only because we may want to return errors.
247  * Do not use this to convert numbers that are allowed to be negative.
248  */
249 static long strtol10_check_range(const char *cp, long min, long max)
250 {
251         long ret;
252         char *p = (char *) cp;
253
254         WARN_ON(min < 0);
255         WARN_ON(max < min);
256
257         ret = simple_strtol(p, &p, 10);
258
259         if (*p && (*p != '\n')) {
260                 printk(KERN_ERR "netconsole: invalid input\n");
261                 return -EINVAL;
262         }
263         if ((ret < min) || (ret > max)) {
264                 printk(KERN_ERR "netconsole: input %ld must be between "
265                                 "%ld and %ld\n", ret, min, max);
266                 return -EINVAL;
267         }
268
269         return ret;
270 }
271
272 /*
273  * Attribute operations for netconsole_target.
274  */
275
276 static ssize_t show_enabled(struct netconsole_target *nt, char *buf)
277 {
278         return snprintf(buf, PAGE_SIZE, "%d\n", nt->enabled);
279 }
280
281 static ssize_t show_dev_name(struct netconsole_target *nt, char *buf)
282 {
283         return snprintf(buf, PAGE_SIZE, "%s\n", nt->np.dev_name);
284 }
285
286 static ssize_t show_local_port(struct netconsole_target *nt, char *buf)
287 {
288         return snprintf(buf, PAGE_SIZE, "%d\n", nt->np.local_port);
289 }
290
291 static ssize_t show_remote_port(struct netconsole_target *nt, char *buf)
292 {
293         return snprintf(buf, PAGE_SIZE, "%d\n", nt->np.remote_port);
294 }
295
296 static ssize_t show_local_ip(struct netconsole_target *nt, char *buf)
297 {
298         return snprintf(buf, PAGE_SIZE, "%pI4\n", &nt->np.local_ip);
299 }
300
301 static ssize_t show_remote_ip(struct netconsole_target *nt, char *buf)
302 {
303         return snprintf(buf, PAGE_SIZE, "%pI4\n", &nt->np.remote_ip);
304 }
305
306 static ssize_t show_local_mac(struct netconsole_target *nt, char *buf)
307 {
308         struct net_device *dev = nt->np.dev;
309         static const u8 bcast[ETH_ALEN] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
310
311         return snprintf(buf, PAGE_SIZE, "%pM\n", dev ? dev->dev_addr : bcast);
312 }
313
314 static ssize_t show_remote_mac(struct netconsole_target *nt, char *buf)
315 {
316         return snprintf(buf, PAGE_SIZE, "%pM\n", nt->np.remote_mac);
317 }
318
319 /*
320  * This one is special -- targets created through the configfs interface
321  * are not enabled (and the corresponding netpoll activated) by default.
322  * The user is expected to set the desired parameters first (which
323  * would enable him to dynamically add new netpoll targets for new
324  * network interfaces as and when they come up).
325  */
326 static ssize_t store_enabled(struct netconsole_target *nt,
327                              const char *buf,
328                              size_t count)
329 {
330         int err;
331         long enabled;
332
333         enabled = strtol10_check_range(buf, 0, 1);
334         if (enabled < 0)
335                 return enabled;
336
337         if (enabled) {  /* 1 */
338
339                 /*
340                  * Skip netpoll_parse_options() -- all the attributes are
341                  * already configured via configfs. Just print them out.
342                  */
343                 netpoll_print_options(&nt->np);
344
345                 err = netpoll_setup(&nt->np);
346                 if (err)
347                         return err;
348
349                 printk(KERN_INFO "netconsole: network logging started\n");
350
351         } else {        /* 0 */
352                 netpoll_cleanup(&nt->np);
353         }
354
355         nt->enabled = enabled;
356
357         return strnlen(buf, count);
358 }
359
360 static ssize_t store_dev_name(struct netconsole_target *nt,
361                               const char *buf,
362                               size_t count)
363 {
364         size_t len;
365
366         if (nt->enabled) {
367                 printk(KERN_ERR "netconsole: target (%s) is enabled, "
368                                 "disable to update parameters\n",
369                                 config_item_name(&nt->item));
370                 return -EINVAL;
371         }
372
373         strlcpy(nt->np.dev_name, buf, IFNAMSIZ);
374
375         /* Get rid of possible trailing newline from echo(1) */
376         len = strnlen(nt->np.dev_name, IFNAMSIZ);
377         if (nt->np.dev_name[len - 1] == '\n')
378                 nt->np.dev_name[len - 1] = '\0';
379
380         return strnlen(buf, count);
381 }
382
383 static ssize_t store_local_port(struct netconsole_target *nt,
384                                 const char *buf,
385                                 size_t count)
386 {
387         long local_port;
388 #define __U16_MAX       ((__u16) ~0U)
389
390         if (nt->enabled) {
391                 printk(KERN_ERR "netconsole: target (%s) is enabled, "
392                                 "disable to update parameters\n",
393                                 config_item_name(&nt->item));
394                 return -EINVAL;
395         }
396
397         local_port = strtol10_check_range(buf, 0, __U16_MAX);
398         if (local_port < 0)
399                 return local_port;
400
401         nt->np.local_port = local_port;
402
403         return strnlen(buf, count);
404 }
405
406 static ssize_t store_remote_port(struct netconsole_target *nt,
407                                  const char *buf,
408                                  size_t count)
409 {
410         long remote_port;
411 #define __U16_MAX       ((__u16) ~0U)
412
413         if (nt->enabled) {
414                 printk(KERN_ERR "netconsole: target (%s) is enabled, "
415                                 "disable to update parameters\n",
416                                 config_item_name(&nt->item));
417                 return -EINVAL;
418         }
419
420         remote_port = strtol10_check_range(buf, 0, __U16_MAX);
421         if (remote_port < 0)
422                 return remote_port;
423
424         nt->np.remote_port = remote_port;
425
426         return strnlen(buf, count);
427 }
428
429 static ssize_t store_local_ip(struct netconsole_target *nt,
430                               const char *buf,
431                               size_t count)
432 {
433         if (nt->enabled) {
434                 printk(KERN_ERR "netconsole: target (%s) is enabled, "
435                                 "disable to update parameters\n",
436                                 config_item_name(&nt->item));
437                 return -EINVAL;
438         }
439
440         nt->np.local_ip = in_aton(buf);
441
442         return strnlen(buf, count);
443 }
444
445 static ssize_t store_remote_ip(struct netconsole_target *nt,
446                                const char *buf,
447                                size_t count)
448 {
449         if (nt->enabled) {
450                 printk(KERN_ERR "netconsole: target (%s) is enabled, "
451                                 "disable to update parameters\n",
452                                 config_item_name(&nt->item));
453                 return -EINVAL;
454         }
455
456         nt->np.remote_ip = in_aton(buf);
457
458         return strnlen(buf, count);
459 }
460
461 static ssize_t store_remote_mac(struct netconsole_target *nt,
462                                 const char *buf,
463                                 size_t count)
464 {
465         u8 remote_mac[ETH_ALEN];
466         char *p = (char *) buf;
467         int i;
468
469         if (nt->enabled) {
470                 printk(KERN_ERR "netconsole: target (%s) is enabled, "
471                                 "disable to update parameters\n",
472                                 config_item_name(&nt->item));
473                 return -EINVAL;
474         }
475
476         for (i = 0; i < ETH_ALEN - 1; i++) {
477                 remote_mac[i] = simple_strtoul(p, &p, 16);
478                 if (*p != ':')
479                         goto invalid;
480                 p++;
481         }
482         remote_mac[ETH_ALEN - 1] = simple_strtoul(p, &p, 16);
483         if (*p && (*p != '\n'))
484                 goto invalid;
485
486         memcpy(nt->np.remote_mac, remote_mac, ETH_ALEN);
487
488         return strnlen(buf, count);
489
490 invalid:
491         printk(KERN_ERR "netconsole: invalid input\n");
492         return -EINVAL;
493 }
494
495 /*
496  * Attribute definitions for netconsole_target.
497  */
498
499 #define NETCONSOLE_TARGET_ATTR_RO(_name)                                \
500 static struct netconsole_target_attr netconsole_target_##_name =        \
501         __CONFIGFS_ATTR(_name, S_IRUGO, show_##_name, NULL)
502
503 #define NETCONSOLE_TARGET_ATTR_RW(_name)                                \
504 static struct netconsole_target_attr netconsole_target_##_name =        \
505         __CONFIGFS_ATTR(_name, S_IRUGO | S_IWUSR, show_##_name, store_##_name)
506
507 NETCONSOLE_TARGET_ATTR_RW(enabled);
508 NETCONSOLE_TARGET_ATTR_RW(dev_name);
509 NETCONSOLE_TARGET_ATTR_RW(local_port);
510 NETCONSOLE_TARGET_ATTR_RW(remote_port);
511 NETCONSOLE_TARGET_ATTR_RW(local_ip);
512 NETCONSOLE_TARGET_ATTR_RW(remote_ip);
513 NETCONSOLE_TARGET_ATTR_RO(local_mac);
514 NETCONSOLE_TARGET_ATTR_RW(remote_mac);
515
516 static struct configfs_attribute *netconsole_target_attrs[] = {
517         &netconsole_target_enabled.attr,
518         &netconsole_target_dev_name.attr,
519         &netconsole_target_local_port.attr,
520         &netconsole_target_remote_port.attr,
521         &netconsole_target_local_ip.attr,
522         &netconsole_target_remote_ip.attr,
523         &netconsole_target_local_mac.attr,
524         &netconsole_target_remote_mac.attr,
525         NULL,
526 };
527
528 /*
529  * Item operations and type for netconsole_target.
530  */
531
532 static void netconsole_target_release(struct config_item *item)
533 {
534         kfree(to_target(item));
535 }
536
537 static ssize_t netconsole_target_attr_show(struct config_item *item,
538                                            struct configfs_attribute *attr,
539                                            char *buf)
540 {
541         ssize_t ret = -EINVAL;
542         struct netconsole_target *nt = to_target(item);
543         struct netconsole_target_attr *na =
544                 container_of(attr, struct netconsole_target_attr, attr);
545
546         if (na->show)
547                 ret = na->show(nt, buf);
548
549         return ret;
550 }
551
552 static ssize_t netconsole_target_attr_store(struct config_item *item,
553                                             struct configfs_attribute *attr,
554                                             const char *buf,
555                                             size_t count)
556 {
557         ssize_t ret = -EINVAL;
558         struct netconsole_target *nt = to_target(item);
559         struct netconsole_target_attr *na =
560                 container_of(attr, struct netconsole_target_attr, attr);
561
562         if (na->store)
563                 ret = na->store(nt, buf, count);
564
565         return ret;
566 }
567
568 static struct configfs_item_operations netconsole_target_item_ops = {
569         .release                = netconsole_target_release,
570         .show_attribute         = netconsole_target_attr_show,
571         .store_attribute        = netconsole_target_attr_store,
572 };
573
574 static struct config_item_type netconsole_target_type = {
575         .ct_attrs               = netconsole_target_attrs,
576         .ct_item_ops            = &netconsole_target_item_ops,
577         .ct_owner               = THIS_MODULE,
578 };
579
580 /*
581  * Group operations and type for netconsole_subsys.
582  */
583
584 static struct config_item *make_netconsole_target(struct config_group *group,
585                                                   const char *name)
586 {
587         unsigned long flags;
588         struct netconsole_target *nt;
589
590         /*
591          * Allocate and initialize with defaults.
592          * Target is disabled at creation (enabled == 0).
593          */
594         nt = kzalloc(sizeof(*nt), GFP_KERNEL);
595         if (!nt) {
596                 printk(KERN_ERR "netconsole: failed to allocate memory\n");
597                 return ERR_PTR(-ENOMEM);
598         }
599
600         nt->np.name = "netconsole";
601         strlcpy(nt->np.dev_name, "eth0", IFNAMSIZ);
602         nt->np.local_port = 6665;
603         nt->np.remote_port = 6666;
604         memset(nt->np.remote_mac, 0xff, ETH_ALEN);
605
606         /* Initialize the config_item member */
607         config_item_init_type_name(&nt->item, name, &netconsole_target_type);
608
609         /* Adding, but it is disabled */
610         spin_lock_irqsave(&target_list_lock, flags);
611         list_add(&nt->list, &target_list);
612         spin_unlock_irqrestore(&target_list_lock, flags);
613
614         return &nt->item;
615 }
616
617 static void drop_netconsole_target(struct config_group *group,
618                                    struct config_item *item)
619 {
620         unsigned long flags;
621         struct netconsole_target *nt = to_target(item);
622
623         spin_lock_irqsave(&target_list_lock, flags);
624         list_del(&nt->list);
625         spin_unlock_irqrestore(&target_list_lock, flags);
626
627         /*
628          * The target may have never been enabled, or was manually disabled
629          * before being removed so netpoll may have already been cleaned up.
630          */
631         if (nt->enabled)
632                 netpoll_cleanup(&nt->np);
633
634         config_item_put(&nt->item);
635 }
636
637 static struct configfs_group_operations netconsole_subsys_group_ops = {
638         .make_item      = make_netconsole_target,
639         .drop_item      = drop_netconsole_target,
640 };
641
642 static struct config_item_type netconsole_subsys_type = {
643         .ct_group_ops   = &netconsole_subsys_group_ops,
644         .ct_owner       = THIS_MODULE,
645 };
646
647 /* The netconsole configfs subsystem */
648 static struct configfs_subsystem netconsole_subsys = {
649         .su_group       = {
650                 .cg_item        = {
651                         .ci_namebuf     = "netconsole",
652                         .ci_type        = &netconsole_subsys_type,
653                 },
654         },
655 };
656
657 #endif  /* CONFIG_NETCONSOLE_DYNAMIC */
658
659 /* Handle network interface device notifications */
660 static int netconsole_netdev_event(struct notifier_block *this,
661                                    unsigned long event,
662                                    void *ptr)
663 {
664         unsigned long flags;
665         struct netconsole_target *nt;
666         struct net_device *dev = ptr;
667
668         if (!(event == NETDEV_CHANGENAME || event == NETDEV_UNREGISTER ||
669               event == NETDEV_BONDING_DESLAVE || event == NETDEV_GOING_DOWN))
670                 goto done;
671
672         spin_lock_irqsave(&target_list_lock, flags);
673         list_for_each_entry(nt, &target_list, list) {
674                 netconsole_target_get(nt);
675                 if (nt->np.dev == dev) {
676                         switch (event) {
677                         case NETDEV_CHANGENAME:
678                                 strlcpy(nt->np.dev_name, dev->name, IFNAMSIZ);
679                                 break;
680                         case NETDEV_UNREGISTER:
681                                 netpoll_cleanup(&nt->np);
682                                 /* Fall through */
683                         case NETDEV_GOING_DOWN:
684                         case NETDEV_BONDING_DESLAVE:
685                                 nt->enabled = 0;
686                                 break;
687                         }
688                 }
689                 netconsole_target_put(nt);
690         }
691         spin_unlock_irqrestore(&target_list_lock, flags);
692         if (event == NETDEV_UNREGISTER || event == NETDEV_BONDING_DESLAVE)
693                 printk(KERN_INFO "netconsole: network logging stopped, "
694                         "interface %s %s\n",  dev->name,
695                         event == NETDEV_UNREGISTER ? "unregistered" : "released slaves");
696
697 done:
698         return NOTIFY_DONE;
699 }
700
701 static struct notifier_block netconsole_netdev_notifier = {
702         .notifier_call  = netconsole_netdev_event,
703 };
704
705 static void write_msg(struct console *con, const char *msg, unsigned int len)
706 {
707         int frag, left;
708         unsigned long flags;
709         struct netconsole_target *nt;
710         const char *tmp;
711
712         /* Avoid taking lock and disabling interrupts unnecessarily */
713         if (list_empty(&target_list))
714                 return;
715
716         spin_lock_irqsave(&target_list_lock, flags);
717         list_for_each_entry(nt, &target_list, list) {
718                 netconsole_target_get(nt);
719                 if (nt->enabled && netif_running(nt->np.dev)) {
720                         /*
721                          * We nest this inside the for-each-target loop above
722                          * so that we're able to get as much logging out to
723                          * at least one target if we die inside here, instead
724                          * of unnecessarily keeping all targets in lock-step.
725                          */
726                         tmp = msg;
727                         for (left = len; left;) {
728                                 frag = min(left, MAX_PRINT_CHUNK);
729                                 netpoll_send_udp(&nt->np, tmp, frag);
730                                 tmp += frag;
731                                 left -= frag;
732                         }
733                 }
734                 netconsole_target_put(nt);
735         }
736         spin_unlock_irqrestore(&target_list_lock, flags);
737 }
738
739 static struct console netconsole = {
740         .name   = "netcon",
741         .flags  = CON_ENABLED,
742         .write  = write_msg,
743 };
744
745 static int __init init_netconsole(void)
746 {
747         int err;
748         struct netconsole_target *nt, *tmp;
749         unsigned long flags;
750         char *target_config;
751         char *input = config;
752
753         if (strnlen(input, MAX_PARAM_LENGTH)) {
754                 while ((target_config = strsep(&input, ";"))) {
755                         nt = alloc_param_target(target_config);
756                         if (IS_ERR(nt)) {
757                                 err = PTR_ERR(nt);
758                                 goto fail;
759                         }
760                         /* Dump existing printks when we register */
761                         netconsole.flags |= CON_PRINTBUFFER;
762
763                         spin_lock_irqsave(&target_list_lock, flags);
764                         list_add(&nt->list, &target_list);
765                         spin_unlock_irqrestore(&target_list_lock, flags);
766                 }
767         }
768
769         err = register_netdevice_notifier(&netconsole_netdev_notifier);
770         if (err)
771                 goto fail;
772
773         err = dynamic_netconsole_init();
774         if (err)
775                 goto undonotifier;
776
777         register_console(&netconsole);
778         printk(KERN_INFO "netconsole: network logging started\n");
779
780         return err;
781
782 undonotifier:
783         unregister_netdevice_notifier(&netconsole_netdev_notifier);
784
785 fail:
786         printk(KERN_ERR "netconsole: cleaning up\n");
787
788         /*
789          * Remove all targets and destroy them (only targets created
790          * from the boot/module option exist here). Skipping the list
791          * lock is safe here, and netpoll_cleanup() will sleep.
792          */
793         list_for_each_entry_safe(nt, tmp, &target_list, list) {
794                 list_del(&nt->list);
795                 free_param_target(nt);
796         }
797
798         return err;
799 }
800
801 static void __exit cleanup_netconsole(void)
802 {
803         struct netconsole_target *nt, *tmp;
804
805         unregister_console(&netconsole);
806         dynamic_netconsole_exit();
807         unregister_netdevice_notifier(&netconsole_netdev_notifier);
808
809         /*
810          * Targets created via configfs pin references on our module
811          * and would first be rmdir(2)'ed from userspace. We reach
812          * here only when they are already destroyed, and only those
813          * created from the boot/module option are left, so remove and
814          * destroy them. Skipping the list lock is safe here, and
815          * netpoll_cleanup() will sleep.
816          */
817         list_for_each_entry_safe(nt, tmp, &target_list, list) {
818                 list_del(&nt->list);
819                 free_param_target(nt);
820         }
821 }
822
823 module_init(init_netconsole);
824 module_exit(cleanup_netconsole);