14cf49a43SJulian Elischer /* 24cf49a43SJulian Elischer * ng_base.c 3c398230bSWarner Losh */ 4c398230bSWarner Losh 5c398230bSWarner Losh /*- 64cf49a43SJulian Elischer * Copyright (c) 1996-1999 Whistle Communications, Inc. 74cf49a43SJulian Elischer * All rights reserved. 84cf49a43SJulian Elischer * 94cf49a43SJulian Elischer * Subject to the following obligations and disclaimer of warranty, use and 104cf49a43SJulian Elischer * redistribution of this software, in source or object code forms, with or 114cf49a43SJulian Elischer * without modifications are expressly permitted by Whistle Communications; 124cf49a43SJulian Elischer * provided, however, that: 134cf49a43SJulian Elischer * 1. Any and all reproductions of the source or object code must include the 144cf49a43SJulian Elischer * copyright notice above and the following disclaimer of warranties; and 154cf49a43SJulian Elischer * 2. No rights are granted, in any manner or form, to use Whistle 164cf49a43SJulian Elischer * Communications, Inc. trademarks, including the mark "WHISTLE 174cf49a43SJulian Elischer * COMMUNICATIONS" on advertising, endorsements, or otherwise except as 184cf49a43SJulian Elischer * such appears in the above copyright notice or in the software. 194cf49a43SJulian Elischer * 204cf49a43SJulian Elischer * THIS SOFTWARE IS BEING PROVIDED BY WHISTLE COMMUNICATIONS "AS IS", AND 214cf49a43SJulian Elischer * TO THE MAXIMUM EXTENT PERMITTED BY LAW, WHISTLE COMMUNICATIONS MAKES NO 224cf49a43SJulian Elischer * REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED, REGARDING THIS SOFTWARE, 234cf49a43SJulian Elischer * INCLUDING WITHOUT LIMITATION, ANY AND ALL IMPLIED WARRANTIES OF 244cf49a43SJulian Elischer * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT. 254cf49a43SJulian Elischer * WHISTLE COMMUNICATIONS DOES NOT WARRANT, GUARANTEE, OR MAKE ANY 264cf49a43SJulian Elischer * REPRESENTATIONS REGARDING THE USE OF, OR THE RESULTS OF THE USE OF THIS 274cf49a43SJulian Elischer * SOFTWARE IN TERMS OF ITS CORRECTNESS, ACCURACY, RELIABILITY OR OTHERWISE. 284cf49a43SJulian Elischer * IN NO EVENT SHALL WHISTLE COMMUNICATIONS BE LIABLE FOR ANY DAMAGES 294cf49a43SJulian Elischer * RESULTING FROM OR ARISING OUT OF ANY USE OF THIS SOFTWARE, INCLUDING 304cf49a43SJulian Elischer * WITHOUT LIMITATION, ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, 314cf49a43SJulian Elischer * PUNITIVE, OR CONSEQUENTIAL DAMAGES, PROCUREMENT OF SUBSTITUTE GOODS OR 324cf49a43SJulian Elischer * SERVICES, LOSS OF USE, DATA OR PROFITS, HOWEVER CAUSED AND UNDER ANY 334cf49a43SJulian Elischer * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 344cf49a43SJulian Elischer * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 354cf49a43SJulian Elischer * THIS SOFTWARE, EVEN IF WHISTLE COMMUNICATIONS IS ADVISED OF THE POSSIBILITY 364cf49a43SJulian Elischer * OF SUCH DAMAGE. 374cf49a43SJulian Elischer * 38cc3bbd68SJulian Elischer * Authors: Julian Elischer <julian@freebsd.org> 39cc3bbd68SJulian Elischer * Archie Cobbs <archie@freebsd.org> 404cf49a43SJulian Elischer * 414cf49a43SJulian Elischer * $FreeBSD$ 424cf49a43SJulian Elischer * $Whistle: ng_base.c,v 1.39 1999/01/28 23:54:53 julian Exp $ 434cf49a43SJulian Elischer */ 444cf49a43SJulian Elischer 454cf49a43SJulian Elischer /* 464cf49a43SJulian Elischer * This file implements the base netgraph code. 474cf49a43SJulian Elischer */ 484cf49a43SJulian Elischer 494cf49a43SJulian Elischer #include <sys/param.h> 508e853a2cSGleb Smirnoff #include <sys/systm.h> 5177a58296SGleb Smirnoff #include <sys/ctype.h> 524cf49a43SJulian Elischer #include <sys/errno.h> 53f33ca0c9SMarcel Moolenaar #include <sys/kdb.h> 544cf49a43SJulian Elischer #include <sys/kernel.h> 553b33fbe7SGleb Smirnoff #include <sys/ktr.h> 56104a9b7eSAlexander Kabaev #include <sys/limits.h> 574cf49a43SJulian Elischer #include <sys/malloc.h> 584cf49a43SJulian Elischer #include <sys/mbuf.h> 5977a58296SGleb Smirnoff #include <sys/queue.h> 60bfa7e882SJulian Elischer #include <sys/sysctl.h> 6177a58296SGleb Smirnoff #include <sys/syslog.h> 624cf49a43SJulian Elischer 634cf49a43SJulian Elischer #include <net/netisr.h> 644cf49a43SJulian Elischer 654cf49a43SJulian Elischer #include <netgraph/ng_message.h> 664cf49a43SJulian Elischer #include <netgraph/netgraph.h> 67f8307e12SArchie Cobbs #include <netgraph/ng_parse.h> 684cf49a43SJulian Elischer 699d72a7a3SJulian Elischer MODULE_VERSION(netgraph, NG_ABI_VERSION); 7099ff8176SPeter Wemm 7130400f03SJulian Elischer /* List of all active nodes */ 72069154d5SJulian Elischer static LIST_HEAD(, ng_node) ng_nodelist; 73069154d5SJulian Elischer static struct mtx ng_nodelist_mtx; 74069154d5SJulian Elischer 75ac5dd141SGleb Smirnoff /* Mutex to protect topology events. */ 76ac5dd141SGleb Smirnoff static struct mtx ng_topo_mtx; 77ac5dd141SGleb Smirnoff 7830400f03SJulian Elischer #ifdef NETGRAPH_DEBUG 791489164fSGleb Smirnoff static struct mtx ngq_mtx; /* protects the queue item list */ 8030400f03SJulian Elischer 8130400f03SJulian Elischer static SLIST_HEAD(, ng_node) ng_allnodes; 8230400f03SJulian Elischer static LIST_HEAD(, ng_node) ng_freenodes; /* in debug, we never free() them */ 8330400f03SJulian Elischer static SLIST_HEAD(, ng_hook) ng_allhooks; 8430400f03SJulian Elischer static LIST_HEAD(, ng_hook) ng_freehooks; /* in debug, we never free() them */ 8530400f03SJulian Elischer 8630400f03SJulian Elischer static void ng_dumpitems(void); 8730400f03SJulian Elischer static void ng_dumpnodes(void); 8830400f03SJulian Elischer static void ng_dumphooks(void); 8930400f03SJulian Elischer 9030400f03SJulian Elischer #endif /* NETGRAPH_DEBUG */ 91954c4772SJulian Elischer /* 92954c4772SJulian Elischer * DEAD versions of the structures. 93954c4772SJulian Elischer * In order to avoid races, it is sometimes neccesary to point 94954c4772SJulian Elischer * at SOMETHING even though theoretically, the current entity is 95954c4772SJulian Elischer * INVALID. Use these to avoid these races. 96954c4772SJulian Elischer */ 97954c4772SJulian Elischer struct ng_type ng_deadtype = { 98954c4772SJulian Elischer NG_ABI_VERSION, 99954c4772SJulian Elischer "dead", 100954c4772SJulian Elischer NULL, /* modevent */ 101954c4772SJulian Elischer NULL, /* constructor */ 102954c4772SJulian Elischer NULL, /* rcvmsg */ 103954c4772SJulian Elischer NULL, /* shutdown */ 104954c4772SJulian Elischer NULL, /* newhook */ 105954c4772SJulian Elischer NULL, /* findhook */ 106954c4772SJulian Elischer NULL, /* connect */ 107954c4772SJulian Elischer NULL, /* rcvdata */ 108954c4772SJulian Elischer NULL, /* disconnect */ 109954c4772SJulian Elischer NULL, /* cmdlist */ 110954c4772SJulian Elischer }; 11130400f03SJulian Elischer 112954c4772SJulian Elischer struct ng_node ng_deadnode = { 113954c4772SJulian Elischer "dead", 114954c4772SJulian Elischer &ng_deadtype, 115be4252b3SJulian Elischer NGF_INVALID, 116954c4772SJulian Elischer 1, /* refs */ 117954c4772SJulian Elischer 0, /* numhooks */ 118954c4772SJulian Elischer NULL, /* private */ 119954c4772SJulian Elischer 0, /* ID */ 120954c4772SJulian Elischer LIST_HEAD_INITIALIZER(ng_deadnode.hooks), 121954c4772SJulian Elischer {}, /* all_nodes list entry */ 122954c4772SJulian Elischer {}, /* id hashtable list entry */ 123954c4772SJulian Elischer {}, /* workqueue entry */ 124954c4772SJulian Elischer { 0, 125954c4772SJulian Elischer {}, /* should never use! (should hang) */ 126954c4772SJulian Elischer NULL, 127954c4772SJulian Elischer &ng_deadnode.nd_input_queue.queue, 128954c4772SJulian Elischer &ng_deadnode 129954c4772SJulian Elischer }, 130954c4772SJulian Elischer #ifdef NETGRAPH_DEBUG 131954c4772SJulian Elischer ND_MAGIC, 132954c4772SJulian Elischer __FILE__, 133954c4772SJulian Elischer __LINE__, 134954c4772SJulian Elischer {NULL} 135954c4772SJulian Elischer #endif /* NETGRAPH_DEBUG */ 136954c4772SJulian Elischer }; 137954c4772SJulian Elischer 138954c4772SJulian Elischer struct ng_hook ng_deadhook = { 139954c4772SJulian Elischer "dead", 140954c4772SJulian Elischer NULL, /* private */ 141954c4772SJulian Elischer HK_INVALID | HK_DEAD, 142954c4772SJulian Elischer 1, /* refs always >= 1 */ 143e58d779dSGleb Smirnoff 0, /* undefined data link type */ 144954c4772SJulian Elischer &ng_deadhook, /* Peer is self */ 145954c4772SJulian Elischer &ng_deadnode, /* attached to deadnode */ 146954c4772SJulian Elischer {}, /* hooks list */ 147c4b5eea4SJulian Elischer NULL, /* override rcvmsg() */ 148c4b5eea4SJulian Elischer NULL, /* override rcvdata() */ 149954c4772SJulian Elischer #ifdef NETGRAPH_DEBUG 150954c4772SJulian Elischer HK_MAGIC, 151954c4772SJulian Elischer __FILE__, 152954c4772SJulian Elischer __LINE__, 153954c4772SJulian Elischer {NULL} 154954c4772SJulian Elischer #endif /* NETGRAPH_DEBUG */ 155954c4772SJulian Elischer }; 156954c4772SJulian Elischer 157954c4772SJulian Elischer /* 158954c4772SJulian Elischer * END DEAD STRUCTURES 159954c4772SJulian Elischer */ 160069154d5SJulian Elischer /* List nodes with unallocated work */ 161069154d5SJulian Elischer static TAILQ_HEAD(, ng_node) ng_worklist = TAILQ_HEAD_INITIALIZER(ng_worklist); 162b57a7965SJulian Elischer static struct mtx ng_worklist_mtx; /* MUST LOCK NODE FIRST */ 1634cf49a43SJulian Elischer 1644cf49a43SJulian Elischer /* List of installed types */ 165069154d5SJulian Elischer static LIST_HEAD(, ng_type) ng_typelist; 166069154d5SJulian Elischer static struct mtx ng_typelist_mtx; 1674cf49a43SJulian Elischer 168069154d5SJulian Elischer /* Hash related definitions */ 1690f150d04SJulian Elischer /* XXX Don't need to initialise them because it's a LIST */ 1700f150d04SJulian Elischer #define NG_ID_HASH_SIZE 32 /* most systems wont need even this many */ 1710f150d04SJulian Elischer static LIST_HEAD(, ng_node) ng_ID_hash[NG_ID_HASH_SIZE]; 172069154d5SJulian Elischer static struct mtx ng_idhash_mtx; 1730f150d04SJulian Elischer /* Method to find a node.. used twice so do it here */ 1740f150d04SJulian Elischer #define NG_IDHASH_FN(ID) ((ID) % (NG_ID_HASH_SIZE)) 1750f150d04SJulian Elischer #define NG_IDHASH_FIND(ID, node) \ 1760f150d04SJulian Elischer do { \ 17753f9c5e9SRobert Watson mtx_assert(&ng_idhash_mtx, MA_OWNED); \ 1780f150d04SJulian Elischer LIST_FOREACH(node, &ng_ID_hash[NG_IDHASH_FN(ID)], \ 1790f150d04SJulian Elischer nd_idnodes) { \ 1800f150d04SJulian Elischer if (NG_NODE_IS_VALID(node) \ 1810f150d04SJulian Elischer && (NG_NODE_ID(node) == ID)) { \ 1820f150d04SJulian Elischer break; \ 1830f150d04SJulian Elischer } \ 1840f150d04SJulian Elischer } \ 1850f150d04SJulian Elischer } while (0) 186069154d5SJulian Elischer 187dc90cad9SJulian Elischer 1884cf49a43SJulian Elischer /* Internal functions */ 1894cf49a43SJulian Elischer static int ng_add_hook(node_p node, const char *name, hook_p * hookp); 190069154d5SJulian Elischer static int ng_generic_msg(node_p here, item_p item, hook_p lasthook); 191dc90cad9SJulian Elischer static ng_ID_t ng_decodeidname(const char *name); 1924cf49a43SJulian Elischer static int ngb_mod_event(module_t mod, int event, void *data); 193069154d5SJulian Elischer static void ng_worklist_remove(node_p node); 1944cf49a43SJulian Elischer static void ngintr(void); 195714fb865SGleb Smirnoff static int ng_apply_item(node_p node, item_p item, int rw); 196069154d5SJulian Elischer static void ng_flush_input_queue(struct ng_queue * ngq); 197069154d5SJulian Elischer static void ng_setisr(node_p node); 198069154d5SJulian Elischer static node_p ng_ID2noderef(ng_ID_t ID); 1996b795970SJulian Elischer static int ng_con_nodes(node_p node, const char *name, node_p node2, 2006b795970SJulian Elischer const char *name2); 2011acb27c6SJulian Elischer static void ng_con_part2(node_p node, hook_p hook, void *arg1, int arg2); 2021acb27c6SJulian Elischer static void ng_con_part3(node_p node, hook_p hook, void *arg1, int arg2); 2036b795970SJulian Elischer static int ng_mkpeer(node_p node, const char *name, 2046b795970SJulian Elischer const char *name2, char *type); 205069154d5SJulian Elischer 2064c9b5910SGleb Smirnoff /* Imported, these used to be externally visible, some may go back. */ 207069154d5SJulian Elischer void ng_destroy_hook(hook_p hook); 208069154d5SJulian Elischer node_p ng_name2noderef(node_p node, const char *name); 209069154d5SJulian Elischer int ng_path2noderef(node_p here, const char *path, 210069154d5SJulian Elischer node_p *dest, hook_p *lasthook); 211069154d5SJulian Elischer int ng_make_node(const char *type, node_p *nodepp); 212069154d5SJulian Elischer int ng_path_parse(char *addr, char **node, char **path, char **hook); 2131acb27c6SJulian Elischer void ng_rmnode(node_p node, hook_p dummy1, void *dummy2, int dummy3); 21430400f03SJulian Elischer void ng_unname(node_p node); 215069154d5SJulian Elischer 2164cf49a43SJulian Elischer 2174cf49a43SJulian Elischer /* Our own netgraph malloc type */ 2184cf49a43SJulian Elischer MALLOC_DEFINE(M_NETGRAPH, "netgraph", "netgraph structures and ctrl messages"); 219069154d5SJulian Elischer MALLOC_DEFINE(M_NETGRAPH_HOOK, "netgraph_hook", "netgraph hook structures"); 220069154d5SJulian Elischer MALLOC_DEFINE(M_NETGRAPH_NODE, "netgraph_node", "netgraph node structures"); 221069154d5SJulian Elischer MALLOC_DEFINE(M_NETGRAPH_ITEM, "netgraph_item", "netgraph item structures"); 222069154d5SJulian Elischer MALLOC_DEFINE(M_NETGRAPH_MSG, "netgraph_msg", "netgraph name storage"); 223069154d5SJulian Elischer 224069154d5SJulian Elischer /* Should not be visible outside this file */ 22530400f03SJulian Elischer 22630400f03SJulian Elischer #define _NG_ALLOC_HOOK(hook) \ 22730400f03SJulian Elischer MALLOC(hook, hook_p, sizeof(*hook), M_NETGRAPH_HOOK, M_NOWAIT | M_ZERO) 22830400f03SJulian Elischer #define _NG_ALLOC_NODE(node) \ 22930400f03SJulian Elischer MALLOC(node, node_p, sizeof(*node), M_NETGRAPH_NODE, M_NOWAIT | M_ZERO) 23030400f03SJulian Elischer 23130400f03SJulian Elischer #ifdef NETGRAPH_DEBUG /*----------------------------------------------*/ 23230400f03SJulian Elischer /* 23330400f03SJulian Elischer * In debug mode: 23430400f03SJulian Elischer * In an attempt to help track reference count screwups 23530400f03SJulian Elischer * we do not free objects back to the malloc system, but keep them 23630400f03SJulian Elischer * in a local cache where we can examine them and keep information safely 23730400f03SJulian Elischer * after they have been freed. 23830400f03SJulian Elischer * We use this scheme for nodes and hooks, and to some extent for items. 23930400f03SJulian Elischer */ 24030400f03SJulian Elischer static __inline hook_p 24130400f03SJulian Elischer ng_alloc_hook(void) 24230400f03SJulian Elischer { 24330400f03SJulian Elischer hook_p hook; 24430400f03SJulian Elischer SLIST_ENTRY(ng_hook) temp; 2459ed346baSBosko Milekic mtx_lock(&ng_nodelist_mtx); 24630400f03SJulian Elischer hook = LIST_FIRST(&ng_freehooks); 24730400f03SJulian Elischer if (hook) { 24830400f03SJulian Elischer LIST_REMOVE(hook, hk_hooks); 24930400f03SJulian Elischer bcopy(&hook->hk_all, &temp, sizeof(temp)); 25030400f03SJulian Elischer bzero(hook, sizeof(struct ng_hook)); 25130400f03SJulian Elischer bcopy(&temp, &hook->hk_all, sizeof(temp)); 2529ed346baSBosko Milekic mtx_unlock(&ng_nodelist_mtx); 25330400f03SJulian Elischer hook->hk_magic = HK_MAGIC; 25430400f03SJulian Elischer } else { 2559ed346baSBosko Milekic mtx_unlock(&ng_nodelist_mtx); 25630400f03SJulian Elischer _NG_ALLOC_HOOK(hook); 25730400f03SJulian Elischer if (hook) { 25830400f03SJulian Elischer hook->hk_magic = HK_MAGIC; 2599ed346baSBosko Milekic mtx_lock(&ng_nodelist_mtx); 26030400f03SJulian Elischer SLIST_INSERT_HEAD(&ng_allhooks, hook, hk_all); 2619ed346baSBosko Milekic mtx_unlock(&ng_nodelist_mtx); 26230400f03SJulian Elischer } 26330400f03SJulian Elischer } 26430400f03SJulian Elischer return (hook); 26530400f03SJulian Elischer } 26630400f03SJulian Elischer 26730400f03SJulian Elischer static __inline node_p 26830400f03SJulian Elischer ng_alloc_node(void) 26930400f03SJulian Elischer { 27030400f03SJulian Elischer node_p node; 27130400f03SJulian Elischer SLIST_ENTRY(ng_node) temp; 2729ed346baSBosko Milekic mtx_lock(&ng_nodelist_mtx); 27330400f03SJulian Elischer node = LIST_FIRST(&ng_freenodes); 27430400f03SJulian Elischer if (node) { 27530400f03SJulian Elischer LIST_REMOVE(node, nd_nodes); 27630400f03SJulian Elischer bcopy(&node->nd_all, &temp, sizeof(temp)); 27730400f03SJulian Elischer bzero(node, sizeof(struct ng_node)); 27830400f03SJulian Elischer bcopy(&temp, &node->nd_all, sizeof(temp)); 2799ed346baSBosko Milekic mtx_unlock(&ng_nodelist_mtx); 28030400f03SJulian Elischer node->nd_magic = ND_MAGIC; 28130400f03SJulian Elischer } else { 2829ed346baSBosko Milekic mtx_unlock(&ng_nodelist_mtx); 28330400f03SJulian Elischer _NG_ALLOC_NODE(node); 28430400f03SJulian Elischer if (node) { 28530400f03SJulian Elischer node->nd_magic = ND_MAGIC; 2869ed346baSBosko Milekic mtx_lock(&ng_nodelist_mtx); 28730400f03SJulian Elischer SLIST_INSERT_HEAD(&ng_allnodes, node, nd_all); 2889ed346baSBosko Milekic mtx_unlock(&ng_nodelist_mtx); 28930400f03SJulian Elischer } 29030400f03SJulian Elischer } 29130400f03SJulian Elischer return (node); 29230400f03SJulian Elischer } 29330400f03SJulian Elischer 29430400f03SJulian Elischer #define NG_ALLOC_HOOK(hook) do { (hook) = ng_alloc_hook(); } while (0) 29530400f03SJulian Elischer #define NG_ALLOC_NODE(node) do { (node) = ng_alloc_node(); } while (0) 29630400f03SJulian Elischer 29730400f03SJulian Elischer 29830400f03SJulian Elischer #define NG_FREE_HOOK(hook) \ 29930400f03SJulian Elischer do { \ 3009ed346baSBosko Milekic mtx_lock(&ng_nodelist_mtx); \ 30130400f03SJulian Elischer LIST_INSERT_HEAD(&ng_freehooks, hook, hk_hooks); \ 30230400f03SJulian Elischer hook->hk_magic = 0; \ 3039ed346baSBosko Milekic mtx_unlock(&ng_nodelist_mtx); \ 30430400f03SJulian Elischer } while (0) 30530400f03SJulian Elischer 30630400f03SJulian Elischer #define NG_FREE_NODE(node) \ 30730400f03SJulian Elischer do { \ 3089ed346baSBosko Milekic mtx_lock(&ng_nodelist_mtx); \ 30930400f03SJulian Elischer LIST_INSERT_HEAD(&ng_freenodes, node, nd_nodes); \ 31030400f03SJulian Elischer node->nd_magic = 0; \ 3119ed346baSBosko Milekic mtx_unlock(&ng_nodelist_mtx); \ 31230400f03SJulian Elischer } while (0) 31330400f03SJulian Elischer 31430400f03SJulian Elischer #else /* NETGRAPH_DEBUG */ /*----------------------------------------------*/ 31530400f03SJulian Elischer 31630400f03SJulian Elischer #define NG_ALLOC_HOOK(hook) _NG_ALLOC_HOOK(hook) 31730400f03SJulian Elischer #define NG_ALLOC_NODE(node) _NG_ALLOC_NODE(node) 31830400f03SJulian Elischer 319069154d5SJulian Elischer #define NG_FREE_HOOK(hook) do { FREE((hook), M_NETGRAPH_HOOK); } while (0) 320069154d5SJulian Elischer #define NG_FREE_NODE(node) do { FREE((node), M_NETGRAPH_NODE); } while (0) 32130400f03SJulian Elischer 32230400f03SJulian Elischer #endif /* NETGRAPH_DEBUG */ /*----------------------------------------------*/ 32330400f03SJulian Elischer 324f33ca0c9SMarcel Moolenaar /* Set this to kdb_enter("X") to catch all errors as they occur */ 3254cf49a43SJulian Elischer #ifndef TRAP_ERROR 3266b795970SJulian Elischer #define TRAP_ERROR() 3274cf49a43SJulian Elischer #endif 3284cf49a43SJulian Elischer 329dc90cad9SJulian Elischer static ng_ID_t nextID = 1; 330dc90cad9SJulian Elischer 331b2da83c2SArchie Cobbs #ifdef INVARIANTS 332b2da83c2SArchie Cobbs #define CHECK_DATA_MBUF(m) do { \ 333b2da83c2SArchie Cobbs struct mbuf *n; \ 334b2da83c2SArchie Cobbs int total; \ 335b2da83c2SArchie Cobbs \ 336fe584538SDag-Erling Smørgrav M_ASSERTPKTHDR(m); \ 337b32cfb32SGleb Smirnoff for (total = 0, n = (m); n != NULL; n = n->m_next) { \ 338b2da83c2SArchie Cobbs total += n->m_len; \ 339b32cfb32SGleb Smirnoff if (n->m_nextpkt != NULL) \ 340b32cfb32SGleb Smirnoff panic("%s: m_nextpkt", __func__); \ 341b32cfb32SGleb Smirnoff } \ 342ba5b359aSGleb Smirnoff \ 343b2da83c2SArchie Cobbs if ((m)->m_pkthdr.len != total) { \ 344b2da83c2SArchie Cobbs panic("%s: %d != %d", \ 3456e551fb6SDavid E. O'Brien __func__, (m)->m_pkthdr.len, total); \ 346b2da83c2SArchie Cobbs } \ 347b2da83c2SArchie Cobbs } while (0) 348b2da83c2SArchie Cobbs #else 349b2da83c2SArchie Cobbs #define CHECK_DATA_MBUF(m) 350b2da83c2SArchie Cobbs #endif 351b2da83c2SArchie Cobbs 352dc90cad9SJulian Elischer 3534cf49a43SJulian Elischer /************************************************************************ 354f8307e12SArchie Cobbs Parse type definitions for generic messages 355f8307e12SArchie Cobbs ************************************************************************/ 356f8307e12SArchie Cobbs 357f8307e12SArchie Cobbs /* Handy structure parse type defining macro */ 358f8307e12SArchie Cobbs #define DEFINE_PARSE_STRUCT_TYPE(lo, up, args) \ 359f0184ff8SArchie Cobbs static const struct ng_parse_struct_field \ 360f0184ff8SArchie Cobbs ng_ ## lo ## _type_fields[] = NG_GENERIC_ ## up ## _INFO args; \ 361f8307e12SArchie Cobbs static const struct ng_parse_type ng_generic_ ## lo ## _type = { \ 362f8307e12SArchie Cobbs &ng_parse_struct_type, \ 363f0184ff8SArchie Cobbs &ng_ ## lo ## _type_fields \ 364f8307e12SArchie Cobbs } 365f8307e12SArchie Cobbs 366f8307e12SArchie Cobbs DEFINE_PARSE_STRUCT_TYPE(mkpeer, MKPEER, ()); 367f8307e12SArchie Cobbs DEFINE_PARSE_STRUCT_TYPE(connect, CONNECT, ()); 368f8307e12SArchie Cobbs DEFINE_PARSE_STRUCT_TYPE(name, NAME, ()); 369f8307e12SArchie Cobbs DEFINE_PARSE_STRUCT_TYPE(rmhook, RMHOOK, ()); 370f8307e12SArchie Cobbs DEFINE_PARSE_STRUCT_TYPE(nodeinfo, NODEINFO, ()); 371f8307e12SArchie Cobbs DEFINE_PARSE_STRUCT_TYPE(typeinfo, TYPEINFO, ()); 372f8307e12SArchie Cobbs DEFINE_PARSE_STRUCT_TYPE(linkinfo, LINKINFO, (&ng_generic_nodeinfo_type)); 373f8307e12SArchie Cobbs 374f8307e12SArchie Cobbs /* Get length of an array when the length is stored as a 32 bit 375d7d97eb0SJeroen Ruigrok van der Werven value immediately preceding the array -- as with struct namelist 376f8307e12SArchie Cobbs and struct typelist. */ 377f8307e12SArchie Cobbs static int 378f8307e12SArchie Cobbs ng_generic_list_getLength(const struct ng_parse_type *type, 379f8307e12SArchie Cobbs const u_char *start, const u_char *buf) 380f8307e12SArchie Cobbs { 381f8307e12SArchie Cobbs return *((const u_int32_t *)(buf - 4)); 382f8307e12SArchie Cobbs } 383f8307e12SArchie Cobbs 384f8307e12SArchie Cobbs /* Get length of the array of struct linkinfo inside a struct hooklist */ 385f8307e12SArchie Cobbs static int 386f8307e12SArchie Cobbs ng_generic_linkinfo_getLength(const struct ng_parse_type *type, 387f8307e12SArchie Cobbs const u_char *start, const u_char *buf) 388f8307e12SArchie Cobbs { 389f8307e12SArchie Cobbs const struct hooklist *hl = (const struct hooklist *)start; 390f8307e12SArchie Cobbs 391f8307e12SArchie Cobbs return hl->nodeinfo.hooks; 392f8307e12SArchie Cobbs } 393f8307e12SArchie Cobbs 394f8307e12SArchie Cobbs /* Array type for a variable length array of struct namelist */ 395f8307e12SArchie Cobbs static const struct ng_parse_array_info ng_nodeinfoarray_type_info = { 396f8307e12SArchie Cobbs &ng_generic_nodeinfo_type, 397f8307e12SArchie Cobbs &ng_generic_list_getLength 398f8307e12SArchie Cobbs }; 399f8307e12SArchie Cobbs static const struct ng_parse_type ng_generic_nodeinfoarray_type = { 400f8307e12SArchie Cobbs &ng_parse_array_type, 401f8307e12SArchie Cobbs &ng_nodeinfoarray_type_info 402f8307e12SArchie Cobbs }; 403f8307e12SArchie Cobbs 404f8307e12SArchie Cobbs /* Array type for a variable length array of struct typelist */ 405f8307e12SArchie Cobbs static const struct ng_parse_array_info ng_typeinfoarray_type_info = { 406f8307e12SArchie Cobbs &ng_generic_typeinfo_type, 407f8307e12SArchie Cobbs &ng_generic_list_getLength 408f8307e12SArchie Cobbs }; 409f8307e12SArchie Cobbs static const struct ng_parse_type ng_generic_typeinfoarray_type = { 410f8307e12SArchie Cobbs &ng_parse_array_type, 411f8307e12SArchie Cobbs &ng_typeinfoarray_type_info 412f8307e12SArchie Cobbs }; 413f8307e12SArchie Cobbs 414f8307e12SArchie Cobbs /* Array type for array of struct linkinfo in struct hooklist */ 415f8307e12SArchie Cobbs static const struct ng_parse_array_info ng_generic_linkinfo_array_type_info = { 416f8307e12SArchie Cobbs &ng_generic_linkinfo_type, 417f8307e12SArchie Cobbs &ng_generic_linkinfo_getLength 418f8307e12SArchie Cobbs }; 419f8307e12SArchie Cobbs static const struct ng_parse_type ng_generic_linkinfo_array_type = { 420f8307e12SArchie Cobbs &ng_parse_array_type, 421f8307e12SArchie Cobbs &ng_generic_linkinfo_array_type_info 422f8307e12SArchie Cobbs }; 423f8307e12SArchie Cobbs 424f8307e12SArchie Cobbs DEFINE_PARSE_STRUCT_TYPE(typelist, TYPELIST, (&ng_generic_nodeinfoarray_type)); 425f8307e12SArchie Cobbs DEFINE_PARSE_STRUCT_TYPE(hooklist, HOOKLIST, 426f8307e12SArchie Cobbs (&ng_generic_nodeinfo_type, &ng_generic_linkinfo_array_type)); 427f8307e12SArchie Cobbs DEFINE_PARSE_STRUCT_TYPE(listnodes, LISTNODES, 428f8307e12SArchie Cobbs (&ng_generic_nodeinfoarray_type)); 429f8307e12SArchie Cobbs 430f8307e12SArchie Cobbs /* List of commands and how to convert arguments to/from ASCII */ 431f8307e12SArchie Cobbs static const struct ng_cmdlist ng_generic_cmds[] = { 432f8307e12SArchie Cobbs { 433f8307e12SArchie Cobbs NGM_GENERIC_COOKIE, 434f8307e12SArchie Cobbs NGM_SHUTDOWN, 435f8307e12SArchie Cobbs "shutdown", 436f8307e12SArchie Cobbs NULL, 437f8307e12SArchie Cobbs NULL 438f8307e12SArchie Cobbs }, 439f8307e12SArchie Cobbs { 440f8307e12SArchie Cobbs NGM_GENERIC_COOKIE, 441f8307e12SArchie Cobbs NGM_MKPEER, 442f8307e12SArchie Cobbs "mkpeer", 443f8307e12SArchie Cobbs &ng_generic_mkpeer_type, 444f8307e12SArchie Cobbs NULL 445f8307e12SArchie Cobbs }, 446f8307e12SArchie Cobbs { 447f8307e12SArchie Cobbs NGM_GENERIC_COOKIE, 448f8307e12SArchie Cobbs NGM_CONNECT, 449f8307e12SArchie Cobbs "connect", 450f8307e12SArchie Cobbs &ng_generic_connect_type, 451f8307e12SArchie Cobbs NULL 452f8307e12SArchie Cobbs }, 453f8307e12SArchie Cobbs { 454f8307e12SArchie Cobbs NGM_GENERIC_COOKIE, 455f8307e12SArchie Cobbs NGM_NAME, 456f8307e12SArchie Cobbs "name", 457f8307e12SArchie Cobbs &ng_generic_name_type, 458f8307e12SArchie Cobbs NULL 459f8307e12SArchie Cobbs }, 460f8307e12SArchie Cobbs { 461f8307e12SArchie Cobbs NGM_GENERIC_COOKIE, 462f8307e12SArchie Cobbs NGM_RMHOOK, 463f8307e12SArchie Cobbs "rmhook", 464f8307e12SArchie Cobbs &ng_generic_rmhook_type, 465f8307e12SArchie Cobbs NULL 466f8307e12SArchie Cobbs }, 467f8307e12SArchie Cobbs { 468f8307e12SArchie Cobbs NGM_GENERIC_COOKIE, 469f8307e12SArchie Cobbs NGM_NODEINFO, 470f8307e12SArchie Cobbs "nodeinfo", 471f8307e12SArchie Cobbs NULL, 472f8307e12SArchie Cobbs &ng_generic_nodeinfo_type 473f8307e12SArchie Cobbs }, 474f8307e12SArchie Cobbs { 475f8307e12SArchie Cobbs NGM_GENERIC_COOKIE, 476f8307e12SArchie Cobbs NGM_LISTHOOKS, 477f8307e12SArchie Cobbs "listhooks", 478f8307e12SArchie Cobbs NULL, 479f8307e12SArchie Cobbs &ng_generic_hooklist_type 480f8307e12SArchie Cobbs }, 481f8307e12SArchie Cobbs { 482f8307e12SArchie Cobbs NGM_GENERIC_COOKIE, 483f8307e12SArchie Cobbs NGM_LISTNAMES, 484f8307e12SArchie Cobbs "listnames", 485f8307e12SArchie Cobbs NULL, 486f8307e12SArchie Cobbs &ng_generic_listnodes_type /* same as NGM_LISTNODES */ 487f8307e12SArchie Cobbs }, 488f8307e12SArchie Cobbs { 489f8307e12SArchie Cobbs NGM_GENERIC_COOKIE, 490f8307e12SArchie Cobbs NGM_LISTNODES, 491f8307e12SArchie Cobbs "listnodes", 492f8307e12SArchie Cobbs NULL, 493f8307e12SArchie Cobbs &ng_generic_listnodes_type 494f8307e12SArchie Cobbs }, 495f8307e12SArchie Cobbs { 496f8307e12SArchie Cobbs NGM_GENERIC_COOKIE, 497f8307e12SArchie Cobbs NGM_LISTTYPES, 498f8307e12SArchie Cobbs "listtypes", 499f8307e12SArchie Cobbs NULL, 500f8307e12SArchie Cobbs &ng_generic_typeinfo_type 501f8307e12SArchie Cobbs }, 502f8307e12SArchie Cobbs { 503f8307e12SArchie Cobbs NGM_GENERIC_COOKIE, 5047095e097SPoul-Henning Kamp NGM_TEXT_CONFIG, 5057095e097SPoul-Henning Kamp "textconfig", 5067095e097SPoul-Henning Kamp NULL, 5077095e097SPoul-Henning Kamp &ng_parse_string_type 5087095e097SPoul-Henning Kamp }, 5097095e097SPoul-Henning Kamp { 5107095e097SPoul-Henning Kamp NGM_GENERIC_COOKIE, 511f8307e12SArchie Cobbs NGM_TEXT_STATUS, 512f8307e12SArchie Cobbs "textstatus", 513f8307e12SArchie Cobbs NULL, 514f8307e12SArchie Cobbs &ng_parse_string_type 515f8307e12SArchie Cobbs }, 516f8307e12SArchie Cobbs { 517f8307e12SArchie Cobbs NGM_GENERIC_COOKIE, 518f8307e12SArchie Cobbs NGM_ASCII2BINARY, 519f8307e12SArchie Cobbs "ascii2binary", 520f8307e12SArchie Cobbs &ng_parse_ng_mesg_type, 521f8307e12SArchie Cobbs &ng_parse_ng_mesg_type 522f8307e12SArchie Cobbs }, 523f8307e12SArchie Cobbs { 524f8307e12SArchie Cobbs NGM_GENERIC_COOKIE, 525f8307e12SArchie Cobbs NGM_BINARY2ASCII, 526f8307e12SArchie Cobbs "binary2ascii", 527f8307e12SArchie Cobbs &ng_parse_ng_mesg_type, 528f8307e12SArchie Cobbs &ng_parse_ng_mesg_type 529f8307e12SArchie Cobbs }, 530f8307e12SArchie Cobbs { 0 } 531f8307e12SArchie Cobbs }; 532f8307e12SArchie Cobbs 533f8307e12SArchie Cobbs /************************************************************************ 5344cf49a43SJulian Elischer Node routines 5354cf49a43SJulian Elischer ************************************************************************/ 5364cf49a43SJulian Elischer 5374cf49a43SJulian Elischer /* 5384cf49a43SJulian Elischer * Instantiate a node of the requested type 5394cf49a43SJulian Elischer */ 5404cf49a43SJulian Elischer int 5414cf49a43SJulian Elischer ng_make_node(const char *typename, node_p *nodepp) 5424cf49a43SJulian Elischer { 5434cf49a43SJulian Elischer struct ng_type *type; 544069154d5SJulian Elischer int error; 5454cf49a43SJulian Elischer 5464cf49a43SJulian Elischer /* Check that the type makes sense */ 5474cf49a43SJulian Elischer if (typename == NULL) { 5486b795970SJulian Elischer TRAP_ERROR(); 5494cf49a43SJulian Elischer return (EINVAL); 5504cf49a43SJulian Elischer } 5514cf49a43SJulian Elischer 5527610f574SGleb Smirnoff /* Locate the node type. If we fail we return. Do not try to load 5537610f574SGleb Smirnoff * module. 5547610f574SGleb Smirnoff */ 5554cf49a43SJulian Elischer if ((type = ng_findtype(typename)) == NULL) 5564cf49a43SJulian Elischer return (ENXIO); 5574cf49a43SJulian Elischer 558069154d5SJulian Elischer /* 559069154d5SJulian Elischer * If we have a constructor, then make the node and 560069154d5SJulian Elischer * call the constructor to do type specific initialisation. 561069154d5SJulian Elischer */ 562069154d5SJulian Elischer if (type->constructor != NULL) { 563069154d5SJulian Elischer if ((error = ng_make_node_common(type, nodepp)) == 0) { 564069154d5SJulian Elischer if ((error = ((*type->constructor)(*nodepp)) != 0)) { 56530400f03SJulian Elischer NG_NODE_UNREF(*nodepp); 566069154d5SJulian Elischer } 567069154d5SJulian Elischer } 568069154d5SJulian Elischer } else { 569069154d5SJulian Elischer /* 570069154d5SJulian Elischer * Node has no constructor. We cannot ask for one 571069154d5SJulian Elischer * to be made. It must be brought into existance by 572954c4772SJulian Elischer * some external agency. The external agency should 573069154d5SJulian Elischer * call ng_make_node_common() directly to get the 574069154d5SJulian Elischer * netgraph part initialised. 575069154d5SJulian Elischer */ 5766b795970SJulian Elischer TRAP_ERROR(); 577069154d5SJulian Elischer error = EINVAL; 578069154d5SJulian Elischer } 579069154d5SJulian Elischer return (error); 5804cf49a43SJulian Elischer } 5814cf49a43SJulian Elischer 5824cf49a43SJulian Elischer /* 583069154d5SJulian Elischer * Generic node creation. Called by node initialisation for externally 584069154d5SJulian Elischer * instantiated nodes (e.g. hardware, sockets, etc ). 5854cf49a43SJulian Elischer * The returned node has a reference count of 1. 5864cf49a43SJulian Elischer */ 5874cf49a43SJulian Elischer int 5884cf49a43SJulian Elischer ng_make_node_common(struct ng_type *type, node_p *nodepp) 5894cf49a43SJulian Elischer { 5904cf49a43SJulian Elischer node_p node; 5914cf49a43SJulian Elischer 5924cf49a43SJulian Elischer /* Require the node type to have been already installed */ 5934cf49a43SJulian Elischer if (ng_findtype(type->name) == NULL) { 5946b795970SJulian Elischer TRAP_ERROR(); 5954cf49a43SJulian Elischer return (EINVAL); 5964cf49a43SJulian Elischer } 5974cf49a43SJulian Elischer 5984cf49a43SJulian Elischer /* Make a node and try attach it to the type */ 59930400f03SJulian Elischer NG_ALLOC_NODE(node); 6004cf49a43SJulian Elischer if (node == NULL) { 6016b795970SJulian Elischer TRAP_ERROR(); 6024cf49a43SJulian Elischer return (ENOMEM); 6034cf49a43SJulian Elischer } 60430400f03SJulian Elischer node->nd_type = type; 60530400f03SJulian Elischer NG_NODE_REF(node); /* note reference */ 6064cf49a43SJulian Elischer type->refs++; 6074cf49a43SJulian Elischer 6086008862bSJohn Baldwin mtx_init(&node->nd_input_queue.q_mtx, "ng_node", NULL, MTX_SPIN); 60930400f03SJulian Elischer node->nd_input_queue.queue = NULL; 61030400f03SJulian Elischer node->nd_input_queue.last = &node->nd_input_queue.queue; 61130400f03SJulian Elischer node->nd_input_queue.q_flags = 0; 61230400f03SJulian Elischer node->nd_input_queue.q_node = node; 6134cf49a43SJulian Elischer 6144cf49a43SJulian Elischer /* Initialize hook list for new node */ 61530400f03SJulian Elischer LIST_INIT(&node->nd_hooks); 6164cf49a43SJulian Elischer 617069154d5SJulian Elischer /* Link us into the node linked list */ 6189ed346baSBosko Milekic mtx_lock(&ng_nodelist_mtx); 61930400f03SJulian Elischer LIST_INSERT_HEAD(&ng_nodelist, node, nd_nodes); 6209ed346baSBosko Milekic mtx_unlock(&ng_nodelist_mtx); 621069154d5SJulian Elischer 622069154d5SJulian Elischer 623dc90cad9SJulian Elischer /* get an ID and put us in the hash chain */ 6249ed346baSBosko Milekic mtx_lock(&ng_idhash_mtx); 62530400f03SJulian Elischer for (;;) { /* wrap protection, even if silly */ 626069154d5SJulian Elischer node_p node2 = NULL; 62730400f03SJulian Elischer node->nd_ID = nextID++; /* 137/second for 1 year before wrap */ 6280f150d04SJulian Elischer 62930400f03SJulian Elischer /* Is there a problem with the new number? */ 6300f150d04SJulian Elischer NG_IDHASH_FIND(node->nd_ID, node2); /* already taken? */ 6310f150d04SJulian Elischer if ((node->nd_ID != 0) && (node2 == NULL)) { 63230400f03SJulian Elischer break; 633069154d5SJulian Elischer } 63430400f03SJulian Elischer } 6350f150d04SJulian Elischer LIST_INSERT_HEAD(&ng_ID_hash[NG_IDHASH_FN(node->nd_ID)], 63630400f03SJulian Elischer node, nd_idnodes); 6379ed346baSBosko Milekic mtx_unlock(&ng_idhash_mtx); 638dc90cad9SJulian Elischer 6394cf49a43SJulian Elischer /* Done */ 6404cf49a43SJulian Elischer *nodepp = node; 6414cf49a43SJulian Elischer return (0); 6424cf49a43SJulian Elischer } 6434cf49a43SJulian Elischer 6444cf49a43SJulian Elischer /* 6454cf49a43SJulian Elischer * Forceably start the shutdown process on a node. Either call 6464cf49a43SJulian Elischer * it's shutdown method, or do the default shutdown if there is 6474cf49a43SJulian Elischer * no type-specific method. 6484cf49a43SJulian Elischer * 649069154d5SJulian Elischer * We can only be called form a shutdown message, so we know we have 6503e4084c8SJulian Elischer * a writer lock, and therefore exclusive access. It also means 6513e4084c8SJulian Elischer * that we should not be on the work queue, but we check anyhow. 652069154d5SJulian Elischer * 653069154d5SJulian Elischer * Persistent node types must have a type-specific method which 6543e4084c8SJulian Elischer * Allocates a new node in which case, this one is irretrievably going away, 6553e4084c8SJulian Elischer * or cleans up anything it needs, and just makes the node valid again, 6563e4084c8SJulian Elischer * in which case we allow the node to survive. 6573e4084c8SJulian Elischer * 6583e4084c8SJulian Elischer * XXX We need to think of how to tell a persistant node that we 6593e4084c8SJulian Elischer * REALLY need to go away because the hardware has gone or we 6603e4084c8SJulian Elischer * are rebooting.... etc. 6614cf49a43SJulian Elischer */ 6624cf49a43SJulian Elischer void 6631acb27c6SJulian Elischer ng_rmnode(node_p node, hook_p dummy1, void *dummy2, int dummy3) 6644cf49a43SJulian Elischer { 6653e4084c8SJulian Elischer hook_p hook; 6663e4084c8SJulian Elischer 6674cf49a43SJulian Elischer /* Check if it's already shutting down */ 668be4252b3SJulian Elischer if ((node->nd_flags & NGF_CLOSING) != 0) 6694cf49a43SJulian Elischer return; 6704cf49a43SJulian Elischer 6711acb27c6SJulian Elischer if (node == &ng_deadnode) { 6721acb27c6SJulian Elischer printf ("shutdown called on deadnode\n"); 6731acb27c6SJulian Elischer return; 6741acb27c6SJulian Elischer } 6751acb27c6SJulian Elischer 6764cf49a43SJulian Elischer /* Add an extra reference so it doesn't go away during this */ 67730400f03SJulian Elischer NG_NODE_REF(node); 6784cf49a43SJulian Elischer 67930400f03SJulian Elischer /* 68030400f03SJulian Elischer * Mark it invalid so any newcomers know not to try use it 68130400f03SJulian Elischer * Also add our own mark so we can't recurse 682be4252b3SJulian Elischer * note that NGF_INVALID does not do this as it's also set during 68330400f03SJulian Elischer * creation 68430400f03SJulian Elischer */ 685be4252b3SJulian Elischer node->nd_flags |= NGF_INVALID|NGF_CLOSING; 6864cf49a43SJulian Elischer 687991fc65aSJulian Elischer /* If node has its pre-shutdown method, then call it first*/ 688991fc65aSJulian Elischer if (node->nd_type && node->nd_type->close) 689991fc65aSJulian Elischer (*node->nd_type->close)(node); 690991fc65aSJulian Elischer 6913e4084c8SJulian Elischer /* Notify all remaining connected nodes to disconnect */ 6923e4084c8SJulian Elischer while ((hook = LIST_FIRST(&node->nd_hooks)) != NULL) 6933e4084c8SJulian Elischer ng_destroy_hook(hook); 69430400f03SJulian Elischer 695069154d5SJulian Elischer /* 696069154d5SJulian Elischer * Drain the input queue forceably. 69730400f03SJulian Elischer * it has no hooks so what's it going to do, bleed on someone? 69830400f03SJulian Elischer * Theoretically we came here from a queue entry that was added 69930400f03SJulian Elischer * Just before the queue was closed, so it should be empty anyway. 700b57a7965SJulian Elischer * Also removes us from worklist if needed. 701069154d5SJulian Elischer */ 70230400f03SJulian Elischer ng_flush_input_queue(&node->nd_input_queue); 703069154d5SJulian Elischer 704069154d5SJulian Elischer /* Ask the type if it has anything to do in this case */ 70530400f03SJulian Elischer if (node->nd_type && node->nd_type->shutdown) { 70630400f03SJulian Elischer (*node->nd_type->shutdown)(node); 70730400f03SJulian Elischer if (NG_NODE_IS_VALID(node)) { 70830400f03SJulian Elischer /* 70930400f03SJulian Elischer * Well, blow me down if the node code hasn't declared 71030400f03SJulian Elischer * that it doesn't want to die. 71130400f03SJulian Elischer * Presumably it is a persistant node. 7121acb27c6SJulian Elischer * If we REALLY want it to go away, 7131acb27c6SJulian Elischer * e.g. hardware going away, 714be4252b3SJulian Elischer * Our caller should set NGF_REALLY_DIE in nd_flags. 71530400f03SJulian Elischer */ 716be4252b3SJulian Elischer node->nd_flags &= ~(NGF_INVALID|NGF_CLOSING); 7171acb27c6SJulian Elischer NG_NODE_UNREF(node); /* Assume they still have theirs */ 71830400f03SJulian Elischer return; 7194cf49a43SJulian Elischer } 7201acb27c6SJulian Elischer } else { /* do the default thing */ 7211acb27c6SJulian Elischer NG_NODE_UNREF(node); 7221acb27c6SJulian Elischer } 7234cf49a43SJulian Elischer 72430400f03SJulian Elischer ng_unname(node); /* basically a NOP these days */ 72530400f03SJulian Elischer 72630400f03SJulian Elischer /* 72730400f03SJulian Elischer * Remove extra reference, possibly the last 72830400f03SJulian Elischer * Possible other holders of references may include 72930400f03SJulian Elischer * timeout callouts, but theoretically the node's supposed to 73030400f03SJulian Elischer * have cancelled them. Possibly hardware dependencies may 73130400f03SJulian Elischer * force a driver to 'linger' with a reference. 73230400f03SJulian Elischer */ 73330400f03SJulian Elischer NG_NODE_UNREF(node); 7344cf49a43SJulian Elischer } 7354cf49a43SJulian Elischer 7365951069aSJulian Elischer /* 7375951069aSJulian Elischer * Remove a reference to the node, possibly the last. 7385951069aSJulian Elischer * deadnode always acts as it it were the last. 7395951069aSJulian Elischer */ 7405951069aSJulian Elischer int 74130400f03SJulian Elischer ng_unref_node(node_p node) 7424cf49a43SJulian Elischer { 74330400f03SJulian Elischer int v; 7446b795970SJulian Elischer 7456b795970SJulian Elischer if (node == &ng_deadnode) { 7465951069aSJulian Elischer return (0); 7476b795970SJulian Elischer } 7486b795970SJulian Elischer 74930400f03SJulian Elischer do { 7505951069aSJulian Elischer v = node->nd_refs - 1; 7515951069aSJulian Elischer } while (! atomic_cmpset_int(&node->nd_refs, v + 1, v)); 752e8a49db2SJulian Elischer 7535951069aSJulian Elischer if (v == 0) { /* we were the last */ 754069154d5SJulian Elischer 7559ed346baSBosko Milekic mtx_lock(&ng_nodelist_mtx); 75630400f03SJulian Elischer node->nd_type->refs--; /* XXX maybe should get types lock? */ 75730400f03SJulian Elischer LIST_REMOVE(node, nd_nodes); 7589ed346baSBosko Milekic mtx_unlock(&ng_nodelist_mtx); 759069154d5SJulian Elischer 7609ed346baSBosko Milekic mtx_lock(&ng_idhash_mtx); 76130400f03SJulian Elischer LIST_REMOVE(node, nd_idnodes); 7629ed346baSBosko Milekic mtx_unlock(&ng_idhash_mtx); 763069154d5SJulian Elischer 76412574a02SJulian Elischer mtx_destroy(&node->nd_input_queue.q_mtx); 765069154d5SJulian Elischer NG_FREE_NODE(node); 7664cf49a43SJulian Elischer } 7675951069aSJulian Elischer return (v); 7684cf49a43SJulian Elischer } 7694cf49a43SJulian Elischer 7704cf49a43SJulian Elischer /************************************************************************ 771dc90cad9SJulian Elischer Node ID handling 772dc90cad9SJulian Elischer ************************************************************************/ 773dc90cad9SJulian Elischer static node_p 774069154d5SJulian Elischer ng_ID2noderef(ng_ID_t ID) 775dc90cad9SJulian Elischer { 77630400f03SJulian Elischer node_p node; 7779ed346baSBosko Milekic mtx_lock(&ng_idhash_mtx); 7780f150d04SJulian Elischer NG_IDHASH_FIND(ID, node); 77930400f03SJulian Elischer if(node) 78030400f03SJulian Elischer NG_NODE_REF(node); 7819ed346baSBosko Milekic mtx_unlock(&ng_idhash_mtx); 78230400f03SJulian Elischer return(node); 783dc90cad9SJulian Elischer } 784dc90cad9SJulian Elischer 785dc90cad9SJulian Elischer ng_ID_t 786dc90cad9SJulian Elischer ng_node2ID(node_p node) 787dc90cad9SJulian Elischer { 78870de87f2SJulian Elischer return (node ? NG_NODE_ID(node) : 0); 789dc90cad9SJulian Elischer } 790dc90cad9SJulian Elischer 791dc90cad9SJulian Elischer /************************************************************************ 7924cf49a43SJulian Elischer Node name handling 7934cf49a43SJulian Elischer ************************************************************************/ 7944cf49a43SJulian Elischer 7954cf49a43SJulian Elischer /* 7964cf49a43SJulian Elischer * Assign a node a name. Once assigned, the name cannot be changed. 7974cf49a43SJulian Elischer */ 7984cf49a43SJulian Elischer int 7994cf49a43SJulian Elischer ng_name_node(node_p node, const char *name) 8004cf49a43SJulian Elischer { 8014cf49a43SJulian Elischer int i; 802069154d5SJulian Elischer node_p node2; 8034cf49a43SJulian Elischer 8044cf49a43SJulian Elischer /* Check the name is valid */ 80587e2c66aSHartmut Brandt for (i = 0; i < NG_NODESIZ; i++) { 8064cf49a43SJulian Elischer if (name[i] == '\0' || name[i] == '.' || name[i] == ':') 8074cf49a43SJulian Elischer break; 8084cf49a43SJulian Elischer } 8094cf49a43SJulian Elischer if (i == 0 || name[i] != '\0') { 8106b795970SJulian Elischer TRAP_ERROR(); 8114cf49a43SJulian Elischer return (EINVAL); 8124cf49a43SJulian Elischer } 813dc90cad9SJulian Elischer if (ng_decodeidname(name) != 0) { /* valid IDs not allowed here */ 8146b795970SJulian Elischer TRAP_ERROR(); 8154cf49a43SJulian Elischer return (EINVAL); 8164cf49a43SJulian Elischer } 8174cf49a43SJulian Elischer 8184cf49a43SJulian Elischer /* Check the name isn't already being used */ 819069154d5SJulian Elischer if ((node2 = ng_name2noderef(node, name)) != NULL) { 82030400f03SJulian Elischer NG_NODE_UNREF(node2); 8216b795970SJulian Elischer TRAP_ERROR(); 8224cf49a43SJulian Elischer return (EADDRINUSE); 8234cf49a43SJulian Elischer } 8244cf49a43SJulian Elischer 825069154d5SJulian Elischer /* copy it */ 82687e2c66aSHartmut Brandt strlcpy(NG_NODE_NAME(node), name, NG_NODESIZ); 8274cf49a43SJulian Elischer 8284cf49a43SJulian Elischer return (0); 8294cf49a43SJulian Elischer } 8304cf49a43SJulian Elischer 8314cf49a43SJulian Elischer /* 8324cf49a43SJulian Elischer * Find a node by absolute name. The name should NOT end with ':' 8334cf49a43SJulian Elischer * The name "." means "this node" and "[xxx]" means "the node 8344cf49a43SJulian Elischer * with ID (ie, at address) xxx". 8354cf49a43SJulian Elischer * 8364cf49a43SJulian Elischer * Returns the node if found, else NULL. 837069154d5SJulian Elischer * Eventually should add something faster than a sequential search. 83830400f03SJulian Elischer * Note it aquires a reference on the node so you can be sure it's still there. 8394cf49a43SJulian Elischer */ 8404cf49a43SJulian Elischer node_p 841069154d5SJulian Elischer ng_name2noderef(node_p here, const char *name) 8424cf49a43SJulian Elischer { 843dc90cad9SJulian Elischer node_p node; 844dc90cad9SJulian Elischer ng_ID_t temp; 8454cf49a43SJulian Elischer 8464cf49a43SJulian Elischer /* "." means "this node" */ 847069154d5SJulian Elischer if (strcmp(name, ".") == 0) { 84830400f03SJulian Elischer NG_NODE_REF(here); 849069154d5SJulian Elischer return(here); 850069154d5SJulian Elischer } 8514cf49a43SJulian Elischer 8524cf49a43SJulian Elischer /* Check for name-by-ID */ 853dc90cad9SJulian Elischer if ((temp = ng_decodeidname(name)) != 0) { 854069154d5SJulian Elischer return (ng_ID2noderef(temp)); 8554cf49a43SJulian Elischer } 8564cf49a43SJulian Elischer 8574cf49a43SJulian Elischer /* Find node by name */ 8589ed346baSBosko Milekic mtx_lock(&ng_nodelist_mtx); 85930400f03SJulian Elischer LIST_FOREACH(node, &ng_nodelist, nd_nodes) { 86070de87f2SJulian Elischer if (NG_NODE_IS_VALID(node) 86170de87f2SJulian Elischer && NG_NODE_HAS_NAME(node) 86270de87f2SJulian Elischer && (strcmp(NG_NODE_NAME(node), name) == 0)) { 8634cf49a43SJulian Elischer break; 8644cf49a43SJulian Elischer } 86570de87f2SJulian Elischer } 866069154d5SJulian Elischer if (node) 86730400f03SJulian Elischer NG_NODE_REF(node); 8689ed346baSBosko Milekic mtx_unlock(&ng_nodelist_mtx); 8694cf49a43SJulian Elischer return (node); 8704cf49a43SJulian Elischer } 8714cf49a43SJulian Elischer 8724cf49a43SJulian Elischer /* 8739d5abbddSJens Schweikhardt * Decode an ID name, eg. "[f03034de]". Returns 0 if the 874dc90cad9SJulian Elischer * string is not valid, otherwise returns the value. 8754cf49a43SJulian Elischer */ 876dc90cad9SJulian Elischer static ng_ID_t 8774cf49a43SJulian Elischer ng_decodeidname(const char *name) 8784cf49a43SJulian Elischer { 8792b70adcbSArchie Cobbs const int len = strlen(name); 88025792ef3SArchie Cobbs char *eptr; 8812b70adcbSArchie Cobbs u_long val; 8824cf49a43SJulian Elischer 8832b70adcbSArchie Cobbs /* Check for proper length, brackets, no leading junk */ 88470de87f2SJulian Elischer if ((len < 3) 88570de87f2SJulian Elischer || (name[0] != '[') 88670de87f2SJulian Elischer || (name[len - 1] != ']') 88770de87f2SJulian Elischer || (!isxdigit(name[1]))) { 88870de87f2SJulian Elischer return ((ng_ID_t)0); 88970de87f2SJulian Elischer } 8904cf49a43SJulian Elischer 8912b70adcbSArchie Cobbs /* Decode number */ 8922b70adcbSArchie Cobbs val = strtoul(name + 1, &eptr, 16); 89370de87f2SJulian Elischer if ((eptr - name != len - 1) 89470de87f2SJulian Elischer || (val == ULONG_MAX) 89570de87f2SJulian Elischer || (val == 0)) { 89612f035e0SJulian Elischer return ((ng_ID_t)0); 89770de87f2SJulian Elischer } 8982b70adcbSArchie Cobbs return (ng_ID_t)val; 8994cf49a43SJulian Elischer } 9004cf49a43SJulian Elischer 9014cf49a43SJulian Elischer /* 9024cf49a43SJulian Elischer * Remove a name from a node. This should only be called 9034cf49a43SJulian Elischer * when shutting down and removing the node. 9041acb27c6SJulian Elischer * IF we allow name changing this may be more resurected. 9054cf49a43SJulian Elischer */ 9064cf49a43SJulian Elischer void 9074cf49a43SJulian Elischer ng_unname(node_p node) 9084cf49a43SJulian Elischer { 9094cf49a43SJulian Elischer } 9104cf49a43SJulian Elischer 9114cf49a43SJulian Elischer /************************************************************************ 9124cf49a43SJulian Elischer Hook routines 9134cf49a43SJulian Elischer Names are not optional. Hooks are always connected, except for a 9143e4084c8SJulian Elischer brief moment within these routines. On invalidation or during creation 9153e4084c8SJulian Elischer they are connected to the 'dead' hook. 9164cf49a43SJulian Elischer ************************************************************************/ 9174cf49a43SJulian Elischer 9184cf49a43SJulian Elischer /* 9194cf49a43SJulian Elischer * Remove a hook reference 9204cf49a43SJulian Elischer */ 92130400f03SJulian Elischer void 9224cf49a43SJulian Elischer ng_unref_hook(hook_p hook) 9234cf49a43SJulian Elischer { 92430400f03SJulian Elischer int v; 9256b795970SJulian Elischer 9266b795970SJulian Elischer if (hook == &ng_deadhook) { 9276b795970SJulian Elischer return; 9286b795970SJulian Elischer } 92930400f03SJulian Elischer do { 93030400f03SJulian Elischer v = hook->hk_refs; 93130400f03SJulian Elischer } while (! atomic_cmpset_int(&hook->hk_refs, v, v - 1)); 932e8a49db2SJulian Elischer 93330400f03SJulian Elischer if (v == 1) { /* we were the last */ 9346b795970SJulian Elischer if (_NG_HOOK_NODE(hook)) { /* it'll probably be ng_deadnode */ 9356b795970SJulian Elischer _NG_NODE_UNREF((_NG_HOOK_NODE(hook))); 93630400f03SJulian Elischer hook->hk_node = NULL; 937069154d5SJulian Elischer } 938069154d5SJulian Elischer NG_FREE_HOOK(hook); 939069154d5SJulian Elischer } 9404cf49a43SJulian Elischer } 9414cf49a43SJulian Elischer 9424cf49a43SJulian Elischer /* 9434cf49a43SJulian Elischer * Add an unconnected hook to a node. Only used internally. 9443e4084c8SJulian Elischer * Assumes node is locked. (XXX not yet true ) 9454cf49a43SJulian Elischer */ 9464cf49a43SJulian Elischer static int 9474cf49a43SJulian Elischer ng_add_hook(node_p node, const char *name, hook_p *hookp) 9484cf49a43SJulian Elischer { 9494cf49a43SJulian Elischer hook_p hook; 9504cf49a43SJulian Elischer int error = 0; 9514cf49a43SJulian Elischer 9524cf49a43SJulian Elischer /* Check that the given name is good */ 9534cf49a43SJulian Elischer if (name == NULL) { 9546b795970SJulian Elischer TRAP_ERROR(); 9554cf49a43SJulian Elischer return (EINVAL); 9564cf49a43SJulian Elischer } 957899e9c4eSArchie Cobbs if (ng_findhook(node, name) != NULL) { 9586b795970SJulian Elischer TRAP_ERROR(); 9594cf49a43SJulian Elischer return (EEXIST); 9604cf49a43SJulian Elischer } 9614cf49a43SJulian Elischer 9624cf49a43SJulian Elischer /* Allocate the hook and link it up */ 96330400f03SJulian Elischer NG_ALLOC_HOOK(hook); 9644cf49a43SJulian Elischer if (hook == NULL) { 9656b795970SJulian Elischer TRAP_ERROR(); 9664cf49a43SJulian Elischer return (ENOMEM); 9674cf49a43SJulian Elischer } 9683e4084c8SJulian Elischer hook->hk_refs = 1; /* add a reference for us to return */ 96930400f03SJulian Elischer hook->hk_flags = HK_INVALID; 9703e4084c8SJulian Elischer hook->hk_peer = &ng_deadhook; /* start off this way */ 97130400f03SJulian Elischer hook->hk_node = node; 97230400f03SJulian Elischer NG_NODE_REF(node); /* each hook counts as a reference */ 9734cf49a43SJulian Elischer 9743e4084c8SJulian Elischer /* Set hook name */ 97587e2c66aSHartmut Brandt strlcpy(NG_HOOK_NAME(hook), name, NG_HOOKSIZ); 9763e4084c8SJulian Elischer 9773e4084c8SJulian Elischer /* 9783e4084c8SJulian Elischer * Check if the node type code has something to say about it 9793e4084c8SJulian Elischer * If it fails, the unref of the hook will also unref the node. 9803e4084c8SJulian Elischer */ 981954c4772SJulian Elischer if (node->nd_type->newhook != NULL) { 982954c4772SJulian Elischer if ((error = (*node->nd_type->newhook)(node, hook, name))) { 98330400f03SJulian Elischer NG_HOOK_UNREF(hook); /* this frees the hook */ 984069154d5SJulian Elischer return (error); 985069154d5SJulian Elischer } 986954c4772SJulian Elischer } 9874cf49a43SJulian Elischer /* 9884cf49a43SJulian Elischer * The 'type' agrees so far, so go ahead and link it in. 9894cf49a43SJulian Elischer * We'll ask again later when we actually connect the hooks. 9904cf49a43SJulian Elischer */ 99130400f03SJulian Elischer LIST_INSERT_HEAD(&node->nd_hooks, hook, hk_hooks); 99230400f03SJulian Elischer node->nd_numhooks++; 9933e4084c8SJulian Elischer NG_HOOK_REF(hook); /* one for the node */ 9944cf49a43SJulian Elischer 9954cf49a43SJulian Elischer if (hookp) 9964cf49a43SJulian Elischer *hookp = hook; 9973e4084c8SJulian Elischer return (0); 9984cf49a43SJulian Elischer } 9994cf49a43SJulian Elischer 10004cf49a43SJulian Elischer /* 1001899e9c4eSArchie Cobbs * Find a hook 1002899e9c4eSArchie Cobbs * 1003899e9c4eSArchie Cobbs * Node types may supply their own optimized routines for finding 1004899e9c4eSArchie Cobbs * hooks. If none is supplied, we just do a linear search. 10053e4084c8SJulian Elischer * XXX Possibly we should add a reference to the hook? 1006899e9c4eSArchie Cobbs */ 1007899e9c4eSArchie Cobbs hook_p 1008899e9c4eSArchie Cobbs ng_findhook(node_p node, const char *name) 1009899e9c4eSArchie Cobbs { 1010899e9c4eSArchie Cobbs hook_p hook; 1011899e9c4eSArchie Cobbs 101230400f03SJulian Elischer if (node->nd_type->findhook != NULL) 101330400f03SJulian Elischer return (*node->nd_type->findhook)(node, name); 101430400f03SJulian Elischer LIST_FOREACH(hook, &node->nd_hooks, hk_hooks) { 101570de87f2SJulian Elischer if (NG_HOOK_IS_VALID(hook) 1016ce5e5f99SArchie Cobbs && (strcmp(NG_HOOK_NAME(hook), name) == 0)) 1017899e9c4eSArchie Cobbs return (hook); 1018899e9c4eSArchie Cobbs } 1019899e9c4eSArchie Cobbs return (NULL); 1020899e9c4eSArchie Cobbs } 1021899e9c4eSArchie Cobbs 1022899e9c4eSArchie Cobbs /* 10234cf49a43SJulian Elischer * Destroy a hook 10244cf49a43SJulian Elischer * 10254cf49a43SJulian Elischer * As hooks are always attached, this really destroys two hooks. 10264cf49a43SJulian Elischer * The one given, and the one attached to it. Disconnect the hooks 10273e4084c8SJulian Elischer * from each other first. We reconnect the peer hook to the 'dead' 10283e4084c8SJulian Elischer * hook so that it can still exist after we depart. We then 10293e4084c8SJulian Elischer * send the peer its own destroy message. This ensures that we only 10303e4084c8SJulian Elischer * interact with the peer's structures when it is locked processing that 10313e4084c8SJulian Elischer * message. We hold a reference to the peer hook so we are guaranteed that 10323e4084c8SJulian Elischer * the peer hook and node are still going to exist until 10333e4084c8SJulian Elischer * we are finished there as the hook holds a ref on the node. 10343e4084c8SJulian Elischer * We run this same code again on the peer hook, but that time it is already 10353e4084c8SJulian Elischer * attached to the 'dead' hook. 10366b795970SJulian Elischer * 10376b795970SJulian Elischer * This routine is called at all stages of hook creation 10386b795970SJulian Elischer * on error detection and must be able to handle any such stage. 10394cf49a43SJulian Elischer */ 10404cf49a43SJulian Elischer void 10414cf49a43SJulian Elischer ng_destroy_hook(hook_p hook) 10424cf49a43SJulian Elischer { 1043ac5dd141SGleb Smirnoff hook_p peer; 1044ac5dd141SGleb Smirnoff node_p node; 10454cf49a43SJulian Elischer 10466b795970SJulian Elischer if (hook == &ng_deadhook) { /* better safe than sorry */ 10476b795970SJulian Elischer printf("ng_destroy_hook called on deadhook\n"); 10486b795970SJulian Elischer return; 10496b795970SJulian Elischer } 1050ac5dd141SGleb Smirnoff 1051ac5dd141SGleb Smirnoff /* 1052ac5dd141SGleb Smirnoff * Protect divorce process with mutex, to avoid races on 1053ac5dd141SGleb Smirnoff * simultaneous disconnect. 1054ac5dd141SGleb Smirnoff */ 1055ac5dd141SGleb Smirnoff mtx_lock(&ng_topo_mtx); 1056ac5dd141SGleb Smirnoff 1057ac5dd141SGleb Smirnoff hook->hk_flags |= HK_INVALID; 1058ac5dd141SGleb Smirnoff 1059ac5dd141SGleb Smirnoff peer = NG_HOOK_PEER(hook); 1060ac5dd141SGleb Smirnoff node = NG_HOOK_NODE(hook); 1061ac5dd141SGleb Smirnoff 10623e4084c8SJulian Elischer if (peer && (peer != &ng_deadhook)) { 10633e4084c8SJulian Elischer /* 10643e4084c8SJulian Elischer * Set the peer to point to ng_deadhook 10653e4084c8SJulian Elischer * from this moment on we are effectively independent it. 10663e4084c8SJulian Elischer * send it an rmhook message of it's own. 10673e4084c8SJulian Elischer */ 10683e4084c8SJulian Elischer peer->hk_peer = &ng_deadhook; /* They no longer know us */ 10693e4084c8SJulian Elischer hook->hk_peer = &ng_deadhook; /* Nor us, them */ 10706b795970SJulian Elischer if (NG_HOOK_NODE(peer) == &ng_deadnode) { 10716b795970SJulian Elischer /* 10726b795970SJulian Elischer * If it's already divorced from a node, 10736b795970SJulian Elischer * just free it. 10746b795970SJulian Elischer */ 1075ac5dd141SGleb Smirnoff mtx_unlock(&ng_topo_mtx); 10766b795970SJulian Elischer } else { 1077ac5dd141SGleb Smirnoff mtx_unlock(&ng_topo_mtx); 10786b795970SJulian Elischer ng_rmhook_self(peer); /* Send it a surprise */ 10796b795970SJulian Elischer } 108052fa3556SJulian Elischer NG_HOOK_UNREF(peer); /* account for peer link */ 108152fa3556SJulian Elischer NG_HOOK_UNREF(hook); /* account for peer link */ 1082ac5dd141SGleb Smirnoff } else 1083ac5dd141SGleb Smirnoff mtx_unlock(&ng_topo_mtx); 1084ac5dd141SGleb Smirnoff 1085ac5dd141SGleb Smirnoff mtx_assert(&ng_topo_mtx, MA_NOTOWNED); 10864cf49a43SJulian Elischer 10874cf49a43SJulian Elischer /* 10884cf49a43SJulian Elischer * Remove the hook from the node's list to avoid possible recursion 10894cf49a43SJulian Elischer * in case the disconnection results in node shutdown. 10904cf49a43SJulian Elischer */ 10916b795970SJulian Elischer if (node == &ng_deadnode) { /* happens if called from ng_con_nodes() */ 10926b795970SJulian Elischer return; 10936b795970SJulian Elischer } 109430400f03SJulian Elischer LIST_REMOVE(hook, hk_hooks); 109530400f03SJulian Elischer node->nd_numhooks--; 109630400f03SJulian Elischer if (node->nd_type->disconnect) { 10974cf49a43SJulian Elischer /* 10986b795970SJulian Elischer * The type handler may elect to destroy the node so don't 10996b795970SJulian Elischer * trust its existance after this point. (except 11006b795970SJulian Elischer * that we still hold a reference on it. (which we 11016b795970SJulian Elischer * inherrited from the hook we are destroying) 11024cf49a43SJulian Elischer */ 110330400f03SJulian Elischer (*node->nd_type->disconnect) (hook); 11044cf49a43SJulian Elischer } 11056b795970SJulian Elischer 11066b795970SJulian Elischer /* 11076b795970SJulian Elischer * Note that because we will point to ng_deadnode, the original node 11086b795970SJulian Elischer * is not decremented automatically so we do that manually. 11096b795970SJulian Elischer */ 11106b795970SJulian Elischer _NG_HOOK_NODE(hook) = &ng_deadnode; 11116b795970SJulian Elischer NG_NODE_UNREF(node); /* We no longer point to it so adjust count */ 11126b795970SJulian Elischer NG_HOOK_UNREF(hook); /* Account for linkage (in list) to node */ 11134cf49a43SJulian Elischer } 11144cf49a43SJulian Elischer 11154cf49a43SJulian Elischer /* 11164cf49a43SJulian Elischer * Take two hooks on a node and merge the connection so that the given node 11174cf49a43SJulian Elischer * is effectively bypassed. 11184cf49a43SJulian Elischer */ 11194cf49a43SJulian Elischer int 11204cf49a43SJulian Elischer ng_bypass(hook_p hook1, hook_p hook2) 11214cf49a43SJulian Elischer { 112230400f03SJulian Elischer if (hook1->hk_node != hook2->hk_node) { 11236b795970SJulian Elischer TRAP_ERROR(); 11244cf49a43SJulian Elischer return (EINVAL); 112530400f03SJulian Elischer } 112630400f03SJulian Elischer hook1->hk_peer->hk_peer = hook2->hk_peer; 112730400f03SJulian Elischer hook2->hk_peer->hk_peer = hook1->hk_peer; 11284cf49a43SJulian Elischer 11293e4084c8SJulian Elischer hook1->hk_peer = &ng_deadhook; 11303e4084c8SJulian Elischer hook2->hk_peer = &ng_deadhook; 11313e4084c8SJulian Elischer 1132cf3254aaSGleb Smirnoff NG_HOOK_UNREF(hook1); 1133cf3254aaSGleb Smirnoff NG_HOOK_UNREF(hook2); 1134cf3254aaSGleb Smirnoff 11354cf49a43SJulian Elischer /* XXX If we ever cache methods on hooks update them as well */ 11364cf49a43SJulian Elischer ng_destroy_hook(hook1); 11374cf49a43SJulian Elischer ng_destroy_hook(hook2); 11384cf49a43SJulian Elischer return (0); 11394cf49a43SJulian Elischer } 11404cf49a43SJulian Elischer 11414cf49a43SJulian Elischer /* 11424cf49a43SJulian Elischer * Install a new netgraph type 11434cf49a43SJulian Elischer */ 11444cf49a43SJulian Elischer int 11454cf49a43SJulian Elischer ng_newtype(struct ng_type *tp) 11464cf49a43SJulian Elischer { 11474cf49a43SJulian Elischer const size_t namelen = strlen(tp->name); 11484cf49a43SJulian Elischer 11494cf49a43SJulian Elischer /* Check version and type name fields */ 1150589f6ed8SJulian Elischer if ((tp->version != NG_ABI_VERSION) 1151589f6ed8SJulian Elischer || (namelen == 0) 115287e2c66aSHartmut Brandt || (namelen >= NG_TYPESIZ)) { 11536b795970SJulian Elischer TRAP_ERROR(); 11548ed370fdSJulian Elischer if (tp->version != NG_ABI_VERSION) { 11558ed370fdSJulian Elischer printf("Netgraph: Node type rejected. ABI mismatch. Suggest recompile\n"); 11568ed370fdSJulian Elischer } 11574cf49a43SJulian Elischer return (EINVAL); 11584cf49a43SJulian Elischer } 11594cf49a43SJulian Elischer 11604cf49a43SJulian Elischer /* Check for name collision */ 11614cf49a43SJulian Elischer if (ng_findtype(tp->name) != NULL) { 11626b795970SJulian Elischer TRAP_ERROR(); 11634cf49a43SJulian Elischer return (EEXIST); 11644cf49a43SJulian Elischer } 11654cf49a43SJulian Elischer 1166069154d5SJulian Elischer 1167069154d5SJulian Elischer /* Link in new type */ 11689ed346baSBosko Milekic mtx_lock(&ng_typelist_mtx); 1169069154d5SJulian Elischer LIST_INSERT_HEAD(&ng_typelist, tp, types); 1170c73b94a2SJulian Elischer tp->refs = 1; /* first ref is linked list */ 11719ed346baSBosko Milekic mtx_unlock(&ng_typelist_mtx); 11724cf49a43SJulian Elischer return (0); 11734cf49a43SJulian Elischer } 11744cf49a43SJulian Elischer 11754cf49a43SJulian Elischer /* 1176c31b4a53SJulian Elischer * unlink a netgraph type 1177c31b4a53SJulian Elischer * If no examples exist 1178c31b4a53SJulian Elischer */ 1179c31b4a53SJulian Elischer int 1180c31b4a53SJulian Elischer ng_rmtype(struct ng_type *tp) 1181c31b4a53SJulian Elischer { 1182c31b4a53SJulian Elischer /* Check for name collision */ 1183c31b4a53SJulian Elischer if (tp->refs != 1) { 1184c31b4a53SJulian Elischer TRAP_ERROR(); 1185c31b4a53SJulian Elischer return (EBUSY); 1186c31b4a53SJulian Elischer } 1187c31b4a53SJulian Elischer 1188c31b4a53SJulian Elischer /* Unlink type */ 1189c31b4a53SJulian Elischer mtx_lock(&ng_typelist_mtx); 1190c31b4a53SJulian Elischer LIST_REMOVE(tp, types); 1191c31b4a53SJulian Elischer mtx_unlock(&ng_typelist_mtx); 1192c31b4a53SJulian Elischer return (0); 1193c31b4a53SJulian Elischer } 1194c31b4a53SJulian Elischer 1195c31b4a53SJulian Elischer /* 11964cf49a43SJulian Elischer * Look for a type of the name given 11974cf49a43SJulian Elischer */ 11984cf49a43SJulian Elischer struct ng_type * 11994cf49a43SJulian Elischer ng_findtype(const char *typename) 12004cf49a43SJulian Elischer { 12014cf49a43SJulian Elischer struct ng_type *type; 12024cf49a43SJulian Elischer 12039ed346baSBosko Milekic mtx_lock(&ng_typelist_mtx); 1204069154d5SJulian Elischer LIST_FOREACH(type, &ng_typelist, types) { 12054cf49a43SJulian Elischer if (strcmp(type->name, typename) == 0) 12064cf49a43SJulian Elischer break; 12074cf49a43SJulian Elischer } 12089ed346baSBosko Milekic mtx_unlock(&ng_typelist_mtx); 12094cf49a43SJulian Elischer return (type); 12104cf49a43SJulian Elischer } 12114cf49a43SJulian Elischer 12124cf49a43SJulian Elischer /************************************************************************ 12134cf49a43SJulian Elischer Composite routines 12144cf49a43SJulian Elischer ************************************************************************/ 12154cf49a43SJulian Elischer /* 12166b795970SJulian Elischer * Connect two nodes using the specified hooks, using queued functions. 12174cf49a43SJulian Elischer */ 12181acb27c6SJulian Elischer static void 12196b795970SJulian Elischer ng_con_part3(node_p node, hook_p hook, void *arg1, int arg2) 12204cf49a43SJulian Elischer { 12214cf49a43SJulian Elischer 12226b795970SJulian Elischer /* 12236b795970SJulian Elischer * When we run, we know that the node 'node' is locked for us. 12246b795970SJulian Elischer * Our caller has a reference on the hook. 12256b795970SJulian Elischer * Our caller has a reference on the node. 12266b795970SJulian Elischer * (In this case our caller is ng_apply_item() ). 12276b795970SJulian Elischer * The peer hook has a reference on the hook. 12281acb27c6SJulian Elischer * We are all set up except for the final call to the node, and 12291acb27c6SJulian Elischer * the clearing of the INVALID flag. 12306b795970SJulian Elischer */ 12316b795970SJulian Elischer if (NG_HOOK_NODE(hook) == &ng_deadnode) { 12326b795970SJulian Elischer /* 12336b795970SJulian Elischer * The node must have been freed again since we last visited 12346b795970SJulian Elischer * here. ng_destry_hook() has this effect but nothing else does. 12356b795970SJulian Elischer * We should just release our references and 12366b795970SJulian Elischer * free anything we can think of. 12376b795970SJulian Elischer * Since we know it's been destroyed, and it's our caller 12386b795970SJulian Elischer * that holds the references, just return. 12396b795970SJulian Elischer */ 12401acb27c6SJulian Elischer return ; 12416b795970SJulian Elischer } 12426b795970SJulian Elischer if (hook->hk_node->nd_type->connect) { 12431acb27c6SJulian Elischer if ((*hook->hk_node->nd_type->connect) (hook)) { 12446b795970SJulian Elischer ng_destroy_hook(hook); /* also zaps peer */ 12451acb27c6SJulian Elischer printf("failed in ng_con_part3()\n"); 12461acb27c6SJulian Elischer return ; 12474cf49a43SJulian Elischer } 12486b795970SJulian Elischer } 12496b795970SJulian Elischer /* 12506b795970SJulian Elischer * XXX this is wrong for SMP. Possibly we need 12516b795970SJulian Elischer * to separate out 'create' and 'invalid' flags. 12526b795970SJulian Elischer * should only set flags on hooks we have locked under our node. 12536b795970SJulian Elischer */ 12546b795970SJulian Elischer hook->hk_flags &= ~HK_INVALID; 12551acb27c6SJulian Elischer return ; 12566b795970SJulian Elischer } 12576b795970SJulian Elischer 12581acb27c6SJulian Elischer static void 12596b795970SJulian Elischer ng_con_part2(node_p node, hook_p hook, void *arg1, int arg2) 12606b795970SJulian Elischer { 1261ac5dd141SGleb Smirnoff hook_p peer; 12626b795970SJulian Elischer 12636b795970SJulian Elischer /* 12646b795970SJulian Elischer * When we run, we know that the node 'node' is locked for us. 12656b795970SJulian Elischer * Our caller has a reference on the hook. 12666b795970SJulian Elischer * Our caller has a reference on the node. 12676b795970SJulian Elischer * (In this case our caller is ng_apply_item() ). 12686b795970SJulian Elischer * The peer hook has a reference on the hook. 12696b795970SJulian Elischer * our node pointer points to the 'dead' node. 12706b795970SJulian Elischer * First check the hook name is unique. 12711acb27c6SJulian Elischer * Should not happen because we checked before queueing this. 12726b795970SJulian Elischer */ 12736b795970SJulian Elischer if (ng_findhook(node, NG_HOOK_NAME(hook)) != NULL) { 12746b795970SJulian Elischer TRAP_ERROR(); 12756b795970SJulian Elischer ng_destroy_hook(hook); /* should destroy peer too */ 12761acb27c6SJulian Elischer printf("failed in ng_con_part2()\n"); 12771acb27c6SJulian Elischer return ; 12786b795970SJulian Elischer } 12796b795970SJulian Elischer /* 12806b795970SJulian Elischer * Check if the node type code has something to say about it 12816b795970SJulian Elischer * If it fails, the unref of the hook will also unref the attached node, 12826b795970SJulian Elischer * however since that node is 'ng_deadnode' this will do nothing. 12836b795970SJulian Elischer * The peer hook will also be destroyed. 12846b795970SJulian Elischer */ 12856b795970SJulian Elischer if (node->nd_type->newhook != NULL) { 12861acb27c6SJulian Elischer if ((*node->nd_type->newhook)(node, hook, hook->hk_name)) { 12876b795970SJulian Elischer ng_destroy_hook(hook); /* should destroy peer too */ 12881acb27c6SJulian Elischer printf("failed in ng_con_part2()\n"); 12891acb27c6SJulian Elischer return ; 12906b795970SJulian Elischer } 12916b795970SJulian Elischer } 12926b795970SJulian Elischer 12936b795970SJulian Elischer /* 12946b795970SJulian Elischer * The 'type' agrees so far, so go ahead and link it in. 12956b795970SJulian Elischer * We'll ask again later when we actually connect the hooks. 12966b795970SJulian Elischer */ 12976b795970SJulian Elischer hook->hk_node = node; /* just overwrite ng_deadnode */ 12986b795970SJulian Elischer NG_NODE_REF(node); /* each hook counts as a reference */ 12996b795970SJulian Elischer LIST_INSERT_HEAD(&node->nd_hooks, hook, hk_hooks); 13006b795970SJulian Elischer node->nd_numhooks++; 13016b795970SJulian Elischer NG_HOOK_REF(hook); /* one for the node */ 13026b795970SJulian Elischer 13036b795970SJulian Elischer /* 13046b795970SJulian Elischer * We now have a symetrical situation, where both hooks have been 13055951069aSJulian Elischer * linked to their nodes, the newhook methods have been called 13066b795970SJulian Elischer * And the references are all correct. The hooks are still marked 13076b795970SJulian Elischer * as invalid, as we have not called the 'connect' methods 13086b795970SJulian Elischer * yet. 13096b795970SJulian Elischer * We can call the local one immediatly as we have the 13106b795970SJulian Elischer * node locked, but we need to queue the remote one. 13116b795970SJulian Elischer */ 13126b795970SJulian Elischer if (hook->hk_node->nd_type->connect) { 13131acb27c6SJulian Elischer if ((*hook->hk_node->nd_type->connect) (hook)) { 13146b795970SJulian Elischer ng_destroy_hook(hook); /* also zaps peer */ 13151acb27c6SJulian Elischer printf("failed in ng_con_part2(A)\n"); 13161acb27c6SJulian Elischer return ; 13176b795970SJulian Elischer } 13186b795970SJulian Elischer } 1319ac5dd141SGleb Smirnoff 1320ac5dd141SGleb Smirnoff /* 1321ac5dd141SGleb Smirnoff * Acquire topo mutex to avoid race with ng_destroy_hook(). 1322ac5dd141SGleb Smirnoff */ 1323ac5dd141SGleb Smirnoff mtx_lock(&ng_topo_mtx); 1324ac5dd141SGleb Smirnoff peer = hook->hk_peer; 1325ac5dd141SGleb Smirnoff if (peer == &ng_deadhook) { 1326ac5dd141SGleb Smirnoff mtx_unlock(&ng_topo_mtx); 1327ac5dd141SGleb Smirnoff printf("failed in ng_con_part2(B)\n"); 1328ac5dd141SGleb Smirnoff ng_destroy_hook(hook); 1329ac5dd141SGleb Smirnoff return ; 1330ac5dd141SGleb Smirnoff } 1331ac5dd141SGleb Smirnoff mtx_unlock(&ng_topo_mtx); 1332ac5dd141SGleb Smirnoff 1333ac5dd141SGleb Smirnoff if (ng_send_fn(peer->hk_node, peer, &ng_con_part3, arg1, arg2)) { 1334ac5dd141SGleb Smirnoff printf("failed in ng_con_part2(C)\n"); 13351acb27c6SJulian Elischer ng_destroy_hook(hook); /* also zaps peer */ 13361acb27c6SJulian Elischer return ; 13371acb27c6SJulian Elischer } 13386b795970SJulian Elischer hook->hk_flags &= ~HK_INVALID; /* need both to be able to work */ 13391acb27c6SJulian Elischer return ; 13404cf49a43SJulian Elischer } 13414cf49a43SJulian Elischer 13424cf49a43SJulian Elischer /* 13436b795970SJulian Elischer * Connect this node with another node. We assume that this node is 13446b795970SJulian Elischer * currently locked, as we are only called from an NGM_CONNECT message. 13454cf49a43SJulian Elischer */ 13466b795970SJulian Elischer static int 13474cf49a43SJulian Elischer ng_con_nodes(node_p node, const char *name, node_p node2, const char *name2) 13484cf49a43SJulian Elischer { 13494cf49a43SJulian Elischer int error; 13504cf49a43SJulian Elischer hook_p hook; 13514cf49a43SJulian Elischer hook_p hook2; 13524cf49a43SJulian Elischer 13531acb27c6SJulian Elischer if (ng_findhook(node2, name2) != NULL) { 13541acb27c6SJulian Elischer return(EEXIST); 13551acb27c6SJulian Elischer } 13563e4084c8SJulian Elischer if ((error = ng_add_hook(node, name, &hook))) /* gives us a ref */ 13574cf49a43SJulian Elischer return (error); 13586b795970SJulian Elischer /* Allocate the other hook and link it up */ 13596b795970SJulian Elischer NG_ALLOC_HOOK(hook2); 136019724144SGleb Smirnoff if (hook2 == NULL) { 13616b795970SJulian Elischer TRAP_ERROR(); 13626b795970SJulian Elischer ng_destroy_hook(hook); /* XXX check ref counts so far */ 13636b795970SJulian Elischer NG_HOOK_UNREF(hook); /* including our ref */ 13646b795970SJulian Elischer return (ENOMEM); 13656b795970SJulian Elischer } 13666b795970SJulian Elischer hook2->hk_refs = 1; /* start with a reference for us. */ 13676b795970SJulian Elischer hook2->hk_flags = HK_INVALID; 13686b795970SJulian Elischer hook2->hk_peer = hook; /* Link the two together */ 13696b795970SJulian Elischer hook->hk_peer = hook2; 13706b795970SJulian Elischer NG_HOOK_REF(hook); /* Add a ref for the peer to each*/ 13716b795970SJulian Elischer NG_HOOK_REF(hook2); 13726b795970SJulian Elischer hook2->hk_node = &ng_deadnode; 137387e2c66aSHartmut Brandt strlcpy(NG_HOOK_NAME(hook2), name2, NG_HOOKSIZ); 13746b795970SJulian Elischer 13756b795970SJulian Elischer /* 13766b795970SJulian Elischer * Queue the function above. 13776b795970SJulian Elischer * Procesing continues in that function in the lock context of 13786b795970SJulian Elischer * the other node. 13796b795970SJulian Elischer */ 13801acb27c6SJulian Elischer ng_send_fn(node2, hook2, &ng_con_part2, NULL, 0); 13816b795970SJulian Elischer 13826b795970SJulian Elischer NG_HOOK_UNREF(hook); /* Let each hook go if it wants to */ 13836b795970SJulian Elischer NG_HOOK_UNREF(hook2); 13841acb27c6SJulian Elischer return (0); 13854cf49a43SJulian Elischer } 13866b795970SJulian Elischer 13876b795970SJulian Elischer /* 13886b795970SJulian Elischer * Make a peer and connect. 13896b795970SJulian Elischer * We assume that the local node is locked. 13906b795970SJulian Elischer * The new node probably doesn't need a lock until 13916b795970SJulian Elischer * it has a hook, because it cannot really have any work until then, 13926b795970SJulian Elischer * but we should think about it a bit more. 13936b795970SJulian Elischer * 13946b795970SJulian Elischer * The problem may come if the other node also fires up 13956b795970SJulian Elischer * some hardware or a timer or some other source of activation, 13966b795970SJulian Elischer * also it may already get a command msg via it's ID. 13976b795970SJulian Elischer * 13986b795970SJulian Elischer * We could use the same method as ng_con_nodes() but we'd have 13996b795970SJulian Elischer * to add ability to remove the node when failing. (Not hard, just 14006b795970SJulian Elischer * make arg1 point to the node to remove). 14016b795970SJulian Elischer * Unless of course we just ignore failure to connect and leave 14026b795970SJulian Elischer * an unconnected node? 14036b795970SJulian Elischer */ 14046b795970SJulian Elischer static int 14056b795970SJulian Elischer ng_mkpeer(node_p node, const char *name, const char *name2, char *type) 14066b795970SJulian Elischer { 14076b795970SJulian Elischer node_p node2; 14084c9b5910SGleb Smirnoff hook_p hook1, hook2; 14096b795970SJulian Elischer int error; 14106b795970SJulian Elischer 14116b795970SJulian Elischer if ((error = ng_make_node(type, &node2))) { 14126b795970SJulian Elischer return (error); 14136b795970SJulian Elischer } 14146b795970SJulian Elischer 14156b795970SJulian Elischer if ((error = ng_add_hook(node, name, &hook1))) { /* gives us a ref */ 14161acb27c6SJulian Elischer ng_rmnode(node2, NULL, NULL, 0); 14176b795970SJulian Elischer return (error); 14186b795970SJulian Elischer } 14196b795970SJulian Elischer 14206b795970SJulian Elischer if ((error = ng_add_hook(node2, name2, &hook2))) { 14211acb27c6SJulian Elischer ng_rmnode(node2, NULL, NULL, 0); 14226b795970SJulian Elischer ng_destroy_hook(hook1); 14236b795970SJulian Elischer NG_HOOK_UNREF(hook1); 14246b795970SJulian Elischer return (error); 14256b795970SJulian Elischer } 14266b795970SJulian Elischer 14276b795970SJulian Elischer /* 14286b795970SJulian Elischer * Actually link the two hooks together. 14296b795970SJulian Elischer */ 14306b795970SJulian Elischer hook1->hk_peer = hook2; 14316b795970SJulian Elischer hook2->hk_peer = hook1; 14326b795970SJulian Elischer 14336b795970SJulian Elischer /* Each hook is referenced by the other */ 14346b795970SJulian Elischer NG_HOOK_REF(hook1); 14356b795970SJulian Elischer NG_HOOK_REF(hook2); 14366b795970SJulian Elischer 14376b795970SJulian Elischer /* Give each node the opportunity to veto the pending connection */ 14386b795970SJulian Elischer if (hook1->hk_node->nd_type->connect) { 14396b795970SJulian Elischer error = (*hook1->hk_node->nd_type->connect) (hook1); 14406b795970SJulian Elischer } 14416b795970SJulian Elischer 14426b795970SJulian Elischer if ((error == 0) && hook2->hk_node->nd_type->connect) { 14436b795970SJulian Elischer error = (*hook2->hk_node->nd_type->connect) (hook2); 14446b795970SJulian Elischer 14456b795970SJulian Elischer } 14463e4084c8SJulian Elischer 14473e4084c8SJulian Elischer /* 14483e4084c8SJulian Elischer * drop the references we were holding on the two hooks. 14493e4084c8SJulian Elischer */ 14506b795970SJulian Elischer if (error) { 14516b795970SJulian Elischer ng_destroy_hook(hook2); /* also zaps hook1 */ 14521acb27c6SJulian Elischer ng_rmnode(node2, NULL, NULL, 0); 14536b795970SJulian Elischer } else { 14546b795970SJulian Elischer /* As a last act, allow the hooks to be used */ 14556b795970SJulian Elischer hook1->hk_flags &= ~HK_INVALID; 14566b795970SJulian Elischer hook2->hk_flags &= ~HK_INVALID; 14576b795970SJulian Elischer } 14586b795970SJulian Elischer NG_HOOK_UNREF(hook1); 14593e4084c8SJulian Elischer NG_HOOK_UNREF(hook2); 14603e4084c8SJulian Elischer return (error); 14614cf49a43SJulian Elischer } 14626b795970SJulian Elischer 1463069154d5SJulian Elischer /************************************************************************ 1464069154d5SJulian Elischer Utility routines to send self messages 1465069154d5SJulian Elischer ************************************************************************/ 1466069154d5SJulian Elischer 14671acb27c6SJulian Elischer /* Shut this node down as soon as everyone is clear of it */ 14681acb27c6SJulian Elischer /* Should add arg "immediatly" to jump the queue */ 1469069154d5SJulian Elischer int 14701acb27c6SJulian Elischer ng_rmnode_self(node_p node) 1471069154d5SJulian Elischer { 14721acb27c6SJulian Elischer int error; 14734cf49a43SJulian Elischer 14741acb27c6SJulian Elischer if (node == &ng_deadnode) 14751acb27c6SJulian Elischer return (0); 1476be4252b3SJulian Elischer node->nd_flags |= NGF_INVALID; 1477be4252b3SJulian Elischer if (node->nd_flags & NGF_CLOSING) 14781acb27c6SJulian Elischer return (0); 1479069154d5SJulian Elischer 14801acb27c6SJulian Elischer error = ng_send_fn(node, NULL, &ng_rmnode, NULL, 0); 14811acb27c6SJulian Elischer return (error); 1482069154d5SJulian Elischer } 1483069154d5SJulian Elischer 14841acb27c6SJulian Elischer static void 14856b795970SJulian Elischer ng_rmhook_part2(node_p node, hook_p hook, void *arg1, int arg2) 14866b795970SJulian Elischer { 14876b795970SJulian Elischer ng_destroy_hook(hook); 14881acb27c6SJulian Elischer return ; 14896b795970SJulian Elischer } 14906b795970SJulian Elischer 1491954c4772SJulian Elischer int 1492954c4772SJulian Elischer ng_rmhook_self(hook_p hook) 1493954c4772SJulian Elischer { 14946b795970SJulian Elischer int error; 1495954c4772SJulian Elischer node_p node = NG_HOOK_NODE(hook); 1496954c4772SJulian Elischer 14976b795970SJulian Elischer if (node == &ng_deadnode) 14986b795970SJulian Elischer return (0); 14996b795970SJulian Elischer 15006b795970SJulian Elischer error = ng_send_fn(node, hook, &ng_rmhook_part2, NULL, 0); 15016b795970SJulian Elischer return (error); 1502954c4772SJulian Elischer } 1503954c4772SJulian Elischer 1504069154d5SJulian Elischer /*********************************************************************** 15054cf49a43SJulian Elischer * Parse and verify a string of the form: <NODE:><PATH> 15064cf49a43SJulian Elischer * 15074cf49a43SJulian Elischer * Such a string can refer to a specific node or a specific hook 15084cf49a43SJulian Elischer * on a specific node, depending on how you look at it. In the 15094cf49a43SJulian Elischer * latter case, the PATH component must not end in a dot. 15104cf49a43SJulian Elischer * 15114cf49a43SJulian Elischer * Both <NODE:> and <PATH> are optional. The <PATH> is a string 15124cf49a43SJulian Elischer * of hook names separated by dots. This breaks out the original 15134cf49a43SJulian Elischer * string, setting *nodep to "NODE" (or NULL if none) and *pathp 15144cf49a43SJulian Elischer * to "PATH" (or NULL if degenerate). Also, *hookp will point to 15154cf49a43SJulian Elischer * the final hook component of <PATH>, if any, otherwise NULL. 15164cf49a43SJulian Elischer * 15174cf49a43SJulian Elischer * This returns -1 if the path is malformed. The char ** are optional. 1518069154d5SJulian Elischer ***********************************************************************/ 15194cf49a43SJulian Elischer int 15204cf49a43SJulian Elischer ng_path_parse(char *addr, char **nodep, char **pathp, char **hookp) 15214cf49a43SJulian Elischer { 15224cf49a43SJulian Elischer char *node, *path, *hook; 15234cf49a43SJulian Elischer int k; 15244cf49a43SJulian Elischer 15254cf49a43SJulian Elischer /* 15264cf49a43SJulian Elischer * Extract absolute NODE, if any 15274cf49a43SJulian Elischer */ 15284cf49a43SJulian Elischer for (path = addr; *path && *path != ':'; path++); 15294cf49a43SJulian Elischer if (*path) { 15304cf49a43SJulian Elischer node = addr; /* Here's the NODE */ 15314cf49a43SJulian Elischer *path++ = '\0'; /* Here's the PATH */ 15324cf49a43SJulian Elischer 15334cf49a43SJulian Elischer /* Node name must not be empty */ 15344cf49a43SJulian Elischer if (!*node) 15354cf49a43SJulian Elischer return -1; 15364cf49a43SJulian Elischer 15374cf49a43SJulian Elischer /* A name of "." is OK; otherwise '.' not allowed */ 15384cf49a43SJulian Elischer if (strcmp(node, ".") != 0) { 15394cf49a43SJulian Elischer for (k = 0; node[k]; k++) 15404cf49a43SJulian Elischer if (node[k] == '.') 15414cf49a43SJulian Elischer return -1; 15424cf49a43SJulian Elischer } 15434cf49a43SJulian Elischer } else { 15444cf49a43SJulian Elischer node = NULL; /* No absolute NODE */ 15454cf49a43SJulian Elischer path = addr; /* Here's the PATH */ 15464cf49a43SJulian Elischer } 15474cf49a43SJulian Elischer 15484cf49a43SJulian Elischer /* Snoop for illegal characters in PATH */ 15494cf49a43SJulian Elischer for (k = 0; path[k]; k++) 15504cf49a43SJulian Elischer if (path[k] == ':') 15514cf49a43SJulian Elischer return -1; 15524cf49a43SJulian Elischer 15534cf49a43SJulian Elischer /* Check for no repeated dots in PATH */ 15544cf49a43SJulian Elischer for (k = 0; path[k]; k++) 15554cf49a43SJulian Elischer if (path[k] == '.' && path[k + 1] == '.') 15564cf49a43SJulian Elischer return -1; 15574cf49a43SJulian Elischer 15584cf49a43SJulian Elischer /* Remove extra (degenerate) dots from beginning or end of PATH */ 15594cf49a43SJulian Elischer if (path[0] == '.') 15604cf49a43SJulian Elischer path++; 15614cf49a43SJulian Elischer if (*path && path[strlen(path) - 1] == '.') 15624cf49a43SJulian Elischer path[strlen(path) - 1] = 0; 15634cf49a43SJulian Elischer 15644cf49a43SJulian Elischer /* If PATH has a dot, then we're not talking about a hook */ 15654cf49a43SJulian Elischer if (*path) { 15664cf49a43SJulian Elischer for (hook = path, k = 0; path[k]; k++) 15674cf49a43SJulian Elischer if (path[k] == '.') { 15684cf49a43SJulian Elischer hook = NULL; 15694cf49a43SJulian Elischer break; 15704cf49a43SJulian Elischer } 15714cf49a43SJulian Elischer } else 15724cf49a43SJulian Elischer path = hook = NULL; 15734cf49a43SJulian Elischer 15744cf49a43SJulian Elischer /* Done */ 15754cf49a43SJulian Elischer if (nodep) 15764cf49a43SJulian Elischer *nodep = node; 15774cf49a43SJulian Elischer if (pathp) 15784cf49a43SJulian Elischer *pathp = path; 15794cf49a43SJulian Elischer if (hookp) 15804cf49a43SJulian Elischer *hookp = hook; 15814cf49a43SJulian Elischer return (0); 15824cf49a43SJulian Elischer } 15834cf49a43SJulian Elischer 15844cf49a43SJulian Elischer /* 15854cf49a43SJulian Elischer * Given a path, which may be absolute or relative, and a starting node, 1586069154d5SJulian Elischer * return the destination node. 15874cf49a43SJulian Elischer */ 15884cf49a43SJulian Elischer int 1589069154d5SJulian Elischer ng_path2noderef(node_p here, const char *address, 1590069154d5SJulian Elischer node_p *destp, hook_p *lasthook) 15914cf49a43SJulian Elischer { 159287e2c66aSHartmut Brandt char fullpath[NG_PATHSIZ]; 15934cf49a43SJulian Elischer char *nodename, *path, pbuf[2]; 1594069154d5SJulian Elischer node_p node, oldnode; 15954cf49a43SJulian Elischer char *cp; 1596a4ec03cfSJulian Elischer hook_p hook = NULL; 15974cf49a43SJulian Elischer 15984cf49a43SJulian Elischer /* Initialize */ 159930400f03SJulian Elischer if (destp == NULL) { 16006b795970SJulian Elischer TRAP_ERROR(); 16014cf49a43SJulian Elischer return EINVAL; 160230400f03SJulian Elischer } 16034cf49a43SJulian Elischer *destp = NULL; 16044cf49a43SJulian Elischer 16054cf49a43SJulian Elischer /* Make a writable copy of address for ng_path_parse() */ 16064cf49a43SJulian Elischer strncpy(fullpath, address, sizeof(fullpath) - 1); 16074cf49a43SJulian Elischer fullpath[sizeof(fullpath) - 1] = '\0'; 16084cf49a43SJulian Elischer 16094cf49a43SJulian Elischer /* Parse out node and sequence of hooks */ 16104cf49a43SJulian Elischer if (ng_path_parse(fullpath, &nodename, &path, NULL) < 0) { 16116b795970SJulian Elischer TRAP_ERROR(); 16124cf49a43SJulian Elischer return EINVAL; 16134cf49a43SJulian Elischer } 16144cf49a43SJulian Elischer if (path == NULL) { 16154cf49a43SJulian Elischer pbuf[0] = '.'; /* Needs to be writable */ 16164cf49a43SJulian Elischer pbuf[1] = '\0'; 16174cf49a43SJulian Elischer path = pbuf; 16184cf49a43SJulian Elischer } 16194cf49a43SJulian Elischer 1620069154d5SJulian Elischer /* 1621069154d5SJulian Elischer * For an absolute address, jump to the starting node. 1622069154d5SJulian Elischer * Note that this holds a reference on the node for us. 1623069154d5SJulian Elischer * Don't forget to drop the reference if we don't need it. 1624069154d5SJulian Elischer */ 16254cf49a43SJulian Elischer if (nodename) { 1626069154d5SJulian Elischer node = ng_name2noderef(here, nodename); 16274cf49a43SJulian Elischer if (node == NULL) { 16286b795970SJulian Elischer TRAP_ERROR(); 16294cf49a43SJulian Elischer return (ENOENT); 16304cf49a43SJulian Elischer } 1631069154d5SJulian Elischer } else { 1632069154d5SJulian Elischer if (here == NULL) { 16336b795970SJulian Elischer TRAP_ERROR(); 1634069154d5SJulian Elischer return (EINVAL); 1635069154d5SJulian Elischer } 16364cf49a43SJulian Elischer node = here; 163730400f03SJulian Elischer NG_NODE_REF(node); 1638069154d5SJulian Elischer } 16394cf49a43SJulian Elischer 1640069154d5SJulian Elischer /* 1641069154d5SJulian Elischer * Now follow the sequence of hooks 1642069154d5SJulian Elischer * XXX 1643069154d5SJulian Elischer * We actually cannot guarantee that the sequence 1644069154d5SJulian Elischer * is not being demolished as we crawl along it 1645069154d5SJulian Elischer * without extra-ordinary locking etc. 1646069154d5SJulian Elischer * So this is a bit dodgy to say the least. 1647069154d5SJulian Elischer * We can probably hold up some things by holding 1648069154d5SJulian Elischer * the nodelist mutex for the time of this 1649069154d5SJulian Elischer * crawl if we wanted.. At least that way we wouldn't have to 1650069154d5SJulian Elischer * worry about the nodes dissappearing, but the hooks would still 1651069154d5SJulian Elischer * be a problem. 1652069154d5SJulian Elischer */ 16534cf49a43SJulian Elischer for (cp = path; node != NULL && *cp != '\0'; ) { 16544cf49a43SJulian Elischer char *segment; 16554cf49a43SJulian Elischer 16564cf49a43SJulian Elischer /* 16574cf49a43SJulian Elischer * Break out the next path segment. Replace the dot we just 16584cf49a43SJulian Elischer * found with a NUL; "cp" points to the next segment (or the 16594cf49a43SJulian Elischer * NUL at the end). 16604cf49a43SJulian Elischer */ 16614cf49a43SJulian Elischer for (segment = cp; *cp != '\0'; cp++) { 16624cf49a43SJulian Elischer if (*cp == '.') { 16634cf49a43SJulian Elischer *cp++ = '\0'; 16644cf49a43SJulian Elischer break; 16654cf49a43SJulian Elischer } 16664cf49a43SJulian Elischer } 16674cf49a43SJulian Elischer 16684cf49a43SJulian Elischer /* Empty segment */ 16694cf49a43SJulian Elischer if (*segment == '\0') 16704cf49a43SJulian Elischer continue; 16714cf49a43SJulian Elischer 16724cf49a43SJulian Elischer /* We have a segment, so look for a hook by that name */ 1673899e9c4eSArchie Cobbs hook = ng_findhook(node, segment); 16744cf49a43SJulian Elischer 16754cf49a43SJulian Elischer /* Can't get there from here... */ 16764cf49a43SJulian Elischer if (hook == NULL 167730400f03SJulian Elischer || NG_HOOK_PEER(hook) == NULL 167830400f03SJulian Elischer || NG_HOOK_NOT_VALID(hook) 167930400f03SJulian Elischer || NG_HOOK_NOT_VALID(NG_HOOK_PEER(hook))) { 16806b795970SJulian Elischer TRAP_ERROR(); 168130400f03SJulian Elischer NG_NODE_UNREF(node); 168230400f03SJulian Elischer #if 0 168330400f03SJulian Elischer printf("hooknotvalid %s %s %d %d %d %d ", 168430400f03SJulian Elischer path, 168530400f03SJulian Elischer segment, 168630400f03SJulian Elischer hook == NULL, 168730400f03SJulian Elischer NG_HOOK_PEER(hook) == NULL, 168830400f03SJulian Elischer NG_HOOK_NOT_VALID(hook), 168930400f03SJulian Elischer NG_HOOK_NOT_VALID(NG_HOOK_PEER(hook))); 169030400f03SJulian Elischer #endif 16914cf49a43SJulian Elischer return (ENOENT); 16924cf49a43SJulian Elischer } 16934cf49a43SJulian Elischer 1694069154d5SJulian Elischer /* 1695069154d5SJulian Elischer * Hop on over to the next node 1696069154d5SJulian Elischer * XXX 1697069154d5SJulian Elischer * Big race conditions here as hooks and nodes go away 1698069154d5SJulian Elischer * *** Idea.. store an ng_ID_t in each hook and use that 1699069154d5SJulian Elischer * instead of the direct hook in this crawl? 1700069154d5SJulian Elischer */ 1701069154d5SJulian Elischer oldnode = node; 170230400f03SJulian Elischer if ((node = NG_PEER_NODE(hook))) 170330400f03SJulian Elischer NG_NODE_REF(node); /* XXX RACE */ 170430400f03SJulian Elischer NG_NODE_UNREF(oldnode); /* XXX another race */ 170530400f03SJulian Elischer if (NG_NODE_NOT_VALID(node)) { 170630400f03SJulian Elischer NG_NODE_UNREF(node); /* XXX more races */ 1707069154d5SJulian Elischer node = NULL; 1708069154d5SJulian Elischer } 17094cf49a43SJulian Elischer } 17104cf49a43SJulian Elischer 17114cf49a43SJulian Elischer /* If node somehow missing, fail here (probably this is not needed) */ 17124cf49a43SJulian Elischer if (node == NULL) { 17136b795970SJulian Elischer TRAP_ERROR(); 17144cf49a43SJulian Elischer return (ENXIO); 17154cf49a43SJulian Elischer } 17164cf49a43SJulian Elischer 17174cf49a43SJulian Elischer /* Done */ 17184cf49a43SJulian Elischer *destp = node; 17191bdebe4dSArchie Cobbs if (lasthook != NULL) 172030400f03SJulian Elischer *lasthook = (hook ? NG_HOOK_PEER(hook) : NULL); 1721069154d5SJulian Elischer return (0); 1722069154d5SJulian Elischer } 1723069154d5SJulian Elischer 1724069154d5SJulian Elischer /***************************************************************\ 1725069154d5SJulian Elischer * Input queue handling. 1726069154d5SJulian Elischer * All activities are submitted to the node via the input queue 1727069154d5SJulian Elischer * which implements a multiple-reader/single-writer gate. 1728069154d5SJulian Elischer * Items which cannot be handled immeditly are queued. 1729069154d5SJulian Elischer * 1730069154d5SJulian Elischer * read-write queue locking inline functions * 1731069154d5SJulian Elischer \***************************************************************/ 1732069154d5SJulian Elischer 1733714fb865SGleb Smirnoff static __inline item_p ng_dequeue(struct ng_queue * ngq, int *rw); 1734069154d5SJulian Elischer static __inline item_p ng_acquire_read(struct ng_queue * ngq, 1735069154d5SJulian Elischer item_p item); 1736069154d5SJulian Elischer static __inline item_p ng_acquire_write(struct ng_queue * ngq, 1737069154d5SJulian Elischer item_p item); 1738069154d5SJulian Elischer static __inline void ng_leave_read(struct ng_queue * ngq); 1739069154d5SJulian Elischer static __inline void ng_leave_write(struct ng_queue * ngq); 1740069154d5SJulian Elischer static __inline void ng_queue_rw(struct ng_queue * ngq, 1741069154d5SJulian Elischer item_p item, int rw); 1742069154d5SJulian Elischer 1743069154d5SJulian Elischer /* 1744069154d5SJulian Elischer * Definition of the bits fields in the ng_queue flag word. 1745069154d5SJulian Elischer * Defined here rather than in netgraph.h because no-one should fiddle 1746069154d5SJulian Elischer * with them. 1747069154d5SJulian Elischer * 1748b57a7965SJulian Elischer * The ordering here may be important! don't shuffle these. 1749069154d5SJulian Elischer */ 1750069154d5SJulian Elischer /*- 1751069154d5SJulian Elischer Safety Barrier--------+ (adjustable to suit taste) (not used yet) 1752069154d5SJulian Elischer | 1753069154d5SJulian Elischer V 1754069154d5SJulian Elischer +-------+-------+-------+-------+-------+-------+-------+-------+ 17554be59335SGleb Smirnoff | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 17564be59335SGleb Smirnoff | |A|c|t|i|v|e| |R|e|a|d|e|r| |C|o|u|n|t| | | | | | | | | |P|A| 17574be59335SGleb Smirnoff | | | | | | | | | | | | | | | | | | | | | | | | | | | | | |O|W| 1758069154d5SJulian Elischer +-------+-------+-------+-------+-------+-------+-------+-------+ 17594be59335SGleb Smirnoff \___________________________ ____________________________/ | | 17604be59335SGleb Smirnoff V | | 17614be59335SGleb Smirnoff [active reader count] | | 1762069154d5SJulian Elischer | | 17634be59335SGleb Smirnoff Operation Pending -------------------------------+ | 1764069154d5SJulian Elischer | 17654be59335SGleb Smirnoff Active Writer ---------------------------------------+ 1766b57a7965SJulian Elischer 1767b57a7965SJulian Elischer 1768069154d5SJulian Elischer */ 17694be59335SGleb Smirnoff #define WRITER_ACTIVE 0x00000001 17704be59335SGleb Smirnoff #define OP_PENDING 0x00000002 17714be59335SGleb Smirnoff #define READER_INCREMENT 0x00000004 17724be59335SGleb Smirnoff #define READER_MASK 0xfffffffc /* Not valid if WRITER_ACTIVE is set */ 17734be59335SGleb Smirnoff #define SAFETY_BARRIER 0x00100000 /* 128K items queued should be enough */ 1774b57a7965SJulian Elischer 1775b57a7965SJulian Elischer /* Defines of more elaborate states on the queue */ 17764be59335SGleb Smirnoff /* Mask of bits a new read cares about */ 17774be59335SGleb Smirnoff #define NGQ_RMASK (WRITER_ACTIVE|OP_PENDING) 1778b57a7965SJulian Elischer 17794be59335SGleb Smirnoff /* Mask of bits a new write cares about */ 1780b57a7965SJulian Elischer #define NGQ_WMASK (NGQ_RMASK|READER_MASK) 1781b57a7965SJulian Elischer 17824be59335SGleb Smirnoff /* Test to decide if there is something on the queue. */ 17834be59335SGleb Smirnoff #define QUEUE_ACTIVE(QP) ((QP)->q_flags & OP_PENDING) 17844be59335SGleb Smirnoff 17854be59335SGleb Smirnoff /* How to decide what the next queued item is. */ 17864be59335SGleb Smirnoff #define HEAD_IS_READER(QP) NGI_QUEUED_READER((QP)->queue) 17874be59335SGleb Smirnoff #define HEAD_IS_WRITER(QP) NGI_QUEUED_WRITER((QP)->queue) /* notused */ 17884be59335SGleb Smirnoff 17894be59335SGleb Smirnoff /* Read the status to decide if the next item on the queue can now run. */ 17904be59335SGleb Smirnoff #define QUEUED_READER_CAN_PROCEED(QP) \ 17914be59335SGleb Smirnoff (((QP)->q_flags & (NGQ_RMASK & ~OP_PENDING)) == 0) 17924be59335SGleb Smirnoff #define QUEUED_WRITER_CAN_PROCEED(QP) \ 17934be59335SGleb Smirnoff (((QP)->q_flags & (NGQ_WMASK & ~OP_PENDING)) == 0) 1794b57a7965SJulian Elischer 1795b57a7965SJulian Elischer /* Is there a chance of getting ANY work off the queue? */ 17964be59335SGleb Smirnoff #define NEXT_QUEUED_ITEM_CAN_PROCEED(QP) \ 17974be59335SGleb Smirnoff (QUEUE_ACTIVE(QP) && \ 17984be59335SGleb Smirnoff ((HEAD_IS_READER(QP)) ? QUEUED_READER_CAN_PROCEED(QP) : \ 17994be59335SGleb Smirnoff QUEUED_WRITER_CAN_PROCEED(QP))) 18004be59335SGleb Smirnoff 1801b57a7965SJulian Elischer 1802714fb865SGleb Smirnoff #define NGQRW_R 0 1803714fb865SGleb Smirnoff #define NGQRW_W 1 1804714fb865SGleb Smirnoff 1805069154d5SJulian Elischer /* 1806069154d5SJulian Elischer * Taking into account the current state of the queue and node, possibly take 1807069154d5SJulian Elischer * the next entry off the queue and return it. Return NULL if there was 1808069154d5SJulian Elischer * nothing we could return, either because there really was nothing there, or 1809069154d5SJulian Elischer * because the node was in a state where it cannot yet process the next item 1810069154d5SJulian Elischer * on the queue. 1811069154d5SJulian Elischer * 1812069154d5SJulian Elischer * This MUST MUST MUST be called with the mutex held. 1813069154d5SJulian Elischer */ 1814069154d5SJulian Elischer static __inline item_p 1815714fb865SGleb Smirnoff ng_dequeue(struct ng_queue *ngq, int *rw) 1816069154d5SJulian Elischer { 1817069154d5SJulian Elischer item_p item; 1818069154d5SJulian Elischer u_int add_arg; 1819b57a7965SJulian Elischer 1820d58e678fSGleb Smirnoff mtx_assert(&ngq->q_mtx, MA_OWNED); 18214be59335SGleb Smirnoff /* 18224be59335SGleb Smirnoff * If there is nothing queued, then just return. 18234be59335SGleb Smirnoff * No point in continuing. 18244be59335SGleb Smirnoff * XXXGL: assert this? 18254be59335SGleb Smirnoff */ 18264be59335SGleb Smirnoff if (!QUEUE_ACTIVE(ngq)) { 18272955ee18SGleb Smirnoff CTR4(KTR_NET, "%20s: node [%x] (%p) queue empty; " 18282955ee18SGleb Smirnoff "queue flags 0x%lx", __func__, 18292955ee18SGleb Smirnoff ngq->q_node->nd_ID, ngq->q_node, ngq->q_flags); 18304be59335SGleb Smirnoff return (NULL); 18314be59335SGleb Smirnoff } 1832d58e678fSGleb Smirnoff 18334be59335SGleb Smirnoff /* 18344be59335SGleb Smirnoff * From here, we can assume there is a head item. 18354be59335SGleb Smirnoff * We need to find out what it is and if it can be dequeued, given 18364be59335SGleb Smirnoff * the current state of the node. 18374be59335SGleb Smirnoff */ 18384be59335SGleb Smirnoff if (HEAD_IS_READER(ngq)) { 18394be59335SGleb Smirnoff if (!QUEUED_READER_CAN_PROCEED(ngq)) { 18404be59335SGleb Smirnoff /* 18414be59335SGleb Smirnoff * It's a reader but we can't use it. 18424be59335SGleb Smirnoff * We are stalled so make sure we don't 18434be59335SGleb Smirnoff * get called again until something changes. 18444be59335SGleb Smirnoff */ 18454be59335SGleb Smirnoff ng_worklist_remove(ngq->q_node); 18462955ee18SGleb Smirnoff CTR4(KTR_NET, "%20s: node [%x] (%p) queued reader " 18472955ee18SGleb Smirnoff "can't proceed; queue flags 0x%lx", __func__, 18482955ee18SGleb Smirnoff ngq->q_node->nd_ID, ngq->q_node, ngq->q_flags); 18494be59335SGleb Smirnoff return (NULL); 18504be59335SGleb Smirnoff } 1851069154d5SJulian Elischer /* 1852b57a7965SJulian Elischer * Head of queue is a reader and we have no write active. 1853b57a7965SJulian Elischer * We don't care how many readers are already active. 18544be59335SGleb Smirnoff * Add the correct increment for the reader count. 1855069154d5SJulian Elischer */ 18564be59335SGleb Smirnoff add_arg = READER_INCREMENT; 1857714fb865SGleb Smirnoff *rw = NGQRW_R; 18584be59335SGleb Smirnoff } else if (QUEUED_WRITER_CAN_PROCEED(ngq)) { 1859069154d5SJulian Elischer /* 1860069154d5SJulian Elischer * There is a pending write, no readers and no active writer. 1861069154d5SJulian Elischer * This means we can go ahead with the pending writer. Note 1862069154d5SJulian Elischer * the fact that we now have a writer, ready for when we take 1863069154d5SJulian Elischer * it off the queue. 1864069154d5SJulian Elischer * 1865069154d5SJulian Elischer * We don't need to worry about a possible collision with the 1866069154d5SJulian Elischer * fasttrack reader. 1867069154d5SJulian Elischer * 1868069154d5SJulian Elischer * The fasttrack thread may take a long time to discover that we 1869069154d5SJulian Elischer * are running so we would have an inconsistent state in the 1870069154d5SJulian Elischer * flags for a while. Since we ignore the reader count 1871069154d5SJulian Elischer * entirely when the WRITER_ACTIVE flag is set, this should 1872069154d5SJulian Elischer * not matter (in fact it is defined that way). If it tests 18734be59335SGleb Smirnoff * the flag before this operation, the OP_PENDING flag 1874069154d5SJulian Elischer * will make it fail, and if it tests it later, the 1875b57a7965SJulian Elischer * WRITER_ACTIVE flag will do the same. If it is SO slow that 1876069154d5SJulian Elischer * we have actually completed the operation, and neither flag 18774be59335SGleb Smirnoff * is set by the time that it tests the flags, then it is 18784be59335SGleb Smirnoff * actually ok for it to continue. If it completes and we've 18794be59335SGleb Smirnoff * finished and the read pending is set it still fails. 1880069154d5SJulian Elischer * 1881069154d5SJulian Elischer * So we can just ignore it, as long as we can ensure that the 1882069154d5SJulian Elischer * transition from WRITE_PENDING state to the WRITER_ACTIVE 1883069154d5SJulian Elischer * state is atomic. 1884069154d5SJulian Elischer * 1885069154d5SJulian Elischer * After failing, first it will be held back by the mutex, then 1886069154d5SJulian Elischer * when it can proceed, it will queue its request, then it 1887069154d5SJulian Elischer * would arrive at this function. Usually it will have to 1888b57a7965SJulian Elischer * leave empty handed because the ACTIVE WRITER bit will be 1889069154d5SJulian Elischer * set. 1890b57a7965SJulian Elischer * 18914be59335SGleb Smirnoff * Adjust the flags for the new active writer. 1892069154d5SJulian Elischer */ 18934be59335SGleb Smirnoff add_arg = WRITER_ACTIVE; 1894714fb865SGleb Smirnoff *rw = NGQRW_W; 1895069154d5SJulian Elischer /* 1896069154d5SJulian Elischer * We want to write "active writer, no readers " Now go make 1897069154d5SJulian Elischer * it true. In fact there may be a number in the readers 1898069154d5SJulian Elischer * count but we know it is not true and will be fixed soon. 1899069154d5SJulian Elischer * We will fix the flags for the next pending entry in a 1900069154d5SJulian Elischer * moment. 1901069154d5SJulian Elischer */ 1902069154d5SJulian Elischer } else { 1903069154d5SJulian Elischer /* 1904069154d5SJulian Elischer * We can't dequeue anything.. return and say so. Probably we 1905069154d5SJulian Elischer * have a write pending and the readers count is non zero. If 1906069154d5SJulian Elischer * we got here because a reader hit us just at the wrong 1907069154d5SJulian Elischer * moment with the fasttrack code, and put us in a strange 19084be59335SGleb Smirnoff * state, then it will be coming through in just a moment, 19094be59335SGleb Smirnoff * (just as soon as we release the mutex) and keep things 19104be59335SGleb Smirnoff * moving. 19114be59335SGleb Smirnoff * Make sure we remove ourselves from the work queue. It 19124be59335SGleb Smirnoff * would be a waste of effort to do all this again. 1913069154d5SJulian Elischer */ 1914b57a7965SJulian Elischer ng_worklist_remove(ngq->q_node); 19152955ee18SGleb Smirnoff CTR4(KTR_NET, "%20s: node [%x] (%p) can't dequeue anything; " 19162955ee18SGleb Smirnoff "queue flags 0x%lx", __func__, 19172955ee18SGleb Smirnoff ngq->q_node->nd_ID, ngq->q_node, ngq->q_flags); 19184be59335SGleb Smirnoff return (NULL); 19194cf49a43SJulian Elischer } 19204cf49a43SJulian Elischer 19214cf49a43SJulian Elischer /* 1922069154d5SJulian Elischer * Now we dequeue the request (whatever it may be) and correct the 1923069154d5SJulian Elischer * pending flags and the next and last pointers. 19244cf49a43SJulian Elischer */ 1925069154d5SJulian Elischer item = ngq->queue; 1926069154d5SJulian Elischer ngq->queue = item->el_next; 19272955ee18SGleb Smirnoff CTR6(KTR_NET, "%20s: node [%x] (%p) dequeued item %p with flags 0x%lx; " 19282955ee18SGleb Smirnoff "queue flags 0x%lx", __func__, 19292955ee18SGleb Smirnoff ngq->q_node->nd_ID,ngq->q_node, item, item->el_flags, ngq->q_flags); 1930069154d5SJulian Elischer if (ngq->last == &(item->el_next)) { 19314cf49a43SJulian Elischer /* 1932069154d5SJulian Elischer * that was the last entry in the queue so set the 'last 19334be59335SGleb Smirnoff * pointer up correctly and make sure the pending flag is 1934069154d5SJulian Elischer * clear. 19354cf49a43SJulian Elischer */ 19364be59335SGleb Smirnoff add_arg += -OP_PENDING; 1937069154d5SJulian Elischer ngq->last = &(ngq->queue); 1938859a4d16SJulian Elischer /* 1939b57a7965SJulian Elischer * Whatever flag was set will be cleared and 1940b57a7965SJulian Elischer * the new acive field will be set by the add as well, 1941b57a7965SJulian Elischer * so we don't need to change add_arg. 1942b57a7965SJulian Elischer * But we know we don't need to be on the work list. 1943859a4d16SJulian Elischer */ 1944b57a7965SJulian Elischer atomic_add_long(&ngq->q_flags, add_arg); 1945b57a7965SJulian Elischer ng_worklist_remove(ngq->q_node); 1946859a4d16SJulian Elischer } else { 1947069154d5SJulian Elischer /* 19484be59335SGleb Smirnoff * Since there is still something on the queue 19494be59335SGleb Smirnoff * we don't need to change the PENDING flag. 1950069154d5SJulian Elischer */ 1951069154d5SJulian Elischer atomic_add_long(&ngq->q_flags, add_arg); 1952069154d5SJulian Elischer /* 1953b57a7965SJulian Elischer * If we see more doable work, make sure we are 1954b57a7965SJulian Elischer * on the work queue. 1955b57a7965SJulian Elischer */ 19564be59335SGleb Smirnoff if (NEXT_QUEUED_ITEM_CAN_PROCEED(ngq)) { 1957b57a7965SJulian Elischer ng_setisr(ngq->q_node); 1958b57a7965SJulian Elischer } 1959b57a7965SJulian Elischer } 19602955ee18SGleb Smirnoff CTR6(KTR_NET, "%20s: node [%x] (%p) returning item %p as %s; " 19612955ee18SGleb Smirnoff "queue flags 0x%lx", __func__, 19622955ee18SGleb Smirnoff ngq->q_node->nd_ID, ngq->q_node, item, *rw ? "WRITER" : "READER" , 19633b33fbe7SGleb Smirnoff ngq->q_flags); 1964069154d5SJulian Elischer return (item); 1965069154d5SJulian Elischer } 1966859a4d16SJulian Elischer 1967859a4d16SJulian Elischer /* 1968069154d5SJulian Elischer * Queue a packet to be picked up by someone else. 1969069154d5SJulian Elischer * We really don't care who, but we can't or don't want to hang around 1970069154d5SJulian Elischer * to process it ourselves. We are probably an interrupt routine.. 19714be59335SGleb Smirnoff * If the queue could be run, flag the netisr handler to start. 1972859a4d16SJulian Elischer */ 1973069154d5SJulian Elischer static __inline void 1974069154d5SJulian Elischer ng_queue_rw(struct ng_queue * ngq, item_p item, int rw) 1975069154d5SJulian Elischer { 1976d58e678fSGleb Smirnoff mtx_assert(&ngq->q_mtx, MA_OWNED); 1977d58e678fSGleb Smirnoff 19784be59335SGleb Smirnoff if (rw == NGQRW_W) 19794be59335SGleb Smirnoff NGI_SET_WRITER(item); 19804be59335SGleb Smirnoff else 19814be59335SGleb Smirnoff NGI_SET_READER(item); 1982069154d5SJulian Elischer item->el_next = NULL; /* maybe not needed */ 1983069154d5SJulian Elischer *ngq->last = item; 19842955ee18SGleb Smirnoff CTR5(KTR_NET, "%20s: node [%x] (%p) queued item %p as %s", __func__, 19852955ee18SGleb Smirnoff ngq->q_node->nd_ID, ngq->q_node, item, rw ? "WRITER" : "READER" ); 1986069154d5SJulian Elischer /* 1987069154d5SJulian Elischer * If it was the first item in the queue then we need to 1988069154d5SJulian Elischer * set the last pointer and the type flags. 1989069154d5SJulian Elischer */ 19903b33fbe7SGleb Smirnoff if (ngq->last == &(ngq->queue)) { 19914be59335SGleb Smirnoff atomic_add_long(&ngq->q_flags, OP_PENDING); 19922955ee18SGleb Smirnoff CTR3(KTR_NET, "%20s: node [%x] (%p) set OP_PENDING", __func__, 19932955ee18SGleb Smirnoff ngq->q_node->nd_ID, ngq->q_node); 19943b33fbe7SGleb Smirnoff } 19954be59335SGleb Smirnoff 1996069154d5SJulian Elischer ngq->last = &(item->el_next); 19974be59335SGleb Smirnoff /* 19984be59335SGleb Smirnoff * We can take the worklist lock with the node locked 19994be59335SGleb Smirnoff * BUT NOT THE REVERSE! 20004be59335SGleb Smirnoff */ 20014be59335SGleb Smirnoff if (NEXT_QUEUED_ITEM_CAN_PROCEED(ngq)) 20024be59335SGleb Smirnoff ng_setisr(ngq->q_node); 2003069154d5SJulian Elischer } 2004069154d5SJulian Elischer 2005069154d5SJulian Elischer 2006069154d5SJulian Elischer /* 2007069154d5SJulian Elischer * This function 'cheats' in that it first tries to 'grab' the use of the 2008069154d5SJulian Elischer * node, without going through the mutex. We can do this becasue of the 2009069154d5SJulian Elischer * semantics of the lock. The semantics include a clause that says that the 2010069154d5SJulian Elischer * value of the readers count is invalid if the WRITER_ACTIVE flag is set. It 2011069154d5SJulian Elischer * also says that the WRITER_ACTIVE flag cannot be set if the readers count 2012069154d5SJulian Elischer * is not zero. Note that this talks about what is valid to SET the 2013069154d5SJulian Elischer * WRITER_ACTIVE flag, because from the moment it is set, the value if the 2014069154d5SJulian Elischer * reader count is immaterial, and not valid. The two 'pending' flags have a 2015069154d5SJulian Elischer * similar effect, in that If they are orthogonal to the two active fields in 2016069154d5SJulian Elischer * how they are set, but if either is set, the attempted 'grab' need to be 2017069154d5SJulian Elischer * backed out because there is earlier work, and we maintain ordering in the 2018069154d5SJulian Elischer * queue. The result of this is that the reader request can try obtain use of 2019069154d5SJulian Elischer * the node with only a single atomic addition, and without any of the mutex 2020069154d5SJulian Elischer * overhead. If this fails the operation degenerates to the same as for other 2021069154d5SJulian Elischer * cases. 2022069154d5SJulian Elischer * 2023069154d5SJulian Elischer */ 2024069154d5SJulian Elischer static __inline item_p 2025069154d5SJulian Elischer ng_acquire_read(struct ng_queue *ngq, item_p item) 2026069154d5SJulian Elischer { 2027ac5dd141SGleb Smirnoff KASSERT(ngq != &ng_deadnode.nd_input_queue, 2028ac5dd141SGleb Smirnoff ("%s: working on deadnode", __func__)); 2029069154d5SJulian Elischer 2030069154d5SJulian Elischer /* ######### Hack alert ######### */ 2031069154d5SJulian Elischer atomic_add_long(&ngq->q_flags, READER_INCREMENT); 2032b57a7965SJulian Elischer if ((ngq->q_flags & NGQ_RMASK) == 0) { 2033069154d5SJulian Elischer /* Successfully grabbed node */ 20342955ee18SGleb Smirnoff CTR4(KTR_NET, "%20s: node [%x] (%p) fast acquired item %p", 20352955ee18SGleb Smirnoff __func__, ngq->q_node->nd_ID, ngq->q_node, item); 2036069154d5SJulian Elischer return (item); 2037069154d5SJulian Elischer } 2038069154d5SJulian Elischer /* undo the damage if we didn't succeed */ 2039069154d5SJulian Elischer atomic_subtract_long(&ngq->q_flags, READER_INCREMENT); 2040069154d5SJulian Elischer 2041069154d5SJulian Elischer /* ######### End Hack alert ######### */ 20429ed346baSBosko Milekic mtx_lock_spin((&ngq->q_mtx)); 2043069154d5SJulian Elischer /* 2044069154d5SJulian Elischer * Try again. Another processor (or interrupt for that matter) may 2045069154d5SJulian Elischer * have removed the last queued item that was stopping us from 2046069154d5SJulian Elischer * running, between the previous test, and the moment that we took 2047069154d5SJulian Elischer * the mutex. (Or maybe a writer completed.) 20484be59335SGleb Smirnoff * Even if another fast-track reader hits during this period 20494be59335SGleb Smirnoff * we don't care as multiple readers is OK. 2050069154d5SJulian Elischer */ 2051b57a7965SJulian Elischer if ((ngq->q_flags & NGQ_RMASK) == 0) { 2052069154d5SJulian Elischer atomic_add_long(&ngq->q_flags, READER_INCREMENT); 20539ed346baSBosko Milekic mtx_unlock_spin((&ngq->q_mtx)); 20542955ee18SGleb Smirnoff CTR4(KTR_NET, "%20s: node [%x] (%p) slow acquired item %p", 20552955ee18SGleb Smirnoff __func__, ngq->q_node->nd_ID, ngq->q_node, item); 2056069154d5SJulian Elischer return (item); 2057069154d5SJulian Elischer } 2058069154d5SJulian Elischer 2059069154d5SJulian Elischer /* 2060069154d5SJulian Elischer * and queue the request for later. 2061069154d5SJulian Elischer */ 2062069154d5SJulian Elischer ng_queue_rw(ngq, item, NGQRW_R); 20639ed346baSBosko Milekic mtx_unlock_spin(&(ngq->q_mtx)); 2064f912c0f7SGleb Smirnoff 2065f912c0f7SGleb Smirnoff return (NULL); 2066069154d5SJulian Elischer } 2067069154d5SJulian Elischer 2068069154d5SJulian Elischer static __inline item_p 2069069154d5SJulian Elischer ng_acquire_write(struct ng_queue *ngq, item_p item) 2070069154d5SJulian Elischer { 2071ac5dd141SGleb Smirnoff KASSERT(ngq != &ng_deadnode.nd_input_queue, 2072ac5dd141SGleb Smirnoff ("%s: working on deadnode", __func__)); 2073ac5dd141SGleb Smirnoff 2074069154d5SJulian Elischer restart: 20759ed346baSBosko Milekic mtx_lock_spin(&(ngq->q_mtx)); 2076069154d5SJulian Elischer /* 2077069154d5SJulian Elischer * If there are no readers, no writer, and no pending packets, then 2078069154d5SJulian Elischer * we can just go ahead. In all other situations we need to queue the 2079069154d5SJulian Elischer * request 2080069154d5SJulian Elischer */ 2081b57a7965SJulian Elischer if ((ngq->q_flags & NGQ_WMASK) == 0) { 20824be59335SGleb Smirnoff /* collision could happen *HERE* */ 2083069154d5SJulian Elischer atomic_add_long(&ngq->q_flags, WRITER_ACTIVE); 20849ed346baSBosko Milekic mtx_unlock_spin((&ngq->q_mtx)); 2085069154d5SJulian Elischer if (ngq->q_flags & READER_MASK) { 2086069154d5SJulian Elischer /* Collision with fast-track reader */ 2087b57a7965SJulian Elischer atomic_subtract_long(&ngq->q_flags, WRITER_ACTIVE); 2088069154d5SJulian Elischer goto restart; 2089069154d5SJulian Elischer } 20902955ee18SGleb Smirnoff CTR4(KTR_NET, "%20s: node [%x] (%p) acquired item %p", 20912955ee18SGleb Smirnoff __func__, ngq->q_node->nd_ID, ngq->q_node, item); 2092069154d5SJulian Elischer return (item); 2093069154d5SJulian Elischer } 2094069154d5SJulian Elischer 2095069154d5SJulian Elischer /* 2096069154d5SJulian Elischer * and queue the request for later. 2097069154d5SJulian Elischer */ 2098069154d5SJulian Elischer ng_queue_rw(ngq, item, NGQRW_W); 20999ed346baSBosko Milekic mtx_unlock_spin(&(ngq->q_mtx)); 2100f912c0f7SGleb Smirnoff 2101f912c0f7SGleb Smirnoff return (NULL); 2102069154d5SJulian Elischer } 2103069154d5SJulian Elischer 2104069154d5SJulian Elischer static __inline void 2105069154d5SJulian Elischer ng_leave_read(struct ng_queue *ngq) 2106069154d5SJulian Elischer { 2107069154d5SJulian Elischer atomic_subtract_long(&ngq->q_flags, READER_INCREMENT); 2108069154d5SJulian Elischer } 2109069154d5SJulian Elischer 2110069154d5SJulian Elischer static __inline void 2111069154d5SJulian Elischer ng_leave_write(struct ng_queue *ngq) 2112069154d5SJulian Elischer { 2113069154d5SJulian Elischer atomic_subtract_long(&ngq->q_flags, WRITER_ACTIVE); 2114069154d5SJulian Elischer } 2115069154d5SJulian Elischer 2116069154d5SJulian Elischer static void 2117069154d5SJulian Elischer ng_flush_input_queue(struct ng_queue * ngq) 2118069154d5SJulian Elischer { 2119069154d5SJulian Elischer item_p item; 2120069154d5SJulian Elischer 21214be59335SGleb Smirnoff mtx_lock_spin(&ngq->q_mtx); 21224be59335SGleb Smirnoff while (ngq->queue) { 2123069154d5SJulian Elischer item = ngq->queue; 2124069154d5SJulian Elischer ngq->queue = item->el_next; 2125069154d5SJulian Elischer if (ngq->last == &(item->el_next)) { 2126069154d5SJulian Elischer ngq->last = &(ngq->queue); 21274be59335SGleb Smirnoff atomic_add_long(&ngq->q_flags, -OP_PENDING); 2128069154d5SJulian Elischer } 21299ed346baSBosko Milekic mtx_unlock_spin(&ngq->q_mtx); 21304be59335SGleb Smirnoff 21314be59335SGleb Smirnoff /* If the item is supplying a callback, call it with an error */ 2132eb2405ddSGleb Smirnoff if (item->apply != NULL) { 2133eb2405ddSGleb Smirnoff (item->apply)(item->context, ENOENT); 2134eb2405ddSGleb Smirnoff item->apply = NULL; 2135eb2405ddSGleb Smirnoff } 2136505fad52SJulian Elischer NG_FREE_ITEM(item); 2137505fad52SJulian Elischer mtx_lock_spin(&ngq->q_mtx); 2138069154d5SJulian Elischer } 2139b57a7965SJulian Elischer /* 2140b57a7965SJulian Elischer * Take us off the work queue if we are there. 2141b57a7965SJulian Elischer * We definatly have no work to be done. 2142b57a7965SJulian Elischer */ 2143b57a7965SJulian Elischer ng_worklist_remove(ngq->q_node); 21449ed346baSBosko Milekic mtx_unlock_spin(&ngq->q_mtx); 2145069154d5SJulian Elischer } 2146069154d5SJulian Elischer 2147069154d5SJulian Elischer /*********************************************************************** 2148069154d5SJulian Elischer * Externally visible method for sending or queueing messages or data. 2149069154d5SJulian Elischer ***********************************************************************/ 2150069154d5SJulian Elischer 2151069154d5SJulian Elischer /* 21521acb27c6SJulian Elischer * The module code should have filled out the item correctly by this stage: 2153069154d5SJulian Elischer * Common: 2154069154d5SJulian Elischer * reference to destination node. 2155069154d5SJulian Elischer * Reference to destination rcv hook if relevant. 2156069154d5SJulian Elischer * Data: 2157069154d5SJulian Elischer * pointer to mbuf 2158069154d5SJulian Elischer * Control_Message: 2159069154d5SJulian Elischer * pointer to msg. 2160069154d5SJulian Elischer * ID of original sender node. (return address) 21611acb27c6SJulian Elischer * Function: 21621acb27c6SJulian Elischer * Function pointer 21631acb27c6SJulian Elischer * void * argument 21641acb27c6SJulian Elischer * integer argument 2165069154d5SJulian Elischer * 2166069154d5SJulian Elischer * The nodes have several routines and macros to help with this task: 2167069154d5SJulian Elischer */ 2168069154d5SJulian Elischer 2169069154d5SJulian Elischer int 217042282202SGleb Smirnoff ng_snd_item(item_p item, int flags) 2171069154d5SJulian Elischer { 21721acb27c6SJulian Elischer hook_p hook = NGI_HOOK(item); 2173b57a7965SJulian Elischer node_p node = NGI_NODE(item); 217442282202SGleb Smirnoff int queue, rw; 2175b57a7965SJulian Elischer struct ng_queue * ngq = &node->nd_input_queue; 217632b33288SGleb Smirnoff int error = 0; 2177069154d5SJulian Elischer 217830400f03SJulian Elischer #ifdef NETGRAPH_DEBUG 2179069154d5SJulian Elischer _ngi_check(item, __FILE__, __LINE__); 2180069154d5SJulian Elischer #endif 2181069154d5SJulian Elischer 218242282202SGleb Smirnoff queue = (flags & NG_QUEUE) ? 1 : 0; 218342282202SGleb Smirnoff 2184069154d5SJulian Elischer if (item == NULL) { 21856b795970SJulian Elischer TRAP_ERROR(); 2186069154d5SJulian Elischer return (EINVAL); /* failed to get queue element */ 2187069154d5SJulian Elischer } 2188b57a7965SJulian Elischer if (node == NULL) { 2189069154d5SJulian Elischer NG_FREE_ITEM(item); 21906b795970SJulian Elischer TRAP_ERROR(); 2191069154d5SJulian Elischer return (EINVAL); /* No address */ 2192069154d5SJulian Elischer } 21936b795970SJulian Elischer switch(item->el_flags & NGQF_TYPE) { 21946b795970SJulian Elischer case NGQF_DATA: 2195069154d5SJulian Elischer /* 2196069154d5SJulian Elischer * DATA MESSAGE 2197069154d5SJulian Elischer * Delivered to a node via a non-optional hook. 2198069154d5SJulian Elischer * Both should be present in the item even though 2199069154d5SJulian Elischer * the node is derivable from the hook. 2200069154d5SJulian Elischer * References are held on both by the item. 2201069154d5SJulian Elischer */ 22021cf3fa79SJulian Elischer 22031cf3fa79SJulian Elischer /* Protect nodes from sending NULL pointers 22041cf3fa79SJulian Elischer * to each other 22051cf3fa79SJulian Elischer */ 220610204449SJulian Elischer if (NGI_M(item) == NULL) 22071cf3fa79SJulian Elischer return (EINVAL); 22081cf3fa79SJulian Elischer 2209069154d5SJulian Elischer CHECK_DATA_MBUF(NGI_M(item)); 2210069154d5SJulian Elischer if (hook == NULL) { 2211069154d5SJulian Elischer NG_FREE_ITEM(item); 22126b795970SJulian Elischer TRAP_ERROR(); 2213069154d5SJulian Elischer return(EINVAL); 2214069154d5SJulian Elischer } 221530400f03SJulian Elischer if ((NG_HOOK_NOT_VALID(hook)) 221630400f03SJulian Elischer || (NG_NODE_NOT_VALID(NG_HOOK_NODE(hook)))) { 2217069154d5SJulian Elischer NG_FREE_ITEM(item); 2218069154d5SJulian Elischer return (ENOTCONN); 2219859a4d16SJulian Elischer } 222030400f03SJulian Elischer if ((hook->hk_flags & HK_QUEUE)) { 2221069154d5SJulian Elischer queue = 1; 22224cf49a43SJulian Elischer } 22236b795970SJulian Elischer break; 22246b795970SJulian Elischer case NGQF_MESG: 22254cf49a43SJulian Elischer /* 2226069154d5SJulian Elischer * CONTROL MESSAGE 2227069154d5SJulian Elischer * Delivered to a node. 2228069154d5SJulian Elischer * Hook is optional. 2229069154d5SJulian Elischer * References are held by the item on the node and 2230069154d5SJulian Elischer * the hook if it is present. 22314cf49a43SJulian Elischer */ 223230400f03SJulian Elischer if (hook && (hook->hk_flags & HK_QUEUE)) { 2233069154d5SJulian Elischer queue = 1; 2234069154d5SJulian Elischer } 22356b795970SJulian Elischer break; 22366b795970SJulian Elischer case NGQF_FN: 22376b795970SJulian Elischer break; 22386b795970SJulian Elischer default: 22396b795970SJulian Elischer NG_FREE_ITEM(item); 22406b795970SJulian Elischer TRAP_ERROR(); 22416b795970SJulian Elischer return (EINVAL); 2242069154d5SJulian Elischer } 22436f683eeeSGleb Smirnoff switch(item->el_flags & NGQF_RW) { 22446f683eeeSGleb Smirnoff case NGQF_READER: 22456f683eeeSGleb Smirnoff rw = NGQRW_R; 22466f683eeeSGleb Smirnoff break; 22476f683eeeSGleb Smirnoff case NGQF_WRITER: 22486f683eeeSGleb Smirnoff rw = NGQRW_W; 22496f683eeeSGleb Smirnoff break; 22506f683eeeSGleb Smirnoff default: 22516f683eeeSGleb Smirnoff panic("%s: invalid item flags %lx", __func__, item->el_flags); 22526f683eeeSGleb Smirnoff } 22536f683eeeSGleb Smirnoff 2254069154d5SJulian Elischer /* 22556f683eeeSGleb Smirnoff * If the node specifies single threading, force writer semantics. 22566f683eeeSGleb Smirnoff * Similarly, the node may say one hook always produces writers. 2257714fb865SGleb Smirnoff * These are overrides. 2258069154d5SJulian Elischer */ 2259be4252b3SJulian Elischer if ((node->nd_flags & NGF_FORCE_WRITER) 2260714fb865SGleb Smirnoff || (hook && (hook->hk_flags & HK_FORCE_WRITER))) 2261069154d5SJulian Elischer rw = NGQRW_W; 22626f683eeeSGleb Smirnoff 2263069154d5SJulian Elischer if (queue) { 2264069154d5SJulian Elischer /* Put it on the queue for that node*/ 226530400f03SJulian Elischer #ifdef NETGRAPH_DEBUG 2266069154d5SJulian Elischer _ngi_check(item, __FILE__, __LINE__); 2267069154d5SJulian Elischer #endif 22689ed346baSBosko Milekic mtx_lock_spin(&(ngq->q_mtx)); 2269069154d5SJulian Elischer ng_queue_rw(ngq, item, rw); 22709ed346baSBosko Milekic mtx_unlock_spin(&(ngq->q_mtx)); 22718afe16d5SGleb Smirnoff 22728afe16d5SGleb Smirnoff if (flags & NG_PROGRESS) 22738afe16d5SGleb Smirnoff return (EINPROGRESS); 22748afe16d5SGleb Smirnoff else 2275069154d5SJulian Elischer return (0); 2276069154d5SJulian Elischer } 2277069154d5SJulian Elischer 2278069154d5SJulian Elischer /* 2279069154d5SJulian Elischer * We already decided how we will be queueud or treated. 2280069154d5SJulian Elischer * Try get the appropriate operating permission. 2281069154d5SJulian Elischer */ 228232b33288SGleb Smirnoff if (rw == NGQRW_R) 2283069154d5SJulian Elischer item = ng_acquire_read(ngq, item); 228432b33288SGleb Smirnoff else 2285069154d5SJulian Elischer item = ng_acquire_write(ngq, item); 22864cf49a43SJulian Elischer 22874be59335SGleb Smirnoff 2288069154d5SJulian Elischer if (item == NULL) { 22898afe16d5SGleb Smirnoff if (flags & NG_PROGRESS) 22908afe16d5SGleb Smirnoff return (EINPROGRESS); 22918afe16d5SGleb Smirnoff else 2292069154d5SJulian Elischer return (0); 2293069154d5SJulian Elischer } 2294069154d5SJulian Elischer 229530400f03SJulian Elischer #ifdef NETGRAPH_DEBUG 2296069154d5SJulian Elischer _ngi_check(item, __FILE__, __LINE__); 2297069154d5SJulian Elischer #endif 22984be59335SGleb Smirnoff 22995951069aSJulian Elischer NGI_GET_NODE(item, node); /* zaps stored node */ 23005951069aSJulian Elischer 230132b33288SGleb Smirnoff error = ng_apply_item(node, item, rw); /* drops r/w lock when done */ 2302069154d5SJulian Elischer 2303069154d5SJulian Elischer /* 23045951069aSJulian Elischer * If the node goes away when we remove the reference, 2305376958b4SBrian Somers * whatever we just did caused it.. whatever we do, DO NOT 23065951069aSJulian Elischer * access the node again! 23075951069aSJulian Elischer */ 23085951069aSJulian Elischer if (NG_NODE_UNREF(node) == 0) { 23095951069aSJulian Elischer return (error); 23105951069aSJulian Elischer } 23115951069aSJulian Elischer 2312f912c0f7SGleb Smirnoff mtx_lock_spin(&(ngq->q_mtx)); 23134be59335SGleb Smirnoff if (NEXT_QUEUED_ITEM_CAN_PROCEED(ngq)) 2314f912c0f7SGleb Smirnoff ng_setisr(ngq->q_node); 2315f912c0f7SGleb Smirnoff mtx_unlock_spin(&(ngq->q_mtx)); 2316069154d5SJulian Elischer 23171acb27c6SJulian Elischer return (error); 2318069154d5SJulian Elischer } 2319069154d5SJulian Elischer 2320069154d5SJulian Elischer /* 2321069154d5SJulian Elischer * We have an item that was possibly queued somewhere. 2322069154d5SJulian Elischer * It should contain all the information needed 2323069154d5SJulian Elischer * to run it on the appropriate node/hook. 23244cf49a43SJulian Elischer */ 23254cf49a43SJulian Elischer static int 2326714fb865SGleb Smirnoff ng_apply_item(node_p node, item_p item, int rw) 2327069154d5SJulian Elischer { 2328069154d5SJulian Elischer hook_p hook; 2329069154d5SJulian Elischer int error = 0; 2330069154d5SJulian Elischer ng_rcvdata_t *rcvdata; 2331c4b5eea4SJulian Elischer ng_rcvmsg_t *rcvmsg; 23328afe16d5SGleb Smirnoff ng_apply_t *apply = NULL; 23338afe16d5SGleb Smirnoff void *context = NULL; 2334069154d5SJulian Elischer 23351acb27c6SJulian Elischer NGI_GET_HOOK(item, hook); /* clears stored hook */ 233630400f03SJulian Elischer #ifdef NETGRAPH_DEBUG 2337069154d5SJulian Elischer _ngi_check(item, __FILE__, __LINE__); 2338069154d5SJulian Elischer #endif 23398afe16d5SGleb Smirnoff 23408afe16d5SGleb Smirnoff /* 23414be59335SGleb Smirnoff * If the item has an "apply" callback, store it. 23424be59335SGleb Smirnoff * Clear item's callback immediately, to avoid an extra call if 23434be59335SGleb Smirnoff * the item is reused by the destination node. 23448afe16d5SGleb Smirnoff */ 23458afe16d5SGleb Smirnoff if (item->apply != NULL) { 23468afe16d5SGleb Smirnoff apply = item->apply; 23478afe16d5SGleb Smirnoff context = item->context; 23488afe16d5SGleb Smirnoff item->apply = NULL; 23498afe16d5SGleb Smirnoff } 23508afe16d5SGleb Smirnoff 23516b795970SJulian Elischer switch (item->el_flags & NGQF_TYPE) { 2352069154d5SJulian Elischer case NGQF_DATA: 2353069154d5SJulian Elischer /* 2354069154d5SJulian Elischer * Check things are still ok as when we were queued. 2355069154d5SJulian Elischer */ 2356069154d5SJulian Elischer if ((hook == NULL) 235730400f03SJulian Elischer || NG_HOOK_NOT_VALID(hook) 2358c4b5eea4SJulian Elischer || NG_NODE_NOT_VALID(node) ) { 2359069154d5SJulian Elischer error = EIO; 2360069154d5SJulian Elischer NG_FREE_ITEM(item); 2361c4b5eea4SJulian Elischer break; 2362069154d5SJulian Elischer } 2363c4b5eea4SJulian Elischer /* 2364c4b5eea4SJulian Elischer * If no receive method, just silently drop it. 2365c4b5eea4SJulian Elischer * Give preference to the hook over-ride method 2366c4b5eea4SJulian Elischer */ 2367c4b5eea4SJulian Elischer if ((!(rcvdata = hook->hk_rcvdata)) 2368c4b5eea4SJulian Elischer && (!(rcvdata = NG_HOOK_NODE(hook)->nd_type->rcvdata))) { 2369c4b5eea4SJulian Elischer error = 0; 2370c4b5eea4SJulian Elischer NG_FREE_ITEM(item); 2371c4b5eea4SJulian Elischer break; 2372c4b5eea4SJulian Elischer } 2373c4b5eea4SJulian Elischer error = (*rcvdata)(hook, item); 2374069154d5SJulian Elischer break; 2375069154d5SJulian Elischer case NGQF_MESG: 2376069154d5SJulian Elischer if (hook) { 237730400f03SJulian Elischer if (NG_HOOK_NOT_VALID(hook)) { 2378069154d5SJulian Elischer /* 23791acb27c6SJulian Elischer * The hook has been zapped then we can't 23801acb27c6SJulian Elischer * use it. Immediatly drop its reference. 2381069154d5SJulian Elischer * The message may not need it. 2382069154d5SJulian Elischer */ 238330400f03SJulian Elischer NG_HOOK_UNREF(hook); 2384069154d5SJulian Elischer hook = NULL; 2385069154d5SJulian Elischer } 2386069154d5SJulian Elischer } 2387069154d5SJulian Elischer /* 2388069154d5SJulian Elischer * Similarly, if the node is a zombie there is 2389069154d5SJulian Elischer * nothing we can do with it, drop everything. 2390069154d5SJulian Elischer */ 239130400f03SJulian Elischer if (NG_NODE_NOT_VALID(node)) { 23926b795970SJulian Elischer TRAP_ERROR(); 2393069154d5SJulian Elischer error = EINVAL; 2394069154d5SJulian Elischer NG_FREE_ITEM(item); 2395069154d5SJulian Elischer } else { 2396069154d5SJulian Elischer /* 2397069154d5SJulian Elischer * Call the appropriate message handler for the object. 2398069154d5SJulian Elischer * It is up to the message handler to free the message. 2399069154d5SJulian Elischer * If it's a generic message, handle it generically, 2400069154d5SJulian Elischer * otherwise call the type's message handler 2401069154d5SJulian Elischer * (if it exists) 2402069154d5SJulian Elischer * XXX (race). Remember that a queued message may 2403069154d5SJulian Elischer * reference a node or hook that has just been 2404069154d5SJulian Elischer * invalidated. It will exist as the queue code 2405069154d5SJulian Elischer * is holding a reference, but.. 2406069154d5SJulian Elischer */ 2407069154d5SJulian Elischer 2408069154d5SJulian Elischer struct ng_mesg *msg = NGI_MSG(item); 2409069154d5SJulian Elischer 2410c4b5eea4SJulian Elischer /* 2411c4b5eea4SJulian Elischer * check if the generic handler owns it. 2412c4b5eea4SJulian Elischer */ 2413069154d5SJulian Elischer if ((msg->header.typecookie == NGM_GENERIC_COOKIE) 2414069154d5SJulian Elischer && ((msg->header.flags & NGF_RESP) == 0)) { 2415069154d5SJulian Elischer error = ng_generic_msg(node, item, hook); 2416c4b5eea4SJulian Elischer break; 2417c4b5eea4SJulian Elischer } 2418c4b5eea4SJulian Elischer /* 2419c4b5eea4SJulian Elischer * Now see if there is a handler (hook or node specific) 2420c4b5eea4SJulian Elischer * in the target node. If none, silently discard. 2421c4b5eea4SJulian Elischer */ 2422c4b5eea4SJulian Elischer if (((!hook) || (!(rcvmsg = hook->hk_rcvmsg))) 2423c4b5eea4SJulian Elischer && (!(rcvmsg = node->nd_type->rcvmsg))) { 24246b795970SJulian Elischer TRAP_ERROR(); 2425c4b5eea4SJulian Elischer error = 0; 2426069154d5SJulian Elischer NG_FREE_ITEM(item); 2427c4b5eea4SJulian Elischer break; 2428069154d5SJulian Elischer } 2429c4b5eea4SJulian Elischer error = (*rcvmsg)(node, item, hook); 2430069154d5SJulian Elischer } 2431069154d5SJulian Elischer break; 24326b795970SJulian Elischer case NGQF_FN: 24336b795970SJulian Elischer /* 24346b795970SJulian Elischer * We have to implicitly trust the hook, 24356b795970SJulian Elischer * as some of these are used for system purposes 24361acb27c6SJulian Elischer * where the hook is invalid. In the case of 24371acb27c6SJulian Elischer * the shutdown message we allow it to hit 24381acb27c6SJulian Elischer * even if the node is invalid. 24396b795970SJulian Elischer */ 24401acb27c6SJulian Elischer if ((NG_NODE_NOT_VALID(node)) 24411acb27c6SJulian Elischer && (NGI_FN(item) != &ng_rmnode)) { 24426b795970SJulian Elischer TRAP_ERROR(); 24436b795970SJulian Elischer error = EINVAL; 24448bb55179SGleb Smirnoff NG_FREE_ITEM(item); 24456b795970SJulian Elischer break; 24466b795970SJulian Elischer } 24476b795970SJulian Elischer (*NGI_FN(item))(node, hook, NGI_ARG1(item), NGI_ARG2(item)); 24486b795970SJulian Elischer NG_FREE_ITEM(item); 24496b795970SJulian Elischer break; 24506b795970SJulian Elischer 2451069154d5SJulian Elischer } 2452069154d5SJulian Elischer /* 2453069154d5SJulian Elischer * We held references on some of the resources 2454069154d5SJulian Elischer * that we took from the item. Now that we have 2455069154d5SJulian Elischer * finished doing everything, drop those references. 2456069154d5SJulian Elischer */ 2457069154d5SJulian Elischer if (hook) { 245830400f03SJulian Elischer NG_HOOK_UNREF(hook); 2459069154d5SJulian Elischer } 2460069154d5SJulian Elischer 2461714fb865SGleb Smirnoff if (rw == NGQRW_R) { 246230400f03SJulian Elischer ng_leave_read(&node->nd_input_queue); 2463069154d5SJulian Elischer } else { 246430400f03SJulian Elischer ng_leave_write(&node->nd_input_queue); 2465069154d5SJulian Elischer } 24668afe16d5SGleb Smirnoff 24678afe16d5SGleb Smirnoff /* Apply callback. */ 24688afe16d5SGleb Smirnoff if (apply != NULL) 24698afe16d5SGleb Smirnoff (*apply)(context, error); 24708afe16d5SGleb Smirnoff 2471069154d5SJulian Elischer return (error); 2472069154d5SJulian Elischer } 2473069154d5SJulian Elischer 2474069154d5SJulian Elischer /*********************************************************************** 2475069154d5SJulian Elischer * Implement the 'generic' control messages 2476069154d5SJulian Elischer ***********************************************************************/ 2477069154d5SJulian Elischer static int 2478069154d5SJulian Elischer ng_generic_msg(node_p here, item_p item, hook_p lasthook) 24794cf49a43SJulian Elischer { 24804cf49a43SJulian Elischer int error = 0; 2481069154d5SJulian Elischer struct ng_mesg *msg; 2482069154d5SJulian Elischer struct ng_mesg *resp = NULL; 24834cf49a43SJulian Elischer 2484069154d5SJulian Elischer NGI_GET_MSG(item, msg); 24854cf49a43SJulian Elischer if (msg->header.typecookie != NGM_GENERIC_COOKIE) { 24866b795970SJulian Elischer TRAP_ERROR(); 2487069154d5SJulian Elischer error = EINVAL; 2488069154d5SJulian Elischer goto out; 24894cf49a43SJulian Elischer } 24904cf49a43SJulian Elischer switch (msg->header.cmd) { 24914cf49a43SJulian Elischer case NGM_SHUTDOWN: 24921acb27c6SJulian Elischer ng_rmnode(here, NULL, NULL, 0); 24934cf49a43SJulian Elischer break; 24944cf49a43SJulian Elischer case NGM_MKPEER: 24954cf49a43SJulian Elischer { 24964cf49a43SJulian Elischer struct ngm_mkpeer *const mkp = (struct ngm_mkpeer *) msg->data; 24974cf49a43SJulian Elischer 24984cf49a43SJulian Elischer if (msg->header.arglen != sizeof(*mkp)) { 24996b795970SJulian Elischer TRAP_ERROR(); 2500069154d5SJulian Elischer error = EINVAL; 2501069154d5SJulian Elischer break; 25024cf49a43SJulian Elischer } 25034cf49a43SJulian Elischer mkp->type[sizeof(mkp->type) - 1] = '\0'; 25044cf49a43SJulian Elischer mkp->ourhook[sizeof(mkp->ourhook) - 1] = '\0'; 25054cf49a43SJulian Elischer mkp->peerhook[sizeof(mkp->peerhook) - 1] = '\0'; 25064cf49a43SJulian Elischer error = ng_mkpeer(here, mkp->ourhook, mkp->peerhook, mkp->type); 25074cf49a43SJulian Elischer break; 25084cf49a43SJulian Elischer } 25094cf49a43SJulian Elischer case NGM_CONNECT: 25104cf49a43SJulian Elischer { 25114cf49a43SJulian Elischer struct ngm_connect *const con = 25124cf49a43SJulian Elischer (struct ngm_connect *) msg->data; 25134cf49a43SJulian Elischer node_p node2; 25144cf49a43SJulian Elischer 25154cf49a43SJulian Elischer if (msg->header.arglen != sizeof(*con)) { 25166b795970SJulian Elischer TRAP_ERROR(); 2517069154d5SJulian Elischer error = EINVAL; 2518069154d5SJulian Elischer break; 25194cf49a43SJulian Elischer } 25204cf49a43SJulian Elischer con->path[sizeof(con->path) - 1] = '\0'; 25214cf49a43SJulian Elischer con->ourhook[sizeof(con->ourhook) - 1] = '\0'; 25224cf49a43SJulian Elischer con->peerhook[sizeof(con->peerhook) - 1] = '\0'; 2523069154d5SJulian Elischer /* Don't forget we get a reference.. */ 2524069154d5SJulian Elischer error = ng_path2noderef(here, con->path, &node2, NULL); 25254cf49a43SJulian Elischer if (error) 25264cf49a43SJulian Elischer break; 25274cf49a43SJulian Elischer error = ng_con_nodes(here, con->ourhook, node2, con->peerhook); 252830400f03SJulian Elischer NG_NODE_UNREF(node2); 25294cf49a43SJulian Elischer break; 25304cf49a43SJulian Elischer } 25314cf49a43SJulian Elischer case NGM_NAME: 25324cf49a43SJulian Elischer { 25334cf49a43SJulian Elischer struct ngm_name *const nam = (struct ngm_name *) msg->data; 25344cf49a43SJulian Elischer 25354cf49a43SJulian Elischer if (msg->header.arglen != sizeof(*nam)) { 25366b795970SJulian Elischer TRAP_ERROR(); 2537069154d5SJulian Elischer error = EINVAL; 2538069154d5SJulian Elischer break; 25394cf49a43SJulian Elischer } 25404cf49a43SJulian Elischer nam->name[sizeof(nam->name) - 1] = '\0'; 25414cf49a43SJulian Elischer error = ng_name_node(here, nam->name); 25424cf49a43SJulian Elischer break; 25434cf49a43SJulian Elischer } 25444cf49a43SJulian Elischer case NGM_RMHOOK: 25454cf49a43SJulian Elischer { 25464cf49a43SJulian Elischer struct ngm_rmhook *const rmh = (struct ngm_rmhook *) msg->data; 25474cf49a43SJulian Elischer hook_p hook; 25484cf49a43SJulian Elischer 25494cf49a43SJulian Elischer if (msg->header.arglen != sizeof(*rmh)) { 25506b795970SJulian Elischer TRAP_ERROR(); 2551069154d5SJulian Elischer error = EINVAL; 2552069154d5SJulian Elischer break; 25534cf49a43SJulian Elischer } 25544cf49a43SJulian Elischer rmh->ourhook[sizeof(rmh->ourhook) - 1] = '\0'; 2555899e9c4eSArchie Cobbs if ((hook = ng_findhook(here, rmh->ourhook)) != NULL) 25564cf49a43SJulian Elischer ng_destroy_hook(hook); 25574cf49a43SJulian Elischer break; 25584cf49a43SJulian Elischer } 25594cf49a43SJulian Elischer case NGM_NODEINFO: 25604cf49a43SJulian Elischer { 25614cf49a43SJulian Elischer struct nodeinfo *ni; 25624cf49a43SJulian Elischer 2563069154d5SJulian Elischer NG_MKRESPONSE(resp, msg, sizeof(*ni), M_NOWAIT); 25644cf49a43SJulian Elischer if (resp == NULL) { 25654cf49a43SJulian Elischer error = ENOMEM; 25664cf49a43SJulian Elischer break; 25674cf49a43SJulian Elischer } 25684cf49a43SJulian Elischer 25694cf49a43SJulian Elischer /* Fill in node info */ 2570069154d5SJulian Elischer ni = (struct nodeinfo *) resp->data; 257130400f03SJulian Elischer if (NG_NODE_HAS_NAME(here)) 257287e2c66aSHartmut Brandt strcpy(ni->name, NG_NODE_NAME(here)); 257387e2c66aSHartmut Brandt strcpy(ni->type, here->nd_type->name); 2574dc90cad9SJulian Elischer ni->id = ng_node2ID(here); 257530400f03SJulian Elischer ni->hooks = here->nd_numhooks; 25764cf49a43SJulian Elischer break; 25774cf49a43SJulian Elischer } 25784cf49a43SJulian Elischer case NGM_LISTHOOKS: 25794cf49a43SJulian Elischer { 258030400f03SJulian Elischer const int nhooks = here->nd_numhooks; 25814cf49a43SJulian Elischer struct hooklist *hl; 25824cf49a43SJulian Elischer struct nodeinfo *ni; 25834cf49a43SJulian Elischer hook_p hook; 25844cf49a43SJulian Elischer 25854cf49a43SJulian Elischer /* Get response struct */ 2586069154d5SJulian Elischer NG_MKRESPONSE(resp, msg, sizeof(*hl) 25874cf49a43SJulian Elischer + (nhooks * sizeof(struct linkinfo)), M_NOWAIT); 2588069154d5SJulian Elischer if (resp == NULL) { 25894cf49a43SJulian Elischer error = ENOMEM; 25904cf49a43SJulian Elischer break; 25914cf49a43SJulian Elischer } 2592069154d5SJulian Elischer hl = (struct hooklist *) resp->data; 25934cf49a43SJulian Elischer ni = &hl->nodeinfo; 25944cf49a43SJulian Elischer 25954cf49a43SJulian Elischer /* Fill in node info */ 259630400f03SJulian Elischer if (NG_NODE_HAS_NAME(here)) 259787e2c66aSHartmut Brandt strcpy(ni->name, NG_NODE_NAME(here)); 259887e2c66aSHartmut Brandt strcpy(ni->type, here->nd_type->name); 2599dc90cad9SJulian Elischer ni->id = ng_node2ID(here); 26004cf49a43SJulian Elischer 26014cf49a43SJulian Elischer /* Cycle through the linked list of hooks */ 26024cf49a43SJulian Elischer ni->hooks = 0; 260330400f03SJulian Elischer LIST_FOREACH(hook, &here->nd_hooks, hk_hooks) { 26044cf49a43SJulian Elischer struct linkinfo *const link = &hl->link[ni->hooks]; 26054cf49a43SJulian Elischer 26064cf49a43SJulian Elischer if (ni->hooks >= nhooks) { 26074cf49a43SJulian Elischer log(LOG_ERR, "%s: number of %s changed\n", 26086e551fb6SDavid E. O'Brien __func__, "hooks"); 26094cf49a43SJulian Elischer break; 26104cf49a43SJulian Elischer } 261130400f03SJulian Elischer if (NG_HOOK_NOT_VALID(hook)) 26124cf49a43SJulian Elischer continue; 261387e2c66aSHartmut Brandt strcpy(link->ourhook, NG_HOOK_NAME(hook)); 261487e2c66aSHartmut Brandt strcpy(link->peerhook, NG_PEER_HOOK_NAME(hook)); 261530400f03SJulian Elischer if (NG_PEER_NODE_NAME(hook)[0] != '\0') 261687e2c66aSHartmut Brandt strcpy(link->nodeinfo.name, 261787e2c66aSHartmut Brandt NG_PEER_NODE_NAME(hook)); 261887e2c66aSHartmut Brandt strcpy(link->nodeinfo.type, 261987e2c66aSHartmut Brandt NG_PEER_NODE(hook)->nd_type->name); 262030400f03SJulian Elischer link->nodeinfo.id = ng_node2ID(NG_PEER_NODE(hook)); 262130400f03SJulian Elischer link->nodeinfo.hooks = NG_PEER_NODE(hook)->nd_numhooks; 26224cf49a43SJulian Elischer ni->hooks++; 26234cf49a43SJulian Elischer } 26244cf49a43SJulian Elischer break; 26254cf49a43SJulian Elischer } 26264cf49a43SJulian Elischer 26274cf49a43SJulian Elischer case NGM_LISTNAMES: 26284cf49a43SJulian Elischer case NGM_LISTNODES: 26294cf49a43SJulian Elischer { 26304cf49a43SJulian Elischer const int unnamed = (msg->header.cmd == NGM_LISTNODES); 26314cf49a43SJulian Elischer struct namelist *nl; 26324cf49a43SJulian Elischer node_p node; 26334cf49a43SJulian Elischer int num = 0; 26344cf49a43SJulian Elischer 26359ed346baSBosko Milekic mtx_lock(&ng_nodelist_mtx); 26364cf49a43SJulian Elischer /* Count number of nodes */ 263730400f03SJulian Elischer LIST_FOREACH(node, &ng_nodelist, nd_nodes) { 263870de87f2SJulian Elischer if (NG_NODE_IS_VALID(node) 263970de87f2SJulian Elischer && (unnamed || NG_NODE_HAS_NAME(node))) { 26404cf49a43SJulian Elischer num++; 26414cf49a43SJulian Elischer } 264270de87f2SJulian Elischer } 26439ed346baSBosko Milekic mtx_unlock(&ng_nodelist_mtx); 26444cf49a43SJulian Elischer 26454cf49a43SJulian Elischer /* Get response struct */ 2646069154d5SJulian Elischer NG_MKRESPONSE(resp, msg, sizeof(*nl) 26474cf49a43SJulian Elischer + (num * sizeof(struct nodeinfo)), M_NOWAIT); 2648069154d5SJulian Elischer if (resp == NULL) { 26494cf49a43SJulian Elischer error = ENOMEM; 26504cf49a43SJulian Elischer break; 26514cf49a43SJulian Elischer } 2652069154d5SJulian Elischer nl = (struct namelist *) resp->data; 26534cf49a43SJulian Elischer 26544cf49a43SJulian Elischer /* Cycle through the linked list of nodes */ 26554cf49a43SJulian Elischer nl->numnames = 0; 26569ed346baSBosko Milekic mtx_lock(&ng_nodelist_mtx); 265730400f03SJulian Elischer LIST_FOREACH(node, &ng_nodelist, nd_nodes) { 26584cf49a43SJulian Elischer struct nodeinfo *const np = &nl->nodeinfo[nl->numnames]; 26594cf49a43SJulian Elischer 2660b96baf0aSGleb Smirnoff if (NG_NODE_NOT_VALID(node)) 2661b96baf0aSGleb Smirnoff continue; 2662b96baf0aSGleb Smirnoff if (!unnamed && (! NG_NODE_HAS_NAME(node))) 2663b96baf0aSGleb Smirnoff continue; 26644cf49a43SJulian Elischer if (nl->numnames >= num) { 26654cf49a43SJulian Elischer log(LOG_ERR, "%s: number of %s changed\n", 26666e551fb6SDavid E. O'Brien __func__, "nodes"); 26674cf49a43SJulian Elischer break; 26684cf49a43SJulian Elischer } 266930400f03SJulian Elischer if (NG_NODE_HAS_NAME(node)) 267087e2c66aSHartmut Brandt strcpy(np->name, NG_NODE_NAME(node)); 267187e2c66aSHartmut Brandt strcpy(np->type, node->nd_type->name); 2672dc90cad9SJulian Elischer np->id = ng_node2ID(node); 267330400f03SJulian Elischer np->hooks = node->nd_numhooks; 26744cf49a43SJulian Elischer nl->numnames++; 26754cf49a43SJulian Elischer } 26769ed346baSBosko Milekic mtx_unlock(&ng_nodelist_mtx); 26774cf49a43SJulian Elischer break; 26784cf49a43SJulian Elischer } 26794cf49a43SJulian Elischer 26804cf49a43SJulian Elischer case NGM_LISTTYPES: 26814cf49a43SJulian Elischer { 26824cf49a43SJulian Elischer struct typelist *tl; 26834cf49a43SJulian Elischer struct ng_type *type; 26844cf49a43SJulian Elischer int num = 0; 26854cf49a43SJulian Elischer 26869ed346baSBosko Milekic mtx_lock(&ng_typelist_mtx); 26874cf49a43SJulian Elischer /* Count number of types */ 268870de87f2SJulian Elischer LIST_FOREACH(type, &ng_typelist, types) { 26894cf49a43SJulian Elischer num++; 269070de87f2SJulian Elischer } 26919ed346baSBosko Milekic mtx_unlock(&ng_typelist_mtx); 26924cf49a43SJulian Elischer 26934cf49a43SJulian Elischer /* Get response struct */ 2694069154d5SJulian Elischer NG_MKRESPONSE(resp, msg, sizeof(*tl) 26954cf49a43SJulian Elischer + (num * sizeof(struct typeinfo)), M_NOWAIT); 2696069154d5SJulian Elischer if (resp == NULL) { 26974cf49a43SJulian Elischer error = ENOMEM; 26984cf49a43SJulian Elischer break; 26994cf49a43SJulian Elischer } 2700069154d5SJulian Elischer tl = (struct typelist *) resp->data; 27014cf49a43SJulian Elischer 27024cf49a43SJulian Elischer /* Cycle through the linked list of types */ 27034cf49a43SJulian Elischer tl->numtypes = 0; 27049ed346baSBosko Milekic mtx_lock(&ng_typelist_mtx); 2705069154d5SJulian Elischer LIST_FOREACH(type, &ng_typelist, types) { 27064cf49a43SJulian Elischer struct typeinfo *const tp = &tl->typeinfo[tl->numtypes]; 27074cf49a43SJulian Elischer 27084cf49a43SJulian Elischer if (tl->numtypes >= num) { 27094cf49a43SJulian Elischer log(LOG_ERR, "%s: number of %s changed\n", 27106e551fb6SDavid E. O'Brien __func__, "types"); 27114cf49a43SJulian Elischer break; 27124cf49a43SJulian Elischer } 271387e2c66aSHartmut Brandt strcpy(tp->type_name, type->name); 2714c73b94a2SJulian Elischer tp->numnodes = type->refs - 1; /* don't count list */ 27154cf49a43SJulian Elischer tl->numtypes++; 27164cf49a43SJulian Elischer } 27179ed346baSBosko Milekic mtx_unlock(&ng_typelist_mtx); 27184cf49a43SJulian Elischer break; 27194cf49a43SJulian Elischer } 27204cf49a43SJulian Elischer 2721f8307e12SArchie Cobbs case NGM_BINARY2ASCII: 2722f8307e12SArchie Cobbs { 27237133ac27SArchie Cobbs int bufSize = 20 * 1024; /* XXX hard coded constant */ 2724f8307e12SArchie Cobbs const struct ng_parse_type *argstype; 2725f8307e12SArchie Cobbs const struct ng_cmdlist *c; 2726069154d5SJulian Elischer struct ng_mesg *binary, *ascii; 2727f8307e12SArchie Cobbs 2728f8307e12SArchie Cobbs /* Data area must contain a valid netgraph message */ 2729f8307e12SArchie Cobbs binary = (struct ng_mesg *)msg->data; 27304c9b5910SGleb Smirnoff if (msg->header.arglen < sizeof(struct ng_mesg) || 27314c9b5910SGleb Smirnoff (msg->header.arglen - sizeof(struct ng_mesg) < 27324c9b5910SGleb Smirnoff binary->header.arglen)) { 27336b795970SJulian Elischer TRAP_ERROR(); 2734f8307e12SArchie Cobbs error = EINVAL; 2735f8307e12SArchie Cobbs break; 2736f8307e12SArchie Cobbs } 2737f8307e12SArchie Cobbs 2738f8307e12SArchie Cobbs /* Get a response message with lots of room */ 2739069154d5SJulian Elischer NG_MKRESPONSE(resp, msg, sizeof(*ascii) + bufSize, M_NOWAIT); 2740069154d5SJulian Elischer if (resp == NULL) { 2741f8307e12SArchie Cobbs error = ENOMEM; 2742f8307e12SArchie Cobbs break; 2743f8307e12SArchie Cobbs } 2744069154d5SJulian Elischer ascii = (struct ng_mesg *)resp->data; 2745f8307e12SArchie Cobbs 2746f8307e12SArchie Cobbs /* Copy binary message header to response message payload */ 2747f8307e12SArchie Cobbs bcopy(binary, ascii, sizeof(*binary)); 2748f8307e12SArchie Cobbs 2749f8307e12SArchie Cobbs /* Find command by matching typecookie and command number */ 275030400f03SJulian Elischer for (c = here->nd_type->cmdlist; 2751f8307e12SArchie Cobbs c != NULL && c->name != NULL; c++) { 2752f8307e12SArchie Cobbs if (binary->header.typecookie == c->cookie 2753f8307e12SArchie Cobbs && binary->header.cmd == c->cmd) 2754f8307e12SArchie Cobbs break; 2755f8307e12SArchie Cobbs } 2756f8307e12SArchie Cobbs if (c == NULL || c->name == NULL) { 2757f8307e12SArchie Cobbs for (c = ng_generic_cmds; c->name != NULL; c++) { 2758f8307e12SArchie Cobbs if (binary->header.typecookie == c->cookie 2759f8307e12SArchie Cobbs && binary->header.cmd == c->cmd) 2760f8307e12SArchie Cobbs break; 2761f8307e12SArchie Cobbs } 2762f8307e12SArchie Cobbs if (c->name == NULL) { 2763069154d5SJulian Elischer NG_FREE_MSG(resp); 2764f8307e12SArchie Cobbs error = ENOSYS; 2765f8307e12SArchie Cobbs break; 2766f8307e12SArchie Cobbs } 2767f8307e12SArchie Cobbs } 2768f8307e12SArchie Cobbs 2769f8307e12SArchie Cobbs /* Convert command name to ASCII */ 2770f8307e12SArchie Cobbs snprintf(ascii->header.cmdstr, sizeof(ascii->header.cmdstr), 2771f8307e12SArchie Cobbs "%s", c->name); 2772f8307e12SArchie Cobbs 2773f8307e12SArchie Cobbs /* Convert command arguments to ASCII */ 2774f8307e12SArchie Cobbs argstype = (binary->header.flags & NGF_RESP) ? 2775f8307e12SArchie Cobbs c->respType : c->mesgType; 277670de87f2SJulian Elischer if (argstype == NULL) { 2777f8307e12SArchie Cobbs *ascii->data = '\0'; 277870de87f2SJulian Elischer } else { 2779f8307e12SArchie Cobbs if ((error = ng_unparse(argstype, 2780f8307e12SArchie Cobbs (u_char *)binary->data, 2781f8307e12SArchie Cobbs ascii->data, bufSize)) != 0) { 2782069154d5SJulian Elischer NG_FREE_MSG(resp); 2783f8307e12SArchie Cobbs break; 2784f8307e12SArchie Cobbs } 2785f8307e12SArchie Cobbs } 2786f8307e12SArchie Cobbs 2787f8307e12SArchie Cobbs /* Return the result as struct ng_mesg plus ASCII string */ 2788f8307e12SArchie Cobbs bufSize = strlen(ascii->data) + 1; 2789f8307e12SArchie Cobbs ascii->header.arglen = bufSize; 2790069154d5SJulian Elischer resp->header.arglen = sizeof(*ascii) + bufSize; 2791f8307e12SArchie Cobbs break; 2792f8307e12SArchie Cobbs } 2793f8307e12SArchie Cobbs 2794f8307e12SArchie Cobbs case NGM_ASCII2BINARY: 2795f8307e12SArchie Cobbs { 2796f8307e12SArchie Cobbs int bufSize = 2000; /* XXX hard coded constant */ 2797f8307e12SArchie Cobbs const struct ng_cmdlist *c; 2798f8307e12SArchie Cobbs const struct ng_parse_type *argstype; 2799069154d5SJulian Elischer struct ng_mesg *ascii, *binary; 280052ec4a03SArchie Cobbs int off = 0; 2801f8307e12SArchie Cobbs 2802f8307e12SArchie Cobbs /* Data area must contain at least a struct ng_mesg + '\0' */ 2803f8307e12SArchie Cobbs ascii = (struct ng_mesg *)msg->data; 28044c9b5910SGleb Smirnoff if ((msg->header.arglen < sizeof(*ascii) + 1) || 28054c9b5910SGleb Smirnoff (ascii->header.arglen < 1) || 28064c9b5910SGleb Smirnoff (msg->header.arglen < sizeof(*ascii) + 28074c9b5910SGleb Smirnoff ascii->header.arglen)) { 28086b795970SJulian Elischer TRAP_ERROR(); 2809f8307e12SArchie Cobbs error = EINVAL; 2810f8307e12SArchie Cobbs break; 2811f8307e12SArchie Cobbs } 2812f8307e12SArchie Cobbs ascii->data[ascii->header.arglen - 1] = '\0'; 2813f8307e12SArchie Cobbs 2814f8307e12SArchie Cobbs /* Get a response message with lots of room */ 2815069154d5SJulian Elischer NG_MKRESPONSE(resp, msg, sizeof(*binary) + bufSize, M_NOWAIT); 2816069154d5SJulian Elischer if (resp == NULL) { 2817f8307e12SArchie Cobbs error = ENOMEM; 2818f8307e12SArchie Cobbs break; 2819f8307e12SArchie Cobbs } 2820069154d5SJulian Elischer binary = (struct ng_mesg *)resp->data; 2821f8307e12SArchie Cobbs 2822f8307e12SArchie Cobbs /* Copy ASCII message header to response message payload */ 2823f8307e12SArchie Cobbs bcopy(ascii, binary, sizeof(*ascii)); 2824f8307e12SArchie Cobbs 2825f8307e12SArchie Cobbs /* Find command by matching ASCII command string */ 282630400f03SJulian Elischer for (c = here->nd_type->cmdlist; 2827f8307e12SArchie Cobbs c != NULL && c->name != NULL; c++) { 2828f8307e12SArchie Cobbs if (strcmp(ascii->header.cmdstr, c->name) == 0) 2829f8307e12SArchie Cobbs break; 2830f8307e12SArchie Cobbs } 2831f8307e12SArchie Cobbs if (c == NULL || c->name == NULL) { 2832f8307e12SArchie Cobbs for (c = ng_generic_cmds; c->name != NULL; c++) { 2833f8307e12SArchie Cobbs if (strcmp(ascii->header.cmdstr, c->name) == 0) 2834f8307e12SArchie Cobbs break; 2835f8307e12SArchie Cobbs } 2836f8307e12SArchie Cobbs if (c->name == NULL) { 2837069154d5SJulian Elischer NG_FREE_MSG(resp); 2838f8307e12SArchie Cobbs error = ENOSYS; 2839f8307e12SArchie Cobbs break; 2840f8307e12SArchie Cobbs } 2841f8307e12SArchie Cobbs } 2842f8307e12SArchie Cobbs 2843f8307e12SArchie Cobbs /* Convert command name to binary */ 2844f8307e12SArchie Cobbs binary->header.cmd = c->cmd; 2845f8307e12SArchie Cobbs binary->header.typecookie = c->cookie; 2846f8307e12SArchie Cobbs 2847f8307e12SArchie Cobbs /* Convert command arguments to binary */ 2848f8307e12SArchie Cobbs argstype = (binary->header.flags & NGF_RESP) ? 2849f8307e12SArchie Cobbs c->respType : c->mesgType; 285070de87f2SJulian Elischer if (argstype == NULL) { 2851f8307e12SArchie Cobbs bufSize = 0; 285270de87f2SJulian Elischer } else { 2853f8307e12SArchie Cobbs if ((error = ng_parse(argstype, ascii->data, 2854f8307e12SArchie Cobbs &off, (u_char *)binary->data, &bufSize)) != 0) { 2855069154d5SJulian Elischer NG_FREE_MSG(resp); 2856f8307e12SArchie Cobbs break; 2857f8307e12SArchie Cobbs } 2858f8307e12SArchie Cobbs } 2859f8307e12SArchie Cobbs 2860f8307e12SArchie Cobbs /* Return the result */ 2861f8307e12SArchie Cobbs binary->header.arglen = bufSize; 2862069154d5SJulian Elischer resp->header.arglen = sizeof(*binary) + bufSize; 2863f8307e12SArchie Cobbs break; 2864f8307e12SArchie Cobbs } 2865f8307e12SArchie Cobbs 28667095e097SPoul-Henning Kamp case NGM_TEXT_CONFIG: 28674cf49a43SJulian Elischer case NGM_TEXT_STATUS: 28684cf49a43SJulian Elischer /* 28694cf49a43SJulian Elischer * This one is tricky as it passes the command down to the 28704cf49a43SJulian Elischer * actual node, even though it is a generic type command. 2871069154d5SJulian Elischer * This means we must assume that the item/msg is already freed 28724cf49a43SJulian Elischer * when control passes back to us. 28734cf49a43SJulian Elischer */ 287430400f03SJulian Elischer if (here->nd_type->rcvmsg != NULL) { 2875069154d5SJulian Elischer NGI_MSG(item) = msg; /* put it back as we found it */ 287630400f03SJulian Elischer return((*here->nd_type->rcvmsg)(here, item, lasthook)); 28774cf49a43SJulian Elischer } 28784cf49a43SJulian Elischer /* Fall through if rcvmsg not supported */ 28794cf49a43SJulian Elischer default: 28806b795970SJulian Elischer TRAP_ERROR(); 28814cf49a43SJulian Elischer error = EINVAL; 28824cf49a43SJulian Elischer } 2883069154d5SJulian Elischer /* 2884069154d5SJulian Elischer * Sometimes a generic message may be statically allocated 2885069154d5SJulian Elischer * to avoid problems with allocating when in tight memeory situations. 2886069154d5SJulian Elischer * Don't free it if it is so. 2887069154d5SJulian Elischer * I break them appart here, because erros may cause a free if the item 2888069154d5SJulian Elischer * in which case we'd be doing it twice. 2889069154d5SJulian Elischer * they are kept together above, to simplify freeing. 2890069154d5SJulian Elischer */ 2891069154d5SJulian Elischer out: 2892069154d5SJulian Elischer NG_RESPOND_MSG(error, here, item, resp); 28931acb27c6SJulian Elischer if (msg) 2894069154d5SJulian Elischer NG_FREE_MSG(msg); 28954cf49a43SJulian Elischer return (error); 28964cf49a43SJulian Elischer } 28974cf49a43SJulian Elischer 28984cf49a43SJulian Elischer /************************************************************************ 28998253c060SGleb Smirnoff Queue element get/free routines 29008253c060SGleb Smirnoff ************************************************************************/ 29018253c060SGleb Smirnoff 29028253c060SGleb Smirnoff uma_zone_t ng_qzone; 29038253c060SGleb Smirnoff static int maxalloc = 512; /* limit the damage of a leak */ 29048253c060SGleb Smirnoff 29058253c060SGleb Smirnoff TUNABLE_INT("net.graph.maxalloc", &maxalloc); 29068253c060SGleb Smirnoff SYSCTL_INT(_net_graph, OID_AUTO, maxalloc, CTLFLAG_RDTUN, &maxalloc, 29078253c060SGleb Smirnoff 0, "Maximum number of queue items to allocate"); 29088253c060SGleb Smirnoff 29098253c060SGleb Smirnoff #ifdef NETGRAPH_DEBUG 29108253c060SGleb Smirnoff static TAILQ_HEAD(, ng_item) ng_itemlist = TAILQ_HEAD_INITIALIZER(ng_itemlist); 29118253c060SGleb Smirnoff static int allocated; /* number of items malloc'd */ 29128253c060SGleb Smirnoff #endif 29138253c060SGleb Smirnoff 29148253c060SGleb Smirnoff /* 29158253c060SGleb Smirnoff * Get a queue entry. 29168253c060SGleb Smirnoff * This is usually called when a packet first enters netgraph. 29178253c060SGleb Smirnoff * By definition, this is usually from an interrupt, or from a user. 29188253c060SGleb Smirnoff * Users are not so important, but try be quick for the times that it's 29198253c060SGleb Smirnoff * an interrupt. 29208253c060SGleb Smirnoff */ 29218253c060SGleb Smirnoff static __inline item_p 292242282202SGleb Smirnoff ng_getqblk(int flags) 29238253c060SGleb Smirnoff { 29248253c060SGleb Smirnoff item_p item = NULL; 292542282202SGleb Smirnoff int wait; 29268253c060SGleb Smirnoff 292742282202SGleb Smirnoff wait = (flags & NG_WAITOK) ? M_WAITOK : M_NOWAIT; 292842282202SGleb Smirnoff 292942282202SGleb Smirnoff item = uma_zalloc(ng_qzone, wait | M_ZERO); 29308253c060SGleb Smirnoff 29318253c060SGleb Smirnoff #ifdef NETGRAPH_DEBUG 29328253c060SGleb Smirnoff if (item) { 29338253c060SGleb Smirnoff mtx_lock(&ngq_mtx); 29348253c060SGleb Smirnoff TAILQ_INSERT_TAIL(&ng_itemlist, item, all); 29358253c060SGleb Smirnoff allocated++; 29368253c060SGleb Smirnoff mtx_unlock(&ngq_mtx); 29378253c060SGleb Smirnoff } 29388253c060SGleb Smirnoff #endif 29398253c060SGleb Smirnoff 29408253c060SGleb Smirnoff return (item); 29418253c060SGleb Smirnoff } 29428253c060SGleb Smirnoff 29438253c060SGleb Smirnoff /* 29448253c060SGleb Smirnoff * Release a queue entry 29458253c060SGleb Smirnoff */ 29468253c060SGleb Smirnoff void 29478253c060SGleb Smirnoff ng_free_item(item_p item) 29488253c060SGleb Smirnoff { 2949eb2405ddSGleb Smirnoff KASSERT(item->apply == NULL, ("%s: leaking apply callback", __func__)); 2950eb2405ddSGleb Smirnoff 29518253c060SGleb Smirnoff /* 29528253c060SGleb Smirnoff * The item may hold resources on it's own. We need to free 29538253c060SGleb Smirnoff * these before we can free the item. What they are depends upon 29548253c060SGleb Smirnoff * what kind of item it is. it is important that nodes zero 29558253c060SGleb Smirnoff * out pointers to resources that they remove from the item 29568253c060SGleb Smirnoff * or we release them again here. 29578253c060SGleb Smirnoff */ 29588253c060SGleb Smirnoff switch (item->el_flags & NGQF_TYPE) { 29598253c060SGleb Smirnoff case NGQF_DATA: 29608253c060SGleb Smirnoff /* If we have an mbuf still attached.. */ 29618253c060SGleb Smirnoff NG_FREE_M(_NGI_M(item)); 29628253c060SGleb Smirnoff break; 29638253c060SGleb Smirnoff case NGQF_MESG: 29648253c060SGleb Smirnoff _NGI_RETADDR(item) = 0; 29658253c060SGleb Smirnoff NG_FREE_MSG(_NGI_MSG(item)); 29668253c060SGleb Smirnoff break; 29678253c060SGleb Smirnoff case NGQF_FN: 29688253c060SGleb Smirnoff /* nothing to free really, */ 29698253c060SGleb Smirnoff _NGI_FN(item) = NULL; 29708253c060SGleb Smirnoff _NGI_ARG1(item) = NULL; 29718253c060SGleb Smirnoff _NGI_ARG2(item) = 0; 29728253c060SGleb Smirnoff case NGQF_UNDEF: 29738253c060SGleb Smirnoff break; 29748253c060SGleb Smirnoff } 29758253c060SGleb Smirnoff /* If we still have a node or hook referenced... */ 29768253c060SGleb Smirnoff _NGI_CLR_NODE(item); 29778253c060SGleb Smirnoff _NGI_CLR_HOOK(item); 29788253c060SGleb Smirnoff 29798253c060SGleb Smirnoff #ifdef NETGRAPH_DEBUG 29808253c060SGleb Smirnoff mtx_lock(&ngq_mtx); 29818253c060SGleb Smirnoff TAILQ_REMOVE(&ng_itemlist, item, all); 29828253c060SGleb Smirnoff allocated--; 29838253c060SGleb Smirnoff mtx_unlock(&ngq_mtx); 29848253c060SGleb Smirnoff #endif 29858253c060SGleb Smirnoff uma_zfree(ng_qzone, item); 29868253c060SGleb Smirnoff } 29878253c060SGleb Smirnoff 29888253c060SGleb Smirnoff /************************************************************************ 29894cf49a43SJulian Elischer Module routines 29904cf49a43SJulian Elischer ************************************************************************/ 29914cf49a43SJulian Elischer 29924cf49a43SJulian Elischer /* 29934cf49a43SJulian Elischer * Handle the loading/unloading of a netgraph node type module 29944cf49a43SJulian Elischer */ 29954cf49a43SJulian Elischer int 29964cf49a43SJulian Elischer ng_mod_event(module_t mod, int event, void *data) 29974cf49a43SJulian Elischer { 29984cf49a43SJulian Elischer struct ng_type *const type = data; 29994cf49a43SJulian Elischer int s, error = 0; 30004cf49a43SJulian Elischer 30014cf49a43SJulian Elischer switch (event) { 30024cf49a43SJulian Elischer case MOD_LOAD: 30034cf49a43SJulian Elischer 30044cf49a43SJulian Elischer /* Register new netgraph node type */ 30054cf49a43SJulian Elischer s = splnet(); 30064cf49a43SJulian Elischer if ((error = ng_newtype(type)) != 0) { 30074cf49a43SJulian Elischer splx(s); 30084cf49a43SJulian Elischer break; 30094cf49a43SJulian Elischer } 30104cf49a43SJulian Elischer 30114cf49a43SJulian Elischer /* Call type specific code */ 30124cf49a43SJulian Elischer if (type->mod_event != NULL) 3013069154d5SJulian Elischer if ((error = (*type->mod_event)(mod, event, data))) { 30149ed346baSBosko Milekic mtx_lock(&ng_typelist_mtx); 3015c73b94a2SJulian Elischer type->refs--; /* undo it */ 30164cf49a43SJulian Elischer LIST_REMOVE(type, types); 30179ed346baSBosko Milekic mtx_unlock(&ng_typelist_mtx); 3018069154d5SJulian Elischer } 30194cf49a43SJulian Elischer splx(s); 30204cf49a43SJulian Elischer break; 30214cf49a43SJulian Elischer 30224cf49a43SJulian Elischer case MOD_UNLOAD: 30234cf49a43SJulian Elischer s = splnet(); 3024c73b94a2SJulian Elischer if (type->refs > 1) { /* make sure no nodes exist! */ 30254cf49a43SJulian Elischer error = EBUSY; 3026c73b94a2SJulian Elischer } else { 3027c73b94a2SJulian Elischer if (type->refs == 0) { 3028c73b94a2SJulian Elischer /* failed load, nothing to undo */ 3029c73b94a2SJulian Elischer splx(s); 3030c73b94a2SJulian Elischer break; 3031c73b94a2SJulian Elischer } 30324cf49a43SJulian Elischer if (type->mod_event != NULL) { /* check with type */ 30334cf49a43SJulian Elischer error = (*type->mod_event)(mod, event, data); 30344cf49a43SJulian Elischer if (error != 0) { /* type refuses.. */ 30354cf49a43SJulian Elischer splx(s); 30364cf49a43SJulian Elischer break; 30374cf49a43SJulian Elischer } 30384cf49a43SJulian Elischer } 30399ed346baSBosko Milekic mtx_lock(&ng_typelist_mtx); 30404cf49a43SJulian Elischer LIST_REMOVE(type, types); 30419ed346baSBosko Milekic mtx_unlock(&ng_typelist_mtx); 30424cf49a43SJulian Elischer } 30434cf49a43SJulian Elischer splx(s); 30444cf49a43SJulian Elischer break; 30454cf49a43SJulian Elischer 30464cf49a43SJulian Elischer default: 30474cf49a43SJulian Elischer if (type->mod_event != NULL) 30484cf49a43SJulian Elischer error = (*type->mod_event)(mod, event, data); 30494cf49a43SJulian Elischer else 30503e019deaSPoul-Henning Kamp error = EOPNOTSUPP; /* XXX ? */ 30514cf49a43SJulian Elischer break; 30524cf49a43SJulian Elischer } 30534cf49a43SJulian Elischer return (error); 30544cf49a43SJulian Elischer } 30554cf49a43SJulian Elischer 30564cf49a43SJulian Elischer /* 30574cf49a43SJulian Elischer * Handle loading and unloading for this code. 30584cf49a43SJulian Elischer * The only thing we need to link into is the NETISR strucure. 30594cf49a43SJulian Elischer */ 30604cf49a43SJulian Elischer static int 30614cf49a43SJulian Elischer ngb_mod_event(module_t mod, int event, void *data) 30624cf49a43SJulian Elischer { 30631489164fSGleb Smirnoff int error = 0; 30644cf49a43SJulian Elischer 30654cf49a43SJulian Elischer switch (event) { 30664cf49a43SJulian Elischer case MOD_LOAD: 30671489164fSGleb Smirnoff /* Initialize everything. */ 30686008862bSJohn Baldwin mtx_init(&ng_worklist_mtx, "ng_worklist", NULL, MTX_SPIN); 3069efd8e7c9SDon Lewis mtx_init(&ng_typelist_mtx, "netgraph types mutex", NULL, 3070efd8e7c9SDon Lewis MTX_DEF); 3071efd8e7c9SDon Lewis mtx_init(&ng_nodelist_mtx, "netgraph nodelist mutex", NULL, 3072efd8e7c9SDon Lewis MTX_DEF); 3073efd8e7c9SDon Lewis mtx_init(&ng_idhash_mtx, "netgraph idhash mutex", NULL, 3074efd8e7c9SDon Lewis MTX_DEF); 3075ac5dd141SGleb Smirnoff mtx_init(&ng_topo_mtx, "netgraph topology mutex", NULL, 3076ac5dd141SGleb Smirnoff MTX_DEF); 30771489164fSGleb Smirnoff #ifdef NETGRAPH_DEBUG 30781489164fSGleb Smirnoff mtx_init(&ngq_mtx, "netgraph item list mutex", NULL, 3079efd8e7c9SDon Lewis MTX_DEF); 30801489164fSGleb Smirnoff #endif 30811489164fSGleb Smirnoff ng_qzone = uma_zcreate("NetGraph items", sizeof(struct ng_item), 30821489164fSGleb Smirnoff NULL, NULL, NULL, NULL, UMA_ALIGN_CACHE, 0); 30831489164fSGleb Smirnoff uma_zone_set_max(ng_qzone, maxalloc); 308468780975SGleb Smirnoff netisr_register(NETISR_NETGRAPH, (netisr_t *)ngintr, NULL, 308568780975SGleb Smirnoff NETISR_MPSAFE); 30864cf49a43SJulian Elischer break; 30874cf49a43SJulian Elischer case MOD_UNLOAD: 30884cf49a43SJulian Elischer /* You cant unload it because an interface may be using it. */ 30894cf49a43SJulian Elischer error = EBUSY; 30904cf49a43SJulian Elischer break; 30914cf49a43SJulian Elischer default: 30924cf49a43SJulian Elischer error = EOPNOTSUPP; 30934cf49a43SJulian Elischer break; 30944cf49a43SJulian Elischer } 30954cf49a43SJulian Elischer return (error); 30964cf49a43SJulian Elischer } 30974cf49a43SJulian Elischer 30984cf49a43SJulian Elischer static moduledata_t netgraph_mod = { 30994cf49a43SJulian Elischer "netgraph", 31004cf49a43SJulian Elischer ngb_mod_event, 31014cf49a43SJulian Elischer (NULL) 31024cf49a43SJulian Elischer }; 3103aa38f8f9SMaksim Yevmenkin DECLARE_MODULE(netgraph, netgraph_mod, SI_SUB_NETGRAPH, SI_ORDER_MIDDLE); 3104bfa7e882SJulian Elischer SYSCTL_NODE(_net, OID_AUTO, graph, CTLFLAG_RW, 0, "netgraph Family"); 3105bfa7e882SJulian Elischer SYSCTL_INT(_net_graph, OID_AUTO, abi_version, CTLFLAG_RD, 0, NG_ABI_VERSION,""); 3106bfa7e882SJulian Elischer SYSCTL_INT(_net_graph, OID_AUTO, msg_version, CTLFLAG_RD, 0, NG_VERSION, ""); 31074cf49a43SJulian Elischer 310830400f03SJulian Elischer #ifdef NETGRAPH_DEBUG 310930400f03SJulian Elischer void 311030400f03SJulian Elischer dumphook (hook_p hook, char *file, int line) 311130400f03SJulian Elischer { 311230400f03SJulian Elischer printf("hook: name %s, %d refs, Last touched:\n", 311330400f03SJulian Elischer _NG_HOOK_NAME(hook), hook->hk_refs); 311430400f03SJulian Elischer printf(" Last active @ %s, line %d\n", 311530400f03SJulian Elischer hook->lastfile, hook->lastline); 311630400f03SJulian Elischer if (line) { 311730400f03SJulian Elischer printf(" problem discovered at file %s, line %d\n", file, line); 311830400f03SJulian Elischer } 311930400f03SJulian Elischer } 312030400f03SJulian Elischer 312130400f03SJulian Elischer void 312230400f03SJulian Elischer dumpnode(node_p node, char *file, int line) 312330400f03SJulian Elischer { 312430400f03SJulian Elischer printf("node: ID [%x]: type '%s', %d hooks, flags 0x%x, %d refs, %s:\n", 31256b795970SJulian Elischer _NG_NODE_ID(node), node->nd_type->name, 312630400f03SJulian Elischer node->nd_numhooks, node->nd_flags, 312730400f03SJulian Elischer node->nd_refs, node->nd_name); 312830400f03SJulian Elischer printf(" Last active @ %s, line %d\n", 312930400f03SJulian Elischer node->lastfile, node->lastline); 313030400f03SJulian Elischer if (line) { 313130400f03SJulian Elischer printf(" problem discovered at file %s, line %d\n", file, line); 313230400f03SJulian Elischer } 313330400f03SJulian Elischer } 313430400f03SJulian Elischer 3135069154d5SJulian Elischer void 3136069154d5SJulian Elischer dumpitem(item_p item, char *file, int line) 3137069154d5SJulian Elischer { 3138069154d5SJulian Elischer printf(" ACTIVE item, last used at %s, line %d", 3139069154d5SJulian Elischer item->lastfile, item->lastline); 31406b795970SJulian Elischer switch(item->el_flags & NGQF_TYPE) { 31416b795970SJulian Elischer case NGQF_DATA: 3142069154d5SJulian Elischer printf(" - [data]\n"); 31436b795970SJulian Elischer break; 31446b795970SJulian Elischer case NGQF_MESG: 31456b795970SJulian Elischer printf(" - retaddr[%d]:\n", _NGI_RETADDR(item)); 31466b795970SJulian Elischer break; 31476b795970SJulian Elischer case NGQF_FN: 31486b795970SJulian Elischer printf(" - fn@%p (%p, %p, %p, %d (%x))\n", 31496b795970SJulian Elischer item->body.fn.fn_fn, 31506064e568SGleb Smirnoff _NGI_NODE(item), 31516064e568SGleb Smirnoff _NGI_HOOK(item), 31526b795970SJulian Elischer item->body.fn.fn_arg1, 31536b795970SJulian Elischer item->body.fn.fn_arg2, 31546b795970SJulian Elischer item->body.fn.fn_arg2); 31556b795970SJulian Elischer break; 31566b795970SJulian Elischer case NGQF_UNDEF: 31576b795970SJulian Elischer printf(" - UNDEFINED!\n"); 3158069154d5SJulian Elischer } 315930400f03SJulian Elischer if (line) { 3160069154d5SJulian Elischer printf(" problem discovered at file %s, line %d\n", file, line); 31616064e568SGleb Smirnoff if (_NGI_NODE(item)) { 316230400f03SJulian Elischer printf("node %p ([%x])\n", 31636064e568SGleb Smirnoff _NGI_NODE(item), ng_node2ID(_NGI_NODE(item))); 3164069154d5SJulian Elischer } 316530400f03SJulian Elischer } 316630400f03SJulian Elischer } 316730400f03SJulian Elischer 316830400f03SJulian Elischer static void 316930400f03SJulian Elischer ng_dumpitems(void) 317030400f03SJulian Elischer { 317130400f03SJulian Elischer item_p item; 317230400f03SJulian Elischer int i = 1; 317330400f03SJulian Elischer TAILQ_FOREACH(item, &ng_itemlist, all) { 317430400f03SJulian Elischer printf("[%d] ", i++); 317530400f03SJulian Elischer dumpitem(item, NULL, 0); 317630400f03SJulian Elischer } 317730400f03SJulian Elischer } 317830400f03SJulian Elischer 317930400f03SJulian Elischer static void 318030400f03SJulian Elischer ng_dumpnodes(void) 318130400f03SJulian Elischer { 318230400f03SJulian Elischer node_p node; 318330400f03SJulian Elischer int i = 1; 318453f9c5e9SRobert Watson mtx_lock(&ng_nodelist_mtx); 318530400f03SJulian Elischer SLIST_FOREACH(node, &ng_allnodes, nd_all) { 318630400f03SJulian Elischer printf("[%d] ", i++); 318730400f03SJulian Elischer dumpnode(node, NULL, 0); 318830400f03SJulian Elischer } 318953f9c5e9SRobert Watson mtx_unlock(&ng_nodelist_mtx); 319030400f03SJulian Elischer } 319130400f03SJulian Elischer 319230400f03SJulian Elischer static void 319330400f03SJulian Elischer ng_dumphooks(void) 319430400f03SJulian Elischer { 319530400f03SJulian Elischer hook_p hook; 319630400f03SJulian Elischer int i = 1; 319753f9c5e9SRobert Watson mtx_lock(&ng_nodelist_mtx); 319830400f03SJulian Elischer SLIST_FOREACH(hook, &ng_allhooks, hk_all) { 319930400f03SJulian Elischer printf("[%d] ", i++); 320030400f03SJulian Elischer dumphook(hook, NULL, 0); 320130400f03SJulian Elischer } 320253f9c5e9SRobert Watson mtx_unlock(&ng_nodelist_mtx); 320330400f03SJulian Elischer } 3204069154d5SJulian Elischer 3205069154d5SJulian Elischer static int 3206069154d5SJulian Elischer sysctl_debug_ng_dump_items(SYSCTL_HANDLER_ARGS) 3207069154d5SJulian Elischer { 3208069154d5SJulian Elischer int error; 3209069154d5SJulian Elischer int val; 3210069154d5SJulian Elischer int i; 3211069154d5SJulian Elischer 3212069154d5SJulian Elischer val = allocated; 3213069154d5SJulian Elischer i = 1; 3214069154d5SJulian Elischer error = sysctl_handle_int(oidp, &val, sizeof(int), req); 32156b795970SJulian Elischer if (error != 0 || req->newptr == NULL) 32166b795970SJulian Elischer return (error); 32176b795970SJulian Elischer if (val == 42) { 321830400f03SJulian Elischer ng_dumpitems(); 321930400f03SJulian Elischer ng_dumpnodes(); 322030400f03SJulian Elischer ng_dumphooks(); 3221069154d5SJulian Elischer } 32226b795970SJulian Elischer return (0); 3223069154d5SJulian Elischer } 3224069154d5SJulian Elischer 32256b795970SJulian Elischer SYSCTL_PROC(_debug, OID_AUTO, ng_dump_items, CTLTYPE_INT | CTLFLAG_RW, 32266b795970SJulian Elischer 0, sizeof(int), sysctl_debug_ng_dump_items, "I", "Number of allocated items"); 322730400f03SJulian Elischer #endif /* NETGRAPH_DEBUG */ 3228069154d5SJulian Elischer 3229069154d5SJulian Elischer 3230069154d5SJulian Elischer /*********************************************************************** 3231069154d5SJulian Elischer * Worklist routines 3232069154d5SJulian Elischer **********************************************************************/ 3233069154d5SJulian Elischer /* NETISR thread enters here */ 3234069154d5SJulian Elischer /* 3235069154d5SJulian Elischer * Pick a node off the list of nodes with work, 3236069154d5SJulian Elischer * try get an item to process off it. 3237069154d5SJulian Elischer * If there are no more, remove the node from the list. 3238069154d5SJulian Elischer */ 3239069154d5SJulian Elischer static void 3240069154d5SJulian Elischer ngintr(void) 3241069154d5SJulian Elischer { 3242069154d5SJulian Elischer item_p item; 3243069154d5SJulian Elischer node_p node = NULL; 3244069154d5SJulian Elischer 3245069154d5SJulian Elischer for (;;) { 32469ed346baSBosko Milekic mtx_lock_spin(&ng_worklist_mtx); 3247069154d5SJulian Elischer node = TAILQ_FIRST(&ng_worklist); 3248069154d5SJulian Elischer if (!node) { 32499ed346baSBosko Milekic mtx_unlock_spin(&ng_worklist_mtx); 3250069154d5SJulian Elischer break; 3251069154d5SJulian Elischer } 3252be4252b3SJulian Elischer node->nd_flags &= ~NGF_WORKQ; 325330400f03SJulian Elischer TAILQ_REMOVE(&ng_worklist, node, nd_work); 32549ed346baSBosko Milekic mtx_unlock_spin(&ng_worklist_mtx); 32552955ee18SGleb Smirnoff CTR3(KTR_NET, "%20s: node [%x] (%p) taken off worklist", 32562955ee18SGleb Smirnoff __func__, node->nd_ID, node); 3257069154d5SJulian Elischer /* 3258069154d5SJulian Elischer * We have the node. We also take over the reference 3259069154d5SJulian Elischer * that the list had on it. 3260069154d5SJulian Elischer * Now process as much as you can, until it won't 3261069154d5SJulian Elischer * let you have another item off the queue. 3262069154d5SJulian Elischer * All this time, keep the reference 3263069154d5SJulian Elischer * that lets us be sure that the node still exists. 3264069154d5SJulian Elischer * Let the reference go at the last minute. 3265b57a7965SJulian Elischer * ng_dequeue will put us back on the worklist 3266b57a7965SJulian Elischer * if there is more too do. This may be of use if there 3267b57a7965SJulian Elischer * are Multiple Processors and multiple Net threads in the 3268b57a7965SJulian Elischer * future. 3269069154d5SJulian Elischer */ 3270069154d5SJulian Elischer for (;;) { 3271714fb865SGleb Smirnoff int rw; 3272714fb865SGleb Smirnoff 32739ed346baSBosko Milekic mtx_lock_spin(&node->nd_input_queue.q_mtx); 3274714fb865SGleb Smirnoff item = ng_dequeue(&node->nd_input_queue, &rw); 3275069154d5SJulian Elischer if (item == NULL) { 32769ed346baSBosko Milekic mtx_unlock_spin(&node->nd_input_queue.q_mtx); 3277069154d5SJulian Elischer break; /* go look for another node */ 3278069154d5SJulian Elischer } else { 32799ed346baSBosko Milekic mtx_unlock_spin(&node->nd_input_queue.q_mtx); 32805951069aSJulian Elischer NGI_GET_NODE(item, node); /* zaps stored node */ 3281714fb865SGleb Smirnoff ng_apply_item(node, item, rw); 32825951069aSJulian Elischer NG_NODE_UNREF(node); 3283069154d5SJulian Elischer } 3284069154d5SJulian Elischer } 3285a96dcd84SJulian Elischer NG_NODE_UNREF(node); 3286069154d5SJulian Elischer } 3287069154d5SJulian Elischer } 3288069154d5SJulian Elischer 3289069154d5SJulian Elischer static void 3290069154d5SJulian Elischer ng_worklist_remove(node_p node) 3291069154d5SJulian Elischer { 32923b33fbe7SGleb Smirnoff mtx_assert(&node->nd_input_queue.q_mtx, MA_OWNED); 32933b33fbe7SGleb Smirnoff 32949ed346baSBosko Milekic mtx_lock_spin(&ng_worklist_mtx); 3295be4252b3SJulian Elischer if (node->nd_flags & NGF_WORKQ) { 3296be4252b3SJulian Elischer node->nd_flags &= ~NGF_WORKQ; 329733338e73SJulian Elischer TAILQ_REMOVE(&ng_worklist, node, nd_work); 329833338e73SJulian Elischer mtx_unlock_spin(&ng_worklist_mtx); 329933338e73SJulian Elischer NG_NODE_UNREF(node); 33002955ee18SGleb Smirnoff CTR3(KTR_NET, "%20s: node [%x] (%p) removed from worklist", 33012955ee18SGleb Smirnoff __func__, node->nd_ID, node); 330233338e73SJulian Elischer } else { 33039ed346baSBosko Milekic mtx_unlock_spin(&ng_worklist_mtx); 3304069154d5SJulian Elischer } 330533338e73SJulian Elischer } 3306069154d5SJulian Elischer 330733338e73SJulian Elischer /* 330833338e73SJulian Elischer * XXX 330933338e73SJulian Elischer * It's posible that a debugging NG_NODE_REF may need 331033338e73SJulian Elischer * to be outside the mutex zone 331133338e73SJulian Elischer */ 3312069154d5SJulian Elischer static void 3313069154d5SJulian Elischer ng_setisr(node_p node) 3314069154d5SJulian Elischer { 3315f912c0f7SGleb Smirnoff 33165bc15201SGleb Smirnoff mtx_assert(&node->nd_input_queue.q_mtx, MA_OWNED); 3317f912c0f7SGleb Smirnoff 3318be4252b3SJulian Elischer if ((node->nd_flags & NGF_WORKQ) == 0) { 3319069154d5SJulian Elischer /* 3320069154d5SJulian Elischer * If we are not already on the work queue, 3321069154d5SJulian Elischer * then put us on. 3322069154d5SJulian Elischer */ 3323be4252b3SJulian Elischer node->nd_flags |= NGF_WORKQ; 3324f912c0f7SGleb Smirnoff mtx_lock_spin(&ng_worklist_mtx); 332530400f03SJulian Elischer TAILQ_INSERT_TAIL(&ng_worklist, node, nd_work); 3326f912c0f7SGleb Smirnoff mtx_unlock_spin(&ng_worklist_mtx); 332733338e73SJulian Elischer NG_NODE_REF(node); /* XXX fafe in mutex? */ 33282955ee18SGleb Smirnoff CTR3(KTR_NET, "%20s: node [%x] (%p) put on worklist", __func__, 33292955ee18SGleb Smirnoff node->nd_ID, node); 33303b33fbe7SGleb Smirnoff } else 33312955ee18SGleb Smirnoff CTR3(KTR_NET, "%20s: node [%x] (%p) already on worklist", 33322955ee18SGleb Smirnoff __func__, node->nd_ID, node); 3333069154d5SJulian Elischer schednetisr(NETISR_NETGRAPH); 3334069154d5SJulian Elischer } 3335069154d5SJulian Elischer 3336069154d5SJulian Elischer 3337069154d5SJulian Elischer /*********************************************************************** 3338069154d5SJulian Elischer * Externally useable functions to set up a queue item ready for sending 3339069154d5SJulian Elischer ***********************************************************************/ 3340069154d5SJulian Elischer 334130400f03SJulian Elischer #ifdef NETGRAPH_DEBUG 334230400f03SJulian Elischer #define ITEM_DEBUG_CHECKS \ 33434cf49a43SJulian Elischer do { \ 33441acb27c6SJulian Elischer if (NGI_NODE(item) ) { \ 3345069154d5SJulian Elischer printf("item already has node"); \ 3346f33ca0c9SMarcel Moolenaar kdb_enter("has node"); \ 33471acb27c6SJulian Elischer NGI_CLR_NODE(item); \ 3348069154d5SJulian Elischer } \ 33491acb27c6SJulian Elischer if (NGI_HOOK(item) ) { \ 3350069154d5SJulian Elischer printf("item already has hook"); \ 3351f33ca0c9SMarcel Moolenaar kdb_enter("has hook"); \ 33521acb27c6SJulian Elischer NGI_CLR_HOOK(item); \ 3353069154d5SJulian Elischer } \ 3354069154d5SJulian Elischer } while (0) 3355069154d5SJulian Elischer #else 335630400f03SJulian Elischer #define ITEM_DEBUG_CHECKS 3357069154d5SJulian Elischer #endif 3358069154d5SJulian Elischer 3359069154d5SJulian Elischer /* 33608ed370fdSJulian Elischer * Put mbuf into the item. 3361069154d5SJulian Elischer * Hook and node references will be removed when the item is dequeued. 3362069154d5SJulian Elischer * (or equivalent) 3363069154d5SJulian Elischer * (XXX) Unsafe because no reference held by peer on remote node. 3364069154d5SJulian Elischer * remote node might go away in this timescale. 3365069154d5SJulian Elischer * We know the hooks can't go away because that would require getting 3366069154d5SJulian Elischer * a writer item on both nodes and we must have at least a reader 33674be59335SGleb Smirnoff * here to be able to do this. 3368069154d5SJulian Elischer * Note that the hook loaded is the REMOTE hook. 3369069154d5SJulian Elischer * 3370069154d5SJulian Elischer * This is possibly in the critical path for new data. 3371069154d5SJulian Elischer */ 3372069154d5SJulian Elischer item_p 337342282202SGleb Smirnoff ng_package_data(struct mbuf *m, int flags) 3374069154d5SJulian Elischer { 3375069154d5SJulian Elischer item_p item; 3376069154d5SJulian Elischer 337742282202SGleb Smirnoff if ((item = ng_getqblk(flags)) == NULL) { 3378069154d5SJulian Elischer NG_FREE_M(m); 3379069154d5SJulian Elischer return (NULL); 3380069154d5SJulian Elischer } 338130400f03SJulian Elischer ITEM_DEBUG_CHECKS; 33826f683eeeSGleb Smirnoff item->el_flags = NGQF_DATA | NGQF_READER; 3383069154d5SJulian Elischer item->el_next = NULL; 3384069154d5SJulian Elischer NGI_M(item) = m; 3385069154d5SJulian Elischer return (item); 3386069154d5SJulian Elischer } 3387069154d5SJulian Elischer 3388069154d5SJulian Elischer /* 3389069154d5SJulian Elischer * Allocate a queue item and put items into it.. 3390069154d5SJulian Elischer * Evaluate the address as this will be needed to queue it and 3391069154d5SJulian Elischer * to work out what some of the fields should be. 3392069154d5SJulian Elischer * Hook and node references will be removed when the item is dequeued. 3393069154d5SJulian Elischer * (or equivalent) 3394069154d5SJulian Elischer */ 3395069154d5SJulian Elischer item_p 339642282202SGleb Smirnoff ng_package_msg(struct ng_mesg *msg, int flags) 3397069154d5SJulian Elischer { 3398069154d5SJulian Elischer item_p item; 3399069154d5SJulian Elischer 340042282202SGleb Smirnoff if ((item = ng_getqblk(flags)) == NULL) { 3401069154d5SJulian Elischer NG_FREE_MSG(msg); 3402069154d5SJulian Elischer return (NULL); 3403069154d5SJulian Elischer } 340430400f03SJulian Elischer ITEM_DEBUG_CHECKS; 34056f683eeeSGleb Smirnoff /* Messages items count as writers unless explicitly exempted. */ 34066f683eeeSGleb Smirnoff if (msg->header.cmd & NGM_READONLY) 34076f683eeeSGleb Smirnoff item->el_flags = NGQF_MESG | NGQF_READER; 34086f683eeeSGleb Smirnoff else 34096f683eeeSGleb Smirnoff item->el_flags = NGQF_MESG | NGQF_WRITER; 3410069154d5SJulian Elischer item->el_next = NULL; 3411069154d5SJulian Elischer /* 3412069154d5SJulian Elischer * Set the current lasthook into the queue item 3413069154d5SJulian Elischer */ 3414069154d5SJulian Elischer NGI_MSG(item) = msg; 3415facfd889SArchie Cobbs NGI_RETADDR(item) = 0; 3416069154d5SJulian Elischer return (item); 3417069154d5SJulian Elischer } 3418069154d5SJulian Elischer 3419069154d5SJulian Elischer 3420069154d5SJulian Elischer 34211acb27c6SJulian Elischer #define SET_RETADDR(item, here, retaddr) \ 34226b795970SJulian Elischer do { /* Data or fn items don't have retaddrs */ \ 34236b795970SJulian Elischer if ((item->el_flags & NGQF_TYPE) == NGQF_MESG) { \ 3424069154d5SJulian Elischer if (retaddr) { \ 3425069154d5SJulian Elischer NGI_RETADDR(item) = retaddr; \ 34264cf49a43SJulian Elischer } else { \ 3427069154d5SJulian Elischer /* \ 3428069154d5SJulian Elischer * The old return address should be ok. \ 3429069154d5SJulian Elischer * If there isn't one, use the address \ 3430069154d5SJulian Elischer * here. \ 3431069154d5SJulian Elischer */ \ 3432069154d5SJulian Elischer if (NGI_RETADDR(item) == 0) { \ 3433069154d5SJulian Elischer NGI_RETADDR(item) \ 3434069154d5SJulian Elischer = ng_node2ID(here); \ 3435069154d5SJulian Elischer } \ 3436069154d5SJulian Elischer } \ 34374cf49a43SJulian Elischer } \ 34384cf49a43SJulian Elischer } while (0) 34394cf49a43SJulian Elischer 34404cf49a43SJulian Elischer int 3441069154d5SJulian Elischer ng_address_hook(node_p here, item_p item, hook_p hook, ng_ID_t retaddr) 34424cf49a43SJulian Elischer { 34431acb27c6SJulian Elischer hook_p peer; 34441acb27c6SJulian Elischer node_p peernode; 344530400f03SJulian Elischer ITEM_DEBUG_CHECKS; 3446069154d5SJulian Elischer /* 3447069154d5SJulian Elischer * Quick sanity check.. 344830400f03SJulian Elischer * Since a hook holds a reference on it's node, once we know 344930400f03SJulian Elischer * that the peer is still connected (even if invalid,) we know 345030400f03SJulian Elischer * that the peer node is present, though maybe invalid. 3451069154d5SJulian Elischer */ 3452069154d5SJulian Elischer if ((hook == NULL) 345330400f03SJulian Elischer || NG_HOOK_NOT_VALID(hook) 345430400f03SJulian Elischer || (NG_HOOK_PEER(hook) == NULL) 345530400f03SJulian Elischer || NG_HOOK_NOT_VALID(NG_HOOK_PEER(hook)) 345630400f03SJulian Elischer || NG_NODE_NOT_VALID(NG_PEER_NODE(hook))) { 3457069154d5SJulian Elischer NG_FREE_ITEM(item); 34586b795970SJulian Elischer TRAP_ERROR(); 3459e08d3e3cSJulian Elischer return (ENETDOWN); 34604cf49a43SJulian Elischer } 34614cf49a43SJulian Elischer 34624cf49a43SJulian Elischer /* 3463069154d5SJulian Elischer * Transfer our interest to the other (peer) end. 34644cf49a43SJulian Elischer */ 34651acb27c6SJulian Elischer peer = NG_HOOK_PEER(hook); 34661acb27c6SJulian Elischer NG_HOOK_REF(peer); 34671acb27c6SJulian Elischer NGI_SET_HOOK(item, peer); 34681acb27c6SJulian Elischer peernode = NG_PEER_NODE(hook); 34691acb27c6SJulian Elischer NG_NODE_REF(peernode); 34701acb27c6SJulian Elischer NGI_SET_NODE(item, peernode); 34718b68f82fSJulian Elischer SET_RETADDR(item, here, retaddr); 3472069154d5SJulian Elischer return (0); 3473069154d5SJulian Elischer } 3474069154d5SJulian Elischer 34754cf49a43SJulian Elischer int 3476069154d5SJulian Elischer ng_address_path(node_p here, item_p item, char *address, ng_ID_t retaddr) 34774cf49a43SJulian Elischer { 34784cf49a43SJulian Elischer node_p dest = NULL; 3479069154d5SJulian Elischer hook_p hook = NULL; 34804cf49a43SJulian Elischer int error; 3481069154d5SJulian Elischer 348230400f03SJulian Elischer ITEM_DEBUG_CHECKS; 3483069154d5SJulian Elischer /* 3484069154d5SJulian Elischer * Note that ng_path2noderef increments the reference count 3485069154d5SJulian Elischer * on the node for us if it finds one. So we don't have to. 3486069154d5SJulian Elischer */ 3487069154d5SJulian Elischer error = ng_path2noderef(here, address, &dest, &hook); 3488069154d5SJulian Elischer if (error) { 3489069154d5SJulian Elischer NG_FREE_ITEM(item); 349030400f03SJulian Elischer return (error); 3491069154d5SJulian Elischer } 34921acb27c6SJulian Elischer NGI_SET_NODE(item, dest); 34931acb27c6SJulian Elischer if ( hook) { 349430400f03SJulian Elischer NG_HOOK_REF(hook); /* don't let it go while on the queue */ 34951acb27c6SJulian Elischer NGI_SET_HOOK(item, hook); 34961acb27c6SJulian Elischer } 34971acb27c6SJulian Elischer SET_RETADDR(item, here, retaddr); 3498069154d5SJulian Elischer return (0); 3499069154d5SJulian Elischer } 3500069154d5SJulian Elischer 3501069154d5SJulian Elischer int 3502069154d5SJulian Elischer ng_address_ID(node_p here, item_p item, ng_ID_t ID, ng_ID_t retaddr) 3503069154d5SJulian Elischer { 3504069154d5SJulian Elischer node_p dest; 3505069154d5SJulian Elischer 350630400f03SJulian Elischer ITEM_DEBUG_CHECKS; 3507069154d5SJulian Elischer /* 3508069154d5SJulian Elischer * Find the target node. 3509069154d5SJulian Elischer */ 3510069154d5SJulian Elischer dest = ng_ID2noderef(ID); /* GETS REFERENCE! */ 3511069154d5SJulian Elischer if (dest == NULL) { 3512069154d5SJulian Elischer NG_FREE_ITEM(item); 35136b795970SJulian Elischer TRAP_ERROR(); 3514069154d5SJulian Elischer return(EINVAL); 3515069154d5SJulian Elischer } 3516069154d5SJulian Elischer /* Fill out the contents */ 35171acb27c6SJulian Elischer NGI_SET_NODE(item, dest); 35181acb27c6SJulian Elischer NGI_CLR_HOOK(item); 35191acb27c6SJulian Elischer SET_RETADDR(item, here, retaddr); 3520069154d5SJulian Elischer return (0); 3521069154d5SJulian Elischer } 3522069154d5SJulian Elischer 3523069154d5SJulian Elischer /* 3524069154d5SJulian Elischer * special case to send a message to self (e.g. destroy node) 3525069154d5SJulian Elischer * Possibly indicate an arrival hook too. 3526069154d5SJulian Elischer * Useful for removing that hook :-) 3527069154d5SJulian Elischer */ 3528069154d5SJulian Elischer item_p 3529069154d5SJulian Elischer ng_package_msg_self(node_p here, hook_p hook, struct ng_mesg *msg) 3530069154d5SJulian Elischer { 3531069154d5SJulian Elischer item_p item; 35324cf49a43SJulian Elischer 3533859a4d16SJulian Elischer /* 3534859a4d16SJulian Elischer * Find the target node. 3535859a4d16SJulian Elischer * If there is a HOOK argument, then use that in preference 3536859a4d16SJulian Elischer * to the address. 3537859a4d16SJulian Elischer */ 353842282202SGleb Smirnoff if ((item = ng_getqblk(NG_NOFLAGS)) == NULL) { 3539069154d5SJulian Elischer NG_FREE_MSG(msg); 3540069154d5SJulian Elischer return (NULL); 35414cf49a43SJulian Elischer } 35424cf49a43SJulian Elischer 35434cf49a43SJulian Elischer /* Fill out the contents */ 35446f683eeeSGleb Smirnoff item->el_flags = NGQF_MESG | NGQF_WRITER; 3545069154d5SJulian Elischer item->el_next = NULL; 354630400f03SJulian Elischer NG_NODE_REF(here); 35471acb27c6SJulian Elischer NGI_SET_NODE(item, here); 35481acb27c6SJulian Elischer if (hook) { 354930400f03SJulian Elischer NG_HOOK_REF(hook); 35501acb27c6SJulian Elischer NGI_SET_HOOK(item, hook); 35511acb27c6SJulian Elischer } 3552069154d5SJulian Elischer NGI_MSG(item) = msg; 3553069154d5SJulian Elischer NGI_RETADDR(item) = ng_node2ID(here); 3554069154d5SJulian Elischer return (item); 35554cf49a43SJulian Elischer } 35564cf49a43SJulian Elischer 355742282202SGleb Smirnoff int 3558aacdb114SGleb Smirnoff ng_send_fn1(node_p node, hook_p hook, ng_item_fn *fn, void * arg1, int arg2, 355942282202SGleb Smirnoff int flags) 35606b795970SJulian Elischer { 35616b795970SJulian Elischer item_p item; 35626b795970SJulian Elischer 356342282202SGleb Smirnoff if ((item = ng_getqblk(flags)) == NULL) { 35646b795970SJulian Elischer return (ENOMEM); 35656b795970SJulian Elischer } 35666b795970SJulian Elischer item->el_flags = NGQF_FN | NGQF_WRITER; 3567a96dcd84SJulian Elischer NG_NODE_REF(node); /* and one for the item */ 35681acb27c6SJulian Elischer NGI_SET_NODE(item, node); 35691acb27c6SJulian Elischer if (hook) { 35706b795970SJulian Elischer NG_HOOK_REF(hook); 35711acb27c6SJulian Elischer NGI_SET_HOOK(item, hook); 35726b795970SJulian Elischer } 35736b795970SJulian Elischer NGI_FN(item) = fn; 35746b795970SJulian Elischer NGI_ARG1(item) = arg1; 35756b795970SJulian Elischer NGI_ARG2(item) = arg2; 357642282202SGleb Smirnoff return(ng_snd_item(item, flags)); 35776b795970SJulian Elischer } 35786b795970SJulian Elischer 35794cf49a43SJulian Elischer /* 3580d2ca21a9SJulian Elischer * Official timeout routines for Netgraph nodes. 3581d2ca21a9SJulian Elischer */ 3582d2ca21a9SJulian Elischer static void 35831fbb36ffSGleb Smirnoff ng_callout_trampoline(void *arg) 3584d2ca21a9SJulian Elischer { 3585d2ca21a9SJulian Elischer item_p item = arg; 3586d2ca21a9SJulian Elischer 3587d2ca21a9SJulian Elischer ng_snd_item(item, 0); 3588d2ca21a9SJulian Elischer } 3589d2ca21a9SJulian Elischer 3590d2ca21a9SJulian Elischer 359130bef41bSGleb Smirnoff int 3592f9d9e1b4SGleb Smirnoff ng_callout(struct callout *c, node_p node, hook_p hook, int ticks, 3593d2ca21a9SJulian Elischer ng_item_fn *fn, void * arg1, int arg2) 3594d2ca21a9SJulian Elischer { 35951bf8e0faSGleb Smirnoff item_p item, oitem; 3596d2ca21a9SJulian Elischer 359742282202SGleb Smirnoff if ((item = ng_getqblk(NG_NOFLAGS)) == NULL) 359830bef41bSGleb Smirnoff return (ENOMEM); 359930bef41bSGleb Smirnoff 3600d2ca21a9SJulian Elischer item->el_flags = NGQF_FN | NGQF_WRITER; 3601d2ca21a9SJulian Elischer NG_NODE_REF(node); /* and one for the item */ 3602d2ca21a9SJulian Elischer NGI_SET_NODE(item, node); 3603d2ca21a9SJulian Elischer if (hook) { 3604d2ca21a9SJulian Elischer NG_HOOK_REF(hook); 3605d2ca21a9SJulian Elischer NGI_SET_HOOK(item, hook); 3606d2ca21a9SJulian Elischer } 3607d2ca21a9SJulian Elischer NGI_FN(item) = fn; 3608d2ca21a9SJulian Elischer NGI_ARG1(item) = arg1; 3609d2ca21a9SJulian Elischer NGI_ARG2(item) = arg2; 36101bf8e0faSGleb Smirnoff oitem = c->c_arg; 36111bf8e0faSGleb Smirnoff if (callout_reset(c, ticks, &ng_callout_trampoline, item) == 1 && 36121bf8e0faSGleb Smirnoff oitem != NULL) 36131bf8e0faSGleb Smirnoff NG_FREE_ITEM(oitem); 361430bef41bSGleb Smirnoff return (0); 3615d2ca21a9SJulian Elischer } 3616d2ca21a9SJulian Elischer 3617d2ca21a9SJulian Elischer /* A special modified version of untimeout() */ 3618d2ca21a9SJulian Elischer int 3619f9d9e1b4SGleb Smirnoff ng_uncallout(struct callout *c, node_p node) 3620d2ca21a9SJulian Elischer { 3621d2ca21a9SJulian Elischer item_p item; 362230bef41bSGleb Smirnoff int rval; 3623d2ca21a9SJulian Elischer 362403b25f5dSGleb Smirnoff KASSERT(c != NULL, ("ng_uncallout: NULL callout")); 362503b25f5dSGleb Smirnoff KASSERT(node != NULL, ("ng_uncallout: NULL node")); 362603b25f5dSGleb Smirnoff 36273eadb26dSGleb Smirnoff rval = callout_stop(c); 362830bef41bSGleb Smirnoff item = c->c_arg; 362930bef41bSGleb Smirnoff /* Do an extra check */ 36301fbb36ffSGleb Smirnoff if ((rval > 0) && (c->c_func == &ng_callout_trampoline) && 363130bef41bSGleb Smirnoff (NGI_NODE(item) == node)) { 3632d2ca21a9SJulian Elischer /* 3633d2ca21a9SJulian Elischer * We successfully removed it from the queue before it ran 3634d2ca21a9SJulian Elischer * So now we need to unreference everything that was 3635d2ca21a9SJulian Elischer * given extra references. (NG_FREE_ITEM does this). 3636d2ca21a9SJulian Elischer */ 3637d2ca21a9SJulian Elischer NG_FREE_ITEM(item); 3638d2ca21a9SJulian Elischer } 36391bf8e0faSGleb Smirnoff c->c_arg = NULL; 364030bef41bSGleb Smirnoff 364130bef41bSGleb Smirnoff return (rval); 3642d2ca21a9SJulian Elischer } 3643d2ca21a9SJulian Elischer 3644d2ca21a9SJulian Elischer /* 3645069154d5SJulian Elischer * Set the address, if none given, give the node here. 36464cf49a43SJulian Elischer */ 3647069154d5SJulian Elischer void 3648069154d5SJulian Elischer ng_replace_retaddr(node_p here, item_p item, ng_ID_t retaddr) 36494cf49a43SJulian Elischer { 3650069154d5SJulian Elischer if (retaddr) { 3651069154d5SJulian Elischer NGI_RETADDR(item) = retaddr; 3652069154d5SJulian Elischer } else { 3653069154d5SJulian Elischer /* 3654069154d5SJulian Elischer * The old return address should be ok. 3655069154d5SJulian Elischer * If there isn't one, use the address here. 3656069154d5SJulian Elischer */ 3657069154d5SJulian Elischer NGI_RETADDR(item) = ng_node2ID(here); 3658069154d5SJulian Elischer } 3659069154d5SJulian Elischer } 3660069154d5SJulian Elischer 3661069154d5SJulian Elischer #define TESTING 3662069154d5SJulian Elischer #ifdef TESTING 3663069154d5SJulian Elischer /* just test all the macros */ 3664069154d5SJulian Elischer void 3665069154d5SJulian Elischer ng_macro_test(item_p item); 3666069154d5SJulian Elischer void 3667069154d5SJulian Elischer ng_macro_test(item_p item) 3668069154d5SJulian Elischer { 3669069154d5SJulian Elischer node_p node = NULL; 3670069154d5SJulian Elischer hook_p hook = NULL; 36714cf49a43SJulian Elischer struct mbuf *m; 36724cf49a43SJulian Elischer struct ng_mesg *msg; 3673069154d5SJulian Elischer ng_ID_t retaddr; 3674069154d5SJulian Elischer int error; 36754cf49a43SJulian Elischer 3676069154d5SJulian Elischer NGI_GET_M(item, m); 3677069154d5SJulian Elischer NGI_GET_MSG(item, msg); 3678069154d5SJulian Elischer retaddr = NGI_RETADDR(item); 36798ed370fdSJulian Elischer NG_SEND_DATA(error, hook, m, NULL); 3680069154d5SJulian Elischer NG_SEND_DATA_ONLY(error, hook, m); 3681069154d5SJulian Elischer NG_FWD_NEW_DATA(error, item, hook, m); 368230400f03SJulian Elischer NG_FWD_ITEM_HOOK(error, item, hook); 3683069154d5SJulian Elischer NG_SEND_MSG_HOOK(error, node, msg, hook, retaddr); 3684069154d5SJulian Elischer NG_SEND_MSG_ID(error, node, msg, retaddr, retaddr); 3685069154d5SJulian Elischer NG_SEND_MSG_PATH(error, node, msg, ".:", retaddr); 3686069154d5SJulian Elischer NG_FWD_MSG_HOOK(error, node, item, hook, retaddr); 36874cf49a43SJulian Elischer } 3688069154d5SJulian Elischer #endif /* TESTING */ 36894cf49a43SJulian Elischer 3690