netgraph7: Directly use objcache_* functions instead of a translation macro.
[dragonfly.git] / sys / netgraph7 / netgraph / ng_base.c
1 /*
2  * ng_base.c
3  */
4
5 /*-
6  * Copyright (c) 1996-1999 Whistle Communications, Inc.
7  * All rights reserved.
8  *
9  * Subject to the following obligations and disclaimer of warranty, use and
10  * redistribution of this software, in source or object code forms, with or
11  * without modifications are expressly permitted by Whistle Communications;
12  * provided, however, that:
13  * 1. Any and all reproductions of the source or object code must include the
14  *    copyright notice above and the following disclaimer of warranties; and
15  * 2. No rights are granted, in any manner or form, to use Whistle
16  *    Communications, Inc. trademarks, including the mark "WHISTLE
17  *    COMMUNICATIONS" on advertising, endorsements, or otherwise except as
18  *    such appears in the above copyright notice or in the software.
19  *
20  * THIS SOFTWARE IS BEING PROVIDED BY WHISTLE COMMUNICATIONS "AS IS", AND
21  * TO THE MAXIMUM EXTENT PERMITTED BY LAW, WHISTLE COMMUNICATIONS MAKES NO
22  * REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED, REGARDING THIS SOFTWARE,
23  * INCLUDING WITHOUT LIMITATION, ANY AND ALL IMPLIED WARRANTIES OF
24  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT.
25  * WHISTLE COMMUNICATIONS DOES NOT WARRANT, GUARANTEE, OR MAKE ANY
26  * REPRESENTATIONS REGARDING THE USE OF, OR THE RESULTS OF THE USE OF THIS
27  * SOFTWARE IN TERMS OF ITS CORRECTNESS, ACCURACY, RELIABILITY OR OTHERWISE.
28  * IN NO EVENT SHALL WHISTLE COMMUNICATIONS BE LIABLE FOR ANY DAMAGES
29  * RESULTING FROM OR ARISING OUT OF ANY USE OF THIS SOFTWARE, INCLUDING
30  * WITHOUT LIMITATION, ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
31  * PUNITIVE, OR CONSEQUENTIAL DAMAGES, PROCUREMENT OF SUBSTITUTE GOODS OR
32  * SERVICES, LOSS OF USE, DATA OR PROFITS, HOWEVER CAUSED AND UNDER ANY
33  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
34  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
35  * THIS SOFTWARE, EVEN IF WHISTLE COMMUNICATIONS IS ADVISED OF THE POSSIBILITY
36  * OF SUCH DAMAGE.
37  *
38  * Authors: Julian Elischer <julian@freebsd.org>
39  *          Archie Cobbs <archie@freebsd.org>
40  *
41  * $FreeBSD: src/sys/netgraph/ng_base.c,v 1.159 2008/04/19 05:30:49 mav Exp $
42  * $Whistle: ng_base.c,v 1.39 1999/01/28 23:54:53 julian Exp $
43  */
44
45 /*
46  * This file implements the base netgraph code.
47  */
48
49 #include <sys/param.h>
50 #include <sys/systm.h>
51 #include <sys/ctype.h>
52 #include <sys/errno.h>
53 /*#include <sys/kdb.h>*/
54 #include <sys/kernel.h>
55 #include <sys/limits.h>
56 #include <sys/malloc.h>
57 #include <sys/mbuf.h>
58 #include <sys/msgport2.h>
59 #include <sys/mutex2.h>
60 #include <sys/queue.h>
61 #include <sys/sysctl.h>
62 #include <sys/syslog.h>
63 #include <sys/refcount.h>
64 #include <sys/proc.h>
65 #include <sys/objcache.h>
66 #include <machine/cpu.h>
67
68 #include <netgraph7/netgraph.h>
69 #include <netgraph7/netgraph2.h>
70 #include <netgraph7/ng_parse.h>
71
72 MODULE_VERSION(netgraph, NG_ABI_VERSION);
73
74 /* Mutex to protect topology events. */
75 static struct mtx       ng_topo_mtx;
76
77 #ifdef  NETGRAPH_DEBUG
78 static struct mtx       ng_nodelist_mtx; /* protects global node/hook lists */
79 static struct mtx       ngq_mtx;        /* protects the queue item list */
80
81 static SLIST_HEAD(, ng_node) ng_allnodes;
82 static LIST_HEAD(, ng_node) ng_freenodes; /* in debug, we never free() them */
83 static SLIST_HEAD(, ng_hook) ng_allhooks;
84 static LIST_HEAD(, ng_hook) ng_freehooks; /* in debug, we never free() them */
85
86 static void ng_dumpitems(void);
87 static void ng_dumpnodes(void);
88 static void ng_dumphooks(void);
89
90 #endif  /* NETGRAPH_DEBUG */
91 /*
92  * DEAD versions of the structures.
93  * In order to avoid races, it is sometimes neccesary to point
94  * at SOMETHING even though theoretically, the current entity is
95  * INVALID. Use these to avoid these races.
96  */
97 struct ng_type ng_deadtype = {
98         NG_ABI_VERSION,
99         "dead",
100         NULL,   /* modevent */
101         NULL,   /* constructor */
102         NULL,   /* rcvmsg */
103         NULL,   /* shutdown */
104         NULL,   /* newhook */
105         NULL,   /* findhook */
106         NULL,   /* connect */
107         NULL,   /* rcvdata */
108         NULL,   /* disconnect */
109         NULL,   /* cmdlist */
110 };
111
112 struct ng_node ng_deadnode = {
113         "dead",
114         &ng_deadtype,   
115         NGF_INVALID,
116         0,      /* numhooks */
117         NULL,   /* private */
118         0,      /* ID */
119         LIST_HEAD_INITIALIZER(ng_deadnode.hooks),
120         {},     /* all_nodes list entry */
121         {},     /* id hashtable list entry */
122         {
123                 0,
124                 NULL,
125                 0,
126                 NULL,
127         },      /* token */
128         1,      /* refs */
129 #ifdef  NETGRAPH_DEBUG
130         ND_MAGIC,
131         __FILE__,
132         __LINE__,
133         {NULL}
134 #endif  /* NETGRAPH_DEBUG */
135 };
136
137 struct ng_hook ng_deadhook = {
138         "dead",
139         NULL,           /* private */
140         HK_INVALID | HK_DEAD,
141         0,              /* undefined data link type */
142         &ng_deadhook,   /* Peer is self */
143         &ng_deadnode,   /* attached to deadnode */
144         {},             /* hooks list */
145         NULL,           /* override rcvmsg() */
146         NULL,           /* override rcvdata() */
147         1,              /* refs always >= 1 */
148 #ifdef  NETGRAPH_DEBUG
149         HK_MAGIC,
150         __FILE__,
151         __LINE__,
152         {NULL}
153 #endif  /* NETGRAPH_DEBUG */
154 };
155
156 /*
157  * END DEAD STRUCTURES
158  */
159
160 /* We don't want our messages to be replied. This is our panic reply port. */
161 static struct lwkt_port ng_panic_reply_port;
162
163 /* Array of per-CPU target ports */
164 struct lwkt_port *ng_msgport[MAXCPU];
165
166 /* List of installed types */
167 static LIST_HEAD(, ng_type) ng_typelist;
168 static struct mtx       ng_typelist_mtx;
169
170 /* Hash related definitions */
171 /* XXX Don't need to initialise them because it's a LIST */
172 #define NG_ID_HASH_SIZE 128 /* most systems wont need even this many */
173 static LIST_HEAD(, ng_node) ng_ID_hash[NG_ID_HASH_SIZE];
174 static struct mtx       ng_idhash_mtx;
175 /* Method to find a node.. used twice so do it here */
176 #define NG_IDHASH_FN(ID) ((ID) % (NG_ID_HASH_SIZE))
177 #define NG_IDHASH_FIND(ID, node)                                        \
178         do {                                                            \
179                 KKASSERT(mtx_owned(&ng_idhash_mtx));                    \
180                 LIST_FOREACH(node, &ng_ID_hash[NG_IDHASH_FN(ID)],       \
181                                                 nd_idnodes) {           \
182                         if (NG_NODE_IS_VALID(node)                      \
183                         && (NG_NODE_ID(node) == ID)) {                  \
184                                 break;                                  \
185                         }                                               \
186                 }                                                       \
187         } while (0)
188
189 #define NG_NAME_HASH_SIZE 128 /* most systems wont need even this many */
190 static LIST_HEAD(, ng_node) ng_name_hash[NG_NAME_HASH_SIZE];
191 static struct mtx       ng_namehash_mtx;
192 #define NG_NAMEHASH(NAME, HASH)                         \
193         do {                                            \
194                 u_char  h = 0;                          \
195                 const u_char    *c;                     \
196                 for (c = (const u_char*)(NAME); *c; c++)\
197                         h += *c;                        \
198                 (HASH) = h % (NG_NAME_HASH_SIZE);       \
199         } while (0)
200
201
202 /* Internal functions */
203 static int      ng_add_hook(node_p node, const char *name, hook_p * hookp);
204 static int      ng_generic_msg(node_p here, item_p item, hook_p lasthook);
205 static ng_ID_t  ng_decodeidname(const char *name);
206 static int      ngb_mod_event(module_t mod, int event, void *data);
207 static void     ngthread(void *dummy);
208 static int      ng_apply_item(item_p item);
209 static node_p   ng_ID2noderef(ng_ID_t ID);
210 static int      ng_con_nodes(item_p item, node_p node, const char *name,
211                     node_p node2, const char *name2);
212 static int      ng_con_part2(node_p node, item_p item, hook_p hook);
213 static int      ng_con_part3(node_p node, item_p item, hook_p hook);
214 static int      ng_mkpeer(node_p node, const char *name,
215                                                 const char *name2, char *type);
216 static void     ng_check_apply(item_p item, int error);
217 static boolean_t        bzero_ctor(void *obj, void *private, int ocflags);
218
219 /* Imported, these used to be externally visible, some may go back. */
220 void    ng_destroy_hook(hook_p hook);
221 node_p  ng_name2noderef(node_p node, const char *name);
222 int     ng_path2noderef(node_p here, const char *path,
223         node_p *dest, hook_p *lasthook);
224 int     ng_make_node(const char *type, node_p *nodepp);
225 int     ng_path_parse(char *addr, char **node, char **path, char **hook);
226 void    ng_rmnode(node_p node, hook_p dummy1, void *dummy2, int dummy3);
227 void    ng_unname(node_p node);
228
229
230 /* Our own netgraph malloc type */
231 MALLOC_DEFINE(M_NETGRAPH, "netgraph", "netgraph structures and ctrl messages");
232 MALLOC_DEFINE(M_NETGRAPH_HOOK, "netgraph_hook", "netgraph hook structures");
233 MALLOC_DEFINE(M_NETGRAPH_NODE, "netgraph_node", "netgraph node structures");
234 MALLOC_DEFINE(M_NETGRAPH_MSG, "netgraph_msg", "netgraph name storage");
235 MALLOC_DEFINE(M_NETGRAPH_APPLY, "netgraph_apply", "netgraph apply_info structures");
236
237 /* Should not be visible outside this file */
238
239 #define _NG_ALLOC_HOOK(hook) \
240         hook = kmalloc(sizeof(*hook), M_NETGRAPH_HOOK, \
241             M_WAITOK | M_NULLOK | M_ZERO)
242 #define _NG_ALLOC_NODE(node) \
243         node = kmalloc(sizeof(*node), M_NETGRAPH_NODE, \
244             M_WAITOK | M_NULLOK | M_ZERO)
245
246 #ifdef NETGRAPH_DEBUG /*----------------------------------------------*/
247 /*
248  * In debug mode:
249  * In an attempt to help track reference count screwups
250  * we do not free objects back to the malloc system, but keep them
251  * in a local cache where we can examine them and keep information safely
252  * after they have been freed.
253  * We use this scheme for nodes and hooks, and to some extent for items.
254  */
255 static __inline hook_p
256 ng_alloc_hook(void)
257 {
258         hook_p hook;
259         SLIST_ENTRY(ng_hook) temp;
260         mtx_lock(&ng_nodelist_mtx);
261         hook = LIST_FIRST(&ng_freehooks);
262         if (hook) {
263                 LIST_REMOVE(hook, hk_hooks);
264                 bcopy(&hook->hk_all, &temp, sizeof(temp));
265                 bzero(hook, sizeof(struct ng_hook));
266                 bcopy(&temp, &hook->hk_all, sizeof(temp));
267                 mtx_unlock(&ng_nodelist_mtx);
268                 hook->hk_magic = HK_MAGIC;
269         } else {
270                 mtx_unlock(&ng_nodelist_mtx);
271                 _NG_ALLOC_HOOK(hook);
272                 if (hook) {
273                         hook->hk_magic = HK_MAGIC;
274                         mtx_lock(&ng_nodelist_mtx);
275                         SLIST_INSERT_HEAD(&ng_allhooks, hook, hk_all);
276                         mtx_unlock(&ng_nodelist_mtx);
277                 }
278         }
279         return (hook);
280 }
281
282 static __inline node_p
283 ng_alloc_node(void)
284 {
285         node_p node;
286         SLIST_ENTRY(ng_node) temp;
287         mtx_lock(&ng_nodelist_mtx);
288         node = LIST_FIRST(&ng_freenodes);
289         if (node) {
290                 LIST_REMOVE(node, nd_nodes);
291                 bcopy(&node->nd_all, &temp, sizeof(temp));
292                 bzero(node, sizeof(struct ng_node));
293                 bcopy(&temp, &node->nd_all, sizeof(temp));
294                 mtx_unlock(&ng_nodelist_mtx);
295                 node->nd_magic = ND_MAGIC;
296         } else {
297                 mtx_unlock(&ng_nodelist_mtx);
298                 _NG_ALLOC_NODE(node);
299                 if (node) {
300                         node->nd_magic = ND_MAGIC;
301                         mtx_lock(&ng_nodelist_mtx);
302                         SLIST_INSERT_HEAD(&ng_allnodes, node, nd_all);
303                         mtx_unlock(&ng_nodelist_mtx);
304                 }
305         }
306         return (node);
307 }
308
309 #define NG_ALLOC_HOOK(hook) do { (hook) = ng_alloc_hook(); } while (0)
310 #define NG_ALLOC_NODE(node) do { (node) = ng_alloc_node(); } while (0)
311
312
313 #define NG_FREE_HOOK(hook)                                              \
314         do {                                                            \
315                 mtx_lock(&ng_nodelist_mtx);                     \
316                 LIST_INSERT_HEAD(&ng_freehooks, hook, hk_hooks);        \
317                 hook->hk_magic = 0;                                     \
318                 mtx_unlock(&ng_nodelist_mtx);                   \
319         } while (0)
320
321 #define NG_FREE_NODE(node)                                              \
322         do {                                                            \
323                 mtx_lock(&ng_nodelist_mtx);                     \
324                 LIST_INSERT_HEAD(&ng_freenodes, node, nd_nodes);        \
325                 node->nd_magic = 0;                                     \
326                 mtx_unlock(&ng_nodelist_mtx);                   \
327         } while (0)
328
329 #else /* NETGRAPH_DEBUG */ /*----------------------------------------------*/
330
331 #define NG_ALLOC_HOOK(hook) _NG_ALLOC_HOOK(hook)
332 #define NG_ALLOC_NODE(node) _NG_ALLOC_NODE(node)
333
334 #define NG_FREE_HOOK(hook) do { kfree((hook), M_NETGRAPH_HOOK); } while (0)
335 #define NG_FREE_NODE(node) do { kfree((node), M_NETGRAPH_NODE); } while (0)
336
337 #endif /* NETGRAPH_DEBUG */ /*----------------------------------------------*/
338
339 /* Set this to kdb_enter("X") to catch all errors as they occur */
340 #ifndef TRAP_ERROR
341 #define TRAP_ERROR()
342 #endif
343
344 static  ng_ID_t nextID = 1;
345
346 #ifdef INVARIANTS
347 #define CHECK_DATA_MBUF(m)      do {                                    \
348                 struct mbuf *n;                                         \
349                 int total;                                              \
350                                                                         \
351                 M_ASSERTPKTHDR(m);                                      \
352                 for (total = 0, n = (m); n != NULL; n = n->m_next) {    \
353                         total += n->m_len;                              \
354                         if (n->m_nextpkt != NULL)                       \
355                                 panic("%s: m_nextpkt", __func__);       \
356                 }                                                       \
357                                                                         \
358                 if ((m)->m_pkthdr.len != total) {                       \
359                         panic("%s: %d != %d",                           \
360                             __func__, (m)->m_pkthdr.len, total);        \
361                 }                                                       \
362         } while (0)
363 #else
364 #define CHECK_DATA_MBUF(m)
365 #endif
366
367 #define ERROUT(x)       do { error = (x); goto done; } while (0)
368
369 /************************************************************************
370         Parse type definitions for generic messages
371 ************************************************************************/
372
373 /* Handy structure parse type defining macro */
374 #define DEFINE_PARSE_STRUCT_TYPE(lo, up, args)                          \
375 static const struct ng_parse_struct_field                               \
376         ng_ ## lo ## _type_fields[] = NG_GENERIC_ ## up ## _INFO args;  \
377 static const struct ng_parse_type ng_generic_ ## lo ## _type = {        \
378         &ng_parse_struct_type,                                          \
379         &ng_ ## lo ## _type_fields                                      \
380 }
381
382 DEFINE_PARSE_STRUCT_TYPE(mkpeer, MKPEER, ());
383 DEFINE_PARSE_STRUCT_TYPE(connect, CONNECT, ());
384 DEFINE_PARSE_STRUCT_TYPE(name, NAME, ());
385 DEFINE_PARSE_STRUCT_TYPE(rmhook, RMHOOK, ());
386 DEFINE_PARSE_STRUCT_TYPE(nodeinfo, NODEINFO, ());
387 DEFINE_PARSE_STRUCT_TYPE(typeinfo, TYPEINFO, ());
388 DEFINE_PARSE_STRUCT_TYPE(linkinfo, LINKINFO, (&ng_generic_nodeinfo_type));
389
390 /* Get length of an array when the length is stored as a 32 bit
391    value immediately preceding the array -- as with struct namelist
392    and struct typelist. */
393 static int
394 ng_generic_list_getLength(const struct ng_parse_type *type,
395         const u_char *start, const u_char *buf)
396 {
397         return *((const u_int32_t *)(buf - 4));
398 }
399
400 /* Get length of the array of struct linkinfo inside a struct hooklist */
401 static int
402 ng_generic_linkinfo_getLength(const struct ng_parse_type *type,
403         const u_char *start, const u_char *buf)
404 {
405         const struct hooklist *hl = (const struct hooklist *)start;
406
407         return hl->nodeinfo.hooks;
408 }
409
410 /* Array type for a variable length array of struct namelist */
411 static const struct ng_parse_array_info ng_nodeinfoarray_type_info = {
412         &ng_generic_nodeinfo_type,
413         &ng_generic_list_getLength
414 };
415 static const struct ng_parse_type ng_generic_nodeinfoarray_type = {
416         &ng_parse_array_type,
417         &ng_nodeinfoarray_type_info
418 };
419
420 /* Array type for a variable length array of struct typelist */
421 static const struct ng_parse_array_info ng_typeinfoarray_type_info = {
422         &ng_generic_typeinfo_type,
423         &ng_generic_list_getLength
424 };
425 static const struct ng_parse_type ng_generic_typeinfoarray_type = {
426         &ng_parse_array_type,
427         &ng_typeinfoarray_type_info
428 };
429
430 /* Array type for array of struct linkinfo in struct hooklist */
431 static const struct ng_parse_array_info ng_generic_linkinfo_array_type_info = {
432         &ng_generic_linkinfo_type,
433         &ng_generic_linkinfo_getLength
434 };
435 static const struct ng_parse_type ng_generic_linkinfo_array_type = {
436         &ng_parse_array_type,
437         &ng_generic_linkinfo_array_type_info
438 };
439
440 DEFINE_PARSE_STRUCT_TYPE(typelist, TYPELIST, (&ng_generic_nodeinfoarray_type));
441 DEFINE_PARSE_STRUCT_TYPE(hooklist, HOOKLIST,
442         (&ng_generic_nodeinfo_type, &ng_generic_linkinfo_array_type));
443 DEFINE_PARSE_STRUCT_TYPE(listnodes, LISTNODES,
444         (&ng_generic_nodeinfoarray_type));
445
446 /* List of commands and how to convert arguments to/from ASCII */
447 static const struct ng_cmdlist ng_generic_cmds[] = {
448         {
449           NGM_GENERIC_COOKIE,
450           NGM_SHUTDOWN,
451           "shutdown",
452           NULL,
453           NULL
454         },
455         {
456           NGM_GENERIC_COOKIE,
457           NGM_MKPEER,
458           "mkpeer",
459           &ng_generic_mkpeer_type,
460           NULL
461         },
462         {
463           NGM_GENERIC_COOKIE,
464           NGM_CONNECT,
465           "connect",
466           &ng_generic_connect_type,
467           NULL
468         },
469         {
470           NGM_GENERIC_COOKIE,
471           NGM_NAME,
472           "name",
473           &ng_generic_name_type,
474           NULL
475         },
476         {
477           NGM_GENERIC_COOKIE,
478           NGM_RMHOOK,
479           "rmhook",
480           &ng_generic_rmhook_type,
481           NULL
482         },
483         {
484           NGM_GENERIC_COOKIE,
485           NGM_NODEINFO,
486           "nodeinfo",
487           NULL,
488           &ng_generic_nodeinfo_type
489         },
490         {
491           NGM_GENERIC_COOKIE,
492           NGM_LISTHOOKS,
493           "listhooks",
494           NULL,
495           &ng_generic_hooklist_type
496         },
497         {
498           NGM_GENERIC_COOKIE,
499           NGM_LISTNAMES,
500           "listnames",
501           NULL,
502           &ng_generic_listnodes_type    /* same as NGM_LISTNODES */
503         },
504         {
505           NGM_GENERIC_COOKIE,
506           NGM_LISTNODES,
507           "listnodes",
508           NULL,
509           &ng_generic_listnodes_type
510         },
511         {
512           NGM_GENERIC_COOKIE,
513           NGM_LISTTYPES,
514           "listtypes",
515           NULL,
516           &ng_generic_typeinfo_type
517         },
518         {
519           NGM_GENERIC_COOKIE,
520           NGM_TEXT_CONFIG,
521           "textconfig",
522           NULL,
523           &ng_parse_string_type
524         },
525         {
526           NGM_GENERIC_COOKIE,
527           NGM_TEXT_STATUS,
528           "textstatus",
529           NULL,
530           &ng_parse_string_type
531         },
532         {
533           NGM_GENERIC_COOKIE,
534           NGM_ASCII2BINARY,
535           "ascii2binary",
536           &ng_parse_ng_mesg_type,
537           &ng_parse_ng_mesg_type
538         },
539         {
540           NGM_GENERIC_COOKIE,
541           NGM_BINARY2ASCII,
542           "binary2ascii",
543           &ng_parse_ng_mesg_type,
544           &ng_parse_ng_mesg_type
545         },
546         { 0 }
547 };
548
549 /************************************************************************
550                         Node routines
551 ************************************************************************/
552
553 /*
554  * Instantiate a node of the requested type
555  */
556 int
557 ng_make_node(const char *typename, node_p *nodepp)
558 {
559         struct ng_type *type;
560         int     error;
561
562         /* Check that the type makes sense */
563         if (typename == NULL) {
564                 TRAP_ERROR();
565                 return (EINVAL);
566         }
567
568         /* Locate the node type. If we fail we return. Do not try to load
569          * module.
570          */
571         if ((type = ng_findtype(typename)) == NULL)
572                 return (ENXIO);
573
574         /*
575          * If we have a constructor, then make the node and
576          * call the constructor to do type specific initialisation.
577          */
578         if (type->constructor != NULL) {
579                 if ((error = ng_make_node_common(type, nodepp)) == 0) {
580                         if ((error = ((*type->constructor)(*nodepp)) != 0)) {
581                                 NG_NODE_UNREF(*nodepp);
582                         }
583                 }
584         } else {
585                 /*
586                  * Node has no constructor. We cannot ask for one
587                  * to be made. It must be brought into existence by
588                  * some external agency. The external agency should
589                  * call ng_make_node_common() directly to get the
590                  * netgraph part initialised.
591                  */
592                 TRAP_ERROR();
593                 error = EINVAL;
594         }
595         return (error);
596 }
597
598 /*
599  * Generic node creation. Called by node initialisation for externally
600  * instantiated nodes (e.g. hardware, sockets, etc ).
601  * The returned node has a reference count of 1.
602  */
603 int
604 ng_make_node_common(struct ng_type *type, node_p *nodepp)
605 {
606         node_p node;
607
608         /* Require the node type to have been already installed */
609         if (ng_findtype(type->name) == NULL) {
610                 TRAP_ERROR();
611                 return (EINVAL);
612         }
613
614         /* Make a node and try attach it to the type */
615         NG_ALLOC_NODE(node);
616         if (node == NULL) {
617                 TRAP_ERROR();
618                 return (ENOMEM);
619         }
620         node->nd_type = type;
621         NG_NODE_REF(node);                              /* note reference */
622         type->refs++;
623
624         /* Initialize the reader/writer shared token */
625         lwkt_token_init(&node->nd_token, type->name);
626
627         /* Initialize hook list for new node */
628         LIST_INIT(&node->nd_hooks);
629
630         /* Link us into the name hash. */
631         mtx_lock(&ng_namehash_mtx);
632         LIST_INSERT_HEAD(&ng_name_hash[0], node, nd_nodes);
633         mtx_unlock(&ng_namehash_mtx);
634
635         /* get an ID and put us in the hash chain */
636         mtx_lock(&ng_idhash_mtx);
637         for (;;) { /* wrap protection, even if silly */
638                 node_p node2 = NULL;
639                 node->nd_ID = nextID++; /* 137/second for 1 year before wrap */
640
641                 /* Is there a problem with the new number? */
642                 NG_IDHASH_FIND(node->nd_ID, node2); /* already taken? */
643                 if ((node->nd_ID != 0) && (node2 == NULL)) {
644                         break;
645                 }
646         }
647         LIST_INSERT_HEAD(&ng_ID_hash[NG_IDHASH_FN(node->nd_ID)],
648                                                         node, nd_idnodes);
649         mtx_unlock(&ng_idhash_mtx);
650
651         /* Done */
652         *nodepp = node;
653         return (0);
654 }
655
656 /*
657  * Forceably start the shutdown process on a node. Either call
658  * its shutdown method, or do the default shutdown if there is
659  * no type-specific method.
660  *
661  * We can only be called from a shutdown message, so we know we have
662  * a writer lock, and therefore exclusive access.
663  *
664  * Persistent node types must have a type-specific method which
665  * allocates a new node in which case, this one is irretrievably going away,
666  * or cleans up anything it needs, and just makes the node valid again,
667  * in which case we allow the node to survive.
668  *
669  * XXX We need to think of how to tell a persistent node that we
670  * REALLY need to go away because the hardware has gone or we
671  * are rebooting.... etc.
672  */
673 void
674 ng_rmnode(node_p node, hook_p dummy1, void *dummy2, int dummy3)
675 {
676         hook_p hook;
677
678         /* Check if it's already shutting down */
679         if ((node->nd_flags & NGF_CLOSING) != 0)
680                 return;
681
682         if (node == &ng_deadnode) {
683                 printf ("shutdown called on deadnode\n");
684                 return;
685         }
686
687         /* Add an extra reference so it doesn't go away during this */
688         NG_NODE_REF(node);
689
690         /*
691          * Mark it invalid so any newcomers know not to try use it
692          * Also add our own mark so we can't recurse
693          * note that NGF_INVALID does not do this as it's also set during
694          * creation
695          */
696         node->nd_flags |= NGF_INVALID|NGF_CLOSING;
697
698         /* If node has its pre-shutdown method, then call it first*/
699         if (node->nd_type && node->nd_type->close)
700                 (*node->nd_type->close)(node);
701
702         /* Notify all remaining connected nodes to disconnect */
703         while ((hook = LIST_FIRST(&node->nd_hooks)) != NULL)
704                 ng_destroy_hook(hook);
705
706         /* Ask the type if it has anything to do in this case */
707         if (node->nd_type && node->nd_type->shutdown) {
708                 (*node->nd_type->shutdown)(node);
709                 if (NG_NODE_IS_VALID(node)) {
710                         /*
711                          * Well, blow me down if the node code hasn't declared
712                          * that it doesn't want to die.
713                          * Presumably it is a persistant node.
714                          * If we REALLY want it to go away,
715                          *  e.g. hardware going away,
716                          * Our caller should set NGF_REALLY_DIE in nd_flags.
717                          */
718                         node->nd_flags &= ~(NGF_INVALID|NGF_CLOSING);
719                         NG_NODE_UNREF(node); /* Assume they still have theirs */
720                         return;
721                 }
722         } else {                                /* do the default thing */
723                 NG_NODE_UNREF(node);
724         }
725
726         ng_unname(node); /* basically a NOP these days */
727
728         /*
729          * Remove extra reference, possibly the last
730          * Possible other holders of references may include
731          * timeout callouts, but theoretically the node's supposed to
732          * have cancelled them. Possibly hardware dependencies may
733          * force a driver to 'linger' with a reference.
734          */
735         NG_NODE_UNREF(node);
736 }
737
738 /*
739  * Remove a reference to the node, possibly the last.
740  * deadnode always acts as it it were the last.
741  */
742 int
743 ng_unref_node(node_p node)
744 {
745         int v;
746
747         if (node == &ng_deadnode) {
748                 return (0);
749         }
750
751         v = atomic_fetchadd_int(&node->nd_refs, -1);
752
753         if (v == 1) { /* we were the last */
754
755                 mtx_lock(&ng_namehash_mtx);
756                 node->nd_type->refs--; /* XXX maybe should get types lock? */
757                 LIST_REMOVE(node, nd_nodes);
758                 mtx_unlock(&ng_namehash_mtx);
759
760                 mtx_lock(&ng_idhash_mtx);
761                 LIST_REMOVE(node, nd_idnodes);
762                 mtx_unlock(&ng_idhash_mtx);
763
764                 NG_FREE_NODE(node);
765         }
766         return (v - 1);
767 }
768
769 /************************************************************************
770                         Node ID handling
771 ************************************************************************/
772 static node_p
773 ng_ID2noderef(ng_ID_t ID)
774 {
775         node_p node;
776         mtx_lock(&ng_idhash_mtx);
777         NG_IDHASH_FIND(ID, node);
778         if(node)
779                 NG_NODE_REF(node);
780         mtx_unlock(&ng_idhash_mtx);
781         return(node);
782 }
783
784 ng_ID_t
785 ng_node2ID(node_p node)
786 {
787         return (node ? NG_NODE_ID(node) : 0);
788 }
789
790 /************************************************************************
791                         Node name handling
792 ************************************************************************/
793
794 /*
795  * Assign a node a name. Once assigned, the name cannot be changed.
796  */
797 int
798 ng_name_node(node_p node, const char *name)
799 {
800         int i, hash;
801         node_p node2;
802
803         /* Check the name is valid */
804         for (i = 0; i < NG_NODESIZ; i++) {
805                 if (name[i] == '\0' || name[i] == '.' || name[i] == ':')
806                         break;
807         }
808         if (i == 0 || name[i] != '\0') {
809                 TRAP_ERROR();
810                 return (EINVAL);
811         }
812         if (ng_decodeidname(name) != 0) { /* valid IDs not allowed here */
813                 TRAP_ERROR();
814                 return (EINVAL);
815         }
816
817         /* Check the name isn't already being used */
818         if ((node2 = ng_name2noderef(node, name)) != NULL) {
819                 NG_NODE_UNREF(node2);
820                 TRAP_ERROR();
821                 return (EADDRINUSE);
822         }
823
824         /* copy it */
825         strlcpy(NG_NODE_NAME(node), name, NG_NODESIZ);
826
827         /* Update name hash. */
828         NG_NAMEHASH(name, hash);
829         mtx_lock(&ng_namehash_mtx);
830         LIST_REMOVE(node, nd_nodes);
831         LIST_INSERT_HEAD(&ng_name_hash[hash], node, nd_nodes);
832         mtx_unlock(&ng_namehash_mtx);
833
834         return (0);
835 }
836
837 /*
838  * Find a node by absolute name. The name should NOT end with ':'
839  * The name "." means "this node" and "[xxx]" means "the node
840  * with ID (ie, at address) xxx".
841  *
842  * Returns the node if found, else NULL.
843  * Eventually should add something faster than a sequential search.
844  * Note it acquires a reference on the node so you can be sure it's still
845  * there.
846  */
847 node_p
848 ng_name2noderef(node_p here, const char *name)
849 {
850         node_p node;
851         ng_ID_t temp;
852         int     hash;
853
854         /* "." means "this node" */
855         if (strcmp(name, ".") == 0) {
856                 NG_NODE_REF(here);
857                 return(here);
858         }
859
860         /* Check for name-by-ID */
861         if ((temp = ng_decodeidname(name)) != 0) {
862                 return (ng_ID2noderef(temp));
863         }
864
865         /* Find node by name */
866         NG_NAMEHASH(name, hash);
867         mtx_lock(&ng_namehash_mtx);
868         LIST_FOREACH(node, &ng_name_hash[hash], nd_nodes) {
869                 if (NG_NODE_IS_VALID(node) &&
870                     (strcmp(NG_NODE_NAME(node), name) == 0)) {
871                         break;
872                 }
873         }
874         if (node)
875                 NG_NODE_REF(node);
876         mtx_unlock(&ng_namehash_mtx);
877         return (node);
878 }
879
880 /*
881  * Decode an ID name, eg. "[f03034de]". Returns 0 if the
882  * string is not valid, otherwise returns the value.
883  */
884 static ng_ID_t
885 ng_decodeidname(const char *name)
886 {
887         const int len = strlen(name);
888         char *eptr;
889         u_long val;
890
891         /* Check for proper length, brackets, no leading junk */
892         if ((len < 3)
893         || (name[0] != '[')
894         || (name[len - 1] != ']')
895         || (!isxdigit(name[1]))) {
896                 return ((ng_ID_t)0);
897         }
898
899         /* Decode number */
900         val = strtoul(name + 1, &eptr, 16);
901         if ((eptr - name != len - 1)
902         || (val == ULONG_MAX)
903         || (val == 0)) {
904                 return ((ng_ID_t)0);
905         }
906         return (ng_ID_t)val;
907 }
908
909 /*
910  * Remove a name from a node. This should only be called
911  * when shutting down and removing the node.
912  * IF we allow name changing this may be more resurrected.
913  */
914 void
915 ng_unname(node_p node)
916 {
917 }
918
919 /************************************************************************
920                         Hook routines
921  Names are not optional. Hooks are always connected, except for a
922  brief moment within these routines. On invalidation or during creation
923  they are connected to the 'dead' hook.
924 ************************************************************************/
925
926 /*
927  * Remove a hook reference
928  */
929 void
930 ng_unref_hook(hook_p hook)
931 {
932         int v;
933
934         if (hook == &ng_deadhook) {
935                 return;
936         }
937
938         v = atomic_fetchadd_int(&hook->hk_refs, -1);
939
940         if (v == 1) { /* we were the last */
941                 if (_NG_HOOK_NODE(hook)) /* it'll probably be ng_deadnode */
942                         _NG_NODE_UNREF((_NG_HOOK_NODE(hook)));
943                 NG_FREE_HOOK(hook);
944         }
945 }
946
947 /*
948  * Add an unconnected hook to a node. Only used internally.
949  * Assumes node is locked. (XXX not yet true )
950  */
951 static int
952 ng_add_hook(node_p node, const char *name, hook_p *hookp)
953 {
954         hook_p hook;
955         int error = 0;
956
957         /* Check that the given name is good */
958         if (name == NULL) {
959                 TRAP_ERROR();
960                 return (EINVAL);
961         }
962         if (ng_findhook(node, name) != NULL) {
963                 TRAP_ERROR();
964                 return (EEXIST);
965         }
966
967         /* Allocate the hook and link it up */
968         NG_ALLOC_HOOK(hook);
969         if (hook == NULL) {
970                 TRAP_ERROR();
971                 return (ENOMEM);
972         }
973         hook->hk_refs = 1;              /* add a reference for us to return */
974         hook->hk_flags = HK_INVALID;
975         hook->hk_peer = &ng_deadhook;   /* start off this way */
976         hook->hk_node = node;
977         NG_NODE_REF(node);              /* each hook counts as a reference */
978
979         /* Set hook name */
980         strlcpy(NG_HOOK_NAME(hook), name, NG_HOOKSIZ);
981
982         /*
983          * Check if the node type code has something to say about it
984          * If it fails, the unref of the hook will also unref the node.
985          */
986         if (node->nd_type->newhook != NULL) {
987                 if ((error = (*node->nd_type->newhook)(node, hook, name))) {
988                         NG_HOOK_UNREF(hook);    /* this frees the hook */
989                         return (error);
990                 }
991         }
992         /*
993          * The 'type' agrees so far, so go ahead and link it in.
994          * We'll ask again later when we actually connect the hooks.
995          */
996         LIST_INSERT_HEAD(&node->nd_hooks, hook, hk_hooks);
997         node->nd_numhooks++;
998         NG_HOOK_REF(hook);      /* one for the node */
999
1000         if (hookp)
1001                 *hookp = hook;
1002         return (0);
1003 }
1004
1005 /*
1006  * Find a hook
1007  *
1008  * Node types may supply their own optimized routines for finding
1009  * hooks.  If none is supplied, we just do a linear search.
1010  * XXX Possibly we should add a reference to the hook?
1011  */
1012 hook_p
1013 ng_findhook(node_p node, const char *name)
1014 {
1015         hook_p hook;
1016
1017         if (node->nd_type->findhook != NULL)
1018                 return (*node->nd_type->findhook)(node, name);
1019         LIST_FOREACH(hook, &node->nd_hooks, hk_hooks) {
1020                 if (NG_HOOK_IS_VALID(hook)
1021                 && (strcmp(NG_HOOK_NAME(hook), name) == 0))
1022                         return (hook);
1023         }
1024         return (NULL);
1025 }
1026
1027 /*
1028  * Destroy a hook
1029  *
1030  * As hooks are always attached, this really destroys two hooks.
1031  * The one given, and the one attached to it. Disconnect the hooks
1032  * from each other first. We reconnect the peer hook to the 'dead'
1033  * hook so that it can still exist after we depart. We then
1034  * send the peer its own destroy message. This ensures that we only
1035  * interact with the peer's structures when it is locked processing that
1036  * message. We hold a reference to the peer hook so we are guaranteed that
1037  * the peer hook and node are still going to exist until
1038  * we are finished there as the hook holds a ref on the node.
1039  * We run this same code again on the peer hook, but that time it is already
1040  * attached to the 'dead' hook.
1041  *
1042  * This routine is called at all stages of hook creation
1043  * on error detection and must be able to handle any such stage.
1044  */
1045 void
1046 ng_destroy_hook(hook_p hook)
1047 {
1048         hook_p peer;
1049         node_p node;
1050
1051         if (hook == &ng_deadhook) {     /* better safe than sorry */
1052                 printf("ng_destroy_hook called on deadhook\n");
1053                 return;
1054         }
1055
1056         /*
1057          * Protect divorce process with mutex, to avoid races on
1058          * simultaneous disconnect.
1059          */
1060         mtx_lock(&ng_topo_mtx);
1061
1062         hook->hk_flags |= HK_INVALID;
1063
1064         peer = NG_HOOK_PEER(hook);
1065         node = NG_HOOK_NODE(hook);
1066
1067         if (peer && (peer != &ng_deadhook)) {
1068                 /*
1069                  * Set the peer to point to ng_deadhook
1070                  * from this moment on we are effectively independent it.
1071                  * send it an rmhook message of it's own.
1072                  */
1073                 peer->hk_peer = &ng_deadhook;   /* They no longer know us */
1074                 hook->hk_peer = &ng_deadhook;   /* Nor us, them */
1075                 if (NG_HOOK_NODE(peer) == &ng_deadnode) {
1076                         /*
1077                          * If it's already divorced from a node,
1078                          * just free it.
1079                          */
1080                         mtx_unlock(&ng_topo_mtx);
1081                 } else {
1082                         mtx_unlock(&ng_topo_mtx);
1083                         ng_rmhook_self(peer);   /* Send it a surprise */
1084                 }
1085                 NG_HOOK_UNREF(peer);            /* account for peer link */
1086                 NG_HOOK_UNREF(hook);            /* account for peer link */
1087         } else
1088                 mtx_unlock(&ng_topo_mtx);
1089
1090         KKASSERT(mtx_notowned(&ng_topo_mtx));
1091
1092         /*
1093          * Remove the hook from the node's list to avoid possible recursion
1094          * in case the disconnection results in node shutdown.
1095          */
1096         if (node == &ng_deadnode) { /* happens if called from ng_con_nodes() */
1097                 return;
1098         }
1099         LIST_REMOVE(hook, hk_hooks);
1100         node->nd_numhooks--;
1101         if (node->nd_type->disconnect) {
1102                 /*
1103                  * The type handler may elect to destroy the node so don't
1104                  * trust its existence after this point. (except
1105                  * that we still hold a reference on it. (which we
1106                  * inherrited from the hook we are destroying)
1107                  */
1108                 (*node->nd_type->disconnect) (hook);
1109         }
1110
1111         /*
1112          * Note that because we will point to ng_deadnode, the original node
1113          * is not decremented automatically so we do that manually.
1114          */
1115         _NG_HOOK_NODE(hook) = &ng_deadnode;
1116         NG_NODE_UNREF(node);    /* We no longer point to it so adjust count */
1117         NG_HOOK_UNREF(hook);    /* Account for linkage (in list) to node */
1118 }
1119
1120 /*
1121  * Take two hooks on a node and merge the connection so that the given node
1122  * is effectively bypassed.
1123  */
1124 int
1125 ng_bypass(hook_p hook1, hook_p hook2)
1126 {
1127         if (hook1->hk_node != hook2->hk_node) {
1128                 TRAP_ERROR();
1129                 return (EINVAL);
1130         }
1131         hook1->hk_peer->hk_peer = hook2->hk_peer;
1132         hook2->hk_peer->hk_peer = hook1->hk_peer;
1133
1134         hook1->hk_peer = &ng_deadhook;
1135         hook2->hk_peer = &ng_deadhook;
1136
1137         NG_HOOK_UNREF(hook1);
1138         NG_HOOK_UNREF(hook2);
1139
1140         /* XXX If we ever cache methods on hooks update them as well */
1141         ng_destroy_hook(hook1);
1142         ng_destroy_hook(hook2);
1143         return (0);
1144 }
1145
1146 /*
1147  * Install a new netgraph type
1148  */
1149 int
1150 ng_newtype(struct ng_type *tp)
1151 {
1152         const size_t namelen = strlen(tp->name);
1153
1154         /* Check version and type name fields */
1155         if ((tp->version != NG_ABI_VERSION)
1156         || (namelen == 0)
1157         || (namelen >= NG_TYPESIZ)) {
1158                 TRAP_ERROR();
1159                 if (tp->version != NG_ABI_VERSION) {
1160                         printf("Netgraph: Node type rejected. ABI mismatch. Suggest recompile\n");
1161                 }
1162                 return (EINVAL);
1163         }
1164
1165         /* Check for name collision */
1166         if (ng_findtype(tp->name) != NULL) {
1167                 TRAP_ERROR();
1168                 return (EEXIST);
1169         }
1170
1171
1172         /* Link in new type */
1173         mtx_lock(&ng_typelist_mtx);
1174         LIST_INSERT_HEAD(&ng_typelist, tp, types);
1175         tp->refs = 1;   /* first ref is linked list */
1176         mtx_unlock(&ng_typelist_mtx);
1177         return (0);
1178 }
1179
1180 /*
1181  * unlink a netgraph type
1182  * If no examples exist
1183  */
1184 int
1185 ng_rmtype(struct ng_type *tp)
1186 {
1187         /* Check for name collision */
1188         if (tp->refs != 1) {
1189                 TRAP_ERROR();
1190                 return (EBUSY);
1191         }
1192
1193         /* Unlink type */
1194         mtx_lock(&ng_typelist_mtx);
1195         LIST_REMOVE(tp, types);
1196         mtx_unlock(&ng_typelist_mtx);
1197         return (0);
1198 }
1199
1200 /*
1201  * Look for a type of the name given
1202  */
1203 struct ng_type *
1204 ng_findtype(const char *typename)
1205 {
1206         struct ng_type *type;
1207
1208         mtx_lock(&ng_typelist_mtx);
1209         LIST_FOREACH(type, &ng_typelist, types) {
1210                 if (strcmp(type->name, typename) == 0)
1211                         break;
1212         }
1213         mtx_unlock(&ng_typelist_mtx);
1214         return (type);
1215 }
1216
1217 /************************************************************************
1218                         Composite routines
1219 ************************************************************************/
1220 /*
1221  * Connect two nodes using the specified hooks, using queued functions.
1222  */
1223 static int
1224 ng_con_part3(node_p node, item_p item, hook_p hook)
1225 {
1226         int     error = 0;
1227
1228         /*
1229          * When we run, we know that the node 'node' is locked for us.
1230          * Our caller has a reference on the hook.
1231          * Our caller has a reference on the node.
1232          * (In this case our caller is ng_apply_item() ).
1233          * The peer hook has a reference on the hook.
1234          * We are all set up except for the final call to the node, and
1235          * the clearing of the INVALID flag.
1236          */
1237         if (NG_HOOK_NODE(hook) == &ng_deadnode) {
1238                 /*
1239                  * The node must have been freed again since we last visited
1240                  * here. ng_destry_hook() has this effect but nothing else does.
1241                  * We should just release our references and
1242                  * free anything we can think of.
1243                  * Since we know it's been destroyed, and it's our caller
1244                  * that holds the references, just return.
1245                  */
1246                 ERROUT(ENOENT);
1247         }
1248         if (hook->hk_node->nd_type->connect) {
1249                 if ((error = (*hook->hk_node->nd_type->connect) (hook))) {
1250                         ng_destroy_hook(hook);  /* also zaps peer */
1251                         printf("failed in ng_con_part3()\n");
1252                         ERROUT(error);
1253                 }
1254         }
1255         /*
1256          *  XXX this is wrong for SMP. Possibly we need
1257          * to separate out 'create' and 'invalid' flags.
1258          * should only set flags on hooks we have locked under our node.
1259          */
1260         hook->hk_flags &= ~HK_INVALID;
1261 done:
1262         NG_FREE_ITEM(item);
1263         return (error);
1264 }
1265
1266 static int
1267 ng_con_part2(node_p node, item_p item, hook_p hook)
1268 {
1269         hook_p  peer;
1270         int     error = 0;
1271
1272         /*
1273          * When we run, we know that the node 'node' is locked for us.
1274          * Our caller has a reference on the hook.
1275          * Our caller has a reference on the node.
1276          * (In this case our caller is ng_apply_item() ).
1277          * The peer hook has a reference on the hook.
1278          * our node pointer points to the 'dead' node.
1279          * First check the hook name is unique.
1280          * Should not happen because we checked before queueing this.
1281          */
1282         if (ng_findhook(node, NG_HOOK_NAME(hook)) != NULL) {
1283                 TRAP_ERROR();
1284                 ng_destroy_hook(hook); /* should destroy peer too */
1285                 printf("failed in ng_con_part2()\n");
1286                 ERROUT(EEXIST);
1287         }
1288         /*
1289          * Check if the node type code has something to say about it
1290          * If it fails, the unref of the hook will also unref the attached node,
1291          * however since that node is 'ng_deadnode' this will do nothing.
1292          * The peer hook will also be destroyed.
1293          */
1294         if (node->nd_type->newhook != NULL) {
1295                 if ((error = (*node->nd_type->newhook)(node, hook,
1296                     hook->hk_name))) {
1297                         ng_destroy_hook(hook); /* should destroy peer too */
1298                         printf("failed in ng_con_part2()\n");
1299                         ERROUT(error);
1300                 }
1301         }
1302
1303         /*
1304          * The 'type' agrees so far, so go ahead and link it in.
1305          * We'll ask again later when we actually connect the hooks.
1306          */
1307         hook->hk_node = node;           /* just overwrite ng_deadnode */
1308         NG_NODE_REF(node);              /* each hook counts as a reference */
1309         LIST_INSERT_HEAD(&node->nd_hooks, hook, hk_hooks);
1310         node->nd_numhooks++;
1311         NG_HOOK_REF(hook);      /* one for the node */
1312         
1313         /*
1314          * We now have a symmetrical situation, where both hooks have been
1315          * linked to their nodes, the newhook methods have been called
1316          * And the references are all correct. The hooks are still marked
1317          * as invalid, as we have not called the 'connect' methods
1318          * yet.
1319          * We can call the local one immediately as we have the
1320          * node locked, but we need to queue the remote one.
1321          */
1322         if (hook->hk_node->nd_type->connect) {
1323                 if ((error = (*hook->hk_node->nd_type->connect) (hook))) {
1324                         ng_destroy_hook(hook);  /* also zaps peer */
1325                         printf("failed in ng_con_part2(A)\n");
1326                         ERROUT(error);
1327                 }
1328         }
1329
1330         /*
1331          * Acquire topo mutex to avoid race with ng_destroy_hook().
1332          */
1333         mtx_lock(&ng_topo_mtx);
1334         peer = hook->hk_peer;
1335         if (peer == &ng_deadhook) {
1336                 mtx_unlock(&ng_topo_mtx);
1337                 printf("failed in ng_con_part2(B)\n");
1338                 ng_destroy_hook(hook);
1339                 ERROUT(ENOENT);
1340         }
1341         mtx_unlock(&ng_topo_mtx);
1342
1343         if ((error = ng_send_fn2(peer->hk_node, peer, item, &ng_con_part3,
1344             NULL, 0, NG_REUSE_ITEM))) {
1345                 printf("failed in ng_con_part2(C)\n");
1346                 ng_destroy_hook(hook);  /* also zaps peer */
1347                 return (error);         /* item was consumed. */
1348         }
1349         hook->hk_flags &= ~HK_INVALID; /* need both to be able to work */
1350         return (0);                     /* item was consumed. */
1351 done:
1352         NG_FREE_ITEM(item);
1353         return (error);
1354 }
1355
1356 /*
1357  * Connect this node with another node. We assume that this node is
1358  * currently locked, as we are only called from an NGM_CONNECT message.
1359  */
1360 static int
1361 ng_con_nodes(item_p item, node_p node, const char *name,
1362     node_p node2, const char *name2)
1363 {
1364         int     error;
1365         hook_p  hook;
1366         hook_p  hook2;
1367
1368         if (ng_findhook(node2, name2) != NULL) {
1369                 return(EEXIST);
1370         }
1371         if ((error = ng_add_hook(node, name, &hook)))  /* gives us a ref */
1372                 return (error);
1373         /* Allocate the other hook and link it up */
1374         NG_ALLOC_HOOK(hook2);
1375         if (hook2 == NULL) {
1376                 TRAP_ERROR();
1377                 ng_destroy_hook(hook);  /* XXX check ref counts so far */
1378                 NG_HOOK_UNREF(hook);    /* including our ref */
1379                 return (ENOMEM);
1380         }
1381         hook2->hk_refs = 1;             /* start with a reference for us. */
1382         hook2->hk_flags = HK_INVALID;
1383         hook2->hk_peer = hook;          /* Link the two together */
1384         hook->hk_peer = hook2;  
1385         NG_HOOK_REF(hook);              /* Add a ref for the peer to each*/
1386         NG_HOOK_REF(hook2);
1387         hook2->hk_node = &ng_deadnode;
1388         strlcpy(NG_HOOK_NAME(hook2), name2, NG_HOOKSIZ);
1389
1390         /*
1391          * Queue the function above.
1392          * Procesing continues in that function in the lock context of
1393          * the other node.
1394          */
1395         if ((error = ng_send_fn2(node2, hook2, item, &ng_con_part2, NULL, 0,
1396             NG_NOFLAGS))) {
1397                 printf("failed in ng_con_nodes(): %d\n", error);
1398                 ng_destroy_hook(hook);  /* also zaps peer */
1399         }
1400
1401         NG_HOOK_UNREF(hook);            /* Let each hook go if it wants to */
1402         NG_HOOK_UNREF(hook2);
1403         return (error);
1404 }
1405
1406 /*
1407  * Make a peer and connect.
1408  * We assume that the local node is locked.
1409  * The new node probably doesn't need a lock until
1410  * it has a hook, because it cannot really have any work until then,
1411  * but we should think about it a bit more.
1412  *
1413  * The problem may come if the other node also fires up
1414  * some hardware or a timer or some other source of activation,
1415  * also it may already get a command msg via it's ID.
1416  *
1417  * We could use the same method as ng_con_nodes() but we'd have
1418  * to add ability to remove the node when failing. (Not hard, just
1419  * make arg1 point to the node to remove).
1420  * Unless of course we just ignore failure to connect and leave
1421  * an unconnected node?
1422  */
1423 static int
1424 ng_mkpeer(node_p node, const char *name, const char *name2, char *type)
1425 {
1426         node_p  node2;
1427         hook_p  hook1, hook2;
1428         int     error;
1429
1430         if ((error = ng_make_node(type, &node2))) {
1431                 return (error);
1432         }
1433
1434         if ((error = ng_add_hook(node, name, &hook1))) { /* gives us a ref */
1435                 ng_rmnode(node2, NULL, NULL, 0);
1436                 return (error);
1437         }
1438
1439         if ((error = ng_add_hook(node2, name2, &hook2))) {
1440                 ng_rmnode(node2, NULL, NULL, 0);
1441                 ng_destroy_hook(hook1);
1442                 NG_HOOK_UNREF(hook1);
1443                 return (error);
1444         }
1445
1446         /*
1447          * Actually link the two hooks together.
1448          */
1449         hook1->hk_peer = hook2;
1450         hook2->hk_peer = hook1;
1451
1452         /* Each hook is referenced by the other */
1453         NG_HOOK_REF(hook1);
1454         NG_HOOK_REF(hook2);
1455
1456         /* Give each node the opportunity to veto the pending connection */
1457         if (hook1->hk_node->nd_type->connect) {
1458                 error = (*hook1->hk_node->nd_type->connect) (hook1);
1459         }
1460
1461         if ((error == 0) && hook2->hk_node->nd_type->connect) {
1462                 error = (*hook2->hk_node->nd_type->connect) (hook2);
1463
1464         }
1465
1466         /*
1467          * drop the references we were holding on the two hooks.
1468          */
1469         if (error) {
1470                 ng_destroy_hook(hook2); /* also zaps hook1 */
1471                 ng_rmnode(node2, NULL, NULL, 0);
1472         } else {
1473                 /* As a last act, allow the hooks to be used */
1474                 hook1->hk_flags &= ~HK_INVALID;
1475                 hook2->hk_flags &= ~HK_INVALID;
1476         }
1477         NG_HOOK_UNREF(hook1);
1478         NG_HOOK_UNREF(hook2);
1479         return (error);
1480 }
1481
1482 /************************************************************************
1483                 Utility routines to send self messages
1484 ************************************************************************/
1485         
1486 /* Shut this node down as soon as everyone is clear of it */
1487 /* Should add arg "immediately" to jump the queue */
1488 int
1489 ng_rmnode_self(node_p node)
1490 {
1491         int             error;
1492
1493         if (node == &ng_deadnode)
1494                 return (0);
1495         node->nd_flags |= NGF_INVALID;
1496         if (node->nd_flags & NGF_CLOSING)
1497                 return (0);
1498
1499         error = ng_send_fn(node, NULL, &ng_rmnode, NULL, 0);
1500         return (error);
1501 }
1502
1503 static void
1504 ng_rmhook_part2(node_p node, hook_p hook, void *arg1, int arg2)
1505 {
1506         ng_destroy_hook(hook);
1507         return ;
1508 }
1509
1510 int
1511 ng_rmhook_self(hook_p hook)
1512 {
1513         int             error;
1514         node_p node = NG_HOOK_NODE(hook);
1515
1516         if (node == &ng_deadnode)
1517                 return (0);
1518
1519         error = ng_send_fn(node, hook, &ng_rmhook_part2, NULL, 0);
1520         return (error);
1521 }
1522
1523 /***********************************************************************
1524  * Parse and verify a string of the form:  <NODE:><PATH>
1525  *
1526  * Such a string can refer to a specific node or a specific hook
1527  * on a specific node, depending on how you look at it. In the
1528  * latter case, the PATH component must not end in a dot.
1529  *
1530  * Both <NODE:> and <PATH> are optional. The <PATH> is a string
1531  * of hook names separated by dots. This breaks out the original
1532  * string, setting *nodep to "NODE" (or NULL if none) and *pathp
1533  * to "PATH" (or NULL if degenerate). Also, *hookp will point to
1534  * the final hook component of <PATH>, if any, otherwise NULL.
1535  *
1536  * This returns -1 if the path is malformed. The char ** are optional.
1537  ***********************************************************************/
1538 int
1539 ng_path_parse(char *addr, char **nodep, char **pathp, char **hookp)
1540 {
1541         char    *node, *path, *hook;
1542         int     k;
1543
1544         /*
1545          * Extract absolute NODE, if any
1546          */
1547         for (path = addr; *path && *path != ':'; path++);
1548         if (*path) {
1549                 node = addr;    /* Here's the NODE */
1550                 *path++ = '\0'; /* Here's the PATH */
1551
1552                 /* Node name must not be empty */
1553                 if (!*node)
1554                         return -1;
1555
1556                 /* A name of "." is OK; otherwise '.' not allowed */
1557                 if (strcmp(node, ".") != 0) {
1558                         for (k = 0; node[k]; k++)
1559                                 if (node[k] == '.')
1560                                         return -1;
1561                 }
1562         } else {
1563                 node = NULL;    /* No absolute NODE */
1564                 path = addr;    /* Here's the PATH */
1565         }
1566
1567         /* Snoop for illegal characters in PATH */
1568         for (k = 0; path[k]; k++)
1569                 if (path[k] == ':')
1570                         return -1;
1571
1572         /* Check for no repeated dots in PATH */
1573         for (k = 0; path[k]; k++)
1574                 if (path[k] == '.' && path[k + 1] == '.')
1575                         return -1;
1576
1577         /* Remove extra (degenerate) dots from beginning or end of PATH */
1578         if (path[0] == '.')
1579                 path++;
1580         if (*path && path[strlen(path) - 1] == '.')
1581                 path[strlen(path) - 1] = 0;
1582
1583         /* If PATH has a dot, then we're not talking about a hook */
1584         if (*path) {
1585                 for (hook = path, k = 0; path[k]; k++)
1586                         if (path[k] == '.') {
1587                                 hook = NULL;
1588                                 break;
1589                         }
1590         } else
1591                 path = hook = NULL;
1592
1593         /* Done */
1594         if (nodep)
1595                 *nodep = node;
1596         if (pathp)
1597                 *pathp = path;
1598         if (hookp)
1599                 *hookp = hook;
1600         return (0);
1601 }
1602
1603 /*
1604  * Given a path, which may be absolute or relative, and a starting node,
1605  * return the destination node.
1606  */
1607 int
1608 ng_path2noderef(node_p here, const char *address,
1609                                 node_p *destp, hook_p *lasthook)
1610 {
1611         char    fullpath[NG_PATHSIZ];
1612         char   *nodename, *path, pbuf[2];
1613         node_p  node, oldnode;
1614         char   *cp;
1615         hook_p hook = NULL;
1616
1617         /* Initialize */
1618         if (destp == NULL) {
1619                 TRAP_ERROR();
1620                 return EINVAL;
1621         }
1622         *destp = NULL;
1623
1624         /* Make a writable copy of address for ng_path_parse() */
1625         strncpy(fullpath, address, sizeof(fullpath) - 1);
1626         fullpath[sizeof(fullpath) - 1] = '\0';
1627
1628         /* Parse out node and sequence of hooks */
1629         if (ng_path_parse(fullpath, &nodename, &path, NULL) < 0) {
1630                 TRAP_ERROR();
1631                 return EINVAL;
1632         }
1633         if (path == NULL) {
1634                 pbuf[0] = '.';  /* Needs to be writable */
1635                 pbuf[1] = '\0';
1636                 path = pbuf;
1637         }
1638
1639         /*
1640          * For an absolute address, jump to the starting node.
1641          * Note that this holds a reference on the node for us.
1642          * Don't forget to drop the reference if we don't need it.
1643          */
1644         if (nodename) {
1645                 node = ng_name2noderef(here, nodename);
1646                 if (node == NULL) {
1647                         TRAP_ERROR();
1648                         return (ENOENT);
1649                 }
1650         } else {
1651                 if (here == NULL) {
1652                         TRAP_ERROR();
1653                         return (EINVAL);
1654                 }
1655                 node = here;
1656                 NG_NODE_REF(node);
1657         }
1658
1659         /*
1660          * Now follow the sequence of hooks
1661          * XXX
1662          * We actually cannot guarantee that the sequence
1663          * is not being demolished as we crawl along it
1664          * without extra-ordinary locking etc.
1665          * So this is a bit dodgy to say the least.
1666          * We can probably hold up some things by holding
1667          * the nodelist mutex for the time of this
1668          * crawl if we wanted.. At least that way we wouldn't have to
1669          * worry about the nodes disappearing, but the hooks would still
1670          * be a problem.
1671          */
1672         for (cp = path; node != NULL && *cp != '\0'; ) {
1673                 char *segment;
1674
1675                 /*
1676                  * Break out the next path segment. Replace the dot we just
1677                  * found with a NUL; "cp" points to the next segment (or the
1678                  * NUL at the end).
1679                  */
1680                 for (segment = cp; *cp != '\0'; cp++) {
1681                         if (*cp == '.') {
1682                                 *cp++ = '\0';
1683                                 break;
1684                         }
1685                 }
1686
1687                 /* Empty segment */
1688                 if (*segment == '\0')
1689                         continue;
1690
1691                 /* We have a segment, so look for a hook by that name */
1692                 hook = ng_findhook(node, segment);
1693
1694                 /* Can't get there from here... */
1695                 if (hook == NULL
1696                     || NG_HOOK_PEER(hook) == NULL
1697                     || NG_HOOK_NOT_VALID(hook)
1698                     || NG_HOOK_NOT_VALID(NG_HOOK_PEER(hook))) {
1699                         TRAP_ERROR();
1700                         NG_NODE_UNREF(node);
1701 #if 0
1702                         printf("hooknotvalid %s %s %d %d %d %d ",
1703                                         path,
1704                                         segment,
1705                                         hook == NULL,
1706                                         NG_HOOK_PEER(hook) == NULL,
1707                                         NG_HOOK_NOT_VALID(hook),
1708                                         NG_HOOK_NOT_VALID(NG_HOOK_PEER(hook)));
1709 #endif
1710                         return (ENOENT);
1711                 }
1712
1713                 /*
1714                  * Hop on over to the next node
1715                  * XXX
1716                  * Big race conditions here as hooks and nodes go away
1717                  * *** Idea.. store an ng_ID_t in each hook and use that
1718                  * instead of the direct hook in this crawl?
1719                  */
1720                 oldnode = node;
1721                 if ((node = NG_PEER_NODE(hook)))
1722                         NG_NODE_REF(node);      /* XXX RACE */
1723                 NG_NODE_UNREF(oldnode); /* XXX another race */
1724                 if (NG_NODE_NOT_VALID(node)) {
1725                         NG_NODE_UNREF(node);    /* XXX more races */
1726                         node = NULL;
1727                 }
1728         }
1729
1730         /* If node somehow missing, fail here (probably this is not needed) */
1731         if (node == NULL) {
1732                 TRAP_ERROR();
1733                 return (ENXIO);
1734         }
1735
1736         /* Done */
1737         *destp = node;
1738         if (lasthook != NULL)
1739                 *lasthook = (hook ? NG_HOOK_PEER(hook) : NULL);
1740         return (0);
1741 }
1742
1743 /*********************************************************************\
1744 * Inter-CPU node synchronization
1745 *
1746 * All activities are submitted to one of the netgraph per-CPU threads.
1747 * There is one item input queue per CPU, not one per node as in
1748 * FreeBSD.  If the item is entering netgraph for the first time, it is
1749 * queued to the thread's msgport.  Otherwise it is applied directly.
1750 * From start to finish, the item is processed on the same CPU.  Items
1751 * are distributed based on the ingress node, to keep item ordering.
1752 \***************************************************************/
1753
1754 static __inline void    ng_acquire_read(node_p node);
1755 static __inline void    ng_acquire_write(node_p node);
1756 static __inline void    ng_leave_readwrite(node_p node);
1757
1758 static __inline void
1759 ng_acquire_read(node_p node)
1760 {
1761         KASSERT(node != &ng_deadnode,
1762             ("%s: working on deadnode", __func__));
1763
1764         lwkt_gettoken_shared(&node->nd_token);
1765 }
1766
1767 /* Acquire writer lock on node. If node is busy, sleep. */
1768 static __inline void
1769 ng_acquire_write(node_p node)
1770 {
1771         KASSERT(node != &ng_deadnode,
1772             ("%s: working on deadnode", __func__));
1773
1774         lwkt_gettoken(&node->nd_token);
1775 }
1776
1777 /* Release reader or writer lock. */
1778 static __inline void
1779 ng_leave_readwrite(node_p node)
1780 {
1781         lwkt_reltoken(&node->nd_token);
1782 }
1783
1784 /***********************************************************************
1785 * Worklist routines
1786 **********************************************************************/
1787 /* NETGRAPH thread routine
1788  *
1789  * Pick an item from our thread's queue and apply it.
1790  */
1791 static void
1792 ngthread(void *dummy __unused)
1793 {
1794         lwkt_msg_t msg;
1795
1796         while ((msg = lwkt_waitport(&curthread->td_msgport, 0)) != NULL) {
1797                 item_p  item = (void *)msg;
1798
1799                 ng_apply_item(item);
1800                 /* Do not reply to the message */
1801         }
1802 }
1803
1804 /***********************************************************************
1805 * Externally visible method for sending or queueing messages or data.
1806 ***********************************************************************/
1807
1808 /*
1809  * The module code should have filled out the item correctly by this stage:
1810  * Common:
1811  *    reference to destination node.
1812  *    Reference to destination rcv hook if relevant.
1813  *    apply pointer must be or NULL or reference valid struct ng_apply_info.
1814  * Data:
1815  *    pointer to mbuf
1816  * Control_Message:
1817  *    pointer to msg.
1818  *    ID of original sender node. (return address)
1819  * Function:
1820  *    Function pointer
1821  *    void * argument
1822  *    integer argument
1823  *
1824  * The nodes have several routines and macros to help with this task:
1825  */
1826
1827 int
1828 ng_snd_item(item_p item, int flags)
1829 {
1830         hook_p hook;
1831         node_p node;
1832         int error = 0;
1833
1834         /* We are sending item, so it must be present! */
1835         KASSERT(item != NULL, ("ng_snd_item: item is NULL"));
1836
1837 #ifdef  NETGRAPH_DEBUG
1838         _ngi_check(item, __FILE__, __LINE__);
1839 #endif
1840
1841         /*
1842          * Every time an item is sent or forwarded we hold a reference on it
1843          * to postone the callback (if there is one) and item freedom.
1844          */
1845         refcount_acquire(&item->depth);
1846
1847         /*
1848          * Node is never optional.
1849          */
1850         node = NGI_NODE(item);
1851         KASSERT(node != NULL, ("ng_snd_item: node is NULL"));
1852
1853         /*
1854          * Valid hook and mbuf are mandatory for data.
1855          */
1856         hook = NGI_HOOK(item);
1857         if ((item->el_flags & NGQF_TYPE) == NGQF_DATA) {
1858                 KASSERT(hook != NULL, ("ng_snd_item: hook for data is NULL"));
1859                 if (NGI_M(item) == NULL)
1860                         ERROUT(EINVAL);
1861                 CHECK_DATA_MBUF(NGI_M(item));
1862         }
1863
1864         /*
1865          * Always queue items entering netgraph for the first time.
1866          */
1867         if (item->depth == 1) {
1868                 struct lwkt_msg *msg = &item->el_lmsg;
1869
1870                 lwkt_initmsg(msg, &ng_panic_reply_port, 0);
1871                 /* Always send to cpu0 for now */
1872                 lwkt_sendmsg(ng_cpuport(0), msg);
1873
1874                 return ((flags & NG_PROGRESS) ? EINPROGRESS : 0);
1875         }
1876
1877         /*
1878          * The item wasn't queued.  Process it synchronously.
1879          */
1880         error = ng_apply_item(item);
1881
1882 done:
1883         return (error);
1884 }
1885
1886 /*
1887  * We have an item that was possibly queued somewhere.
1888  * It should contain all the information needed
1889  * to run it on the appropriate node/hook.
1890  * If there is apply pointer and we own the last reference, call apply().
1891  */
1892 static int
1893 ng_apply_item(item_p item)
1894 {
1895         hook_p  hook;
1896         node_p  node;
1897         ng_rcvdata_t *rcvdata;
1898         ng_rcvmsg_t *rcvmsg;
1899         int     error = 0;
1900
1901         /* Node and item are never optional. */
1902         KASSERT(item != NULL, ("ng_apply_item: item is NULL"));
1903         NGI_GET_NODE(item, node);               /* zaps stored node */
1904         KASSERT(node != NULL, ("ng_apply_item: node is NULL"));
1905         NGI_GET_HOOK(item, hook);               /* clears stored hook */
1906
1907         /*
1908          * If the item or the node specifies single threading, force
1909          * writer semantics. Similarly, the node may say one hook always
1910          * produces writers. These are overrides.
1911          */
1912         if (((item->el_flags & NGQF_RW) == NGQF_WRITER) ||
1913             (node->nd_flags & NGF_FORCE_WRITER) ||
1914             (hook && (hook->hk_flags & HK_FORCE_WRITER))) {
1915                 ng_acquire_write(node);
1916         } else {
1917                 ng_acquire_read(node);
1918         }
1919
1920 #ifdef  NETGRAPH_DEBUG
1921         _ngi_check(item, __FILE__, __LINE__);
1922 #endif
1923
1924         switch (item->el_flags & NGQF_TYPE) {
1925         case NGQF_DATA:
1926                 /*
1927                  * Check things are still ok as when we were queued.
1928                  */
1929                 KASSERT(hook != NULL, ("ng_apply_item: hook for data is NULL"));
1930                 if (NG_HOOK_NOT_VALID(hook) ||
1931                     NG_NODE_NOT_VALID(node)) {
1932                         error = EIO;
1933                         NG_FREE_ITEM(item);
1934                         break;
1935                 }
1936                 /*
1937                  * If no receive method, just silently drop it.
1938                  * Give preference to the hook over-ride method
1939                  */
1940                 if ((!(rcvdata = hook->hk_rcvdata))
1941                 && (!(rcvdata = NG_HOOK_NODE(hook)->nd_type->rcvdata))) {
1942                         error = 0;
1943                         NG_FREE_ITEM(item);
1944                         break;
1945                 }
1946                 error = (*rcvdata)(hook, item);
1947                 break;
1948         case NGQF_MESG:
1949                 if (hook && NG_HOOK_NOT_VALID(hook)) {
1950                         /*
1951                          * The hook has been zapped then we can't use it.
1952                          * Immediately drop its reference.
1953                          * The message may not need it.
1954                          */
1955                         NG_HOOK_UNREF(hook);
1956                         hook = NULL;
1957                 }
1958                 /*
1959                  * Similarly, if the node is a zombie there is
1960                  * nothing we can do with it, drop everything.
1961                  */
1962                 if (NG_NODE_NOT_VALID(node)) {
1963                         TRAP_ERROR();
1964                         error = EINVAL;
1965                         NG_FREE_ITEM(item);
1966                         break;
1967                 }
1968                 /*
1969                  * Call the appropriate message handler for the object.
1970                  * It is up to the message handler to free the message.
1971                  * If it's a generic message, handle it generically,
1972                  * otherwise call the type's message handler (if it exists).
1973                  * XXX (race). Remember that a queued message may
1974                  * reference a node or hook that has just been
1975                  * invalidated. It will exist as the queue code
1976                  * is holding a reference, but..
1977                  */
1978                 if ((NGI_MSG(item)->header.typecookie == NGM_GENERIC_COOKIE) &&
1979                     ((NGI_MSG(item)->header.flags & NGF_RESP) == 0)) {
1980                         error = ng_generic_msg(node, item, hook);
1981                         break;
1982                 }
1983                 if (((!hook) || (!(rcvmsg = hook->hk_rcvmsg))) &&
1984                     (!(rcvmsg = node->nd_type->rcvmsg))) {
1985                         TRAP_ERROR();
1986                         error = 0;
1987                         NG_FREE_ITEM(item);
1988                         break;
1989                 }
1990                 error = (*rcvmsg)(node, item, hook);
1991                 break;
1992         case NGQF_FN:
1993         case NGQF_FN2:
1994                 /*
1995                  *  We have to implicitly trust the hook,
1996                  * as some of these are used for system purposes
1997                  * where the hook is invalid. In the case of
1998                  * the shutdown message we allow it to hit
1999                  * even if the node is invalid.
2000                  */
2001                 if ((NG_NODE_NOT_VALID(node))
2002                 && (NGI_FN(item) != &ng_rmnode)) {
2003                         TRAP_ERROR();
2004                         error = EINVAL;
2005                         NG_FREE_ITEM(item);
2006                         break;
2007                 }
2008                 if ((item->el_flags & NGQF_TYPE) == NGQF_FN) {
2009                         (*NGI_FN(item))(node, hook, NGI_ARG1(item),
2010                             NGI_ARG2(item));
2011                         NG_FREE_ITEM(item);
2012                 } else  /* it is NGQF_FN2 */
2013                         error = (*NGI_FN2(item))(node, item, hook);
2014                 break;
2015         }
2016         /*
2017          * We held references on some of the resources
2018          * that we took from the item. Now that we have
2019          * finished doing everything, drop those references.
2020          */
2021         if (hook)
2022                 NG_HOOK_UNREF(hook);
2023
2024         /* Release our node's token */
2025         ng_leave_readwrite(node);
2026
2027         /* Free the item if we own the last reference to it. */
2028         if (refcount_release(&item->depth)) {
2029                 ng_check_apply(item, error);
2030                 ng_free_item(item);
2031         }
2032         NG_NODE_UNREF(node);
2033
2034         return (error);
2035 }
2036
2037 /***********************************************************************
2038  * Implement the 'generic' control messages
2039  ***********************************************************************/
2040 static int
2041 ng_generic_msg(node_p here, item_p item, hook_p lasthook)
2042 {
2043         int error = 0;
2044         struct ng_mesg *msg;
2045         struct ng_mesg *resp = NULL;
2046
2047         NGI_GET_MSG(item, msg);
2048         if (msg->header.typecookie != NGM_GENERIC_COOKIE) {
2049                 TRAP_ERROR();
2050                 error = EINVAL;
2051                 goto out;
2052         }
2053         switch (msg->header.cmd) {
2054         case NGM_SHUTDOWN:
2055                 ng_rmnode(here, NULL, NULL, 0);
2056                 break;
2057         case NGM_MKPEER:
2058             {
2059                 struct ngm_mkpeer *const mkp = (struct ngm_mkpeer *) msg->data;
2060
2061                 if (msg->header.arglen != sizeof(*mkp)) {
2062                         TRAP_ERROR();
2063                         error = EINVAL;
2064                         break;
2065                 }
2066                 mkp->type[sizeof(mkp->type) - 1] = '\0';
2067                 mkp->ourhook[sizeof(mkp->ourhook) - 1] = '\0';
2068                 mkp->peerhook[sizeof(mkp->peerhook) - 1] = '\0';
2069                 error = ng_mkpeer(here, mkp->ourhook, mkp->peerhook, mkp->type);
2070                 break;
2071             }
2072         case NGM_CONNECT:
2073             {
2074                 struct ngm_connect *const con =
2075                         (struct ngm_connect *) msg->data;
2076                 node_p node2;
2077
2078                 if (msg->header.arglen != sizeof(*con)) {
2079                         TRAP_ERROR();
2080                         error = EINVAL;
2081                         break;
2082                 }
2083                 con->path[sizeof(con->path) - 1] = '\0';
2084                 con->ourhook[sizeof(con->ourhook) - 1] = '\0';
2085                 con->peerhook[sizeof(con->peerhook) - 1] = '\0';
2086                 /* Don't forget we get a reference.. */
2087                 error = ng_path2noderef(here, con->path, &node2, NULL);
2088                 if (error)
2089                         break;
2090                 error = ng_con_nodes(item, here, con->ourhook,
2091                     node2, con->peerhook);
2092                 NG_NODE_UNREF(node2);
2093                 break;
2094             }
2095         case NGM_NAME:
2096             {
2097                 struct ngm_name *const nam = (struct ngm_name *) msg->data;
2098
2099                 if (msg->header.arglen != sizeof(*nam)) {
2100                         TRAP_ERROR();
2101                         error = EINVAL;
2102                         break;
2103                 }
2104                 nam->name[sizeof(nam->name) - 1] = '\0';
2105                 error = ng_name_node(here, nam->name);
2106                 break;
2107             }
2108         case NGM_RMHOOK:
2109             {
2110                 struct ngm_rmhook *const rmh = (struct ngm_rmhook *) msg->data;
2111                 hook_p hook;
2112
2113                 if (msg->header.arglen != sizeof(*rmh)) {
2114                         TRAP_ERROR();
2115                         error = EINVAL;
2116                         break;
2117                 }
2118                 rmh->ourhook[sizeof(rmh->ourhook) - 1] = '\0';
2119                 if ((hook = ng_findhook(here, rmh->ourhook)) != NULL)
2120                         ng_destroy_hook(hook);
2121                 break;
2122             }
2123         case NGM_NODEINFO:
2124             {
2125                 struct nodeinfo *ni;
2126
2127                 NG_MKRESPONSE(resp, msg, sizeof(*ni), M_WAITOK | M_NULLOK);
2128                 if (resp == NULL) {
2129                         error = ENOMEM;
2130                         break;
2131                 }
2132
2133                 /* Fill in node info */
2134                 ni = (struct nodeinfo *) resp->data;
2135                 if (NG_NODE_HAS_NAME(here))
2136                         strcpy(ni->name, NG_NODE_NAME(here));
2137                 strcpy(ni->type, here->nd_type->name);
2138                 ni->id = ng_node2ID(here);
2139                 ni->hooks = here->nd_numhooks;
2140                 break;
2141             }
2142         case NGM_LISTHOOKS:
2143             {
2144                 const int nhooks = here->nd_numhooks;
2145                 struct hooklist *hl;
2146                 struct nodeinfo *ni;
2147                 hook_p hook;
2148
2149                 /* Get response struct */
2150                 NG_MKRESPONSE(resp, msg, sizeof(*hl)
2151                     + (nhooks * sizeof(struct linkinfo)), M_WAITOK | M_NULLOK);
2152                 if (resp == NULL) {
2153                         error = ENOMEM;
2154                         break;
2155                 }
2156                 hl = (struct hooklist *) resp->data;
2157                 ni = &hl->nodeinfo;
2158
2159                 /* Fill in node info */
2160                 if (NG_NODE_HAS_NAME(here))
2161                         strcpy(ni->name, NG_NODE_NAME(here));
2162                 strcpy(ni->type, here->nd_type->name);
2163                 ni->id = ng_node2ID(here);
2164
2165                 /* Cycle through the linked list of hooks */
2166                 ni->hooks = 0;
2167                 LIST_FOREACH(hook, &here->nd_hooks, hk_hooks) {
2168                         struct linkinfo *const link = &hl->link[ni->hooks];
2169
2170                         if (ni->hooks >= nhooks) {
2171                                 log(LOG_ERR, "%s: number of %s changed\n",
2172                                     __func__, "hooks");
2173                                 break;
2174                         }
2175                         if (NG_HOOK_NOT_VALID(hook))
2176                                 continue;
2177                         strcpy(link->ourhook, NG_HOOK_NAME(hook));
2178                         strcpy(link->peerhook, NG_PEER_HOOK_NAME(hook));
2179                         if (NG_PEER_NODE_NAME(hook)[0] != '\0')
2180                                 strcpy(link->nodeinfo.name,
2181                                     NG_PEER_NODE_NAME(hook));
2182                         strcpy(link->nodeinfo.type,
2183                            NG_PEER_NODE(hook)->nd_type->name);
2184                         link->nodeinfo.id = ng_node2ID(NG_PEER_NODE(hook));
2185                         link->nodeinfo.hooks = NG_PEER_NODE(hook)->nd_numhooks;
2186                         ni->hooks++;
2187                 }
2188                 break;
2189             }
2190
2191         case NGM_LISTNAMES:
2192         case NGM_LISTNODES:
2193             {
2194                 const int unnamed = (msg->header.cmd == NGM_LISTNODES);
2195                 struct namelist *nl;
2196                 node_p node;
2197                 int num = 0, i;
2198
2199                 mtx_lock(&ng_namehash_mtx);
2200                 /* Count number of nodes */
2201                 for (i = 0; i < NG_NAME_HASH_SIZE; i++) {
2202                         LIST_FOREACH(node, &ng_name_hash[i], nd_nodes) {
2203                                 if (NG_NODE_IS_VALID(node) &&
2204                                     (unnamed || NG_NODE_HAS_NAME(node))) {
2205                                         num++;
2206                                 }
2207                         }
2208                 }
2209                 mtx_unlock(&ng_namehash_mtx);
2210
2211                 /* Get response struct */
2212                 NG_MKRESPONSE(resp, msg, sizeof(*nl)
2213                     + (num * sizeof(struct nodeinfo)), M_WAITOK | M_NULLOK);
2214                 if (resp == NULL) {
2215                         error = ENOMEM;
2216                         break;
2217                 }
2218                 nl = (struct namelist *) resp->data;
2219
2220                 /* Cycle through the linked list of nodes */
2221                 nl->numnames = 0;
2222                 mtx_lock(&ng_namehash_mtx);
2223                 for (i = 0; i < NG_NAME_HASH_SIZE; i++) {
2224                         LIST_FOREACH(node, &ng_name_hash[i], nd_nodes) {
2225                                 struct nodeinfo *const np =
2226                                     &nl->nodeinfo[nl->numnames];
2227
2228                                 if (NG_NODE_NOT_VALID(node))
2229                                         continue;
2230                                 if (!unnamed && (! NG_NODE_HAS_NAME(node)))
2231                                         continue;
2232                                 if (nl->numnames >= num) {
2233                                         log(LOG_ERR, "%s: number of nodes changed\n",
2234                                             __func__);
2235                                         break;
2236                                 }
2237                                 if (NG_NODE_HAS_NAME(node))
2238                                         strcpy(np->name, NG_NODE_NAME(node));
2239                                 strcpy(np->type, node->nd_type->name);
2240                                 np->id = ng_node2ID(node);
2241                                 np->hooks = node->nd_numhooks;
2242                                 nl->numnames++;
2243                         }
2244                 }
2245                 mtx_unlock(&ng_namehash_mtx);
2246                 break;
2247             }
2248
2249         case NGM_LISTTYPES:
2250             {
2251                 struct typelist *tl;
2252                 struct ng_type *type;
2253                 int num = 0;
2254
2255                 mtx_lock(&ng_typelist_mtx);
2256                 /* Count number of types */
2257                 LIST_FOREACH(type, &ng_typelist, types) {
2258                         num++;
2259                 }
2260                 mtx_unlock(&ng_typelist_mtx);
2261
2262                 /* Get response struct */
2263                 NG_MKRESPONSE(resp, msg, sizeof(*tl)
2264                     + (num * sizeof(struct typeinfo)), M_WAITOK | M_NULLOK);
2265                 if (resp == NULL) {
2266                         error = ENOMEM;
2267                         break;
2268                 }
2269                 tl = (struct typelist *) resp->data;
2270
2271                 /* Cycle through the linked list of types */
2272                 tl->numtypes = 0;
2273                 mtx_lock(&ng_typelist_mtx);
2274                 LIST_FOREACH(type, &ng_typelist, types) {
2275                         struct typeinfo *const tp = &tl->typeinfo[tl->numtypes];
2276
2277                         if (tl->numtypes >= num) {
2278                                 log(LOG_ERR, "%s: number of %s changed\n",
2279                                     __func__, "types");
2280                                 break;
2281                         }
2282                         strcpy(tp->type_name, type->name);
2283                         tp->numnodes = type->refs - 1; /* don't count list */
2284                         tl->numtypes++;
2285                 }
2286                 mtx_unlock(&ng_typelist_mtx);
2287                 break;
2288             }
2289
2290         case NGM_BINARY2ASCII:
2291             {
2292                 int bufSize = 20 * 1024;        /* XXX hard coded constant */
2293                 const struct ng_parse_type *argstype;
2294                 const struct ng_cmdlist *c;
2295                 struct ng_mesg *binary, *ascii;
2296
2297                 /* Data area must contain a valid netgraph message */
2298                 binary = (struct ng_mesg *)msg->data;
2299                 if (msg->header.arglen < sizeof(struct ng_mesg) ||
2300                     (msg->header.arglen - sizeof(struct ng_mesg) <
2301                     binary->header.arglen)) {
2302                         TRAP_ERROR();
2303                         error = EINVAL;
2304                         break;
2305                 }
2306
2307                 /* Get a response message with lots of room */
2308                 NG_MKRESPONSE(resp, msg, sizeof(*ascii) + bufSize, M_WAITOK | M_NULLOK);
2309                 if (resp == NULL) {
2310                         error = ENOMEM;
2311                         break;
2312                 }
2313                 ascii = (struct ng_mesg *)resp->data;
2314
2315                 /* Copy binary message header to response message payload */
2316                 bcopy(binary, ascii, sizeof(*binary));
2317
2318                 /* Find command by matching typecookie and command number */
2319                 for (c = here->nd_type->cmdlist;
2320                     c != NULL && c->name != NULL; c++) {
2321                         if (binary->header.typecookie == c->cookie
2322                             && binary->header.cmd == c->cmd)
2323                                 break;
2324                 }
2325                 if (c == NULL || c->name == NULL) {
2326                         for (c = ng_generic_cmds; c->name != NULL; c++) {
2327                                 if (binary->header.typecookie == c->cookie
2328                                     && binary->header.cmd == c->cmd)
2329                                         break;
2330                         }
2331                         if (c->name == NULL) {
2332                                 NG_FREE_MSG(resp);
2333                                 error = ENOSYS;
2334                                 break;
2335                         }
2336                 }
2337
2338                 /* Convert command name to ASCII */
2339                 snprintf(ascii->header.cmdstr, sizeof(ascii->header.cmdstr),
2340                     "%s", c->name);
2341
2342                 /* Convert command arguments to ASCII */
2343                 argstype = (binary->header.flags & NGF_RESP) ?
2344                     c->respType : c->mesgType;
2345                 if (argstype == NULL) {
2346                         *ascii->data = '\0';
2347                 } else {
2348                         if ((error = ng_unparse(argstype,
2349                             (u_char *)binary->data,
2350                             ascii->data, bufSize)) != 0) {
2351                                 NG_FREE_MSG(resp);
2352                                 break;
2353                         }
2354                 }
2355
2356                 /* Return the result as struct ng_mesg plus ASCII string */
2357                 bufSize = strlen(ascii->data) + 1;
2358                 ascii->header.arglen = bufSize;
2359                 resp->header.arglen = sizeof(*ascii) + bufSize;
2360                 break;
2361             }
2362
2363         case NGM_ASCII2BINARY:
2364             {
2365                 int bufSize = 2000;     /* XXX hard coded constant */
2366                 const struct ng_cmdlist *c;
2367                 const struct ng_parse_type *argstype;
2368                 struct ng_mesg *ascii, *binary;
2369                 int off = 0;
2370
2371                 /* Data area must contain at least a struct ng_mesg + '\0' */
2372                 ascii = (struct ng_mesg *)msg->data;
2373                 if ((msg->header.arglen < sizeof(*ascii) + 1) ||
2374                     (ascii->header.arglen < 1) ||
2375                     (msg->header.arglen < sizeof(*ascii) +
2376                     ascii->header.arglen)) {
2377                         TRAP_ERROR();
2378                         error = EINVAL;
2379                         break;
2380                 }
2381                 ascii->data[ascii->header.arglen - 1] = '\0';
2382
2383                 /* Get a response message with lots of room */
2384                 NG_MKRESPONSE(resp, msg, sizeof(*binary) + bufSize, M_WAITOK | M_NULLOK);
2385                 if (resp == NULL) {
2386                         error = ENOMEM;
2387                         break;
2388                 }
2389                 binary = (struct ng_mesg *)resp->data;
2390
2391                 /* Copy ASCII message header to response message payload */
2392                 bcopy(ascii, binary, sizeof(*ascii));
2393
2394                 /* Find command by matching ASCII command string */
2395                 for (c = here->nd_type->cmdlist;
2396                     c != NULL && c->name != NULL; c++) {
2397                         if (strcmp(ascii->header.cmdstr, c->name) == 0)
2398                                 break;
2399                 }
2400                 if (c == NULL || c->name == NULL) {
2401                         for (c = ng_generic_cmds; c->name != NULL; c++) {
2402                                 if (strcmp(ascii->header.cmdstr, c->name) == 0)
2403                                         break;
2404                         }
2405                         if (c->name == NULL) {
2406                                 NG_FREE_MSG(resp);
2407                                 error = ENOSYS;
2408                                 break;
2409                         }
2410                 }
2411
2412                 /* Convert command name to binary */
2413                 binary->header.cmd = c->cmd;
2414                 binary->header.typecookie = c->cookie;
2415
2416                 /* Convert command arguments to binary */
2417                 argstype = (binary->header.flags & NGF_RESP) ?
2418                     c->respType : c->mesgType;
2419                 if (argstype == NULL) {
2420                         bufSize = 0;
2421                 } else {
2422                         if ((error = ng_parse(argstype, ascii->data,
2423                             &off, (u_char *)binary->data, &bufSize)) != 0) {
2424                                 NG_FREE_MSG(resp);
2425                                 break;
2426                         }
2427                 }
2428
2429                 /* Return the result */
2430                 binary->header.arglen = bufSize;
2431                 resp->header.arglen = sizeof(*binary) + bufSize;
2432                 break;
2433             }
2434
2435         case NGM_TEXT_CONFIG:
2436         case NGM_TEXT_STATUS:
2437                 /*
2438                  * This one is tricky as it passes the command down to the
2439                  * actual node, even though it is a generic type command.
2440                  * This means we must assume that the item/msg is already freed
2441                  * when control passes back to us.
2442                  */
2443                 if (here->nd_type->rcvmsg != NULL) {
2444                         NGI_MSG(item) = msg; /* put it back as we found it */
2445                         return((*here->nd_type->rcvmsg)(here, item, lasthook));
2446                 }
2447                 /* Fall through if rcvmsg not supported */
2448         default:
2449                 TRAP_ERROR();
2450                 error = EINVAL;
2451         }
2452         /*
2453          * Sometimes a generic message may be statically allocated
2454          * to avoid problems with allocating when in tight memeory situations.
2455          * Don't free it if it is so.
2456          * I break them appart here, because erros may cause a free if the item
2457          * in which case we'd be doing it twice.
2458          * they are kept together above, to simplify freeing.
2459          */
2460 out:
2461         NG_RESPOND_MSG(error, here, item, resp);
2462         if (msg)
2463                 NG_FREE_MSG(msg);
2464         return (error);
2465 }
2466
2467 /************************************************************************
2468                         Queue element get/free routines
2469 ************************************************************************/
2470
2471 static struct objcache  *ng_oc;
2472 static struct objcache  *ng_apply_oc;
2473 static int               maxalloc = 4096; /* limit the damage of a leak */
2474
2475 TUNABLE_INT("net.graph.maxalloc", &maxalloc);
2476 SYSCTL_INT(_net_graph, OID_AUTO, maxalloc, CTLFLAG_RD, &maxalloc,
2477     0, "Maximum number of queue items to allocate");
2478
2479 #ifdef  NETGRAPH_DEBUG
2480 static TAILQ_HEAD(, ng_item) ng_itemlist = TAILQ_HEAD_INITIALIZER(ng_itemlist);
2481 static int                      allocated;      /* number of items malloc'd */
2482 #endif
2483
2484 /*
2485  * Get a queue entry.
2486  * This is usually called when a packet first enters netgraph.
2487  * By definition, this is usually from an interrupt, or from a user.
2488  * Users are not so important, but try be quick for the times that it's
2489  * an interrupt.
2490  */
2491 static __inline item_p
2492 ng_alloc_item(int type, int flags)
2493 {
2494         item_p item;
2495
2496         KASSERT(((type & ~NGQF_TYPE) == 0),
2497             ("%s: incorrect item type: %d", __func__, type));
2498
2499         item = objcache_get(ng_oc,
2500             (flags & NG_WAITOK) ? M_WAITOK : M_NOWAIT );
2501
2502         if (item) {
2503                 item->el_flags = type;
2504 #ifdef  NETGRAPH_DEBUG
2505                 mtx_lock(&ngq_mtx);
2506                 TAILQ_INSERT_TAIL(&ng_itemlist, item, all);
2507                 allocated++;
2508                 mtx_unlock(&ngq_mtx);
2509 #endif
2510         }
2511
2512         return (item);
2513 }
2514
2515 /*
2516  * Release a queue entry
2517  */
2518 void
2519 ng_free_item(item_p item)
2520 {
2521         /*
2522          * If the item still has an apply callback registered, it is
2523          * being freed too early.
2524          */
2525         KASSERT(item->apply == NULL, ("freeing item with registered callback"));
2526
2527         /*
2528          * The item may hold resources on it's own. We need to free
2529          * these before we can free the item. What they are depends upon
2530          * what kind of item it is. it is important that nodes zero
2531          * out pointers to resources that they remove from the item
2532          * or we release them again here.
2533          */
2534         switch (item->el_flags & NGQF_TYPE) {
2535         case NGQF_DATA:
2536                 /* If we have an mbuf still attached.. */
2537                 NG_FREE_M(_NGI_M(item));
2538                 break;
2539         case NGQF_MESG:
2540                 _NGI_RETADDR(item) = 0;
2541                 NG_FREE_MSG(_NGI_MSG(item));
2542                 break;
2543         case NGQF_FN:
2544         case NGQF_FN2:
2545                 /* nothing to free really, */
2546                 _NGI_FN(item) = NULL;
2547                 _NGI_ARG1(item) = NULL;
2548                 _NGI_ARG2(item) = 0;
2549                 break;
2550         }
2551         /* If we still have a node or hook referenced... */
2552         _NGI_CLR_NODE(item);
2553         _NGI_CLR_HOOK(item);
2554
2555 #ifdef  NETGRAPH_DEBUG
2556         mtx_lock(&ngq_mtx);
2557         TAILQ_REMOVE(&ng_itemlist, item, all);
2558         allocated--;
2559         mtx_unlock(&ngq_mtx);
2560 #endif
2561         /* Object must be initialized before returning to objcache */
2562         bzero(item, sizeof(struct ng_item));
2563         objcache_put(ng_oc, item);
2564 }
2565
2566 /*
2567  * Change type of the queue entry.
2568  */
2569 static __inline item_p
2570 ng_realloc_item(item_p item, int type, int flags)
2571 {
2572
2573         KASSERT((item != NULL), ("%s: can't reallocate NULL", __func__));
2574         KASSERT(((type & ~NGQF_TYPE) == 0),
2575             ("%s: incorrect item type: %d", __func__, type));
2576
2577         item->el_flags = (item->el_flags & ~NGQF_TYPE) | type;
2578
2579         return (item);
2580 }
2581
2582 __inline apply_p
2583 ng_alloc_apply(void)
2584 {
2585         return (objcache_get(ng_apply_oc, M_WAITOK));
2586 }
2587
2588 __inline void
2589 ng_free_apply(apply_p apply)
2590 {
2591         objcache_put(ng_apply_oc, apply);
2592 }
2593
2594 static void
2595 ng_check_apply(item_p item, int error)
2596 {
2597         if (item->apply == NULL)
2598                 return;
2599
2600         KKASSERT(item->apply->apply != NULL);
2601         (*item->apply->apply)(item->apply->context, error);
2602         ng_free_apply(item->apply);
2603         item->apply = NULL;
2604 }
2605
2606 /************************************************************************
2607                         Module routines
2608 ************************************************************************/
2609
2610 /*
2611  * Handle the loading/unloading of a netgraph node type module
2612  */
2613 int
2614 ng_mod_event(module_t mod, int event, void *data)
2615 {
2616         struct ng_type *const type = data;
2617         int error = 0;
2618
2619         switch (event) {
2620         case MOD_LOAD:
2621
2622                 /* Register new netgraph node type */
2623                 crit_enter();
2624                 if ((error = ng_newtype(type)) != 0) {
2625                         crit_exit();
2626                         break;
2627                 }
2628
2629                 /* Call type specific code */
2630                 if (type->mod_event != NULL)
2631                         if ((error = (*type->mod_event)(mod, event, data))) {
2632                                 mtx_lock(&ng_typelist_mtx);
2633                                 type->refs--;   /* undo it */
2634                                 LIST_REMOVE(type, types);
2635                                 mtx_unlock(&ng_typelist_mtx);
2636                         }
2637                 crit_exit();
2638                 break;
2639
2640         case MOD_UNLOAD:
2641                 crit_enter();
2642                 if (type->refs > 1) {           /* make sure no nodes exist! */
2643                         error = EBUSY;
2644                 } else {
2645                         if (type->refs == 0) {
2646                                 /* failed load, nothing to undo */
2647                                 crit_exit();
2648                                 break;
2649                         }
2650                         if (type->mod_event != NULL) {  /* check with type */
2651                                 error = (*type->mod_event)(mod, event, data);
2652                                 if (error != 0) {       /* type refuses.. */
2653                                         crit_exit();
2654                                         break;
2655                                 }
2656                         }
2657                         mtx_lock(&ng_typelist_mtx);
2658                         LIST_REMOVE(type, types);
2659                         mtx_unlock(&ng_typelist_mtx);
2660                 }
2661                 crit_exit();
2662                 break;
2663
2664         default:
2665                 if (type->mod_event != NULL)
2666                         error = (*type->mod_event)(mod, event, data);
2667                 else
2668                         error = EOPNOTSUPP;             /* XXX ? */
2669                 break;
2670         }
2671         return (error);
2672 }
2673
2674 /*
2675  * Handle loading and unloading for this code.
2676  */
2677 static int
2678 ngb_mod_event(module_t mod, int event, void *data)
2679 {
2680         int i, error = 0;
2681
2682         switch (event) {
2683         case MOD_LOAD:
2684                 /* Initialize everything. */
2685                 lwkt_initport_panic(&ng_panic_reply_port);
2686                 for (i = 0; i < ncpus; ++i) {
2687                         thread_t td;
2688
2689                         lwkt_create(ngthread, NULL, &td,
2690                            NULL, 0, i, "netgraph %d", i);
2691                         ng_msgport[i] = &td->td_msgport;
2692                 }
2693                 mtx_init(&ng_typelist_mtx);
2694                 mtx_init(&ng_idhash_mtx);
2695                 mtx_init(&ng_namehash_mtx);
2696                 mtx_init(&ng_topo_mtx);
2697 #ifdef  NETGRAPH_DEBUG
2698                 mtx_init(&ng_nodelist_mtx);
2699                 mtx_init(&ngq_mtx);
2700 #endif
2701                 ng_oc = objcache_create_mbacked(M_NETGRAPH,
2702                             sizeof(struct ng_item), maxalloc, 0, bzero_ctor,
2703                             NULL, NULL);
2704                 ng_apply_oc = objcache_create_mbacked(M_NETGRAPH_APPLY,
2705                     sizeof(struct ng_apply_info), 0, 0, bzero_ctor, NULL, NULL);
2706                 break;
2707         case MOD_UNLOAD:
2708 #if 0
2709                 /* Destroy the lwkt threads too */
2710                 objcache_destroy(ng_apply_oc);
2711 #endif
2712                 /* You can't unload it because an interface may be using it. */
2713                 error = EBUSY;
2714                 break;
2715         default:
2716                 error = EOPNOTSUPP;
2717                 break;
2718         }
2719         return (error);
2720 }
2721
2722 static moduledata_t netgraph_mod = {
2723         "netgraph",
2724         ngb_mod_event,
2725         (NULL)
2726 };
2727 DECLARE_MODULE(netgraph, netgraph_mod, SI_SUB_NETGRAPH, SI_ORDER_MIDDLE);
2728 SYSCTL_NODE(_net, OID_AUTO, graph, CTLFLAG_RW, 0, "netgraph Family");
2729 SYSCTL_INT(_net_graph, OID_AUTO, abi_version, CTLFLAG_RD, 0, NG_ABI_VERSION,"");
2730 SYSCTL_INT(_net_graph, OID_AUTO, msg_version, CTLFLAG_RD, 0, NG_VERSION, "");
2731
2732 #ifdef  NETGRAPH_DEBUG
2733 void
2734 dumphook (hook_p hook, char *file, int line)
2735 {
2736         printf("hook: name %s, %d refs, Last touched:\n",
2737                 _NG_HOOK_NAME(hook), hook->hk_refs);
2738         printf("        Last active @ %s, line %d\n",
2739                 hook->lastfile, hook->lastline);
2740         if (line) {
2741                 printf(" problem discovered at file %s, line %d\n", file, line);
2742         }
2743 }
2744
2745 void
2746 dumpnode(node_p node, char *file, int line)
2747 {
2748         printf("node: ID [%x]: type '%s', %d hooks, flags 0x%x, %d refs, %s:\n",
2749                 _NG_NODE_ID(node), node->nd_type->name,
2750                 node->nd_numhooks, node->nd_flags,
2751                 node->nd_refs, node->nd_name);
2752         printf("        Last active @ %s, line %d\n",
2753                 node->lastfile, node->lastline);
2754         if (line) {
2755                 printf(" problem discovered at file %s, line %d\n", file, line);
2756         }
2757 }
2758
2759 void
2760 dumpitem(item_p item, char *file, int line)
2761 {
2762         printf(" ACTIVE item, last used at %s, line %d",
2763                 item->lastfile, item->lastline);
2764         switch(item->el_flags & NGQF_TYPE) {
2765         case NGQF_DATA:
2766                 printf(" - [data]\n");
2767                 break;
2768         case NGQF_MESG:
2769                 printf(" - retaddr[%d]:\n", _NGI_RETADDR(item));
2770                 break;
2771         case NGQF_FN:
2772                 printf(" - fn@%p (%p, %p, %p, %d (%x))\n",
2773                         _NGI_FN(item),
2774                         _NGI_NODE(item),
2775                         _NGI_HOOK(item),
2776                         item->body.fn.fn_arg1,
2777                         item->body.fn.fn_arg2,
2778                         item->body.fn.fn_arg2);
2779                 break;
2780         case NGQF_FN2:
2781                 printf(" - fn2@%p (%p, %p, %p, %d (%x))\n",
2782                         _NGI_FN2(item),
2783                         _NGI_NODE(item),
2784                         _NGI_HOOK(item),
2785                         item->body.fn.fn_arg1,
2786                         item->body.fn.fn_arg2,
2787                         item->body.fn.fn_arg2);
2788                 break;
2789         }
2790         if (line) {
2791                 printf(" problem discovered at file %s, line %d\n", file, line);
2792                 if (_NGI_NODE(item)) {
2793                         printf("node %p ([%x])\n",
2794                                 _NGI_NODE(item), ng_node2ID(_NGI_NODE(item)));
2795                 }
2796         }
2797 }
2798
2799 static void
2800 ng_dumpitems(void)
2801 {
2802         item_p item;
2803         int i = 1;
2804         TAILQ_FOREACH(item, &ng_itemlist, all) {
2805                 printf("[%d] ", i++);
2806                 dumpitem(item, NULL, 0);
2807         }
2808 }
2809
2810 static void
2811 ng_dumpnodes(void)
2812 {
2813         node_p node;
2814         int i = 1;
2815         mtx_lock(&ng_nodelist_mtx);
2816         SLIST_FOREACH(node, &ng_allnodes, nd_all) {
2817                 printf("[%d] ", i++);
2818                 dumpnode(node, NULL, 0);
2819         }
2820         mtx_unlock(&ng_nodelist_mtx);
2821 }
2822
2823 static void
2824 ng_dumphooks(void)
2825 {
2826         hook_p hook;
2827         int i = 1;
2828         mtx_lock(&ng_nodelist_mtx);
2829         SLIST_FOREACH(hook, &ng_allhooks, hk_all) {
2830                 printf("[%d] ", i++);
2831                 dumphook(hook, NULL, 0);
2832         }
2833         mtx_unlock(&ng_nodelist_mtx);
2834 }
2835
2836 static int
2837 sysctl_debug_ng_dump_items(SYSCTL_HANDLER_ARGS)
2838 {
2839         int error;
2840         int val;
2841
2842         val = allocated;
2843         error = sysctl_handle_int(oidp, &val, 0, req);
2844         if (error != 0 || req->newptr == NULL)
2845                 return (error);
2846         if (val == 42) {
2847                 ng_dumpitems();
2848                 ng_dumpnodes();
2849                 ng_dumphooks();
2850         }
2851         return (0);
2852 }
2853
2854 SYSCTL_PROC(_debug, OID_AUTO, ng_dump_items, CTLTYPE_INT | CTLFLAG_RW,
2855     0, sizeof(int), sysctl_debug_ng_dump_items, "I", "Number of allocated items");
2856 #endif  /* NETGRAPH_DEBUG */
2857
2858
2859 /***********************************************************************
2860 * Externally useable functions to set up a queue item ready for sending
2861 ***********************************************************************/
2862
2863 #ifdef  NETGRAPH_DEBUG
2864 #define ITEM_DEBUG_CHECKS                                               \
2865         do {                                                            \
2866                 if (NGI_NODE(item) ) {                                  \
2867                         printf("item already has node");                \
2868                         kdb_enter(KDB_WHY_NETGRAPH, "has node");        \
2869                         NGI_CLR_NODE(item);                             \
2870                 }                                                       \
2871                 if (NGI_HOOK(item) ) {                                  \
2872                         printf("item already has hook");                \
2873                         kdb_enter(KDB_WHY_NETGRAPH, "has hook");        \
2874                         NGI_CLR_HOOK(item);                             \
2875                 }                                                       \
2876         } while (0)
2877 #else
2878 #define ITEM_DEBUG_CHECKS
2879 #endif
2880
2881 /*
2882  * Put mbuf into the item.
2883  * Hook and node references will be removed when the item is dequeued.
2884  * (or equivalent)
2885  * (XXX) Unsafe because no reference held by peer on remote node.
2886  * remote node might go away in this timescale.
2887  * We know the hooks can't go away because that would require getting
2888  * a writer item on both nodes and we must have at least a  reader
2889  * here to be able to do this.
2890  * Note that the hook loaded is the REMOTE hook.
2891  *
2892  * This is possibly in the critical path for new data.
2893  */
2894 item_p
2895 ng_package_data(struct mbuf *m, int flags)
2896 {
2897         item_p item;
2898
2899         if ((item = ng_alloc_item(NGQF_DATA, flags)) == NULL) {
2900                 NG_FREE_M(m);
2901                 return (NULL);
2902         }
2903         ITEM_DEBUG_CHECKS;
2904         item->el_flags |= NGQF_READER;
2905         NGI_M(item) = m;
2906         return (item);
2907 }
2908
2909 /*
2910  * Allocate a queue item and put items into it..
2911  * Evaluate the address as this will be needed to queue it and
2912  * to work out what some of the fields should be.
2913  * Hook and node references will be removed when the item is dequeued.
2914  * (or equivalent)
2915  */
2916 item_p
2917 ng_package_msg(struct ng_mesg *msg, int flags)
2918 {
2919         item_p item;
2920
2921         if ((item = ng_alloc_item(NGQF_MESG, flags)) == NULL) {
2922                 NG_FREE_MSG(msg);
2923                 return (NULL);
2924         }
2925         ITEM_DEBUG_CHECKS;
2926         /* Messages items count as writers unless explicitly exempted. */
2927         if (msg->header.cmd & NGM_READONLY)
2928                 item->el_flags |= NGQF_READER;
2929         else
2930                 item->el_flags |= NGQF_WRITER;
2931         /*
2932          * Set the current lasthook into the queue item
2933          */
2934         NGI_MSG(item) = msg;
2935         NGI_RETADDR(item) = 0;
2936         return (item);
2937 }
2938
2939
2940
2941 #define SET_RETADDR(item, here, retaddr)                                \
2942         do {    /* Data or fn items don't have retaddrs */              \
2943                 if ((item->el_flags & NGQF_TYPE) == NGQF_MESG) {        \
2944                         if (retaddr) {                                  \
2945                                 NGI_RETADDR(item) = retaddr;            \
2946                         } else {                                        \
2947                                 /*                                      \
2948                                  * The old return address should be ok. \
2949                                  * If there isn't one, use the address  \
2950                                  * here.                                \
2951                                  */                                     \
2952                                 if (NGI_RETADDR(item) == 0) {           \
2953                                         NGI_RETADDR(item)               \
2954                                                 = ng_node2ID(here);     \
2955                                 }                                       \
2956                         }                                               \
2957                 }                                                       \
2958         } while (0)
2959
2960 int
2961 ng_address_hook(node_p here, item_p item, hook_p hook, ng_ID_t retaddr)
2962 {
2963         hook_p peer;
2964         node_p peernode;
2965         ITEM_DEBUG_CHECKS;
2966         /*
2967          * Quick sanity check..
2968          * Since a hook holds a reference on it's node, once we know
2969          * that the peer is still connected (even if invalid,) we know
2970          * that the peer node is present, though maybe invalid.
2971          */
2972         if ((hook == NULL) ||
2973             NG_HOOK_NOT_VALID(hook) ||
2974             NG_HOOK_NOT_VALID(peer = NG_HOOK_PEER(hook)) ||
2975             NG_NODE_NOT_VALID(peernode = NG_PEER_NODE(hook))) {
2976                 NG_FREE_ITEM(item);
2977                 TRAP_ERROR();
2978                 return (ENETDOWN);
2979         }
2980
2981         /*
2982          * Transfer our interest to the other (peer) end.
2983          */
2984         NG_HOOK_REF(peer);
2985         NG_NODE_REF(peernode);
2986         NGI_SET_HOOK(item, peer);
2987         NGI_SET_NODE(item, peernode);
2988         SET_RETADDR(item, here, retaddr);
2989         return (0);
2990 }
2991
2992 int
2993 ng_address_path(node_p here, item_p item, char *address, ng_ID_t retaddr)
2994 {
2995         node_p  dest = NULL;
2996         hook_p  hook = NULL;
2997         int     error;
2998
2999         ITEM_DEBUG_CHECKS;
3000         /*
3001          * Note that ng_path2noderef increments the reference count
3002          * on the node for us if it finds one. So we don't have to.
3003          */
3004         error = ng_path2noderef(here, address, &dest, &hook);
3005         if (error) {
3006                 NG_FREE_ITEM(item);
3007                 return (error);
3008         }
3009         NGI_SET_NODE(item, dest);
3010         if ( hook) {
3011                 NG_HOOK_REF(hook);      /* don't let it go while on the queue */
3012                 NGI_SET_HOOK(item, hook);
3013         }
3014         SET_RETADDR(item, here, retaddr);
3015         return (0);
3016 }
3017
3018 int
3019 ng_address_ID(node_p here, item_p item, ng_ID_t ID, ng_ID_t retaddr)
3020 {
3021         node_p dest;
3022
3023         ITEM_DEBUG_CHECKS;
3024         /*
3025          * Find the target node.
3026          */
3027         dest = ng_ID2noderef(ID); /* GETS REFERENCE! */
3028         if (dest == NULL) {
3029                 NG_FREE_ITEM(item);
3030                 TRAP_ERROR();
3031                 return(EINVAL);
3032         }
3033         /* Fill out the contents */
3034         NGI_SET_NODE(item, dest);
3035         NGI_CLR_HOOK(item);
3036         SET_RETADDR(item, here, retaddr);
3037         return (0);
3038 }
3039
3040 /*
3041  * special case to send a message to self (e.g. destroy node)
3042  * Possibly indicate an arrival hook too.
3043  * Useful for removing that hook :-)
3044  */
3045 item_p
3046 ng_package_msg_self(node_p here, hook_p hook, struct ng_mesg *msg)
3047 {
3048         item_p item;
3049
3050         /*
3051          * Find the target node.
3052          * If there is a HOOK argument, then use that in preference
3053          * to the address.
3054          */
3055         if ((item = ng_alloc_item(NGQF_MESG, NG_NOFLAGS)) == NULL) {
3056                 NG_FREE_MSG(msg);
3057                 return (NULL);
3058         }
3059
3060         /* Fill out the contents */
3061         item->el_flags |= NGQF_WRITER;
3062         NG_NODE_REF(here);
3063         NGI_SET_NODE(item, here);
3064         if (hook) {
3065                 NG_HOOK_REF(hook);
3066                 NGI_SET_HOOK(item, hook);
3067         }
3068         NGI_MSG(item) = msg;
3069         NGI_RETADDR(item) = ng_node2ID(here);
3070         return (item);
3071 }
3072
3073 /*
3074  * Send ng_item_fn function call to the specified node.
3075  */
3076
3077 int
3078 ng_send_fn(node_p node, hook_p hook, ng_item_fn *fn, void * arg1, int arg2)
3079 {
3080         return ng_send_fn1(node, hook, fn, arg1, arg2, NG_NOFLAGS);
3081 }
3082
3083 int
3084 ng_send_fn1(node_p node, hook_p hook, ng_item_fn *fn, void * arg1, int arg2,
3085         int flags)
3086 {
3087         item_p item;
3088
3089         if ((item = ng_alloc_item(NGQF_FN, flags)) == NULL) {
3090                 return (ENOMEM);
3091         }
3092         item->el_flags |= NGQF_WRITER;
3093         NG_NODE_REF(node); /* and one for the item */
3094         NGI_SET_NODE(item, node);
3095         if (hook) {
3096                 NG_HOOK_REF(hook);
3097                 NGI_SET_HOOK(item, hook);
3098         }
3099         NGI_FN(item) = fn;
3100         NGI_ARG1(item) = arg1;
3101         NGI_ARG2(item) = arg2;
3102         return(ng_snd_item(item, flags));
3103 }
3104
3105 /*
3106  * Send ng_item_fn2 function call to the specified node.
3107  *
3108  * If NG_REUSE_ITEM flag is set, no new item will be allocated,
3109  * pitem will be used instead.
3110  */
3111 int
3112 ng_send_fn2(node_p node, hook_p hook, item_p pitem, ng_item_fn2 *fn, void *arg1,
3113         int arg2, int flags)
3114 {
3115         item_p item;
3116
3117         KASSERT((pitem != NULL || (flags & NG_REUSE_ITEM) == 0),
3118             ("%s: NG_REUSE_ITEM but no pitem", __func__));
3119
3120         /*
3121          * Allocate a new item if no supplied or
3122          * if we can't use supplied one.
3123          */
3124         if (pitem == NULL || (flags & NG_REUSE_ITEM) == 0) {
3125                 if ((item = ng_alloc_item(NGQF_FN2, flags)) == NULL)
3126                         return (ENOMEM);
3127         } else {
3128                 if ((item = ng_realloc_item(pitem, NGQF_FN2, flags)) == NULL)
3129                         return (ENOMEM);
3130         }
3131
3132         item->el_flags = (item->el_flags & ~NGQF_RW) | NGQF_WRITER;
3133         NG_NODE_REF(node); /* and one for the item */
3134         NGI_SET_NODE(item, node);
3135         if (hook) {
3136                 NG_HOOK_REF(hook);
3137                 NGI_SET_HOOK(item, hook);
3138         }
3139         NGI_FN2(item) = fn;
3140         NGI_ARG1(item) = arg1;
3141         NGI_ARG2(item) = arg2;
3142         return(ng_snd_item(item, flags));
3143 }
3144
3145 /*
3146  * Official timeout routines for Netgraph nodes.
3147  */
3148 static void
3149 ng_callout_trampoline(void *arg)
3150 {
3151         item_p item = arg;
3152
3153         ng_snd_item(item, 0);
3154 }
3155
3156
3157 int
3158 ng_callout(struct callout *c, node_p node, hook_p hook, int ticks,
3159     ng_item_fn *fn, void * arg1, int arg2)
3160 {
3161         item_p item, oitem;
3162
3163         if ((item = ng_alloc_item(NGQF_FN, NG_NOFLAGS)) == NULL)
3164                 return (ENOMEM);
3165
3166         item->el_flags |= NGQF_WRITER;
3167         NG_NODE_REF(node);              /* and one for the item */
3168         NGI_SET_NODE(item, node);
3169         if (hook) {
3170                 NG_HOOK_REF(hook);
3171                 NGI_SET_HOOK(item, hook);
3172         }
3173         NGI_FN(item) = fn;
3174         NGI_ARG1(item) = arg1;
3175         NGI_ARG2(item) = arg2;
3176         oitem = c->c_arg;
3177         callout_reset(c, ticks, &ng_callout_trampoline, item);
3178         return (0);
3179 }
3180
3181 /* A special modified version of untimeout() */
3182 int
3183 ng_uncallout(struct callout *c, node_p node)
3184 {
3185         item_p item;
3186         int rval;
3187
3188         KASSERT(c != NULL, ("ng_uncallout: NULL callout"));
3189         KASSERT(node != NULL, ("ng_uncallout: NULL node"));
3190
3191         rval = callout_stop(c);
3192         item = c->c_arg;
3193         /* Do an extra check */
3194         if ((rval > 0) && (c->c_func == &ng_callout_trampoline) &&
3195             (NGI_NODE(item) == node)) {
3196                 /*
3197                  * We successfully removed it from the queue before it ran
3198                  * So now we need to unreference everything that was
3199                  * given extra references. (NG_FREE_ITEM does this).
3200                  */
3201                 NG_FREE_ITEM(item);
3202         }
3203         c->c_arg = NULL;
3204
3205         return (rval);
3206 }
3207
3208 /*
3209  * Set the address, if none given, give the node here.
3210  */
3211 void
3212 ng_replace_retaddr(node_p here, item_p item, ng_ID_t retaddr)
3213 {
3214         if (retaddr) {
3215                 NGI_RETADDR(item) = retaddr;
3216         } else {
3217                 /*
3218                  * The old return address should be ok.
3219                  * If there isn't one, use the address here.
3220                  */
3221                 NGI_RETADDR(item) = ng_node2ID(here);
3222         }
3223 }
3224
3225 static boolean_t
3226 bzero_ctor(void *obj, void *private, int ocflags)
3227 {
3228         struct ng_item *i = obj;
3229
3230         bzero(i, sizeof(struct ng_item));
3231         return(TRUE);
3232 }
3233
3234 #define TESTING
3235 #ifdef TESTING
3236 /* just test all the macros */
3237 void
3238 ng_macro_test(item_p item);
3239 void
3240 ng_macro_test(item_p item)
3241 {
3242         node_p node = NULL;
3243         hook_p hook = NULL;
3244         struct mbuf *m;
3245         struct ng_mesg *msg;
3246         ng_ID_t retaddr;
3247         int     error;
3248
3249         NGI_GET_M(item, m);
3250         NGI_GET_MSG(item, msg);
3251         retaddr = NGI_RETADDR(item);
3252         NG_SEND_DATA(error, hook, m, NULL);
3253         NG_SEND_DATA_ONLY(error, hook, m);
3254         NG_FWD_NEW_DATA(error, item, hook, m);
3255         NG_FWD_ITEM_HOOK(error, item, hook);
3256         NG_SEND_MSG_HOOK(error, node, msg, hook, retaddr);
3257         NG_SEND_MSG_ID(error, node, msg, retaddr, retaddr);
3258         NG_SEND_MSG_PATH(error, node, msg, ".:", retaddr);
3259         NG_FWD_MSG_HOOK(error, node, item, hook, retaddr);
3260 }
3261 #endif /* TESTING */
3262