xref: /illumos-gate/usr/src/uts/common/io/hook.c (revision b22a70ab)
1381a2a9aSdr /*
2381a2a9aSdr  * CDDL HEADER START
3381a2a9aSdr  *
4381a2a9aSdr  * The contents of this file are subject to the terms of the
5381a2a9aSdr  * Common Development and Distribution License (the "License").
6381a2a9aSdr  * You may not use this file except in compliance with the License.
7381a2a9aSdr  *
8381a2a9aSdr  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9381a2a9aSdr  * or http://www.opensolaris.org/os/licensing.
10381a2a9aSdr  * See the License for the specific language governing permissions
11381a2a9aSdr  * and limitations under the License.
12381a2a9aSdr  *
13381a2a9aSdr  * When distributing Covered Code, include this CDDL HEADER in each
14381a2a9aSdr  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15381a2a9aSdr  * If applicable, add the following below this CDDL HEADER, with the
16381a2a9aSdr  * fields enclosed by brackets "[]" replaced with your own identifying
17381a2a9aSdr  * information: Portions Copyright [yyyy] [name of copyright owner]
18381a2a9aSdr  *
19381a2a9aSdr  * CDDL HEADER END
20381a2a9aSdr  */
21381a2a9aSdr /*
227ddc9b1aSDarren Reed  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
23381a2a9aSdr  * Use is subject to license terms.
24652fb50dSRob Gulewich  *
2568c34d04SJason King  * Copyright 2018 Joyent, Inc.  All rights reserved.
2648bbca81SDaniel Hoffman  * Copyright (c) 2016 by Delphix. All rights reserved.
27381a2a9aSdr  */
28381a2a9aSdr #include <sys/param.h>
29381a2a9aSdr #include <sys/types.h>
30381a2a9aSdr #include <sys/systm.h>
31381a2a9aSdr #include <sys/errno.h>
32381a2a9aSdr #include <sys/kmem.h>
33381a2a9aSdr #include <sys/mutex.h>
34381a2a9aSdr #include <sys/condvar.h>
35381a2a9aSdr #include <sys/modctl.h>
36381a2a9aSdr #include <sys/hook_impl.h>
37381a2a9aSdr #include <sys/sdt.h>
387ddc9b1aSDarren Reed #include <sys/cmn_err.h>
39381a2a9aSdr 
40381a2a9aSdr /*
41381a2a9aSdr  * This file provides kernel hook framework.
42381a2a9aSdr  */
43381a2a9aSdr 
44381a2a9aSdr static struct modldrv modlmisc = {
45381a2a9aSdr 	&mod_miscops,				/* drv_modops */
46381a2a9aSdr 	"Hooks Interface v1.0",			/* drv_linkinfo */
47381a2a9aSdr };
48381a2a9aSdr 
49381a2a9aSdr static struct modlinkage modlinkage = {
50381a2a9aSdr 	MODREV_1,				/* ml_rev */
51381a2a9aSdr 	&modlmisc,				/* ml_linkage */
52381a2a9aSdr 	NULL
53381a2a9aSdr };
54381a2a9aSdr 
55652fb50dSRob Gulewich static const char *hook_hintvalue_none = "<none>";
56652fb50dSRob Gulewich 
577ddc9b1aSDarren Reed /*
587ddc9b1aSDarren Reed  * How it works.
597ddc9b1aSDarren Reed  * =============
607ddc9b1aSDarren Reed  * Use of the hook framework here is tied up with zones - when a new zone
617ddc9b1aSDarren Reed  * is created, we create a new hook_stack_t and are open to business for
627ddc9b1aSDarren Reed  * allowing new hook families and their events.
637ddc9b1aSDarren Reed  *
647ddc9b1aSDarren Reed  * A consumer of these hooks is expected to operate in this fashion:
657ddc9b1aSDarren Reed  * 1) call hook_family_add() to create a new family of hooks. It is a
667ddc9b1aSDarren Reed  *    current requirement that this call must be made with the value
677ddc9b1aSDarren Reed  *    returned from hook_stack_init, by way of infrastructure elsewhere.
687ddc9b1aSDarren Reed  * 2) add events to the registered family with calls to hook_event_add.
697ddc9b1aSDarren Reed  *
707ddc9b1aSDarren Reed  * At this point, the structures in place should be open to others to
717ddc9b1aSDarren Reed  * add hooks to the event or add notifiers for when the contents of the
727ddc9b1aSDarren Reed  * hook stack changes.
737ddc9b1aSDarren Reed  *
747ddc9b1aSDarren Reed  * The interesting stuff happens on teardown.
757ddc9b1aSDarren Reed  *
767ddc9b1aSDarren Reed  * It is a requirement that the provider of hook events work in the reverse
777ddc9b1aSDarren Reed  * order to the above, so that the first step is:
787ddc9b1aSDarren Reed  * 1) remove events from each hook family created earlier
797ddc9b1aSDarren Reed  * 2) remove hook families from the hook stack.
807ddc9b1aSDarren Reed  *
817ddc9b1aSDarren Reed  * When doing teardown of both events and families, a check is made to see
824a9b8375SDarren Reed  * if either structure is still "busy". If so then a boolean flag (FWF_DESTROY)
834a9b8375SDarren Reed  * is set to say that the structure is condemned. The presence of this flag
844a9b8375SDarren Reed  * being set must be checked for in _add()/_register()/ functions and a
854a9b8375SDarren Reed  * failure returned if it is set. It is ignored by the _find() functions
864a9b8375SDarren Reed  * because they're used by _remove()/_unregister().
874a9b8375SDarren Reed  * While setting the condemned flag when trying to delete a structure would
884a9b8375SDarren Reed  * normally be keyed from the presence of a reference count being greater
894a9b8375SDarren Reed  * than 1, in this implementation there are no reference counts required:
904a9b8375SDarren Reed  * instead the presence of objects on linked lists is taken to mean
914a9b8375SDarren Reed  * something is still "busy."
927ddc9b1aSDarren Reed  *
937ddc9b1aSDarren Reed  * ONLY the caller that adds the family and the events ever has a direct
947ddc9b1aSDarren Reed  * reference to the internal structures and thus ONLY it should be doing
957ddc9b1aSDarren Reed  * the removal of either the event or family.  In practise, what this means
967ddc9b1aSDarren Reed  * is that in ip_netinfo.c, we have calls to net_protocol_register(), followed
977ddc9b1aSDarren Reed  * by net_event_register() (these interface to hook_family_add() and
987ddc9b1aSDarren Reed  * hook_event_add(), respectively) that are made when we create an instance
997ddc9b1aSDarren Reed  * of IP and when the IP instance is shutdown/destroyed, it calls
1007ddc9b1aSDarren Reed  * net_event_unregister() and net_protocol_unregister(), which in turn call
1017ddc9b1aSDarren Reed  * hook_event_remove() and hook_family_remove() respectively. Nobody else
1027ddc9b1aSDarren Reed  * is entitled to call the _unregister() functions.  It is imperative that
1037ddc9b1aSDarren Reed  * there be only one _remove() call for every _add() call.
1047ddc9b1aSDarren Reed  *
1057ddc9b1aSDarren Reed  * It is possible that code which is interfacing with this hook framework
1067ddc9b1aSDarren Reed  * won't do all the cleaning up that it needs to at the right time. While
1077ddc9b1aSDarren Reed  * we can't prevent programmers from creating memory leaks, we can synchronise
1087ddc9b1aSDarren Reed  * when we clean up data structures to prevent code accessing free'd memory.
1097ddc9b1aSDarren Reed  *
1107ddc9b1aSDarren Reed  * A simple diagram showing the ownership is as follows:
1117ddc9b1aSDarren Reed  *
1127ddc9b1aSDarren Reed  *  Owned       +--------------+
1137ddc9b1aSDarren Reed  *   by         | hook_stack_t |
1147ddc9b1aSDarren Reed  *   the        +--------------+
1157ddc9b1aSDarren Reed  *  Instance      |
1167ddc9b1aSDarren Reed  * - - - - - - - -|- - - - - - - - - - - - - - - - - -
1177ddc9b1aSDarren Reed  *                V
1187ddc9b1aSDarren Reed  *  Owned       +-------------------+     +-------------------+
1197ddc9b1aSDarren Reed  *              | hook_family_int_t |---->| hook_family_int_t |
1207ddc9b1aSDarren Reed  *   by         +-------------------+     +-------------------+
1217ddc9b1aSDarren Reed  *                | \+---------------+        \+---------------+
1227ddc9b1aSDarren Reed  *  network       |  | hook_family_t |         | hook_family_t |
1237ddc9b1aSDarren Reed  *                V  +---------------+         +---------------+
1247ddc9b1aSDarren Reed  *  protocol   +------------------+     +------------------+
1257ddc9b1aSDarren Reed  *             | hook_event_int_t |---->| hook_event_int_t |
1267ddc9b1aSDarren Reed  * (ipv4,ipv6) +------------------+     +------------------+
1277ddc9b1aSDarren Reed  *                | \+--------------+        \+--------------+
1287ddc9b1aSDarren Reed  *                |  | hook_event_t |         | hook_event_t |
1297ddc9b1aSDarren Reed  *                |  +--------------+         +--------------+
1307ddc9b1aSDarren Reed  * - - - - - - - -|- - - - - - - - - - - - - - - - - -
1317ddc9b1aSDarren Reed  *                V
1327ddc9b1aSDarren Reed  *  Owned      +------------+
1337ddc9b1aSDarren Reed  *             | hook_int_t |
1347ddc9b1aSDarren Reed  *   by        +------------+
1357ddc9b1aSDarren Reed  *                  \+--------+
1367ddc9b1aSDarren Reed  * the consumer      | hook_t |
1377ddc9b1aSDarren Reed  *                   +--------+
1387ddc9b1aSDarren Reed  *
1397ddc9b1aSDarren Reed  * The consumers, such as IPFilter, do not have any pointers or hold any
1407ddc9b1aSDarren Reed  * references to hook_int_t, hook_event_t or hook_event_int_t. By placing
1417ddc9b1aSDarren Reed  * a hook on an event through net_hook_register(), an implicit reference
1427ddc9b1aSDarren Reed  * to the hook_event_int_t is returned with a successful call.  Additionally,
1437ddc9b1aSDarren Reed  * IPFilter does not see the hook_family_int_t or hook_family_t directly.
1447ddc9b1aSDarren Reed  * Rather it is returned a net_handle_t (from net_protocol_lookup()) that
1457ddc9b1aSDarren Reed  * contains a pointer to hook_family_int_t.  The structure behind the
1467ddc9b1aSDarren Reed  * net_handle_t (struct net_data) *is* reference counted and managed
1477ddc9b1aSDarren Reed  * appropriately.
1487ddc9b1aSDarren Reed  *
1497ddc9b1aSDarren Reed  * A more detailed picture that describes how the family/event structures
1507ddc9b1aSDarren Reed  * are linked together can be found in <sys/hook_impl.h>
1514a9b8375SDarren Reed  *
1524a9b8375SDarren Reed  * Notification callbacks.
1534a9b8375SDarren Reed  * =======================
1544a9b8375SDarren Reed  * For each of the hook stack, hook family and hook event, it is possible
1554a9b8375SDarren Reed  * to request notificatin of change to them. Why?
1564a9b8375SDarren Reed  * First, lets equate the hook stack to an IP instance, a hook family to
1574a9b8375SDarren Reed  * a network protocol and a hook event to IP packets on the input path.
1584a9b8375SDarren Reed  * If a kernel module wants to apply security from the very start of
1594a9b8375SDarren Reed  * things, it needs to know as soon as a new instance of networking
1604a9b8375SDarren Reed  * is initiated. Whilst for the global zone, it is taken for granted that
1614a9b8375SDarren Reed  * this instance will always exist before any interaction takes place,
1624a9b8375SDarren Reed  * that is not true for zones running with an exclusive networking instance.
1634a9b8375SDarren Reed  * Thus when a local zone is started and a new instance is created to support
1644a9b8375SDarren Reed  * that, parties that wish to monitor it and apply a security policy from
1654a9b8375SDarren Reed  * the onset need to be informed as early as possible - quite probably
1664a9b8375SDarren Reed  * before any networking is started by the zone's boot scripts.
1674a9b8375SDarren Reed  * Inside each instance, it is possible to have a number of network protocols
1684a9b8375SDarren Reed  * (hook families) in operation. Inside the context of the global zone,
1694a9b8375SDarren Reed  * it is possible to have code run before the kernel module providing the
1704a9b8375SDarren Reed  * IP networking is loaded. From here, to apply the appropriate security,
1714a9b8375SDarren Reed  * it is necessary to become informed of when IP is being configured into
1724a9b8375SDarren Reed  * the zone and this is done by registering a notification callback with
1734a9b8375SDarren Reed  * the hook stack for changes to it. The next step is to know when packets
1744a9b8375SDarren Reed  * can be received through the physical_in, etc, events. This is achieved
1754a9b8375SDarren Reed  * by registering a callback with the appropriate network protocol (or in
1764a9b8375SDarren Reed  * this file, the correct hook family.) Thus when IP finally attaches a
1774a9b8375SDarren Reed  * physical_in event to inet, the module looking to enforce a security
1784a9b8375SDarren Reed  * policy can become aware of it being present. Of course there's no
1794a9b8375SDarren Reed  * requirement for such a module to be present before all of the above
1804a9b8375SDarren Reed  * happens and in such a case, it is reasonable for the same module to
1814a9b8375SDarren Reed  * work after everything has been put in place. For this reason, when
1824a9b8375SDarren Reed  * a notification callback is added, a series of fake callback events
1834a9b8375SDarren Reed  * is generated to simulate the arrival of those entities. There is one
1844a9b8375SDarren Reed  * final series of callbacks that can be registered - those to monitor
1854a9b8375SDarren Reed  * actual hooks that are added or removed from an event. In practice,
1864a9b8375SDarren Reed  * this is useful when there are multiple kernel modules participating
1874a9b8375SDarren Reed  * in the processing of packets and there are behaviour dependencies
1884a9b8375SDarren Reed  * involved, such that one kernel module might only register its hook
1894a9b8375SDarren Reed  * if another is already present and also might want to remove its hook
1904a9b8375SDarren Reed  * when the other disappears.
1914a9b8375SDarren Reed  *
1924a9b8375SDarren Reed  * If you know a kernel module will not be loaded before the infrastructure
1934a9b8375SDarren Reed  * used in this file is present then it is not necessary to use this
1944a9b8375SDarren Reed  * notification callback mechanism.
1957ddc9b1aSDarren Reed  */
1967ddc9b1aSDarren Reed 
1977ddc9b1aSDarren Reed /*
1987ddc9b1aSDarren Reed  * Locking
1997ddc9b1aSDarren Reed  * =======
2007ddc9b1aSDarren Reed  * The use of CVW_* macros to do locking is driven by the need to allow
2017ddc9b1aSDarren Reed  * recursive locking with read locks when we're processing packets. This
2027ddc9b1aSDarren Reed  * is necessary because various netinfo functions need to hold read locks,
2037ddc9b1aSDarren Reed  * by design, as they can be called in or out of packet context.
2047ddc9b1aSDarren Reed  */
205381a2a9aSdr /*
206381a2a9aSdr  * Hook internal functions
207381a2a9aSdr  */
208381a2a9aSdr static hook_int_t *hook_copy(hook_t *src);
209f4b3ec61Sdh static hook_event_int_t *hook_event_checkdup(hook_event_t *he,
210f4b3ec61Sdh     hook_stack_t *hks);
211381a2a9aSdr static hook_event_int_t *hook_event_copy(hook_event_t *src);
212381a2a9aSdr static hook_event_int_t *hook_event_find(hook_family_int_t *hfi, char *event);
2137ddc9b1aSDarren Reed static void hook_event_free(hook_event_int_t *hei, hook_family_int_t *hfi);
214381a2a9aSdr static hook_family_int_t *hook_family_copy(hook_family_t *src);
215f4b3ec61Sdh static hook_family_int_t *hook_family_find(char *family, hook_stack_t *hks);
2167ddc9b1aSDarren Reed static void hook_family_free(hook_family_int_t *hfi, hook_stack_t *hks);
217381a2a9aSdr static hook_int_t *hook_find(hook_event_int_t *hei, hook_t *h);
2187ddc9b1aSDarren Reed static void hook_int_free(hook_int_t *hi, netstackid_t);
219381a2a9aSdr static void hook_init(void);
220f4b3ec61Sdh static void hook_fini(void);
221f4b3ec61Sdh static void *hook_stack_init(netstackid_t stackid, netstack_t *ns);
222f4b3ec61Sdh static void hook_stack_fini(netstackid_t stackid, void *arg);
2237ddc9b1aSDarren Reed static void hook_stack_shutdown(netstackid_t stackid, void *arg);
2247ddc9b1aSDarren Reed static int hook_insert(hook_int_head_t *head, hook_int_t *new);
2257ddc9b1aSDarren Reed static void hook_insert_plain(hook_int_head_t *head, hook_int_t *new);
2267ddc9b1aSDarren Reed static int hook_insert_afterbefore(hook_int_head_t *head, hook_int_t *new);
2277ddc9b1aSDarren Reed static hook_int_t *hook_find_byname(hook_int_head_t *head, char *name);
2287ddc9b1aSDarren Reed static void hook_event_init_kstats(hook_family_int_t *, hook_event_int_t *);
2297ddc9b1aSDarren Reed static void hook_event_notify_run(hook_event_int_t *, hook_family_int_t *,
2307ddc9b1aSDarren Reed     char *event, char *name, hook_notify_cmd_t cmd);
2317ddc9b1aSDarren Reed static void hook_init_kstats(hook_family_int_t *hfi, hook_event_int_t *hei,
2327ddc9b1aSDarren Reed     hook_int_t *hi);
2334a9b8375SDarren Reed static int hook_notify_register(hook_notify_head_t *head,
2347ddc9b1aSDarren Reed     hook_notify_fn_t callback, void *arg);
2354a9b8375SDarren Reed static int hook_notify_unregister(hook_notify_head_t *head,
2364a9b8375SDarren Reed     hook_notify_fn_t callback, void **);
2377ddc9b1aSDarren Reed static void hook_notify_run(hook_notify_head_t *head, char *family,
2387ddc9b1aSDarren Reed     char *event, char *name, hook_notify_cmd_t cmd);
2397ddc9b1aSDarren Reed static void hook_stack_notify_run(hook_stack_t *hks, char *name,
2407ddc9b1aSDarren Reed     hook_notify_cmd_t cmd);
2417ddc9b1aSDarren Reed static void hook_stack_remove(hook_stack_t *hks);
2427ddc9b1aSDarren Reed 
2437ddc9b1aSDarren Reed /*
2447ddc9b1aSDarren Reed  * A list of the hook stacks is kept here because we need to enable
2457ddc9b1aSDarren Reed  * net_instance_notify_register() to be called during the creation
2467ddc9b1aSDarren Reed  * of a new instance. Previously hook_stack_get() would just use
2477ddc9b1aSDarren Reed  * the netstack functions for this work but they will return NULL
2487ddc9b1aSDarren Reed  * until the zone has been fully initialised.
2497ddc9b1aSDarren Reed  */
2507ddc9b1aSDarren Reed static hook_stack_head_t hook_stacks;
2517ddc9b1aSDarren Reed static kmutex_t hook_stack_lock;
252381a2a9aSdr 
253381a2a9aSdr /*
254381a2a9aSdr  * Module entry points.
255381a2a9aSdr  */
256381a2a9aSdr int
_init(void)257381a2a9aSdr _init(void)
258381a2a9aSdr {
259f4b3ec61Sdh 	int error;
260f4b3ec61Sdh 
261381a2a9aSdr 	hook_init();
262f4b3ec61Sdh 	error = mod_install(&modlinkage);
263f4b3ec61Sdh 	if (error != 0)
264f4b3ec61Sdh 		hook_fini();
265f4b3ec61Sdh 
266f4b3ec61Sdh 	return (error);
267381a2a9aSdr }
268381a2a9aSdr 
269381a2a9aSdr int
_fini(void)270381a2a9aSdr _fini(void)
271381a2a9aSdr {
272f4b3ec61Sdh 	int error;
273f4b3ec61Sdh 
274f4b3ec61Sdh 	error = mod_remove(&modlinkage);
275f4b3ec61Sdh 	if (error == 0)
276f4b3ec61Sdh 		hook_fini();
277f4b3ec61Sdh 
278f4b3ec61Sdh 	return (error);
279381a2a9aSdr }
280381a2a9aSdr 
281381a2a9aSdr int
_info(struct modinfo * modinfop)282381a2a9aSdr _info(struct modinfo *modinfop)
283381a2a9aSdr {
284381a2a9aSdr 	return (mod_info(&modlinkage, modinfop));
285381a2a9aSdr }
286381a2a9aSdr 
287381a2a9aSdr /*
288381a2a9aSdr  * Function:	hook_init
289381a2a9aSdr  * Returns:	None
290381a2a9aSdr  * Parameters:	None
291381a2a9aSdr  *
292381a2a9aSdr  * Initialize hooks
293381a2a9aSdr  */
294381a2a9aSdr static void
hook_init(void)295381a2a9aSdr hook_init(void)
296381a2a9aSdr {
2977ddc9b1aSDarren Reed 	mutex_init(&hook_stack_lock, NULL, MUTEX_DRIVER, NULL);
2987ddc9b1aSDarren Reed 	SLIST_INIT(&hook_stacks);
2997ddc9b1aSDarren Reed 
300f4b3ec61Sdh 	/*
301f4b3ec61Sdh 	 * We want to be informed each time a stack is created or
302f4b3ec61Sdh 	 * destroyed in the kernel.
303f4b3ec61Sdh 	 */
3047ddc9b1aSDarren Reed 	netstack_register(NS_HOOK, hook_stack_init, hook_stack_shutdown,
305f4b3ec61Sdh 	    hook_stack_fini);
306f4b3ec61Sdh }
307f4b3ec61Sdh 
308f4b3ec61Sdh /*
309f4b3ec61Sdh  * Function:	hook_fini
310f4b3ec61Sdh  * Returns:	None
311f4b3ec61Sdh  * Parameters:	None
312f4b3ec61Sdh  *
313f4b3ec61Sdh  * Deinitialize hooks
314f4b3ec61Sdh  */
315f4b3ec61Sdh static void
hook_fini(void)316f4b3ec61Sdh hook_fini(void)
317f4b3ec61Sdh {
318f4b3ec61Sdh 	netstack_unregister(NS_HOOK);
3197ddc9b1aSDarren Reed 
3207ddc9b1aSDarren Reed 	mutex_destroy(&hook_stack_lock);
3217ddc9b1aSDarren Reed 	ASSERT(SLIST_EMPTY(&hook_stacks));
3227ddc9b1aSDarren Reed }
3237ddc9b1aSDarren Reed 
3247ddc9b1aSDarren Reed /*
3257ddc9b1aSDarren Reed  * Function:	hook_wait_setflag
3267ddc9b1aSDarren Reed  * Returns:     -1 = setting flag is disallowed, 0 = flag set and did
3277ddc9b1aSDarren Reed  *              not have to wait (ie no lock droped), 1 = flag set but
3287ddc9b1aSDarren Reed  *              it was necessary to drop locks to set it.
3297ddc9b1aSDarren Reed  * Parameters:  waiter(I)  - control data structure
3307ddc9b1aSDarren Reed  *              busyset(I) - set of flags that we don't want set while
3317ddc9b1aSDarren Reed  *                           we are active.
3327ddc9b1aSDarren Reed  *              wanted(I)  - flag associated with newflag to indicate
3337ddc9b1aSDarren Reed  *                           what we want to do.
3347ddc9b1aSDarren Reed  *              newflag(I) - the new ACTIVE flag we want to set that
3357ddc9b1aSDarren Reed  *                           indicates what we are doing.
3367ddc9b1aSDarren Reed  *
3377ddc9b1aSDarren Reed  * The set of functions hook_wait_* implement an API that builds on top of
3387ddc9b1aSDarren Reed  * the kcondvar_t to provide controlled execution through a critical region.
3397ddc9b1aSDarren Reed  * For each flag that indicates work is being done (FWF_*_ACTIVE) there is
3407ddc9b1aSDarren Reed  * also a flag that we set to indicate that we want to do it (FWF_*_WANTED).
3417ddc9b1aSDarren Reed  * The combination of flags is required as when this function exits to do
3427ddc9b1aSDarren Reed  * the task, the structure is then free for another caller to use and
3434a9b8375SDarren Reed  * to indicate that it wants to do work.  The flags used when a caller wants
3444a9b8375SDarren Reed  * to destroy an object take precedence over those that are used for making
3454a9b8375SDarren Reed  * changes to it (add/remove.) In this case, we don't try to secure the
3464a9b8375SDarren Reed  * ability to run and return with an error.
3474a9b8375SDarren Reed  *
3484a9b8375SDarren Reed  * "wantedset" is used here to determine who has the right to clear the
34948bbca81SDaniel Hoffman  * wanted bit from the fw_flags set: only whomever sets the flag has the
3504a9b8375SDarren Reed  * right to clear it at the bottom of the loop, even if someone else
3514a9b8375SDarren Reed  * wants to set it.
3527ddc9b1aSDarren Reed  *
3537ddc9b1aSDarren Reed  * wanted - the FWF_*_WANTED flag that describes the action being requested
3547ddc9b1aSDarren Reed  * busyset- the set of FWF_* flags we don't want set when we run
3557ddc9b1aSDarren Reed  * newflag- the FWF_*_ACTIVE flag we will set to indicate we are busy
3567ddc9b1aSDarren Reed  */
3577ddc9b1aSDarren Reed int
hook_wait_setflag(flagwait_t * waiter,uint32_t busyset,fwflag_t wanted,fwflag_t newflag)3587ddc9b1aSDarren Reed hook_wait_setflag(flagwait_t *waiter, uint32_t busyset, fwflag_t wanted,
3597ddc9b1aSDarren Reed     fwflag_t newflag)
3607ddc9b1aSDarren Reed {
3614a9b8375SDarren Reed 	boolean_t wantedset;
3627ddc9b1aSDarren Reed 	int waited = 0;
3637ddc9b1aSDarren Reed 
3647ddc9b1aSDarren Reed 	mutex_enter(&waiter->fw_lock);
3657ddc9b1aSDarren Reed 	if (waiter->fw_flags & FWF_DESTROY) {
3664a9b8375SDarren Reed 		cv_signal(&waiter->fw_cv);
3677ddc9b1aSDarren Reed 		mutex_exit(&waiter->fw_lock);
3687ddc9b1aSDarren Reed 		return (-1);
3697ddc9b1aSDarren Reed 	}
3707ddc9b1aSDarren Reed 	while (waiter->fw_flags & busyset) {
3714a9b8375SDarren Reed 		wantedset = ((waiter->fw_flags & wanted) == wanted);
3724a9b8375SDarren Reed 		if (!wantedset)
3734a9b8375SDarren Reed 			waiter->fw_flags |= wanted;
3747ddc9b1aSDarren Reed 		CVW_EXIT_WRITE(waiter->fw_owner);
3757ddc9b1aSDarren Reed 		cv_wait(&waiter->fw_cv, &waiter->fw_lock);
3764a9b8375SDarren Reed 		/*
3774a9b8375SDarren Reed 		 * This lock needs to be dropped here to preserve the order
3784a9b8375SDarren Reed 		 * of acquisition that is fw_owner followed by fw_lock, else
3794a9b8375SDarren Reed 		 * we can deadlock.
3804a9b8375SDarren Reed 		 */
3814a9b8375SDarren Reed 		mutex_exit(&waiter->fw_lock);
3827ddc9b1aSDarren Reed 		waited = 1;
3837ddc9b1aSDarren Reed 		CVW_ENTER_WRITE(waiter->fw_owner);
3844a9b8375SDarren Reed 		mutex_enter(&waiter->fw_lock);
3854a9b8375SDarren Reed 		if (!wantedset)
3867ddc9b1aSDarren Reed 			waiter->fw_flags &= ~wanted;
3874a9b8375SDarren Reed 		if (waiter->fw_flags & FWF_DESTROY) {
3884a9b8375SDarren Reed 			cv_signal(&waiter->fw_cv);
3897ddc9b1aSDarren Reed 			mutex_exit(&waiter->fw_lock);
3907ddc9b1aSDarren Reed 			return (-1);
3917ddc9b1aSDarren Reed 		}
3927ddc9b1aSDarren Reed 	}
3937ddc9b1aSDarren Reed 	waiter->fw_flags &= ~wanted;
3944a9b8375SDarren Reed 	ASSERT((waiter->fw_flags & wanted) == 0);
3954a9b8375SDarren Reed 	ASSERT((waiter->fw_flags & newflag) == 0);
3967ddc9b1aSDarren Reed 	waiter->fw_flags |= newflag;
3977ddc9b1aSDarren Reed 	mutex_exit(&waiter->fw_lock);
3987ddc9b1aSDarren Reed 	return (waited);
3997ddc9b1aSDarren Reed }
4007ddc9b1aSDarren Reed 
4017ddc9b1aSDarren Reed /*
4027ddc9b1aSDarren Reed  * Function:	hook_wait_unsetflag
4037ddc9b1aSDarren Reed  * Returns:     None
4047ddc9b1aSDarren Reed  * Parameters:  waiter(I)  - control data structure
4057ddc9b1aSDarren Reed  *              oldflag(I) - flag to reset
4067ddc9b1aSDarren Reed  *
4077ddc9b1aSDarren Reed  * Turn off the bit that we had set to run and let others know that
4087ddc9b1aSDarren Reed  * they should now check to see if they can run.
4097ddc9b1aSDarren Reed  */
4107ddc9b1aSDarren Reed void
hook_wait_unsetflag(flagwait_t * waiter,fwflag_t oldflag)4114a9b8375SDarren Reed hook_wait_unsetflag(flagwait_t *waiter, fwflag_t oldflag)
4127ddc9b1aSDarren Reed {
4137ddc9b1aSDarren Reed 	mutex_enter(&waiter->fw_lock);
4147ddc9b1aSDarren Reed 	waiter->fw_flags &= ~oldflag;
4157ddc9b1aSDarren Reed 	cv_signal(&waiter->fw_cv);
4167ddc9b1aSDarren Reed 	mutex_exit(&waiter->fw_lock);
4177ddc9b1aSDarren Reed }
4187ddc9b1aSDarren Reed 
4197ddc9b1aSDarren Reed /*
4207ddc9b1aSDarren Reed  * Function:	hook_wait_destroy
4217ddc9b1aSDarren Reed  * Returns:     None
4227ddc9b1aSDarren Reed  * Parameters:  waiter(I)  - control data structure
4237ddc9b1aSDarren Reed  *
4247ddc9b1aSDarren Reed  * Since outer locking (on fw_owner) should ensure that only one function
4257ddc9b1aSDarren Reed  * at a time gets to call hook_wait_destroy() on a given object, there is
4267ddc9b1aSDarren Reed  * no need to guard against setting FWF_DESTROY_WANTED already being set.
4277ddc9b1aSDarren Reed  * It is, however, necessary to wait for all activity on the owning
4287ddc9b1aSDarren Reed  * structure to cease.
4297ddc9b1aSDarren Reed  */
4304a9b8375SDarren Reed int
hook_wait_destroy(flagwait_t * waiter)4317ddc9b1aSDarren Reed hook_wait_destroy(flagwait_t *waiter)
4327ddc9b1aSDarren Reed {
4337ddc9b1aSDarren Reed 	ASSERT((waiter->fw_flags & FWF_DESTROY_WANTED) == 0);
4344a9b8375SDarren Reed 	mutex_enter(&waiter->fw_lock);
4354a9b8375SDarren Reed 	if (waiter->fw_flags & FWF_DESTROY_WANTED) {
4364a9b8375SDarren Reed 		cv_signal(&waiter->fw_cv);
4374a9b8375SDarren Reed 		mutex_exit(&waiter->fw_lock);
4384a9b8375SDarren Reed 		return (EINPROGRESS);
4394a9b8375SDarren Reed 	}
4407ddc9b1aSDarren Reed 	waiter->fw_flags |= FWF_DESTROY_WANTED;
4417ddc9b1aSDarren Reed 	while (!FWF_DESTROY_OK(waiter)) {
4427ddc9b1aSDarren Reed 		CVW_EXIT_WRITE(waiter->fw_owner);
4437ddc9b1aSDarren Reed 		cv_wait(&waiter->fw_cv, &waiter->fw_lock);
4447ddc9b1aSDarren Reed 		CVW_ENTER_WRITE(waiter->fw_owner);
4457ddc9b1aSDarren Reed 	}
4467ddc9b1aSDarren Reed 	/*
4477ddc9b1aSDarren Reed 	 * There should now be nothing else using "waiter" or its
4487ddc9b1aSDarren Reed 	 * owner, so we can safely assign here without risk of wiiping
4497ddc9b1aSDarren Reed 	 * out someone's bit.
4507ddc9b1aSDarren Reed 	 */
4517ddc9b1aSDarren Reed 	waiter->fw_flags = FWF_DESTROY_ACTIVE;
4524a9b8375SDarren Reed 	cv_signal(&waiter->fw_cv);
4534a9b8375SDarren Reed 	mutex_exit(&waiter->fw_lock);
4544a9b8375SDarren Reed 
4554a9b8375SDarren Reed 	return (0);
4567ddc9b1aSDarren Reed }
4577ddc9b1aSDarren Reed 
4587ddc9b1aSDarren Reed /*
4597ddc9b1aSDarren Reed  * Function:	hook_wait_init
4607ddc9b1aSDarren Reed  * Returns:     None
4617ddc9b1aSDarren Reed  * Parameters:  waiter(I)  - control data structure
4627ddc9b1aSDarren Reed  *              ownder(I)  - pointer to lock that the owner of this
4637ddc9b1aSDarren Reed  *                           waiter uses
4647ddc9b1aSDarren Reed  *
4657ddc9b1aSDarren Reed  * "owner" gets passed in here so that when we need to call cv_wait,
4667ddc9b1aSDarren Reed  * for example in hook_wait_setflag(), we can drop the lock for the
4677ddc9b1aSDarren Reed  * next layer out, which is likely to be held in an exclusive manner.
4687ddc9b1aSDarren Reed  */
4697ddc9b1aSDarren Reed void
hook_wait_init(flagwait_t * waiter,cvwaitlock_t * owner)4707ddc9b1aSDarren Reed hook_wait_init(flagwait_t *waiter, cvwaitlock_t *owner)
4717ddc9b1aSDarren Reed {
4727ddc9b1aSDarren Reed 	cv_init(&waiter->fw_cv, NULL, CV_DRIVER, NULL);
4737ddc9b1aSDarren Reed 	mutex_init(&waiter->fw_lock, NULL, MUTEX_DRIVER, NULL);
4747ddc9b1aSDarren Reed 	waiter->fw_flags = FWF_NONE;
4757ddc9b1aSDarren Reed 	waiter->fw_owner = owner;
476381a2a9aSdr }
477381a2a9aSdr 
478f4b3ec61Sdh /*
4794a9b8375SDarren Reed  * Function:	hook_stack_init
4804a9b8375SDarren Reed  * Returns:     void *     - pointer to new hook stack structure
4814a9b8375SDarren Reed  * Parameters:  stackid(I) - identifier for the network instance that owns this
4824a9b8375SDarren Reed  *              ns(I)      - pointer to the network instance data structure
4834a9b8375SDarren Reed  *
4844a9b8375SDarren Reed  * Allocate and initialize the hook stack instance. This function is not
4854a9b8375SDarren Reed  * allowed to fail, so KM_SLEEP is used here when allocating memory. The
4864a9b8375SDarren Reed  * value returned is passed back into the shutdown and destroy hooks.
487f4b3ec61Sdh  */
488f4b3ec61Sdh /*ARGSUSED*/
489f4b3ec61Sdh static void *
hook_stack_init(netstackid_t stackid,netstack_t * ns)490f4b3ec61Sdh hook_stack_init(netstackid_t stackid, netstack_t *ns)
491f4b3ec61Sdh {
492f4b3ec61Sdh 	hook_stack_t	*hks;
493f4b3ec61Sdh 
494f4b3ec61Sdh #ifdef NS_DEBUG
495f4b3ec61Sdh 	printf("hook_stack_init(stack %d)\n", stackid);
496f4b3ec61Sdh #endif
497f4b3ec61Sdh 
498f4b3ec61Sdh 	hks = (hook_stack_t *)kmem_zalloc(sizeof (*hks), KM_SLEEP);
4997ddc9b1aSDarren Reed 	hks->hks_netstack = ns;
5007ddc9b1aSDarren Reed 	hks->hks_netstackid = stackid;
501f4b3ec61Sdh 
5027ddc9b1aSDarren Reed 	CVW_INIT(&hks->hks_lock);
5037ddc9b1aSDarren Reed 	TAILQ_INIT(&hks->hks_nhead);
504f4b3ec61Sdh 	SLIST_INIT(&hks->hks_familylist);
505f4b3ec61Sdh 
5067ddc9b1aSDarren Reed 	hook_wait_init(&hks->hks_waiter, &hks->hks_lock);
5077ddc9b1aSDarren Reed 
5087ddc9b1aSDarren Reed 	mutex_enter(&hook_stack_lock);
5097ddc9b1aSDarren Reed 	SLIST_INSERT_HEAD(&hook_stacks, hks, hks_entry);
5107ddc9b1aSDarren Reed 	mutex_exit(&hook_stack_lock);
5117ddc9b1aSDarren Reed 
512f4b3ec61Sdh 	return (hks);
513f4b3ec61Sdh }
514f4b3ec61Sdh 
5158ad74188SDarren Reed /*
5164a9b8375SDarren Reed  * Function:	hook_stack_shutdown
5174a9b8375SDarren Reed  * Returns:     void
5184a9b8375SDarren Reed  * Parameters:  stackid(I) - identifier for the network instance that owns this
5194a9b8375SDarren Reed  *              arg(I)     - pointer returned by hook_stack_init
5204a9b8375SDarren Reed  *
5218ad74188SDarren Reed  * Set the shutdown flag to indicate that we should stop accepting new
5224a9b8375SDarren Reed  * register calls as we're now in the cleanup process. The cleanup is a
5234a9b8375SDarren Reed  * two stage process and we're not required to free any memory here.
5244a9b8375SDarren Reed  *
5254a9b8375SDarren Reed  * The curious would wonder why isn't there any code that walks through
5264a9b8375SDarren Reed  * all of the data structures and sets the flag(s) there? The answer is
5274a9b8375SDarren Reed  * that it is expected that this will happen when the zone shutdown calls
5284a9b8375SDarren Reed  * the shutdown callbacks for other modules that they will initiate the
529652fb50dSRob Gulewich  * free'ing and shutdown of the hooks themselves.
5308ad74188SDarren Reed  */
5317ddc9b1aSDarren Reed /*ARGSUSED*/
5327ddc9b1aSDarren Reed static void
hook_stack_shutdown(netstackid_t stackid,void * arg)5337ddc9b1aSDarren Reed hook_stack_shutdown(netstackid_t stackid, void *arg)
5347ddc9b1aSDarren Reed {
5357ddc9b1aSDarren Reed 	hook_stack_t *hks = (hook_stack_t *)arg;
5367ddc9b1aSDarren Reed 
5377ddc9b1aSDarren Reed 	mutex_enter(&hook_stack_lock);
5387ddc9b1aSDarren Reed 	/*
5397ddc9b1aSDarren Reed 	 * Once this flag gets set to one, no more additions are allowed
5407ddc9b1aSDarren Reed 	 * to any of the structures that make up this stack.
5417ddc9b1aSDarren Reed 	 */
5427ddc9b1aSDarren Reed 	hks->hks_shutdown = 1;
5437ddc9b1aSDarren Reed 	mutex_exit(&hook_stack_lock);
5447ddc9b1aSDarren Reed }
5457ddc9b1aSDarren Reed 
546f4b3ec61Sdh /*
5474a9b8375SDarren Reed  * Function:	hook_stack_destroy
5484a9b8375SDarren Reed  * Returns:     void
5494a9b8375SDarren Reed  * Parameters:  stackid(I) - identifier for the network instance that owns this
5504a9b8375SDarren Reed  *              arg(I)     - pointer returned by hook_stack_init
5514a9b8375SDarren Reed  *
552f4b3ec61Sdh  * Free the hook stack instance.
5534a9b8375SDarren Reed  *
5544a9b8375SDarren Reed  * The rationale for the shutdown being lazy (see the comment above for
5554a9b8375SDarren Reed  * hook_stack_shutdown) also applies to the destroy being lazy. Only if
5564a9b8375SDarren Reed  * the hook_stack_t data structure is unused will it go away. Else it
5574a9b8375SDarren Reed  * is left up to the last user of a data structure to actually free it.
558f4b3ec61Sdh  */
559f4b3ec61Sdh /*ARGSUSED*/
560f4b3ec61Sdh static void
hook_stack_fini(netstackid_t stackid,void * arg)561f4b3ec61Sdh hook_stack_fini(netstackid_t stackid, void *arg)
562f4b3ec61Sdh {
5637ddc9b1aSDarren Reed 	hook_stack_t *hks = (hook_stack_t *)arg;
5647ddc9b1aSDarren Reed 
5657ddc9b1aSDarren Reed 	mutex_enter(&hook_stack_lock);
5667ddc9b1aSDarren Reed 	hks->hks_shutdown = 2;
5677ddc9b1aSDarren Reed 	hook_stack_remove(hks);
5687ddc9b1aSDarren Reed 	mutex_exit(&hook_stack_lock);
5697ddc9b1aSDarren Reed }
5707ddc9b1aSDarren Reed 
5717ddc9b1aSDarren Reed /*
5724a9b8375SDarren Reed  * Function:	hook_stack_remove
5734a9b8375SDarren Reed  * Returns:     void
5744a9b8375SDarren Reed  * Parameters:  hks(I) - pointer to an instance of a hook_stack_t
5754a9b8375SDarren Reed  *
5767ddc9b1aSDarren Reed  * This function assumes that it is called with hook_stack_lock held.
5777ddc9b1aSDarren Reed  * It functions differently to hook_family/event_remove in that it does
5787ddc9b1aSDarren Reed  * the checks to see if it can be removed. This difference exists
5797ddc9b1aSDarren Reed  * because this structure has nothing higher up that depends on it.
5807ddc9b1aSDarren Reed  */
5817ddc9b1aSDarren Reed static void
hook_stack_remove(hook_stack_t * hks)5827ddc9b1aSDarren Reed hook_stack_remove(hook_stack_t *hks)
5837ddc9b1aSDarren Reed {
5847ddc9b1aSDarren Reed 
5857ddc9b1aSDarren Reed 	ASSERT(mutex_owned(&hook_stack_lock));
5867ddc9b1aSDarren Reed 
5877ddc9b1aSDarren Reed 	/*
5887ddc9b1aSDarren Reed 	 * Is the structure still in use?
5897ddc9b1aSDarren Reed 	 */
5907ddc9b1aSDarren Reed 	if (!SLIST_EMPTY(&hks->hks_familylist) ||
5917ddc9b1aSDarren Reed 	    !TAILQ_EMPTY(&hks->hks_nhead))
5927ddc9b1aSDarren Reed 		return;
5937ddc9b1aSDarren Reed 
5947ddc9b1aSDarren Reed 	SLIST_REMOVE(&hook_stacks, hks, hook_stack, hks_entry);
5957ddc9b1aSDarren Reed 
5964a9b8375SDarren Reed 	VERIFY(hook_wait_destroy(&hks->hks_waiter) == 0);
5977ddc9b1aSDarren Reed 	CVW_DESTROY(&hks->hks_lock);
598f4b3ec61Sdh 	kmem_free(hks, sizeof (*hks));
599f4b3ec61Sdh }
600381a2a9aSdr 
6014a9b8375SDarren Reed /*
6024a9b8375SDarren Reed  * Function:	hook_stack_get
6034a9b8375SDarren Reed  * Returns:     hook_stack_t * - NULL if not found, else matching instance
6044a9b8375SDarren Reed  * Parameters:  stackid(I)     - instance id to search for
6054a9b8375SDarren Reed  *
6064a9b8375SDarren Reed  * Search the list of currently active hook_stack_t structures for one that
6074a9b8375SDarren Reed  * has a matching netstackid_t to the value passed in. The linked list can
6084a9b8375SDarren Reed  * only ever have at most one match for this value.
6094a9b8375SDarren Reed  */
6107ddc9b1aSDarren Reed static hook_stack_t *
hook_stack_get(netstackid_t stackid)6117ddc9b1aSDarren Reed hook_stack_get(netstackid_t stackid)
6127ddc9b1aSDarren Reed {
6137ddc9b1aSDarren Reed 	hook_stack_t *hks;
6147ddc9b1aSDarren Reed 
6157ddc9b1aSDarren Reed 	SLIST_FOREACH(hks, &hook_stacks, hks_entry) {
6167ddc9b1aSDarren Reed 		if (hks->hks_netstackid == stackid)
6177ddc9b1aSDarren Reed 			break;
6187ddc9b1aSDarren Reed 	}
6197ddc9b1aSDarren Reed 
6207ddc9b1aSDarren Reed 	return (hks);
6217ddc9b1aSDarren Reed }
6227ddc9b1aSDarren Reed 
6237ddc9b1aSDarren Reed /*
6247ddc9b1aSDarren Reed  * Function:	hook_stack_notify_register
6254a9b8375SDarren Reed  * Returns:	int        - 0 = success, else failure
6267ddc9b1aSDarren Reed  * Parameters:	stackid(I) - netstack identifier
6277ddc9b1aSDarren Reed  *              callback(I)- function to be called
6287ddc9b1aSDarren Reed  *              arg(I)     - arg to provide callback when it is called
6297ddc9b1aSDarren Reed  *
6307ddc9b1aSDarren Reed  * If we're not shutting down this instance, append a new function to the
6317ddc9b1aSDarren Reed  * list of those to call when a new family of hooks is added to this stack.
6324a9b8375SDarren Reed  * If the function can be successfully added to the list of callbacks
6334a9b8375SDarren Reed  * activated when there is a change to the stack (addition or removal of
6344a9b8375SDarren Reed  * a hook family) then generate a fake HN_REGISTER event by directly
6354a9b8375SDarren Reed  * calling the callback with the relevant information for each hook
6364a9b8375SDarren Reed  * family that currently exists (and isn't being shutdown.)
6377ddc9b1aSDarren Reed  */
6387ddc9b1aSDarren Reed int
hook_stack_notify_register(netstackid_t stackid,hook_notify_fn_t callback,void * arg)6397ddc9b1aSDarren Reed hook_stack_notify_register(netstackid_t stackid, hook_notify_fn_t callback,
6407ddc9b1aSDarren Reed     void *arg)
6417ddc9b1aSDarren Reed {
6424a9b8375SDarren Reed 	hook_family_int_t *hfi;
6437ddc9b1aSDarren Reed 	hook_stack_t *hks;
6444a9b8375SDarren Reed 	boolean_t canrun;
6454a9b8375SDarren Reed 	char buffer[16];
6467ddc9b1aSDarren Reed 	int error;
6477ddc9b1aSDarren Reed 
6484a9b8375SDarren Reed 	ASSERT(callback != NULL);
6494a9b8375SDarren Reed 
6504a9b8375SDarren Reed 	canrun = B_FALSE;
6517ddc9b1aSDarren Reed 	mutex_enter(&hook_stack_lock);
6527ddc9b1aSDarren Reed 	hks = hook_stack_get(stackid);
6537ddc9b1aSDarren Reed 	if (hks != NULL) {
6547ddc9b1aSDarren Reed 		if (hks->hks_shutdown != 0) {
6557ddc9b1aSDarren Reed 			error = ESHUTDOWN;
6567ddc9b1aSDarren Reed 		} else {
6574a9b8375SDarren Reed 			CVW_ENTER_WRITE(&hks->hks_lock);
6584a9b8375SDarren Reed 			canrun = (hook_wait_setflag(&hks->hks_waiter,
6594a9b8375SDarren Reed 			    FWF_ADD_WAIT_MASK, FWF_ADD_WANTED,
6604a9b8375SDarren Reed 			    FWF_ADD_ACTIVE) != -1);
6614a9b8375SDarren Reed 			error = hook_notify_register(&hks->hks_nhead,
6624a9b8375SDarren Reed 			    callback, arg);
6634a9b8375SDarren Reed 			CVW_EXIT_WRITE(&hks->hks_lock);
6647ddc9b1aSDarren Reed 		}
6657ddc9b1aSDarren Reed 	} else {
6667ddc9b1aSDarren Reed 		error = ESRCH;
6677ddc9b1aSDarren Reed 	}
6687ddc9b1aSDarren Reed 	mutex_exit(&hook_stack_lock);
6697ddc9b1aSDarren Reed 
6704a9b8375SDarren Reed 	if (error == 0 && canrun) {
6714a9b8375SDarren Reed 		/*
6724a9b8375SDarren Reed 		 * Generate fake register event for callback that
6734a9b8375SDarren Reed 		 * is being added, letting it know everything that
6744a9b8375SDarren Reed 		 * already exists.
6754a9b8375SDarren Reed 		 */
6764a9b8375SDarren Reed 		(void) snprintf(buffer, sizeof (buffer), "%u",
6774a9b8375SDarren Reed 		    hks->hks_netstackid);
6784a9b8375SDarren Reed 
6794a9b8375SDarren Reed 		SLIST_FOREACH(hfi, &hks->hks_familylist, hfi_entry) {
6804a9b8375SDarren Reed 			if (hfi->hfi_condemned || hfi->hfi_shutdown)
6814a9b8375SDarren Reed 				continue;
6824a9b8375SDarren Reed 			callback(HN_REGISTER, arg, buffer, NULL,
6834a9b8375SDarren Reed 			    hfi->hfi_family.hf_name);
6844a9b8375SDarren Reed 		}
6854a9b8375SDarren Reed 	}
6864a9b8375SDarren Reed 
6874a9b8375SDarren Reed 	if (canrun)
6884a9b8375SDarren Reed 		hook_wait_unsetflag(&hks->hks_waiter, FWF_ADD_ACTIVE);
6894a9b8375SDarren Reed 
6907ddc9b1aSDarren Reed 	return (error);
6917ddc9b1aSDarren Reed }
6927ddc9b1aSDarren Reed 
6937ddc9b1aSDarren Reed /*
6947ddc9b1aSDarren Reed  * Function:	hook_stack_notify_unregister
6954a9b8375SDarren Reed  * Returns:	int         - 0 = success, else failure
6964a9b8375SDarren Reed  * Parameters:	stackid(I)  - netstack identifier
6977ddc9b1aSDarren Reed  *              callback(I) - function to be called
6987ddc9b1aSDarren Reed  *
6997ddc9b1aSDarren Reed  * Attempt to remove a registered function from a hook stack's list of
7007ddc9b1aSDarren Reed  * callbacks to activiate when protocols are added/deleted.
7014a9b8375SDarren Reed  * As with hook_stack_notify_register, if all things are going well then
7024a9b8375SDarren Reed  * a fake unregister event is delivered to the callback being removed
7034a9b8375SDarren Reed  * for each hook family that presently exists.
7047ddc9b1aSDarren Reed  */
7057ddc9b1aSDarren Reed int
hook_stack_notify_unregister(netstackid_t stackid,hook_notify_fn_t callback)7067ddc9b1aSDarren Reed hook_stack_notify_unregister(netstackid_t stackid, hook_notify_fn_t callback)
7077ddc9b1aSDarren Reed {
7084a9b8375SDarren Reed 	hook_family_int_t *hfi;
7097ddc9b1aSDarren Reed 	hook_stack_t *hks;
7104a9b8375SDarren Reed 	char buffer[16];
7114a9b8375SDarren Reed 	void *arg;
7127ddc9b1aSDarren Reed 	int error;
7137ddc9b1aSDarren Reed 
7147ddc9b1aSDarren Reed 	mutex_enter(&hook_stack_lock);
7157ddc9b1aSDarren Reed 	hks = hook_stack_get(stackid);
71668c34d04SJason King 	if (hks == NULL) {
71768c34d04SJason King 		mutex_exit(&hook_stack_lock);
71868c34d04SJason King 		return (ESRCH);
71968c34d04SJason King 	}
7204a9b8375SDarren Reed 
72168c34d04SJason King 	CVW_ENTER_WRITE(&hks->hks_lock);
72268c34d04SJason King 	/*
72368c34d04SJason King 	 * If hook_wait_setflag returns -1, another thread has flagged that it
72468c34d04SJason King 	 * is attempting to destroy this hook stack.  Before it can flag that
72568c34d04SJason King 	 * it's destroying the hook stack, it must first verify (with
72668c34d04SJason King 	 * hook_stack_lock held) that the hook stack is empty.  If we
72768c34d04SJason King 	 * encounter this, it means we should have nothing to do and we
72868c34d04SJason King 	 * just snuck in.
72968c34d04SJason King 	 */
73068c34d04SJason King 	if (hook_wait_setflag(&hks->hks_waiter, FWF_DEL_WAIT_MASK,
73168c34d04SJason King 	    FWF_DEL_WANTED, FWF_DEL_ACTIVE) == -1) {
73268c34d04SJason King 		VERIFY(TAILQ_EMPTY(&hks->hks_nhead));
7334a9b8375SDarren Reed 		CVW_EXIT_WRITE(&hks->hks_lock);
73468c34d04SJason King 		mutex_exit(&hook_stack_lock);
73568c34d04SJason King 		return (ESRCH);
7367ddc9b1aSDarren Reed 	}
73768c34d04SJason King 
73868c34d04SJason King 	error = hook_notify_unregister(&hks->hks_nhead, callback, &arg);
73968c34d04SJason King 	CVW_EXIT_WRITE(&hks->hks_lock);
7407ddc9b1aSDarren Reed 	mutex_exit(&hook_stack_lock);
7417ddc9b1aSDarren Reed 
7424a9b8375SDarren Reed 	if (error == 0) {
74368c34d04SJason King 		/*
74468c34d04SJason King 		 * Generate fake unregister event for callback that
74568c34d04SJason King 		 * is being removed, letting it know everything that
74668c34d04SJason King 		 * currently exists is now "disappearing."
74768c34d04SJason King 		 */
74868c34d04SJason King 		(void) snprintf(buffer, sizeof (buffer), "%u",
74968c34d04SJason King 		    hks->hks_netstackid);
7504a9b8375SDarren Reed 
75168c34d04SJason King 		SLIST_FOREACH(hfi, &hks->hks_familylist, hfi_entry) {
75268c34d04SJason King 			callback(HN_UNREGISTER, arg, buffer, NULL,
75368c34d04SJason King 			    hfi->hfi_family.hf_name);
7544a9b8375SDarren Reed 		}
75568c34d04SJason King 	} else {
75668c34d04SJason King 		/*
75768c34d04SJason King 		 * hook_notify_unregister() should only fail if the callback has
75868c34d04SJason King 		 * already been deleted (ESRCH).
75968c34d04SJason King 		 */
76068c34d04SJason King 		VERIFY3S(error, ==, ESRCH);
7614a9b8375SDarren Reed 	}
7624a9b8375SDarren Reed 
76368c34d04SJason King 	mutex_enter(&hook_stack_lock);
76468c34d04SJason King 	hook_wait_unsetflag(&hks->hks_waiter, FWF_DEL_ACTIVE);
76568c34d04SJason King 	if (hks->hks_shutdown == 2)
76668c34d04SJason King 		hook_stack_remove(hks);
76768c34d04SJason King 	mutex_exit(&hook_stack_lock);
76868c34d04SJason King 
7697ddc9b1aSDarren Reed 	return (error);
7707ddc9b1aSDarren Reed }
7717ddc9b1aSDarren Reed 
7727ddc9b1aSDarren Reed /*
7737ddc9b1aSDarren Reed  * Function:	hook_stack_notify_run
7747ddc9b1aSDarren Reed  * Returns:	None
7757ddc9b1aSDarren Reed  * Parameters:	hks(I)  - hook stack pointer to execute callbacks for
7767ddc9b1aSDarren Reed  *              name(I) - name of a hook family
7777ddc9b1aSDarren Reed  *              cmd(I)  - either HN_UNREGISTER or HN_REGISTER
7787ddc9b1aSDarren Reed  *
7797ddc9b1aSDarren Reed  * Run through the list of callbacks on the hook stack to be called when
7807ddc9b1aSDarren Reed  * a new hook family is added
7817ddc9b1aSDarren Reed  *
7824a9b8375SDarren Reed  * As hook_notify_run() expects 3 names, one for the family that is associated
7834a9b8375SDarren Reed  * with the cmd (HN_REGISTER or HN_UNREGISTER), one for the event and one
7844a9b8375SDarren Reed  * for the object being introduced and we really only have one name (that
7854a9b8375SDarren Reed  * of the new hook family), fake the hook stack's name by converting the
7864a9b8375SDarren Reed  * integer to a string and for the event just pass NULL.
7877ddc9b1aSDarren Reed  */
7887ddc9b1aSDarren Reed static void
hook_stack_notify_run(hook_stack_t * hks,char * name,hook_notify_cmd_t cmd)7897ddc9b1aSDarren Reed hook_stack_notify_run(hook_stack_t *hks, char *name,
7907ddc9b1aSDarren Reed     hook_notify_cmd_t cmd)
7917ddc9b1aSDarren Reed {
7927ddc9b1aSDarren Reed 	char buffer[16];
7937ddc9b1aSDarren Reed 
7944a9b8375SDarren Reed 	ASSERT(hks != NULL);
7954a9b8375SDarren Reed 	ASSERT(name != NULL);
7964a9b8375SDarren Reed 
7977ddc9b1aSDarren Reed 	(void) snprintf(buffer, sizeof (buffer), "%u", hks->hks_netstackid);
7987ddc9b1aSDarren Reed 
7997ddc9b1aSDarren Reed 	hook_notify_run(&hks->hks_nhead, buffer, NULL, name, cmd);
8007ddc9b1aSDarren Reed }
8017ddc9b1aSDarren Reed 
802381a2a9aSdr /*
803381a2a9aSdr  * Function:	hook_run
8044a9b8375SDarren Reed  * Returns:	int      - return value according to callback func
805381a2a9aSdr  * Parameters:	token(I) - event pointer
8064a9b8375SDarren Reed  *		info(I)  - message
807381a2a9aSdr  *
808381a2a9aSdr  * Run hooks for specific provider.  The hooks registered are stepped through
809381a2a9aSdr  * until either the end of the list is reached or a hook function returns a
810381a2a9aSdr  * non-zero value.  If a non-zero value is returned from a hook function, we
811381a2a9aSdr  * return that value back to our caller.  By design, a hook function can be
812381a2a9aSdr  * called more than once, simultaneously.
813381a2a9aSdr  */
814381a2a9aSdr int
hook_run(hook_family_int_t * hfi,hook_event_token_t token,hook_data_t info)8157ddc9b1aSDarren Reed hook_run(hook_family_int_t *hfi, hook_event_token_t token, hook_data_t info)
816381a2a9aSdr {
817381a2a9aSdr 	hook_event_int_t *hei;
8187ddc9b1aSDarren Reed 	hook_int_t *hi;
819381a2a9aSdr 	int rval = 0;
820381a2a9aSdr 
821381a2a9aSdr 	ASSERT(token != NULL);
822381a2a9aSdr 
823381a2a9aSdr 	hei = (hook_event_int_t *)token;
824381a2a9aSdr 	DTRACE_PROBE2(hook__run__start,
825381a2a9aSdr 	    hook_event_token_t, token,
826381a2a9aSdr 	    hook_data_t, info);
827381a2a9aSdr 
8287ddc9b1aSDarren Reed 	/*
8294a9b8375SDarren Reed 	 * If we consider that this function is only called from within the
830652fb50dSRob Gulewich 	 * stack while an instance is currently active,
8317ddc9b1aSDarren Reed 	 */
8327ddc9b1aSDarren Reed 	CVW_ENTER_READ(&hfi->hfi_lock);
833381a2a9aSdr 
834381a2a9aSdr 	TAILQ_FOREACH(hi, &hei->hei_head, hi_entry) {
835381a2a9aSdr 		ASSERT(hi->hi_hook.h_func != NULL);
836381a2a9aSdr 		DTRACE_PROBE3(hook__func__start,
837381a2a9aSdr 		    hook_event_token_t, token,
838381a2a9aSdr 		    hook_data_t, info,
839381a2a9aSdr 		    hook_int_t *, hi);
8407ddc9b1aSDarren Reed 		rval = (*hi->hi_hook.h_func)(token, info, hi->hi_hook.h_arg);
841381a2a9aSdr 		DTRACE_PROBE4(hook__func__end,
842381a2a9aSdr 		    hook_event_token_t, token,
843381a2a9aSdr 		    hook_data_t, info,
844381a2a9aSdr 		    hook_int_t *, hi,
845381a2a9aSdr 		    int, rval);
8467ddc9b1aSDarren Reed 		hi->hi_kstats.hook_hits.value.ui64++;
847381a2a9aSdr 		if (rval != 0)
848381a2a9aSdr 			break;
849381a2a9aSdr 	}
850381a2a9aSdr 
8517ddc9b1aSDarren Reed 	hei->hei_kstats.events.value.ui64++;
8527ddc9b1aSDarren Reed 
8537ddc9b1aSDarren Reed 	CVW_EXIT_READ(&hfi->hfi_lock);
854381a2a9aSdr 
855381a2a9aSdr 	DTRACE_PROBE3(hook__run__end,
856381a2a9aSdr 	    hook_event_token_t, token,
857381a2a9aSdr 	    hook_data_t, info,
858381a2a9aSdr 	    hook_int_t *, hi);
859381a2a9aSdr 
860381a2a9aSdr 	return (rval);
861381a2a9aSdr }
862381a2a9aSdr 
863381a2a9aSdr /*
864381a2a9aSdr  * Function:	hook_family_add
865381a2a9aSdr  * Returns:	internal family pointer - NULL = Fail
8664a9b8375SDarren Reed  * Parameters:	hf(I)    - family pointer
8674a9b8375SDarren Reed  *              hks(I)   - pointer to an instance of a hook_stack_t
8684a9b8375SDarren Reed  *              store(O) - where returned pointer will be stored
869381a2a9aSdr  *
8704a9b8375SDarren Reed  * Add new family to the family list. The requirements for the addition to
8714a9b8375SDarren Reed  * succeed are that the family name must not already be registered and that
8724a9b8375SDarren Reed  * the hook stack is not being shutdown.
8734a9b8375SDarren Reed  * If store is non-NULL, it is expected to be a pointer to the same variable
8744a9b8375SDarren Reed  * that is awaiting to be assigned the return value of this function.
8754a9b8375SDarren Reed  * In its current use, the returned value is assigned to netd_hooks in
8764a9b8375SDarren Reed  * net_family_register. The use of "store" allows the return value to be
8774a9b8375SDarren Reed  * used before this function returns. How can this happen? Through the
8784a9b8375SDarren Reed  * callbacks that can be activated at the bottom of this function, when
8794a9b8375SDarren Reed  * hook_stack_notify_run is called.
880381a2a9aSdr  */
881381a2a9aSdr hook_family_int_t *
hook_family_add(hook_family_t * hf,hook_stack_t * hks,void ** store)8824a9b8375SDarren Reed hook_family_add(hook_family_t *hf, hook_stack_t *hks, void **store)
883381a2a9aSdr {
884381a2a9aSdr 	hook_family_int_t *hfi, *new;
885381a2a9aSdr 
886381a2a9aSdr 	ASSERT(hf != NULL);
887381a2a9aSdr 	ASSERT(hf->hf_name != NULL);
888381a2a9aSdr 
889381a2a9aSdr 	new = hook_family_copy(hf);
890381a2a9aSdr 	if (new == NULL)
891381a2a9aSdr 		return (NULL);
892381a2a9aSdr 
8937ddc9b1aSDarren Reed 	mutex_enter(&hook_stack_lock);
8947ddc9b1aSDarren Reed 	CVW_ENTER_WRITE(&hks->hks_lock);
8957ddc9b1aSDarren Reed 
8967ddc9b1aSDarren Reed 	if (hks->hks_shutdown != 0) {
8977ddc9b1aSDarren Reed 		CVW_EXIT_WRITE(&hks->hks_lock);
8987ddc9b1aSDarren Reed 		mutex_exit(&hook_stack_lock);
8997ddc9b1aSDarren Reed 		hook_family_free(new, NULL);
9007ddc9b1aSDarren Reed 		return (NULL);
9017ddc9b1aSDarren Reed 	}
902381a2a9aSdr 
903381a2a9aSdr 	/* search family list */
904f4b3ec61Sdh 	hfi = hook_family_find(hf->hf_name, hks);
905381a2a9aSdr 	if (hfi != NULL) {
9067ddc9b1aSDarren Reed 		CVW_EXIT_WRITE(&hks->hks_lock);
9077ddc9b1aSDarren Reed 		mutex_exit(&hook_stack_lock);
9087ddc9b1aSDarren Reed 		hook_family_free(new, NULL);
909381a2a9aSdr 		return (NULL);
910381a2a9aSdr 	}
911381a2a9aSdr 
9124a9b8375SDarren Reed 	/*
9134a9b8375SDarren Reed 	 * Try and set the FWF_ADD_ACTIVE flag so that we can drop all the
9144a9b8375SDarren Reed 	 * lock further down when calling all of the functions registered
9154a9b8375SDarren Reed 	 * for notification when a new hook family is added.
9164a9b8375SDarren Reed 	 */
9174a9b8375SDarren Reed 	if (hook_wait_setflag(&hks->hks_waiter, FWF_ADD_WAIT_MASK,
9187ddc9b1aSDarren Reed 	    FWF_ADD_WANTED, FWF_ADD_ACTIVE) == -1) {
9197ddc9b1aSDarren Reed 		CVW_EXIT_WRITE(&hks->hks_lock);
9207ddc9b1aSDarren Reed 		mutex_exit(&hook_stack_lock);
9217ddc9b1aSDarren Reed 		hook_family_free(new, NULL);
9227ddc9b1aSDarren Reed 		return (NULL);
9237ddc9b1aSDarren Reed 	}
9247ddc9b1aSDarren Reed 
9257ddc9b1aSDarren Reed 	CVW_INIT(&new->hfi_lock);
9267ddc9b1aSDarren Reed 	SLIST_INIT(&new->hfi_head);
9277ddc9b1aSDarren Reed 	TAILQ_INIT(&new->hfi_nhead);
9287ddc9b1aSDarren Reed 
9297ddc9b1aSDarren Reed 	hook_wait_init(&new->hfi_waiter, &new->hfi_lock);
9307ddc9b1aSDarren Reed 
9317ddc9b1aSDarren Reed 	new->hfi_stack = hks;
9324a9b8375SDarren Reed 	if (store != NULL)
9334a9b8375SDarren Reed 		*store = new;
934f4b3ec61Sdh 
935381a2a9aSdr 	/* Add to family list head */
936f4b3ec61Sdh 	SLIST_INSERT_HEAD(&hks->hks_familylist, new, hfi_entry);
937381a2a9aSdr 
9387ddc9b1aSDarren Reed 	CVW_EXIT_WRITE(&hks->hks_lock);
9397ddc9b1aSDarren Reed 	mutex_exit(&hook_stack_lock);
9407ddc9b1aSDarren Reed 
9417ddc9b1aSDarren Reed 	hook_stack_notify_run(hks, hf->hf_name, HN_REGISTER);
9427ddc9b1aSDarren Reed 
9437ddc9b1aSDarren Reed 	hook_wait_unsetflag(&hks->hks_waiter, FWF_ADD_ACTIVE);
9447ddc9b1aSDarren Reed 
945381a2a9aSdr 	return (new);
946381a2a9aSdr }
947381a2a9aSdr 
948381a2a9aSdr /*
949381a2a9aSdr  * Function:	hook_family_remove
9504a9b8375SDarren Reed  * Returns:	int    - 0 = success, else = failure
951381a2a9aSdr  * Parameters:	hfi(I) - internal family pointer
952381a2a9aSdr  *
9537ddc9b1aSDarren Reed  * Remove family from family list. This function has been designed to be
9547ddc9b1aSDarren Reed  * called once and once only per hook_family_int_t. Thus when cleaning up
9557ddc9b1aSDarren Reed  * this structure as an orphan, callers should only call hook_family_free.
956381a2a9aSdr  */
957381a2a9aSdr int
hook_family_remove(hook_family_int_t * hfi)958381a2a9aSdr hook_family_remove(hook_family_int_t *hfi)
959381a2a9aSdr {
960f4b3ec61Sdh 	hook_stack_t *hks;
9618ad74188SDarren Reed 	boolean_t notifydone;
962381a2a9aSdr 
963381a2a9aSdr 	ASSERT(hfi != NULL);
9647ddc9b1aSDarren Reed 	hks = hfi->hfi_stack;
965381a2a9aSdr 
9664a9b8375SDarren Reed 	CVW_ENTER_WRITE(&hfi->hfi_lock);
9674a9b8375SDarren Reed 	notifydone = hfi->hfi_shutdown;
9684a9b8375SDarren Reed 	hfi->hfi_shutdown = B_TRUE;
9694a9b8375SDarren Reed 	CVW_EXIT_WRITE(&hfi->hfi_lock);
9704a9b8375SDarren Reed 
9717ddc9b1aSDarren Reed 	CVW_ENTER_WRITE(&hks->hks_lock);
9727ddc9b1aSDarren Reed 
9734a9b8375SDarren Reed 	if (hook_wait_setflag(&hks->hks_waiter, FWF_DEL_WAIT_MASK,
9747ddc9b1aSDarren Reed 	    FWF_DEL_WANTED, FWF_DEL_ACTIVE) == -1) {
9757ddc9b1aSDarren Reed 		/*
9767ddc9b1aSDarren Reed 		 * If we're trying to destroy the hook_stack_t...
9777ddc9b1aSDarren Reed 		 */
9788ad74188SDarren Reed 		CVW_EXIT_WRITE(&hks->hks_lock);
9797ddc9b1aSDarren Reed 		return (ENXIO);
9807ddc9b1aSDarren Reed 	}
981381a2a9aSdr 
9827ddc9b1aSDarren Reed 	/*
9837ddc9b1aSDarren Reed 	 * Check if the family is in use by the presence of either events
9847ddc9b1aSDarren Reed 	 * or notify callbacks on the hook family.
9857ddc9b1aSDarren Reed 	 */
9867ddc9b1aSDarren Reed 	if (!SLIST_EMPTY(&hfi->hfi_head) || !TAILQ_EMPTY(&hfi->hfi_nhead)) {
9877ddc9b1aSDarren Reed 		hfi->hfi_condemned = B_TRUE;
9887ddc9b1aSDarren Reed 	} else {
9894a9b8375SDarren Reed 		VERIFY(hook_wait_destroy(&hfi->hfi_waiter) == 0);
9907ddc9b1aSDarren Reed 		/*
9917ddc9b1aSDarren Reed 		 * Although hfi_condemned = B_FALSE is implied from creation,
9927ddc9b1aSDarren Reed 		 * putting a comment here inside the else upsets lint.
9937ddc9b1aSDarren Reed 		 */
9947ddc9b1aSDarren Reed 		hfi->hfi_condemned = B_FALSE;
995381a2a9aSdr 	}
9967ddc9b1aSDarren Reed 	CVW_EXIT_WRITE(&hks->hks_lock);
997381a2a9aSdr 
9988ad74188SDarren Reed 	if (!notifydone)
9998ad74188SDarren Reed 		hook_stack_notify_run(hks, hfi->hfi_family.hf_name,
10008ad74188SDarren Reed 		    HN_UNREGISTER);
10017ddc9b1aSDarren Reed 
10027ddc9b1aSDarren Reed 	hook_wait_unsetflag(&hks->hks_waiter, FWF_DEL_ACTIVE);
10037ddc9b1aSDarren Reed 
10047ddc9b1aSDarren Reed 	/*
10057ddc9b1aSDarren Reed 	 * If we don't have to wait for anything else to disappear from this
10067ddc9b1aSDarren Reed 	 * structure then we can free it up.
10077ddc9b1aSDarren Reed 	 */
10087ddc9b1aSDarren Reed 	if (!hfi->hfi_condemned)
10097ddc9b1aSDarren Reed 		hook_family_free(hfi, hks);
1010381a2a9aSdr 
1011381a2a9aSdr 	return (0);
1012381a2a9aSdr }
1013381a2a9aSdr 
1014381a2a9aSdr 
10157ddc9b1aSDarren Reed /*
10167ddc9b1aSDarren Reed  * Function:	hook_family_free
10177ddc9b1aSDarren Reed  * Returns:	None
10187ddc9b1aSDarren Reed  * Parameters:	hfi(I) - internal family pointer
10197ddc9b1aSDarren Reed  *
10207ddc9b1aSDarren Reed  * Free alloc memory for family
10217ddc9b1aSDarren Reed  */
10227ddc9b1aSDarren Reed static void
hook_family_free(hook_family_int_t * hfi,hook_stack_t * hks)10237ddc9b1aSDarren Reed hook_family_free(hook_family_int_t *hfi, hook_stack_t *hks)
10247ddc9b1aSDarren Reed {
10257ddc9b1aSDarren Reed 
10267ddc9b1aSDarren Reed 	/*
10277ddc9b1aSDarren Reed 	 * This lock gives us possession of the hks pointer after the
10287ddc9b1aSDarren Reed 	 * SLIST_REMOVE, for which it is not needed, when hks_shutdown
10297ddc9b1aSDarren Reed 	 * is checked and hook_stack_remove called.
10307ddc9b1aSDarren Reed 	 */
10317ddc9b1aSDarren Reed 	mutex_enter(&hook_stack_lock);
10327ddc9b1aSDarren Reed 
10337ddc9b1aSDarren Reed 	ASSERT(hfi != NULL);
10347ddc9b1aSDarren Reed 
10357ddc9b1aSDarren Reed 	if (hks != NULL) {
10367ddc9b1aSDarren Reed 		CVW_ENTER_WRITE(&hks->hks_lock);
10377ddc9b1aSDarren Reed 		/* Remove from family list */
10387ddc9b1aSDarren Reed 		SLIST_REMOVE(&hks->hks_familylist, hfi, hook_family_int,
10397ddc9b1aSDarren Reed 		    hfi_entry);
10407ddc9b1aSDarren Reed 
10417ddc9b1aSDarren Reed 		CVW_EXIT_WRITE(&hks->hks_lock);
10427ddc9b1aSDarren Reed 	}
10437ddc9b1aSDarren Reed 
10447ddc9b1aSDarren Reed 	/* Free name space */
10457ddc9b1aSDarren Reed 	if (hfi->hfi_family.hf_name != NULL) {
10467ddc9b1aSDarren Reed 		kmem_free(hfi->hfi_family.hf_name,
10477ddc9b1aSDarren Reed 		    strlen(hfi->hfi_family.hf_name) + 1);
10487ddc9b1aSDarren Reed 	}
10497ddc9b1aSDarren Reed 
10507ddc9b1aSDarren Reed 	/* Free container */
10517ddc9b1aSDarren Reed 	kmem_free(hfi, sizeof (*hfi));
10527ddc9b1aSDarren Reed 
1053*b22a70abSPatrick Mooney 	if (hks != NULL && hks->hks_shutdown == 2)
10547ddc9b1aSDarren Reed 		hook_stack_remove(hks);
10557ddc9b1aSDarren Reed 
10567ddc9b1aSDarren Reed 	mutex_exit(&hook_stack_lock);
10577ddc9b1aSDarren Reed }
10587ddc9b1aSDarren Reed 
10598ad74188SDarren Reed /*
10608ad74188SDarren Reed  * Function:	hook_family_shutdown
10614a9b8375SDarren Reed  * Returns:	int    - 0 = success, else = failure
10628ad74188SDarren Reed  * Parameters:	hfi(I) - internal family pointer
10638ad74188SDarren Reed  *
10648ad74188SDarren Reed  * As an alternative to removing a family, we may desire to just generate
10658ad74188SDarren Reed  * a series of callbacks to indicate that we will be going away in the
10668ad74188SDarren Reed  * future. The hfi_condemned flag isn't set because we aren't trying to
10678ad74188SDarren Reed  * remove the structure.
10688ad74188SDarren Reed  */
10698ad74188SDarren Reed int
hook_family_shutdown(hook_family_int_t * hfi)10708ad74188SDarren Reed hook_family_shutdown(hook_family_int_t *hfi)
10718ad74188SDarren Reed {
10728ad74188SDarren Reed 	hook_stack_t *hks;
10738ad74188SDarren Reed 	boolean_t notifydone;
10748ad74188SDarren Reed 
10758ad74188SDarren Reed 	ASSERT(hfi != NULL);
10768ad74188SDarren Reed 	hks = hfi->hfi_stack;
10778ad74188SDarren Reed 
10784a9b8375SDarren Reed 	CVW_ENTER_WRITE(&hfi->hfi_lock);
10794a9b8375SDarren Reed 	notifydone = hfi->hfi_shutdown;
10804a9b8375SDarren Reed 	hfi->hfi_shutdown = B_TRUE;
10814a9b8375SDarren Reed 	CVW_EXIT_WRITE(&hfi->hfi_lock);
10824a9b8375SDarren Reed 
10838ad74188SDarren Reed 	CVW_ENTER_WRITE(&hks->hks_lock);
10848ad74188SDarren Reed 
10854a9b8375SDarren Reed 	if (hook_wait_setflag(&hks->hks_waiter, FWF_DEL_WAIT_MASK,
10868ad74188SDarren Reed 	    FWF_DEL_WANTED, FWF_DEL_ACTIVE) == -1) {
10878ad74188SDarren Reed 		/*
10888ad74188SDarren Reed 		 * If we're trying to destroy the hook_stack_t...
10898ad74188SDarren Reed 		 */
10908ad74188SDarren Reed 		CVW_EXIT_WRITE(&hks->hks_lock);
10918ad74188SDarren Reed 		return (ENXIO);
10928ad74188SDarren Reed 	}
10938ad74188SDarren Reed 
10948ad74188SDarren Reed 	CVW_EXIT_WRITE(&hks->hks_lock);
10958ad74188SDarren Reed 
10968ad74188SDarren Reed 	if (!notifydone)
10978ad74188SDarren Reed 		hook_stack_notify_run(hks, hfi->hfi_family.hf_name,
10988ad74188SDarren Reed 		    HN_UNREGISTER);
10998ad74188SDarren Reed 
11008ad74188SDarren Reed 	hook_wait_unsetflag(&hks->hks_waiter, FWF_DEL_ACTIVE);
11018ad74188SDarren Reed 
11028ad74188SDarren Reed 	return (0);
11038ad74188SDarren Reed }
11047ddc9b1aSDarren Reed 
1105381a2a9aSdr /*
1106381a2a9aSdr  * Function:	hook_family_copy
1107381a2a9aSdr  * Returns:	internal family pointer - NULL = Failed
1108381a2a9aSdr  * Parameters:	src(I) - family pointer
1109381a2a9aSdr  *
1110381a2a9aSdr  * Allocate internal family block and duplicate incoming family
1111381a2a9aSdr  * No locks should be held across this function as it may sleep.
1112381a2a9aSdr  */
1113381a2a9aSdr static hook_family_int_t *
hook_family_copy(hook_family_t * src)1114381a2a9aSdr hook_family_copy(hook_family_t *src)
1115381a2a9aSdr {
1116381a2a9aSdr 	hook_family_int_t *new;
1117381a2a9aSdr 	hook_family_t *dst;
1118381a2a9aSdr 
1119381a2a9aSdr 	ASSERT(src != NULL);
1120381a2a9aSdr 	ASSERT(src->hf_name != NULL);
1121381a2a9aSdr 
1122381a2a9aSdr 	new = (hook_family_int_t *)kmem_zalloc(sizeof (*new), KM_SLEEP);
1123381a2a9aSdr 
1124381a2a9aSdr 	/* Copy body */
1125381a2a9aSdr 	dst = &new->hfi_family;
1126381a2a9aSdr 	*dst = *src;
1127381a2a9aSdr 
11287ddc9b1aSDarren Reed 	SLIST_INIT(&new->hfi_head);
11297ddc9b1aSDarren Reed 	TAILQ_INIT(&new->hfi_nhead);
11307ddc9b1aSDarren Reed 
1131381a2a9aSdr 	/* Copy name */
1132381a2a9aSdr 	dst->hf_name = (char *)kmem_alloc(strlen(src->hf_name) + 1, KM_SLEEP);
1133381a2a9aSdr 	(void) strcpy(dst->hf_name, src->hf_name);
1134381a2a9aSdr 
1135381a2a9aSdr 	return (new);
1136381a2a9aSdr }
1137381a2a9aSdr 
1138381a2a9aSdr /*
11397ddc9b1aSDarren Reed  * Function:	hook_family_find
1140381a2a9aSdr  * Returns:	internal family pointer - NULL = Not match
1141381a2a9aSdr  * Parameters:	family(I) - family name string
1142381a2a9aSdr  *
1143381a2a9aSdr  * Search family list with family name
114468c34d04SJason King  *	A lock on hfi_lock must be held when called.
1145381a2a9aSdr  */
1146381a2a9aSdr static hook_family_int_t *
hook_family_find(char * family,hook_stack_t * hks)1147f4b3ec61Sdh hook_family_find(char *family, hook_stack_t *hks)
1148381a2a9aSdr {
1149381a2a9aSdr 	hook_family_int_t *hfi = NULL;
1150381a2a9aSdr 
1151381a2a9aSdr 	ASSERT(family != NULL);
1152381a2a9aSdr 
1153f4b3ec61Sdh 	SLIST_FOREACH(hfi, &hks->hks_familylist, hfi_entry) {
1154381a2a9aSdr 		if (strcmp(hfi->hfi_family.hf_name, family) == 0)
1155381a2a9aSdr 			break;
1156381a2a9aSdr 	}
1157381a2a9aSdr 	return (hfi);
1158381a2a9aSdr }
1159381a2a9aSdr 
1160381a2a9aSdr /*
11617ddc9b1aSDarren Reed  * Function:	hook_family_notify_register
11624a9b8375SDarren Reed  * Returns:	int         - 0 = success, else failure
11637ddc9b1aSDarren Reed  * Parameters:	hfi(I)      - hook family
11647ddc9b1aSDarren Reed  *              callback(I) - function to be called
11657ddc9b1aSDarren Reed  *              arg(I)      - arg to provide callback when it is called
1166381a2a9aSdr  *
11677ddc9b1aSDarren Reed  * So long as this hook stack isn't being shut down, register a new
11687ddc9b1aSDarren Reed  * callback to be activated each time a new event is added to this
11697ddc9b1aSDarren Reed  * family.
11707ddc9b1aSDarren Reed  *
11717ddc9b1aSDarren Reed  * To call this function we must have an active handle in use on the family,
11727ddc9b1aSDarren Reed  * so if we take this into account, then neither the hook_family_int_t nor
11737ddc9b1aSDarren Reed  * the hook_stack_t that owns it can disappear. We have to put some trust
11747ddc9b1aSDarren Reed  * in the callers to be properly synchronised...
11757ddc9b1aSDarren Reed  *
11767ddc9b1aSDarren Reed  * Holding hks_lock is required to provide synchronisation for hks_shutdown.
1177381a2a9aSdr  */
11787ddc9b1aSDarren Reed int
hook_family_notify_register(hook_family_int_t * hfi,hook_notify_fn_t callback,void * arg)11797ddc9b1aSDarren Reed hook_family_notify_register(hook_family_int_t *hfi,
11807ddc9b1aSDarren Reed     hook_notify_fn_t callback, void *arg)
1181381a2a9aSdr {
11824a9b8375SDarren Reed 	hook_event_int_t *hei;
11837ddc9b1aSDarren Reed 	hook_stack_t *hks;
11844a9b8375SDarren Reed 	boolean_t canrun;
11857ddc9b1aSDarren Reed 	int error;
1186381a2a9aSdr 
11874a9b8375SDarren Reed 	ASSERT(hfi != NULL);
11884a9b8375SDarren Reed 	canrun = B_FALSE;
11897ddc9b1aSDarren Reed 	hks = hfi->hfi_stack;
11907ddc9b1aSDarren Reed 
11917ddc9b1aSDarren Reed 	CVW_ENTER_READ(&hks->hks_lock);
11927ddc9b1aSDarren Reed 
11938ad74188SDarren Reed 	if ((hfi->hfi_stack->hks_shutdown != 0) ||
11948ad74188SDarren Reed 	    hfi->hfi_condemned || hfi->hfi_shutdown) {
11957ddc9b1aSDarren Reed 		CVW_EXIT_READ(&hks->hks_lock);
11967ddc9b1aSDarren Reed 		return (ESHUTDOWN);
1197381a2a9aSdr 	}
1198381a2a9aSdr 
11994a9b8375SDarren Reed 	CVW_ENTER_WRITE(&hfi->hfi_lock);
12004a9b8375SDarren Reed 	canrun = (hook_wait_setflag(&hfi->hfi_waiter, FWF_ADD_WAIT_MASK,
12014a9b8375SDarren Reed 	    FWF_ADD_WANTED, FWF_ADD_ACTIVE) != -1);
12024a9b8375SDarren Reed 	error = hook_notify_register(&hfi->hfi_nhead, callback, arg);
12037ddc9b1aSDarren Reed 	CVW_EXIT_WRITE(&hfi->hfi_lock);
12044a9b8375SDarren Reed 
12057ddc9b1aSDarren Reed 	CVW_EXIT_READ(&hks->hks_lock);
12067ddc9b1aSDarren Reed 
12074a9b8375SDarren Reed 	if (error == 0 && canrun) {
12084a9b8375SDarren Reed 		SLIST_FOREACH(hei, &hfi->hfi_head, hei_entry) {
12094a9b8375SDarren Reed 			callback(HN_REGISTER, arg,
12104a9b8375SDarren Reed 			    hfi->hfi_family.hf_name, NULL,
12114a9b8375SDarren Reed 			    hei->hei_event->he_name);
12124a9b8375SDarren Reed 		}
12134a9b8375SDarren Reed 	}
12144a9b8375SDarren Reed 
12154a9b8375SDarren Reed 	if (canrun)
12164a9b8375SDarren Reed 		hook_wait_unsetflag(&hfi->hfi_waiter, FWF_ADD_ACTIVE);
12174a9b8375SDarren Reed 
12187ddc9b1aSDarren Reed 	return (error);
1219381a2a9aSdr }
1220381a2a9aSdr 
12217ddc9b1aSDarren Reed /*
12227ddc9b1aSDarren Reed  * Function:	hook_family_notify_unregister
12234a9b8375SDarren Reed  * Returns:	int         - 0 = success, else failure
12247ddc9b1aSDarren Reed  * Parameters:	hfi(I)      - hook family
12257ddc9b1aSDarren Reed  *              callback(I) - function to be called
12267ddc9b1aSDarren Reed  *
12277ddc9b1aSDarren Reed  * Remove a callback from the list of those executed when a new event is
12284a9b8375SDarren Reed  * added to a hook family. If the family is not in the process of being
12294a9b8375SDarren Reed  * destroyed then simulate an unregister callback for each event that is
12304a9b8375SDarren Reed  * on the family. This pairs up with the hook_family_notify_register
12314a9b8375SDarren Reed  * action that simulates register events.
12324a9b8375SDarren Reed  * The order of what happens here is important and goes like this.
12334a9b8375SDarren Reed  * 1) Remove the callback from the list of functions to be called as part
12344a9b8375SDarren Reed  *    of the notify operation when an event is added or removed from the
12354a9b8375SDarren Reed  *    hook family.
12364a9b8375SDarren Reed  * 2) If the hook_family_int_t structure is on death row (free_family will
12374a9b8375SDarren Reed  *    be set to true) then there's nothing else to do than let it be free'd.
12384a9b8375SDarren Reed  * 3) If the structure isn't about to die, mark it up as being busy using
12394a9b8375SDarren Reed  *    hook_wait_setflag and then drop the lock so the loop can be run.
12404a9b8375SDarren Reed  * 4) if hook_wait_setflag was successful, tell all of the notify callback
12414a9b8375SDarren Reed  *    functions that this family has been unregistered.
12424a9b8375SDarren Reed  * 5) Cleanup
12437ddc9b1aSDarren Reed  */
12447ddc9b1aSDarren Reed int
hook_family_notify_unregister(hook_family_int_t * hfi,hook_notify_fn_t callback)12457ddc9b1aSDarren Reed hook_family_notify_unregister(hook_family_int_t *hfi,
12467ddc9b1aSDarren Reed     hook_notify_fn_t callback)
12477ddc9b1aSDarren Reed {
12484a9b8375SDarren Reed 	hook_event_int_t *hei;
12497ddc9b1aSDarren Reed 	boolean_t free_family;
12504a9b8375SDarren Reed 	boolean_t canrun;
12517ddc9b1aSDarren Reed 	int error;
12524a9b8375SDarren Reed 	void *arg;
12534a9b8375SDarren Reed 
12544a9b8375SDarren Reed 	canrun = B_FALSE;
12557ddc9b1aSDarren Reed 
12567ddc9b1aSDarren Reed 	CVW_ENTER_WRITE(&hfi->hfi_lock);
12577ddc9b1aSDarren Reed 
12584a9b8375SDarren Reed 	(void) hook_wait_setflag(&hfi->hfi_waiter, FWF_DEL_WAIT_MASK,
12594a9b8375SDarren Reed 	    FWF_DEL_WANTED, FWF_DEL_ACTIVE);
12604a9b8375SDarren Reed 
12614a9b8375SDarren Reed 	error = hook_notify_unregister(&hfi->hfi_nhead, callback, &arg);
12624a9b8375SDarren Reed 
12634a9b8375SDarren Reed 	hook_wait_unsetflag(&hfi->hfi_waiter, FWF_DEL_ACTIVE);
12647ddc9b1aSDarren Reed 
12657ddc9b1aSDarren Reed 	/*
12667ddc9b1aSDarren Reed 	 * If hook_family_remove has been called but the structure was still
12677ddc9b1aSDarren Reed 	 * "busy" ... but we might have just made it "unbusy"...
12687ddc9b1aSDarren Reed 	 */
12697ddc9b1aSDarren Reed 	if ((error == 0) && hfi->hfi_condemned &&
12707ddc9b1aSDarren Reed 	    SLIST_EMPTY(&hfi->hfi_head) && TAILQ_EMPTY(&hfi->hfi_nhead)) {
12717ddc9b1aSDarren Reed 		free_family = B_TRUE;
12727ddc9b1aSDarren Reed 	} else {
12737ddc9b1aSDarren Reed 		free_family = B_FALSE;
12747ddc9b1aSDarren Reed 	}
12757ddc9b1aSDarren Reed 
12764a9b8375SDarren Reed 	if (error == 0 && !free_family) {
12774a9b8375SDarren Reed 		canrun = (hook_wait_setflag(&hfi->hfi_waiter, FWF_ADD_WAIT_MASK,
12784a9b8375SDarren Reed 		    FWF_ADD_WANTED, FWF_ADD_ACTIVE) != -1);
12794a9b8375SDarren Reed 	}
12804a9b8375SDarren Reed 
12817ddc9b1aSDarren Reed 	CVW_EXIT_WRITE(&hfi->hfi_lock);
12827ddc9b1aSDarren Reed 
12834a9b8375SDarren Reed 	if (canrun) {
12844a9b8375SDarren Reed 		SLIST_FOREACH(hei, &hfi->hfi_head, hei_entry) {
12854a9b8375SDarren Reed 			callback(HN_UNREGISTER, arg,
12864a9b8375SDarren Reed 			    hfi->hfi_family.hf_name, NULL,
12874a9b8375SDarren Reed 			    hei->hei_event->he_name);
12884a9b8375SDarren Reed 		}
12894a9b8375SDarren Reed 
12904a9b8375SDarren Reed 		hook_wait_unsetflag(&hfi->hfi_waiter, FWF_ADD_ACTIVE);
12914a9b8375SDarren Reed 	} else if (free_family) {
12927ddc9b1aSDarren Reed 		hook_family_free(hfi, hfi->hfi_stack);
12934a9b8375SDarren Reed 	}
12947ddc9b1aSDarren Reed 
12957ddc9b1aSDarren Reed 	return (error);
12967ddc9b1aSDarren Reed }
1297381a2a9aSdr 
1298381a2a9aSdr /*
1299381a2a9aSdr  * Function:	hook_event_add
1300381a2a9aSdr  * Returns:	internal event pointer - NULL = Fail
1301381a2a9aSdr  * Parameters:	hfi(I) - internal family pointer
13024a9b8375SDarren Reed  *		he(I)  - event pointer
1303381a2a9aSdr  *
1304381a2a9aSdr  * Add new event to event list on specific family.
1305381a2a9aSdr  * This function can fail to return successfully if (1) it cannot allocate
1306381a2a9aSdr  * enough memory for its own internal data structures, (2) the event has
1307381a2a9aSdr  * already been registered (for any hook family.)
1308381a2a9aSdr  */
1309381a2a9aSdr hook_event_int_t *
hook_event_add(hook_family_int_t * hfi,hook_event_t * he)1310381a2a9aSdr hook_event_add(hook_family_int_t *hfi, hook_event_t *he)
1311381a2a9aSdr {
1312381a2a9aSdr 	hook_event_int_t *hei, *new;
13137ddc9b1aSDarren Reed 	hook_stack_t *hks;
1314381a2a9aSdr 
1315381a2a9aSdr 	ASSERT(hfi != NULL);
1316381a2a9aSdr 	ASSERT(he != NULL);
1317381a2a9aSdr 	ASSERT(he->he_name != NULL);
1318381a2a9aSdr 
1319381a2a9aSdr 	new = hook_event_copy(he);
1320381a2a9aSdr 	if (new == NULL)
1321381a2a9aSdr 		return (NULL);
1322381a2a9aSdr 
13237ddc9b1aSDarren Reed 	hks = hfi->hfi_stack;
13247ddc9b1aSDarren Reed 	CVW_ENTER_READ(&hks->hks_lock);
13257ddc9b1aSDarren Reed 
13267ddc9b1aSDarren Reed 	hks = hfi->hfi_stack;
13277ddc9b1aSDarren Reed 	if (hks->hks_shutdown != 0) {
13287ddc9b1aSDarren Reed 		CVW_EXIT_READ(&hks->hks_lock);
13297ddc9b1aSDarren Reed 		hook_event_free(new, NULL);
13307ddc9b1aSDarren Reed 		return (NULL);
13317ddc9b1aSDarren Reed 	}
1332381a2a9aSdr 
1333381a2a9aSdr 	/* Check whether this event pointer is already registered */
1334f4b3ec61Sdh 	hei = hook_event_checkdup(he, hks);
1335381a2a9aSdr 	if (hei != NULL) {
13367ddc9b1aSDarren Reed 		CVW_EXIT_READ(&hks->hks_lock);
13377ddc9b1aSDarren Reed 		hook_event_free(new, NULL);
1338381a2a9aSdr 		return (NULL);
1339381a2a9aSdr 	}
1340381a2a9aSdr 
13417ddc9b1aSDarren Reed 	CVW_ENTER_WRITE(&hfi->hfi_lock);
13427ddc9b1aSDarren Reed 
13438ad74188SDarren Reed 	if (hfi->hfi_condemned || hfi->hfi_shutdown) {
13447ddc9b1aSDarren Reed 		CVW_EXIT_WRITE(&hfi->hfi_lock);
13457ddc9b1aSDarren Reed 		CVW_EXIT_READ(&hks->hks_lock);
13467ddc9b1aSDarren Reed 		hook_event_free(new, NULL);
13477ddc9b1aSDarren Reed 		return (NULL);
13487ddc9b1aSDarren Reed 	}
13494a9b8375SDarren Reed 	CVW_EXIT_READ(&hks->hks_lock);
13507ddc9b1aSDarren Reed 
13514a9b8375SDarren Reed 	if (hook_wait_setflag(&hfi->hfi_waiter, FWF_ADD_WAIT_MASK,
13527ddc9b1aSDarren Reed 	    FWF_ADD_WANTED, FWF_ADD_ACTIVE) == -1) {
13537ddc9b1aSDarren Reed 		CVW_EXIT_WRITE(&hfi->hfi_lock);
13547ddc9b1aSDarren Reed 		hook_event_free(new, NULL);
13557ddc9b1aSDarren Reed 		return (NULL);
13567ddc9b1aSDarren Reed 	}
13577ddc9b1aSDarren Reed 
13587ddc9b1aSDarren Reed 	TAILQ_INIT(&new->hei_nhead);
13597ddc9b1aSDarren Reed 
13607ddc9b1aSDarren Reed 	hook_event_init_kstats(hfi, new);
13617ddc9b1aSDarren Reed 	hook_wait_init(&new->hei_waiter, &new->hei_lock);
13627ddc9b1aSDarren Reed 
1363381a2a9aSdr 	/* Add to event list head */
1364381a2a9aSdr 	SLIST_INSERT_HEAD(&hfi->hfi_head, new, hei_entry);
1365381a2a9aSdr 
13667ddc9b1aSDarren Reed 	CVW_EXIT_WRITE(&hfi->hfi_lock);
13677ddc9b1aSDarren Reed 
13687ddc9b1aSDarren Reed 	hook_notify_run(&hfi->hfi_nhead,
13697ddc9b1aSDarren Reed 	    hfi->hfi_family.hf_name, NULL, he->he_name, HN_REGISTER);
13707ddc9b1aSDarren Reed 
13717ddc9b1aSDarren Reed 	hook_wait_unsetflag(&hfi->hfi_waiter, FWF_ADD_ACTIVE);
13727ddc9b1aSDarren Reed 
1373381a2a9aSdr 	return (new);
1374381a2a9aSdr }
1375381a2a9aSdr 
1376381a2a9aSdr /*
13777ddc9b1aSDarren Reed  * Function:	hook_event_init_kstats
13787ddc9b1aSDarren Reed  * Returns:	None
13797ddc9b1aSDarren Reed  * Parameters:  hfi(I) - pointer to the family that owns this event.
13807ddc9b1aSDarren Reed  *              hei(I) - pointer to the hook event that needs some kstats.
13817ddc9b1aSDarren Reed  *
13827ddc9b1aSDarren Reed  * Create a set of kstats that relate to each event registered with
13837ddc9b1aSDarren Reed  * the hook framework.  A counter is kept for each time the event is
13847ddc9b1aSDarren Reed  * activated and for each time a hook is added or removed.  As the
13857ddc9b1aSDarren Reed  * kstats just count the events as they happen, the total number of
13867ddc9b1aSDarren Reed  * hooks registered must be obtained by subtractived removed from added.
13877ddc9b1aSDarren Reed  */
13887ddc9b1aSDarren Reed static void
hook_event_init_kstats(hook_family_int_t * hfi,hook_event_int_t * hei)13897ddc9b1aSDarren Reed hook_event_init_kstats(hook_family_int_t *hfi, hook_event_int_t *hei)
13907ddc9b1aSDarren Reed {
13917ddc9b1aSDarren Reed 	hook_event_kstat_t template = {
13927ddc9b1aSDarren Reed 		{ "hooksAdded",		KSTAT_DATA_UINT64 },
13937ddc9b1aSDarren Reed 		{ "hooksRemoved",	KSTAT_DATA_UINT64 },
13947ddc9b1aSDarren Reed 		{ "events",		KSTAT_DATA_UINT64 }
13957ddc9b1aSDarren Reed 	};
13967ddc9b1aSDarren Reed 	hook_stack_t *hks;
13977ddc9b1aSDarren Reed 
13987ddc9b1aSDarren Reed 	hks = hfi->hfi_stack;
13997ddc9b1aSDarren Reed 	hei->hei_kstatp = kstat_create_netstack(hfi->hfi_family.hf_name, 0,
14007ddc9b1aSDarren Reed 	    hei->hei_event->he_name, "hook_event", KSTAT_TYPE_NAMED,
14017ddc9b1aSDarren Reed 	    sizeof (hei->hei_kstats) / sizeof (kstat_named_t),
14027ddc9b1aSDarren Reed 	    KSTAT_FLAG_VIRTUAL, hks->hks_netstackid);
14037ddc9b1aSDarren Reed 
14047ddc9b1aSDarren Reed 	bcopy((char *)&template, &hei->hei_kstats, sizeof (template));
14057ddc9b1aSDarren Reed 
14067ddc9b1aSDarren Reed 	if (hei->hei_kstatp != NULL) {
14077ddc9b1aSDarren Reed 		hei->hei_kstatp->ks_data = (void *)&hei->hei_kstats;
14087ddc9b1aSDarren Reed 		hei->hei_kstatp->ks_private =
14097ddc9b1aSDarren Reed 		    (void *)(uintptr_t)hks->hks_netstackid;
14107ddc9b1aSDarren Reed 
14117ddc9b1aSDarren Reed 		kstat_install(hei->hei_kstatp);
14127ddc9b1aSDarren Reed 	}
14137ddc9b1aSDarren Reed }
14147ddc9b1aSDarren Reed 
14157ddc9b1aSDarren Reed /*
14167ddc9b1aSDarren Reed  * Function:	hook_event_remove
14174a9b8375SDarren Reed  * Returns:	int    - 0 = success, else = failure
1418381a2a9aSdr  * Parameters:	hfi(I) - internal family pointer
14194a9b8375SDarren Reed  *		he(I)  - event pointer
1420381a2a9aSdr  *
1421381a2a9aSdr  * Remove event from event list on specific family
14227ddc9b1aSDarren Reed  *
14237ddc9b1aSDarren Reed  * This function assumes that the caller has received a pointer to a the
14247ddc9b1aSDarren Reed  * hook_family_int_t via a call to net_protocol_lookup or net_protocol_unreg'.
14257ddc9b1aSDarren Reed  * This the hook_family_int_t is guaranteed to be around for the life of this
14267ddc9b1aSDarren Reed  * call, unless the caller has decided to call net_protocol_release or
14277ddc9b1aSDarren Reed  * net_protocol_unregister before calling net_event_unregister - an error.
1428381a2a9aSdr  */
1429381a2a9aSdr int
hook_event_remove(hook_family_int_t * hfi,hook_event_t * he)1430381a2a9aSdr hook_event_remove(hook_family_int_t *hfi, hook_event_t *he)
1431381a2a9aSdr {
14327ddc9b1aSDarren Reed 	boolean_t free_family;
1433381a2a9aSdr 	hook_event_int_t *hei;
14348ad74188SDarren Reed 	boolean_t notifydone;
1435381a2a9aSdr 
1436381a2a9aSdr 	ASSERT(hfi != NULL);
1437381a2a9aSdr 	ASSERT(he != NULL);
1438381a2a9aSdr 
14397ddc9b1aSDarren Reed 	CVW_ENTER_WRITE(&hfi->hfi_lock);
14407ddc9b1aSDarren Reed 
14417ddc9b1aSDarren Reed 	/*
14427ddc9b1aSDarren Reed 	 * Set the flag so that we can call hook_event_notify_run without
14437ddc9b1aSDarren Reed 	 * holding any locks but at the same time prevent other changes to
14447ddc9b1aSDarren Reed 	 * the event at the same time.
14457ddc9b1aSDarren Reed 	 */
14464a9b8375SDarren Reed 	if (hook_wait_setflag(&hfi->hfi_waiter, FWF_DEL_WAIT_MASK,
14477ddc9b1aSDarren Reed 	    FWF_DEL_WANTED, FWF_DEL_ACTIVE) == -1) {
14487ddc9b1aSDarren Reed 		CVW_EXIT_WRITE(&hfi->hfi_lock);
14497ddc9b1aSDarren Reed 		return (ENXIO);
14507ddc9b1aSDarren Reed 	}
1451381a2a9aSdr 
1452381a2a9aSdr 	hei = hook_event_find(hfi, he->he_name);
1453381a2a9aSdr 	if (hei == NULL) {
14547ddc9b1aSDarren Reed 		hook_wait_unsetflag(&hfi->hfi_waiter, FWF_DEL_ACTIVE);
14557ddc9b1aSDarren Reed 		CVW_EXIT_WRITE(&hfi->hfi_lock);
14567ddc9b1aSDarren Reed 		return (ESRCH);
1457381a2a9aSdr 	}
1458381a2a9aSdr 
14597ddc9b1aSDarren Reed 	free_family = B_FALSE;
14607ddc9b1aSDarren Reed 
14617ddc9b1aSDarren Reed 	CVW_ENTER_WRITE(&hei->hei_lock);
14628ad74188SDarren Reed 	/*
14638ad74188SDarren Reed 	 * The hei_shutdown flag is used to indicate whether or not we have
14648ad74188SDarren Reed 	 * done a shutdown and thus already walked through the notify list.
14658ad74188SDarren Reed 	 */
14668ad74188SDarren Reed 	notifydone = hei->hei_shutdown;
14678ad74188SDarren Reed 	hei->hei_shutdown = B_TRUE;
14687ddc9b1aSDarren Reed 	/*
14697ddc9b1aSDarren Reed 	 * If there are any hooks still registered for this event or
14707ddc9b1aSDarren Reed 	 * there are any notifiers registered, return an error indicating
14717ddc9b1aSDarren Reed 	 * that the event is still busy.
14727ddc9b1aSDarren Reed 	 */
14737ddc9b1aSDarren Reed 	if (!TAILQ_EMPTY(&hei->hei_head) || !TAILQ_EMPTY(&hei->hei_nhead)) {
14747ddc9b1aSDarren Reed 		hei->hei_condemned = B_TRUE;
14757ddc9b1aSDarren Reed 		CVW_EXIT_WRITE(&hei->hei_lock);
14767ddc9b1aSDarren Reed 	} else {
14777ddc9b1aSDarren Reed 		/* hei_condemned = B_FALSE is implied from creation */
14787ddc9b1aSDarren Reed 		/*
14797ddc9b1aSDarren Reed 		 * Even though we know the notify list is empty, we call
14807ddc9b1aSDarren Reed 		 * hook_wait_destroy here to synchronise wait removing a
14817ddc9b1aSDarren Reed 		 * hook from an event.
14827ddc9b1aSDarren Reed 		 */
14834a9b8375SDarren Reed 		VERIFY(hook_wait_destroy(&hei->hei_waiter) == 0);
14847ddc9b1aSDarren Reed 
14857ddc9b1aSDarren Reed 		CVW_EXIT_WRITE(&hei->hei_lock);
14867ddc9b1aSDarren Reed 
14877ddc9b1aSDarren Reed 		if (hfi->hfi_condemned && SLIST_EMPTY(&hfi->hfi_head) &&
14887ddc9b1aSDarren Reed 		    TAILQ_EMPTY(&hfi->hfi_nhead))
14897ddc9b1aSDarren Reed 			free_family = B_TRUE;
1490381a2a9aSdr 	}
1491381a2a9aSdr 
14927ddc9b1aSDarren Reed 	CVW_EXIT_WRITE(&hfi->hfi_lock);
14937ddc9b1aSDarren Reed 
14948ad74188SDarren Reed 	if (!notifydone)
14958ad74188SDarren Reed 		hook_notify_run(&hfi->hfi_nhead,
14968ad74188SDarren Reed 		    hfi->hfi_family.hf_name, NULL, he->he_name, HN_UNREGISTER);
1497381a2a9aSdr 
14987ddc9b1aSDarren Reed 	hook_wait_unsetflag(&hfi->hfi_waiter, FWF_DEL_ACTIVE);
14997ddc9b1aSDarren Reed 
15007ddc9b1aSDarren Reed 	if (!hei->hei_condemned) {
15017ddc9b1aSDarren Reed 		hook_event_free(hei, hfi);
15027ddc9b1aSDarren Reed 		if (free_family)
15037ddc9b1aSDarren Reed 			hook_family_free(hfi, hfi->hfi_stack);
15047ddc9b1aSDarren Reed 	}
1505381a2a9aSdr 
1506381a2a9aSdr 	return (0);
1507381a2a9aSdr }
1508381a2a9aSdr 
15098ad74188SDarren Reed /*
15108ad74188SDarren Reed  * Function:	hook_event_shutdown
15114a9b8375SDarren Reed  * Returns:	int    - 0 = success, else = failure
15128ad74188SDarren Reed  * Parameters:	hfi(I) - internal family pointer
15138ad74188SDarren Reed  *		he(I)  - event pointer
15148ad74188SDarren Reed  *
15158ad74188SDarren Reed  * As with hook_family_shutdown, we want to generate the notify callbacks
15168ad74188SDarren Reed  * as if the event was being removed but not actually do the remove.
15178ad74188SDarren Reed  */
15188ad74188SDarren Reed int
hook_event_shutdown(hook_family_int_t * hfi,hook_event_t * he)15198ad74188SDarren Reed hook_event_shutdown(hook_family_int_t *hfi, hook_event_t *he)
15208ad74188SDarren Reed {
15218ad74188SDarren Reed 	hook_event_int_t *hei;
15228ad74188SDarren Reed 	boolean_t notifydone;
15238ad74188SDarren Reed 
15248ad74188SDarren Reed 	ASSERT(hfi != NULL);
15258ad74188SDarren Reed 	ASSERT(he != NULL);
15268ad74188SDarren Reed 
15278ad74188SDarren Reed 	CVW_ENTER_WRITE(&hfi->hfi_lock);
15288ad74188SDarren Reed 
15298ad74188SDarren Reed 	/*
15308ad74188SDarren Reed 	 * Set the flag so that we can call hook_event_notify_run without
15318ad74188SDarren Reed 	 * holding any locks but at the same time prevent other changes to
15328ad74188SDarren Reed 	 * the event at the same time.
15338ad74188SDarren Reed 	 */
15344a9b8375SDarren Reed 	if (hook_wait_setflag(&hfi->hfi_waiter, FWF_DEL_WAIT_MASK,
15358ad74188SDarren Reed 	    FWF_DEL_WANTED, FWF_DEL_ACTIVE) == -1) {
15368ad74188SDarren Reed 		CVW_EXIT_WRITE(&hfi->hfi_lock);
15378ad74188SDarren Reed 		return (ENXIO);
15388ad74188SDarren Reed 	}
15398ad74188SDarren Reed 
15408ad74188SDarren Reed 	hei = hook_event_find(hfi, he->he_name);
15418ad74188SDarren Reed 	if (hei == NULL) {
15428ad74188SDarren Reed 		hook_wait_unsetflag(&hfi->hfi_waiter, FWF_DEL_ACTIVE);
15438ad74188SDarren Reed 		CVW_EXIT_WRITE(&hfi->hfi_lock);
15448ad74188SDarren Reed 		return (ESRCH);
15458ad74188SDarren Reed 	}
15468ad74188SDarren Reed 
15478ad74188SDarren Reed 	CVW_ENTER_WRITE(&hei->hei_lock);
15488ad74188SDarren Reed 	notifydone = hei->hei_shutdown;
15498ad74188SDarren Reed 	hei->hei_shutdown = B_TRUE;
15508ad74188SDarren Reed 	CVW_EXIT_WRITE(&hei->hei_lock);
15518ad74188SDarren Reed 
15528ad74188SDarren Reed 	CVW_EXIT_WRITE(&hfi->hfi_lock);
15538ad74188SDarren Reed 
15548ad74188SDarren Reed 	if (!notifydone)
15558ad74188SDarren Reed 		hook_notify_run(&hfi->hfi_nhead,
15568ad74188SDarren Reed 		    hfi->hfi_family.hf_name, NULL, he->he_name, HN_UNREGISTER);
15578ad74188SDarren Reed 
15588ad74188SDarren Reed 	hook_wait_unsetflag(&hfi->hfi_waiter, FWF_DEL_ACTIVE);
15598ad74188SDarren Reed 
15608ad74188SDarren Reed 	return (0);
15618ad74188SDarren Reed }
15628ad74188SDarren Reed 
15637ddc9b1aSDarren Reed /*
15647ddc9b1aSDarren Reed  * Function:	hook_event_free
15657ddc9b1aSDarren Reed  * Returns:	None
15667ddc9b1aSDarren Reed  * Parameters:	hei(I) - internal event pointer
15677ddc9b1aSDarren Reed  *
15687ddc9b1aSDarren Reed  * Free alloc memory for event
15697ddc9b1aSDarren Reed  */
15707ddc9b1aSDarren Reed static void
hook_event_free(hook_event_int_t * hei,hook_family_int_t * hfi)15717ddc9b1aSDarren Reed hook_event_free(hook_event_int_t *hei, hook_family_int_t *hfi)
15727ddc9b1aSDarren Reed {
15737ddc9b1aSDarren Reed 	boolean_t free_family;
15747ddc9b1aSDarren Reed 
15757ddc9b1aSDarren Reed 	ASSERT(hei != NULL);
15767ddc9b1aSDarren Reed 
15777ddc9b1aSDarren Reed 	if (hfi != NULL) {
15787ddc9b1aSDarren Reed 		CVW_ENTER_WRITE(&hfi->hfi_lock);
15797ddc9b1aSDarren Reed 		/*
15807ddc9b1aSDarren Reed 		 * Remove the event from the hook family's list.
15817ddc9b1aSDarren Reed 		 */
15827ddc9b1aSDarren Reed 		SLIST_REMOVE(&hfi->hfi_head, hei, hook_event_int, hei_entry);
15837ddc9b1aSDarren Reed 		if (hfi->hfi_condemned && SLIST_EMPTY(&hfi->hfi_head) &&
15847ddc9b1aSDarren Reed 		    TAILQ_EMPTY(&hfi->hfi_nhead)) {
15857ddc9b1aSDarren Reed 			free_family = B_TRUE;
15867ddc9b1aSDarren Reed 		} else {
15877ddc9b1aSDarren Reed 			free_family = B_FALSE;
15887ddc9b1aSDarren Reed 		}
15897ddc9b1aSDarren Reed 		CVW_EXIT_WRITE(&hfi->hfi_lock);
15907ddc9b1aSDarren Reed 	}
15917ddc9b1aSDarren Reed 
15927ddc9b1aSDarren Reed 	if (hei->hei_kstatp != NULL) {
15937ddc9b1aSDarren Reed 		ASSERT(hfi != NULL);
15947ddc9b1aSDarren Reed 
15957ddc9b1aSDarren Reed 		kstat_delete_netstack(hei->hei_kstatp,
15967ddc9b1aSDarren Reed 		    hfi->hfi_stack->hks_netstackid);
15977ddc9b1aSDarren Reed 		hei->hei_kstatp = NULL;
15987ddc9b1aSDarren Reed 	}
15997ddc9b1aSDarren Reed 
16007ddc9b1aSDarren Reed 	/* Free container */
16017ddc9b1aSDarren Reed 	kmem_free(hei, sizeof (*hei));
16027ddc9b1aSDarren Reed 
16037ddc9b1aSDarren Reed 	if (free_family)
16047ddc9b1aSDarren Reed 		hook_family_free(hfi, hfi->hfi_stack);
16057ddc9b1aSDarren Reed }
1606381a2a9aSdr 
1607381a2a9aSdr /*
1608381a2a9aSdr  * Function:    hook_event_checkdup
1609381a2a9aSdr  * Returns:     internal event pointer - NULL = Not match
1610381a2a9aSdr  * Parameters:  he(I) - event pointer
1611381a2a9aSdr  *
16127ddc9b1aSDarren Reed  * Search all of the hook families to see if the event being passed in
16137ddc9b1aSDarren Reed  * has already been associated with one.
1614381a2a9aSdr  */
1615381a2a9aSdr static hook_event_int_t *
hook_event_checkdup(hook_event_t * he,hook_stack_t * hks)1616f4b3ec61Sdh hook_event_checkdup(hook_event_t *he, hook_stack_t *hks)
1617381a2a9aSdr {
1618381a2a9aSdr 	hook_family_int_t *hfi;
1619381a2a9aSdr 	hook_event_int_t *hei;
1620381a2a9aSdr 
1621381a2a9aSdr 	ASSERT(he != NULL);
1622381a2a9aSdr 
16237ddc9b1aSDarren Reed 	CVW_ENTER_READ(&hks->hks_lock);
1624f4b3ec61Sdh 	SLIST_FOREACH(hfi, &hks->hks_familylist, hfi_entry) {
1625381a2a9aSdr 		SLIST_FOREACH(hei, &hfi->hfi_head, hei_entry) {
16267ddc9b1aSDarren Reed 			if (hei->hei_event == he) {
16277ddc9b1aSDarren Reed 				CVW_EXIT_READ(&hks->hks_lock);
1628381a2a9aSdr 				return (hei);
16297ddc9b1aSDarren Reed 			}
1630381a2a9aSdr 		}
1631381a2a9aSdr 	}
16327ddc9b1aSDarren Reed 	CVW_EXIT_READ(&hks->hks_lock);
1633381a2a9aSdr 
1634381a2a9aSdr 	return (NULL);
1635381a2a9aSdr }
1636381a2a9aSdr 
1637381a2a9aSdr /*
1638381a2a9aSdr  * Function:	hook_event_copy
1639381a2a9aSdr  * Returns:	internal event pointer - NULL = Failed
1640381a2a9aSdr  * Parameters:	src(I) - event pointer
1641381a2a9aSdr  *
1642381a2a9aSdr  * Allocate internal event block and duplicate incoming event
1643381a2a9aSdr  * No locks should be held across this function as it may sleep.
1644381a2a9aSdr  */
1645381a2a9aSdr static hook_event_int_t *
hook_event_copy(hook_event_t * src)1646381a2a9aSdr hook_event_copy(hook_event_t *src)
1647381a2a9aSdr {
1648381a2a9aSdr 	hook_event_int_t *new;
1649381a2a9aSdr 
1650381a2a9aSdr 	ASSERT(src != NULL);
1651381a2a9aSdr 	ASSERT(src->he_name != NULL);
1652381a2a9aSdr 
1653381a2a9aSdr 	new = (hook_event_int_t *)kmem_zalloc(sizeof (*new), KM_SLEEP);
1654381a2a9aSdr 
1655381a2a9aSdr 	/* Copy body */
1656381a2a9aSdr 	TAILQ_INIT(&new->hei_head);
1657381a2a9aSdr 	new->hei_event = src;
1658381a2a9aSdr 
1659381a2a9aSdr 	return (new);
1660381a2a9aSdr }
1661381a2a9aSdr 
1662381a2a9aSdr /*
1663381a2a9aSdr  * Function:	hook_event_find
1664381a2a9aSdr  * Returns:	internal event pointer - NULL = Not match
16654a9b8375SDarren Reed  * Parameters:	hfi(I)   - internal family pointer
1666381a2a9aSdr  *		event(I) - event name string
1667381a2a9aSdr  *
1668381a2a9aSdr  * Search event list with event name
166968c34d04SJason King  *	A lock on hfi->hfi_lock must be held when called.
1670381a2a9aSdr  */
1671381a2a9aSdr static hook_event_int_t *
hook_event_find(hook_family_int_t * hfi,char * event)1672381a2a9aSdr hook_event_find(hook_family_int_t *hfi, char *event)
1673381a2a9aSdr {
1674381a2a9aSdr 	hook_event_int_t *hei = NULL;
1675381a2a9aSdr 
1676381a2a9aSdr 	ASSERT(hfi != NULL);
1677381a2a9aSdr 	ASSERT(event != NULL);
1678381a2a9aSdr 
1679381a2a9aSdr 	SLIST_FOREACH(hei, &hfi->hfi_head, hei_entry) {
16807ddc9b1aSDarren Reed 		if ((strcmp(hei->hei_event->he_name, event) == 0) &&
16817ddc9b1aSDarren Reed 		    ((hei->hei_waiter.fw_flags & FWF_UNSAFE) == 0))
1682381a2a9aSdr 			break;
1683381a2a9aSdr 	}
1684381a2a9aSdr 	return (hei);
1685381a2a9aSdr }
1686381a2a9aSdr 
16877ddc9b1aSDarren Reed /*
16887ddc9b1aSDarren Reed  * Function:	hook_event_notify_register
16894a9b8375SDarren Reed  * Returns:	int         - 0 = success, else failure
16907ddc9b1aSDarren Reed  * Parameters:	hfi(I)      - hook family
16917ddc9b1aSDarren Reed  *              event(I)    - name of the event
16927ddc9b1aSDarren Reed  *              callback(I) - function to be called
16937ddc9b1aSDarren Reed  *              arg(I)      - arg to provide callback when it is called
16947ddc9b1aSDarren Reed  *
16957ddc9b1aSDarren Reed  * Adds a new callback to the event named by "event" (we must find it)
16967ddc9b1aSDarren Reed  * that will be executed each time a new hook is added to the event.
16977ddc9b1aSDarren Reed  * Of course, if the stack is being shut down, this call should fail.
16987ddc9b1aSDarren Reed  */
16997ddc9b1aSDarren Reed int
hook_event_notify_register(hook_family_int_t * hfi,char * event,hook_notify_fn_t callback,void * arg)17007ddc9b1aSDarren Reed hook_event_notify_register(hook_family_int_t *hfi, char *event,
17017ddc9b1aSDarren Reed     hook_notify_fn_t callback, void *arg)
17027ddc9b1aSDarren Reed {
17037ddc9b1aSDarren Reed 	hook_event_int_t *hei;
17047ddc9b1aSDarren Reed 	hook_stack_t *hks;
17054a9b8375SDarren Reed 	boolean_t canrun;
17064a9b8375SDarren Reed 	hook_int_t *h;
17077ddc9b1aSDarren Reed 	int error;
17087ddc9b1aSDarren Reed 
17094a9b8375SDarren Reed 	canrun = B_FALSE;
17107ddc9b1aSDarren Reed 	hks = hfi->hfi_stack;
17117ddc9b1aSDarren Reed 	CVW_ENTER_READ(&hks->hks_lock);
17127ddc9b1aSDarren Reed 	if (hks->hks_shutdown != 0) {
17137ddc9b1aSDarren Reed 		CVW_EXIT_READ(&hks->hks_lock);
17147ddc9b1aSDarren Reed 		return (ESHUTDOWN);
17157ddc9b1aSDarren Reed 	}
17167ddc9b1aSDarren Reed 
17177ddc9b1aSDarren Reed 	CVW_ENTER_READ(&hfi->hfi_lock);
17187ddc9b1aSDarren Reed 
17198ad74188SDarren Reed 	if (hfi->hfi_condemned || hfi->hfi_shutdown) {
17207ddc9b1aSDarren Reed 		CVW_EXIT_READ(&hfi->hfi_lock);
17217ddc9b1aSDarren Reed 		CVW_EXIT_READ(&hks->hks_lock);
17227ddc9b1aSDarren Reed 		return (ESHUTDOWN);
17237ddc9b1aSDarren Reed 	}
17247ddc9b1aSDarren Reed 
17257ddc9b1aSDarren Reed 	hei = hook_event_find(hfi, event);
17267ddc9b1aSDarren Reed 	if (hei == NULL) {
17277ddc9b1aSDarren Reed 		CVW_EXIT_READ(&hfi->hfi_lock);
17287ddc9b1aSDarren Reed 		CVW_EXIT_READ(&hks->hks_lock);
17297ddc9b1aSDarren Reed 		return (ESRCH);
17307ddc9b1aSDarren Reed 	}
17317ddc9b1aSDarren Reed 
17328ad74188SDarren Reed 	if (hei->hei_condemned || hei->hei_shutdown) {
17337ddc9b1aSDarren Reed 		CVW_EXIT_READ(&hfi->hfi_lock);
17347ddc9b1aSDarren Reed 		CVW_EXIT_READ(&hks->hks_lock);
17357ddc9b1aSDarren Reed 		return (ESHUTDOWN);
17367ddc9b1aSDarren Reed 	}
17377ddc9b1aSDarren Reed 
17384a9b8375SDarren Reed 	CVW_ENTER_WRITE(&hei->hei_lock);
17394a9b8375SDarren Reed 	canrun = (hook_wait_setflag(&hei->hei_waiter, FWF_ADD_WAIT_MASK,
17404a9b8375SDarren Reed 	    FWF_ADD_WANTED, FWF_ADD_ACTIVE) != -1);
17414a9b8375SDarren Reed 	error = hook_notify_register(&hei->hei_nhead, callback, arg);
17427ddc9b1aSDarren Reed 	CVW_EXIT_WRITE(&hei->hei_lock);
17434a9b8375SDarren Reed 
17447ddc9b1aSDarren Reed 	CVW_EXIT_READ(&hfi->hfi_lock);
17457ddc9b1aSDarren Reed 	CVW_EXIT_READ(&hks->hks_lock);
17467ddc9b1aSDarren Reed 
17474a9b8375SDarren Reed 	if (error == 0 && canrun) {
17484a9b8375SDarren Reed 		TAILQ_FOREACH(h, &hei->hei_head, hi_entry) {
17494a9b8375SDarren Reed 			callback(HN_REGISTER, arg,
17504a9b8375SDarren Reed 			    hfi->hfi_family.hf_name, hei->hei_event->he_name,
17514a9b8375SDarren Reed 			    h->hi_hook.h_name);
17524a9b8375SDarren Reed 		}
17534a9b8375SDarren Reed 	}
17544a9b8375SDarren Reed 
17554a9b8375SDarren Reed 	if (canrun)
17564a9b8375SDarren Reed 		hook_wait_unsetflag(&hei->hei_waiter, FWF_ADD_ACTIVE);
17574a9b8375SDarren Reed 
17587ddc9b1aSDarren Reed 	return (error);
17597ddc9b1aSDarren Reed }
1760381a2a9aSdr 
1761381a2a9aSdr /*
17627ddc9b1aSDarren Reed  * Function:	hook_event_notify_unregister
17634a9b8375SDarren Reed  * Returns:	int         - 0 = success, else failure
17647ddc9b1aSDarren Reed  * Parameters:	hfi(I)      - hook family
17657ddc9b1aSDarren Reed  *              event(I)    - name of the event
17667ddc9b1aSDarren Reed  *              callback(I) - function to be called
17677ddc9b1aSDarren Reed  *
17687ddc9b1aSDarren Reed  * Remove the given callback from the named event's list of functions
17697ddc9b1aSDarren Reed  * to call when a hook is added or removed.
17707ddc9b1aSDarren Reed  */
17717ddc9b1aSDarren Reed int
hook_event_notify_unregister(hook_family_int_t * hfi,char * event,hook_notify_fn_t callback)17727ddc9b1aSDarren Reed hook_event_notify_unregister(hook_family_int_t *hfi, char *event,
17737ddc9b1aSDarren Reed     hook_notify_fn_t callback)
17747ddc9b1aSDarren Reed {
17757ddc9b1aSDarren Reed 	hook_event_int_t *hei;
17767ddc9b1aSDarren Reed 	boolean_t free_event;
17774a9b8375SDarren Reed 	boolean_t canrun;
17784a9b8375SDarren Reed 	hook_int_t *h;
17794a9b8375SDarren Reed 	void *arg;
17807ddc9b1aSDarren Reed 	int error;
17817ddc9b1aSDarren Reed 
17824a9b8375SDarren Reed 	canrun = B_FALSE;
17834a9b8375SDarren Reed 
17847ddc9b1aSDarren Reed 	CVW_ENTER_READ(&hfi->hfi_lock);
17857ddc9b1aSDarren Reed 
17867ddc9b1aSDarren Reed 	hei = hook_event_find(hfi, event);
17877ddc9b1aSDarren Reed 	if (hei == NULL) {
17887ddc9b1aSDarren Reed 		CVW_EXIT_READ(&hfi->hfi_lock);
17897ddc9b1aSDarren Reed 		return (ESRCH);
17907ddc9b1aSDarren Reed 	}
17917ddc9b1aSDarren Reed 
17927ddc9b1aSDarren Reed 	CVW_ENTER_WRITE(&hei->hei_lock);
17937ddc9b1aSDarren Reed 
17944a9b8375SDarren Reed 	(void) hook_wait_setflag(&hei->hei_waiter, FWF_DEL_WAIT_MASK,
17954a9b8375SDarren Reed 	    FWF_DEL_WANTED, FWF_DEL_ACTIVE);
17964a9b8375SDarren Reed 
17974a9b8375SDarren Reed 	error = hook_notify_unregister(&hei->hei_nhead, callback, &arg);
17984a9b8375SDarren Reed 
17994a9b8375SDarren Reed 	hook_wait_unsetflag(&hei->hei_waiter, FWF_DEL_ACTIVE);
18007ddc9b1aSDarren Reed 
18017ddc9b1aSDarren Reed 	/*
18027ddc9b1aSDarren Reed 	 * hei_condemned has been set if someone tried to remove the
18037ddc9b1aSDarren Reed 	 * event but couldn't because there were still things attached to
18047ddc9b1aSDarren Reed 	 * it. Now that we've done a successful remove, if it is now empty
18057ddc9b1aSDarren Reed 	 * then by all rights we should be free'ing it too.  Note that the
18067ddc9b1aSDarren Reed 	 * expectation is that only the caller of hook_event_add will ever
18077ddc9b1aSDarren Reed 	 * call hook_event_remove.
18087ddc9b1aSDarren Reed 	 */
18097ddc9b1aSDarren Reed 	if ((error == 0) && hei->hei_condemned &&
18107ddc9b1aSDarren Reed 	    TAILQ_EMPTY(&hei->hei_head) && TAILQ_EMPTY(&hei->hei_nhead)) {
18117ddc9b1aSDarren Reed 		free_event = B_TRUE;
18127ddc9b1aSDarren Reed 	} else {
18137ddc9b1aSDarren Reed 		free_event = B_FALSE;
18147ddc9b1aSDarren Reed 	}
18157ddc9b1aSDarren Reed 
18164a9b8375SDarren Reed 	if (error == 0 && !free_event) {
18174a9b8375SDarren Reed 		canrun = (hook_wait_setflag(&hei->hei_waiter, FWF_ADD_WAIT_MASK,
18184a9b8375SDarren Reed 		    FWF_ADD_WANTED, FWF_ADD_ACTIVE) != -1);
18194a9b8375SDarren Reed 	}
18204a9b8375SDarren Reed 
18217ddc9b1aSDarren Reed 	CVW_EXIT_WRITE(&hei->hei_lock);
18227ddc9b1aSDarren Reed 	CVW_EXIT_READ(&hfi->hfi_lock);
18237ddc9b1aSDarren Reed 
18244a9b8375SDarren Reed 	if (canrun) {
18254a9b8375SDarren Reed 		TAILQ_FOREACH(h, &hei->hei_head, hi_entry) {
18264a9b8375SDarren Reed 			callback(HN_UNREGISTER, arg,
18274a9b8375SDarren Reed 			    hfi->hfi_family.hf_name, hei->hei_event->he_name,
18284a9b8375SDarren Reed 			    h->hi_hook.h_name);
18294a9b8375SDarren Reed 		}
18304a9b8375SDarren Reed 
18314a9b8375SDarren Reed 		hook_wait_unsetflag(&hei->hei_waiter, FWF_ADD_ACTIVE);
18324a9b8375SDarren Reed 	}
18334a9b8375SDarren Reed 
18347ddc9b1aSDarren Reed 	if (free_event) {
18357ddc9b1aSDarren Reed 		/*
18367ddc9b1aSDarren Reed 		 * It is safe to pass in hfi here, without a lock, because
18377ddc9b1aSDarren Reed 		 * our structure (hei) is still on one of its lists and thus
18387ddc9b1aSDarren Reed 		 * it won't be able to disappear yet...
18397ddc9b1aSDarren Reed 		 */
18407ddc9b1aSDarren Reed 		hook_event_free(hei, hfi);
18417ddc9b1aSDarren Reed 	}
18427ddc9b1aSDarren Reed 
18437ddc9b1aSDarren Reed 	return (error);
18447ddc9b1aSDarren Reed }
18457ddc9b1aSDarren Reed 
18467ddc9b1aSDarren Reed /*
18477ddc9b1aSDarren Reed  * Function:	hook_event_notify_run
1848381a2a9aSdr  * Returns:	None
18497ddc9b1aSDarren Reed  * Parameters:	nrun(I) - pointer to the list of callbacks to execute
18507ddc9b1aSDarren Reed  *              hfi(I)  - hook stack pointer to execute callbacks for
18517ddc9b1aSDarren Reed  *              name(I) - name of a hook family
18527ddc9b1aSDarren Reed  *              cmd(I)  - either HN_UNREGISTER or HN_REGISTER
1853381a2a9aSdr  *
18547ddc9b1aSDarren Reed  * Execute all of the callbacks registered for this event.
1855381a2a9aSdr  */
1856381a2a9aSdr static void
hook_event_notify_run(hook_event_int_t * hei,hook_family_int_t * hfi,char * event,char * name,hook_notify_cmd_t cmd)18577ddc9b1aSDarren Reed hook_event_notify_run(hook_event_int_t *hei, hook_family_int_t *hfi,
18587ddc9b1aSDarren Reed     char *event, char *name, hook_notify_cmd_t cmd)
1859381a2a9aSdr {
1860381a2a9aSdr 
18617ddc9b1aSDarren Reed 	hook_notify_run(&hei->hei_nhead, hfi->hfi_family.hf_name,
18627ddc9b1aSDarren Reed 	    event, name, cmd);
1863381a2a9aSdr }
1864381a2a9aSdr 
1865381a2a9aSdr /*
1866381a2a9aSdr  * Function:	hook_register
18674a9b8375SDarren Reed  * Returns:	int      - 0 = success, else = failure
18684a9b8375SDarren Reed  * Parameters:	hfi(I)   - internal family pointer
1869381a2a9aSdr  *		event(I) - event name string
18704a9b8375SDarren Reed  *		h(I)     - hook pointer
1871381a2a9aSdr  *
18727ddc9b1aSDarren Reed  * Add new hook to hook list on the specified family and event.
1873381a2a9aSdr  */
1874381a2a9aSdr int
hook_register(hook_family_int_t * hfi,char * event,hook_t * h)1875381a2a9aSdr hook_register(hook_family_int_t *hfi, char *event, hook_t *h)
1876381a2a9aSdr {
1877381a2a9aSdr 	hook_event_int_t *hei;
1878381a2a9aSdr 	hook_int_t *hi, *new;
18797ddc9b1aSDarren Reed 	int error;
1880381a2a9aSdr 
1881381a2a9aSdr 	ASSERT(hfi != NULL);
1882381a2a9aSdr 	ASSERT(event != NULL);
1883381a2a9aSdr 	ASSERT(h != NULL);
18847ddc9b1aSDarren Reed 
18857ddc9b1aSDarren Reed 	if (hfi->hfi_stack->hks_shutdown)
188639100352SToomas Soome 		return (0);
1887381a2a9aSdr 
1888381a2a9aSdr 	/* Alloc hook_int_t and copy hook */
1889381a2a9aSdr 	new = hook_copy(h);
1890381a2a9aSdr 	if (new == NULL)
1891381a2a9aSdr 		return (ENOMEM);
1892381a2a9aSdr 
1893381a2a9aSdr 	/*
1894381a2a9aSdr 	 * Since hook add/remove only impact event, so it is unnecessary
1895381a2a9aSdr 	 * to hold global family write lock. Just get read lock here to
1896381a2a9aSdr 	 * ensure event will not be removed when doing hooks operation
1897381a2a9aSdr 	 */
18987ddc9b1aSDarren Reed 	CVW_ENTER_WRITE(&hfi->hfi_lock);
1899381a2a9aSdr 
1900381a2a9aSdr 	hei = hook_event_find(hfi, event);
1901381a2a9aSdr 	if (hei == NULL) {
19027ddc9b1aSDarren Reed 		CVW_EXIT_WRITE(&hfi->hfi_lock);
19037ddc9b1aSDarren Reed 		hook_int_free(new, hfi->hfi_stack->hks_netstackid);
1904381a2a9aSdr 		return (ENXIO);
1905381a2a9aSdr 	}
1906381a2a9aSdr 
1907381a2a9aSdr 	CVW_ENTER_WRITE(&hei->hei_lock);
1908381a2a9aSdr 
19098ad74188SDarren Reed 	/*
19108ad74188SDarren Reed 	 * If we've run either the remove() or shutdown(), do not allow any
19118ad74188SDarren Reed 	 * more hooks to be added to this event.
19128ad74188SDarren Reed 	 */
19138ad74188SDarren Reed 	if (hei->hei_shutdown) {
19148ad74188SDarren Reed 		error = ESHUTDOWN;
19158ad74188SDarren Reed 		goto bad_add;
19168ad74188SDarren Reed 	}
19178ad74188SDarren Reed 
1918381a2a9aSdr 	hi = hook_find(hei, h);
1919381a2a9aSdr 	if (hi != NULL) {
19207ddc9b1aSDarren Reed 		error = EEXIST;
19217ddc9b1aSDarren Reed 		goto bad_add;
19227ddc9b1aSDarren Reed 	}
19237ddc9b1aSDarren Reed 
19244a9b8375SDarren Reed 	if (hook_wait_setflag(&hei->hei_waiter, FWF_ADD_WAIT_MASK,
19257ddc9b1aSDarren Reed 	    FWF_ADD_WANTED, FWF_ADD_ACTIVE) == -1) {
19267ddc9b1aSDarren Reed 		error = ENOENT;
19277ddc9b1aSDarren Reed bad_add:
1928381a2a9aSdr 		CVW_EXIT_WRITE(&hei->hei_lock);
19297ddc9b1aSDarren Reed 		CVW_EXIT_WRITE(&hfi->hfi_lock);
19307ddc9b1aSDarren Reed 		hook_int_free(new, hfi->hfi_stack->hks_netstackid);
19317ddc9b1aSDarren Reed 		return (error);
1932381a2a9aSdr 	}
1933381a2a9aSdr 
1934381a2a9aSdr 	/* Add to hook list head */
19357ddc9b1aSDarren Reed 	error = hook_insert(&hei->hei_head, new);
19367ddc9b1aSDarren Reed 	if (error == 0) {
19377ddc9b1aSDarren Reed 		hei->hei_event->he_interested = B_TRUE;
19387ddc9b1aSDarren Reed 		hei->hei_kstats.hooks_added.value.ui64++;
19397ddc9b1aSDarren Reed 
19407ddc9b1aSDarren Reed 		hook_init_kstats(hfi, hei, new);
19417ddc9b1aSDarren Reed 	}
1942381a2a9aSdr 
1943381a2a9aSdr 	CVW_EXIT_WRITE(&hei->hei_lock);
19447ddc9b1aSDarren Reed 	CVW_EXIT_WRITE(&hfi->hfi_lock);
19457ddc9b1aSDarren Reed 
19467ddc9b1aSDarren Reed 	/*
19477ddc9b1aSDarren Reed 	 * Note that the name string passed through to the notify callbacks
19487ddc9b1aSDarren Reed 	 * is from the original hook being registered, not the copy being
19497ddc9b1aSDarren Reed 	 * inserted.
19507ddc9b1aSDarren Reed 	 */
19514a9b8375SDarren Reed 	if (error == 0)
19527ddc9b1aSDarren Reed 		hook_event_notify_run(hei, hfi, event, h->h_name, HN_REGISTER);
19534a9b8375SDarren Reed 
19544a9b8375SDarren Reed 	hook_wait_unsetflag(&hei->hei_waiter, FWF_ADD_ACTIVE);
19557ddc9b1aSDarren Reed 
19567ddc9b1aSDarren Reed 	return (error);
19577ddc9b1aSDarren Reed }
19587ddc9b1aSDarren Reed 
19597ddc9b1aSDarren Reed /*
19607ddc9b1aSDarren Reed  * Function:	hook_insert
19614a9b8375SDarren Reed  * Returns:	int     - 0 = success, else = failure
19627ddc9b1aSDarren Reed  * Parameters:	head(I) - pointer to hook list to insert hook onto
19637ddc9b1aSDarren Reed  *		new(I)  - pointer to hook to be inserted
19647ddc9b1aSDarren Reed  *
19657ddc9b1aSDarren Reed  * Try to insert the hook onto the list of hooks according to the hints
19667ddc9b1aSDarren Reed  * given in the hook to be inserted and those that already exist on the
19677ddc9b1aSDarren Reed  * list.  For now, the implementation permits only a single hook to be
19687ddc9b1aSDarren Reed  * either first or last and names provided with before or after are only
19697ddc9b1aSDarren Reed  * loosely coupled with the action.
19707ddc9b1aSDarren Reed  */
19717ddc9b1aSDarren Reed static int
hook_insert(hook_int_head_t * head,hook_int_t * new)19727ddc9b1aSDarren Reed hook_insert(hook_int_head_t *head, hook_int_t *new)
19737ddc9b1aSDarren Reed {
19747ddc9b1aSDarren Reed 	hook_int_t *before;
19757ddc9b1aSDarren Reed 	hook_int_t *hi;
19767ddc9b1aSDarren Reed 	hook_t *hih;
19777ddc9b1aSDarren Reed 	hook_t *h = &new->hi_hook;
19787ddc9b1aSDarren Reed 
19797ddc9b1aSDarren Reed 	switch (new->hi_hook.h_hint) {
19807ddc9b1aSDarren Reed 	case HH_NONE :
19817ddc9b1aSDarren Reed 		before = NULL;
19827ddc9b1aSDarren Reed 		/*
19837ddc9b1aSDarren Reed 		 * If there is no hint present (or not one that can be
19847ddc9b1aSDarren Reed 		 * satisfied now) then try to at least respect the wishes
19857ddc9b1aSDarren Reed 		 * of those that want to be last.  If there are none wanting
19867ddc9b1aSDarren Reed 		 * to be last then add the new hook to the tail of the
19877ddc9b1aSDarren Reed 		 * list - this means we keep any wanting to be first
19887ddc9b1aSDarren Reed 		 * happy without having to search for HH_FIRST.
19897ddc9b1aSDarren Reed 		 */
19907ddc9b1aSDarren Reed 		TAILQ_FOREACH(hi, head, hi_entry) {
19917ddc9b1aSDarren Reed 			hih = &hi->hi_hook;
19927ddc9b1aSDarren Reed 			if ((hih->h_hint == HH_AFTER) &&
19937ddc9b1aSDarren Reed 			    (strcmp(h->h_name,
19947ddc9b1aSDarren Reed 			    (char *)hih->h_hintvalue) == 0)) {
19957ddc9b1aSDarren Reed 				TAILQ_INSERT_BEFORE(hi, new, hi_entry);
19967ddc9b1aSDarren Reed 				return (0);
19977ddc9b1aSDarren Reed 			}
19987ddc9b1aSDarren Reed 			if ((hih->h_hint == HH_BEFORE) && (before == NULL) &&
19997ddc9b1aSDarren Reed 			    (strcmp(h->h_name,
20007ddc9b1aSDarren Reed 			    (char *)hih->h_hintvalue) == 0)) {
20017ddc9b1aSDarren Reed 				before = hi;
20027ddc9b1aSDarren Reed 			}
20037ddc9b1aSDarren Reed 		}
20047ddc9b1aSDarren Reed 		if (before != NULL) {
20057ddc9b1aSDarren Reed 			TAILQ_INSERT_AFTER(head, before, new, hi_entry);
20067ddc9b1aSDarren Reed 			return (0);
20077ddc9b1aSDarren Reed 		}
20087ddc9b1aSDarren Reed 		hook_insert_plain(head, new);
20097ddc9b1aSDarren Reed 		break;
20107ddc9b1aSDarren Reed 
20117ddc9b1aSDarren Reed 	case HH_FIRST :
20127ddc9b1aSDarren Reed 		hi = TAILQ_FIRST(head);
20137ddc9b1aSDarren Reed 		if ((hi != NULL) && (hi->hi_hook.h_hint == HH_FIRST))
20147ddc9b1aSDarren Reed 			return (EBUSY);
20157ddc9b1aSDarren Reed 		TAILQ_INSERT_HEAD(head, new, hi_entry);
20167ddc9b1aSDarren Reed 		break;
20177ddc9b1aSDarren Reed 
20187ddc9b1aSDarren Reed 	case HH_LAST :
20197ddc9b1aSDarren Reed 		hi = TAILQ_LAST(head, hook_int_head);
20207ddc9b1aSDarren Reed 		if ((hi != NULL) && (hi->hi_hook.h_hint == HH_LAST))
20217ddc9b1aSDarren Reed 			return (EBUSY);
20227ddc9b1aSDarren Reed 		TAILQ_INSERT_TAIL(head, new, hi_entry);
20237ddc9b1aSDarren Reed 		break;
20247ddc9b1aSDarren Reed 
20257ddc9b1aSDarren Reed 	case HH_BEFORE :
20267ddc9b1aSDarren Reed 		hi = hook_find_byname(head, (char *)new->hi_hook.h_hintvalue);
20277ddc9b1aSDarren Reed 		if (hi == NULL)
20287ddc9b1aSDarren Reed 			return (hook_insert_afterbefore(head, new));
20297ddc9b1aSDarren Reed 
20307ddc9b1aSDarren Reed 		if (hi->hi_hook.h_hint == HH_FIRST)
20317ddc9b1aSDarren Reed 			return (EBUSY);
20327ddc9b1aSDarren Reed 
20337ddc9b1aSDarren Reed 		TAILQ_INSERT_BEFORE(hi, new, hi_entry);
20347ddc9b1aSDarren Reed 		break;
20357ddc9b1aSDarren Reed 
20367ddc9b1aSDarren Reed 	case HH_AFTER :
20377ddc9b1aSDarren Reed 		hi = hook_find_byname(head, (char *)new->hi_hook.h_hintvalue);
20387ddc9b1aSDarren Reed 		if (hi == NULL)
20397ddc9b1aSDarren Reed 			return (hook_insert_afterbefore(head, new));
20407ddc9b1aSDarren Reed 
20417ddc9b1aSDarren Reed 		if (hi->hi_hook.h_hint == HH_LAST)
20427ddc9b1aSDarren Reed 			return (EBUSY);
20437ddc9b1aSDarren Reed 
20447ddc9b1aSDarren Reed 		TAILQ_INSERT_AFTER(head, hi, new, hi_entry);
20457ddc9b1aSDarren Reed 		break;
20467ddc9b1aSDarren Reed 
20477ddc9b1aSDarren Reed 	default :
20487ddc9b1aSDarren Reed 		return (EINVAL);
20497ddc9b1aSDarren Reed 	}
20507ddc9b1aSDarren Reed 
2051381a2a9aSdr 	return (0);
2052381a2a9aSdr }
2053381a2a9aSdr 
20547ddc9b1aSDarren Reed /*
20557ddc9b1aSDarren Reed  * Function:	hook_insert_plain
20564a9b8375SDarren Reed  * Returns:	int     - 0 = success, else = failure
20577ddc9b1aSDarren Reed  * Parameters:	head(I) - pointer to hook list to insert hook onto
20587ddc9b1aSDarren Reed  *		new(I)  - pointer to hook to be inserted
20597ddc9b1aSDarren Reed  *
20607ddc9b1aSDarren Reed  * Insert a hook such that it respects the wishes of those that want to
20617ddc9b1aSDarren Reed  * be last.  If there are none wanting to be last then add the new hook
20627ddc9b1aSDarren Reed  * to the tail of the list - this means we keep any wanting to be first
20637ddc9b1aSDarren Reed  * happy without having to search for HH_FIRST.
20647ddc9b1aSDarren Reed  */
20657ddc9b1aSDarren Reed static void
hook_insert_plain(hook_int_head_t * head,hook_int_t * new)20667ddc9b1aSDarren Reed hook_insert_plain(hook_int_head_t *head, hook_int_t *new)
20677ddc9b1aSDarren Reed {
20687ddc9b1aSDarren Reed 	hook_int_t *hi;
20697ddc9b1aSDarren Reed 
20707ddc9b1aSDarren Reed 	hi = TAILQ_FIRST(head);
20717ddc9b1aSDarren Reed 	if (hi != NULL) {
20727ddc9b1aSDarren Reed 		if (hi->hi_hook.h_hint == HH_LAST) {
20737ddc9b1aSDarren Reed 			TAILQ_INSERT_BEFORE(hi, new, hi_entry);
20747ddc9b1aSDarren Reed 		} else {
20757ddc9b1aSDarren Reed 			TAILQ_INSERT_TAIL(head, new, hi_entry);
20767ddc9b1aSDarren Reed 		}
20777ddc9b1aSDarren Reed 	} else {
20787ddc9b1aSDarren Reed 		TAILQ_INSERT_TAIL(head, new, hi_entry);
20797ddc9b1aSDarren Reed 	}
20807ddc9b1aSDarren Reed }
20817ddc9b1aSDarren Reed 
20827ddc9b1aSDarren Reed /*
20837ddc9b1aSDarren Reed  * Function:	hook_insert_afterbefore
20844a9b8375SDarren Reed  * Returns:	int     - 0 = success, else = failure
20857ddc9b1aSDarren Reed  * Parameters:	head(I) - pointer to hook list to insert hook onto
20867ddc9b1aSDarren Reed  *		new(I)  - pointer to hook to be inserted
20877ddc9b1aSDarren Reed  *
20887ddc9b1aSDarren Reed  * Simple insertion of a hook specifying a HH_BEFORE or HH_AFTER was not
20897ddc9b1aSDarren Reed  * possible, so now we need to be more careful.  The first pass is to go
20907ddc9b1aSDarren Reed  * through the list and look for any other hooks that also specify the
20917ddc9b1aSDarren Reed  * same hint name as the new one.  The object of this exercise is to make
20927ddc9b1aSDarren Reed  * sure that hooks with HH_BEFORE always appear on the list before those
20937ddc9b1aSDarren Reed  * with HH_AFTER so that when said hook arrives, it can be placed in the
20947ddc9b1aSDarren Reed  * middle of the BEFOREs and AFTERs.  If this condition does not arise,
20957ddc9b1aSDarren Reed  * just use hook_insert_plain() to try and insert the hook somewhere that
20967ddc9b1aSDarren Reed  * is innocuous to existing efforts.
20977ddc9b1aSDarren Reed  */
20987ddc9b1aSDarren Reed static int
hook_insert_afterbefore(hook_int_head_t * head,hook_int_t * new)20997ddc9b1aSDarren Reed hook_insert_afterbefore(hook_int_head_t *head, hook_int_t *new)
21007ddc9b1aSDarren Reed {
21017ddc9b1aSDarren Reed 	hook_int_t *hi;
21027ddc9b1aSDarren Reed 	hook_t *nh;
21037ddc9b1aSDarren Reed 	hook_t *h;
21047ddc9b1aSDarren Reed 
21057ddc9b1aSDarren Reed 	nh = &new->hi_hook;
21067ddc9b1aSDarren Reed 	ASSERT(new->hi_hook.h_hint != HH_NONE);
21077ddc9b1aSDarren Reed 	ASSERT(new->hi_hook.h_hint != HH_LAST);
21087ddc9b1aSDarren Reed 	ASSERT(new->hi_hook.h_hint != HH_FIRST);
21097ddc9b1aSDarren Reed 
21107ddc9b1aSDarren Reed 	/*
21117ddc9b1aSDarren Reed 	 * First, look through the list to see if there are any other
21127ddc9b1aSDarren Reed 	 * before's or after's that have a matching hint name.
21137ddc9b1aSDarren Reed 	 */
21147ddc9b1aSDarren Reed 	TAILQ_FOREACH(hi, head, hi_entry) {
21157ddc9b1aSDarren Reed 		h = &hi->hi_hook;
21167ddc9b1aSDarren Reed 		switch (h->h_hint) {
21177ddc9b1aSDarren Reed 		case HH_FIRST :
21187ddc9b1aSDarren Reed 		case HH_LAST :
21197ddc9b1aSDarren Reed 		case HH_NONE :
21207ddc9b1aSDarren Reed 			break;
21217ddc9b1aSDarren Reed 		case HH_BEFORE :
21227ddc9b1aSDarren Reed 			if ((nh->h_hint == HH_BEFORE) &&
21237ddc9b1aSDarren Reed 			    (strcmp((char *)h->h_hintvalue,
21247ddc9b1aSDarren Reed 			    (char *)nh->h_hintvalue) == 0)) {
21257ddc9b1aSDarren Reed 				TAILQ_INSERT_AFTER(head, hi, new, hi_entry);
21267ddc9b1aSDarren Reed 				return (0);
21277ddc9b1aSDarren Reed 			}
21287ddc9b1aSDarren Reed 			if ((nh->h_hint == HH_AFTER) &&
21297ddc9b1aSDarren Reed 			    (strcmp((char *)h->h_hintvalue,
21307ddc9b1aSDarren Reed 			    (char *)nh->h_hintvalue) == 0)) {
21317ddc9b1aSDarren Reed 				TAILQ_INSERT_BEFORE(hi, new, hi_entry);
21327ddc9b1aSDarren Reed 				return (0);
21337ddc9b1aSDarren Reed 			}
21347ddc9b1aSDarren Reed 			break;
21357ddc9b1aSDarren Reed 		case HH_AFTER :
21367ddc9b1aSDarren Reed 			if ((nh->h_hint == HH_AFTER) &&
21377ddc9b1aSDarren Reed 			    (strcmp((char *)h->h_hintvalue,
21387ddc9b1aSDarren Reed 			    (char *)nh->h_hintvalue) == 0)) {
21397ddc9b1aSDarren Reed 				TAILQ_INSERT_AFTER(head, hi, new, hi_entry);
21407ddc9b1aSDarren Reed 				return (0);
21417ddc9b1aSDarren Reed 			}
21427ddc9b1aSDarren Reed 			if ((nh->h_hint == HH_BEFORE) &&
21437ddc9b1aSDarren Reed 			    (strcmp((char *)h->h_hintvalue,
21447ddc9b1aSDarren Reed 			    (char *)nh->h_hintvalue) == 0)) {
21457ddc9b1aSDarren Reed 				TAILQ_INSERT_BEFORE(hi, new, hi_entry);
21467ddc9b1aSDarren Reed 				return (0);
21477ddc9b1aSDarren Reed 			}
21487ddc9b1aSDarren Reed 			break;
21497ddc9b1aSDarren Reed 		}
21507ddc9b1aSDarren Reed 	}
21517ddc9b1aSDarren Reed 
21527ddc9b1aSDarren Reed 	hook_insert_plain(head, new);
21537ddc9b1aSDarren Reed 
21547ddc9b1aSDarren Reed 	return (0);
21557ddc9b1aSDarren Reed }
2156381a2a9aSdr 
2157381a2a9aSdr /*
2158381a2a9aSdr  * Function:	hook_unregister
21594a9b8375SDarren Reed  * Returns:	int      - 0 = success, else = failure
21604a9b8375SDarren Reed  * Parameters:	hfi(I)   - internal family pointer
2161381a2a9aSdr  *		event(I) - event name string
21624a9b8375SDarren Reed  *		h(I)     - hook pointer
2163381a2a9aSdr  *
2164381a2a9aSdr  * Remove hook from hook list on specific family, event
2165381a2a9aSdr  */
2166381a2a9aSdr int
hook_unregister(hook_family_int_t * hfi,char * event,hook_t * h)2167381a2a9aSdr hook_unregister(hook_family_int_t *hfi, char *event, hook_t *h)
2168381a2a9aSdr {
2169381a2a9aSdr 	hook_event_int_t *hei;
2170381a2a9aSdr 	hook_int_t *hi;
21717ddc9b1aSDarren Reed 	boolean_t free_event;
2172381a2a9aSdr 
2173381a2a9aSdr 	ASSERT(hfi != NULL);
2174381a2a9aSdr 	ASSERT(h != NULL);
2175381a2a9aSdr 
21767ddc9b1aSDarren Reed 	CVW_ENTER_WRITE(&hfi->hfi_lock);
2177381a2a9aSdr 
2178381a2a9aSdr 	hei = hook_event_find(hfi, event);
2179381a2a9aSdr 	if (hei == NULL) {
21807ddc9b1aSDarren Reed 		CVW_EXIT_WRITE(&hfi->hfi_lock);
2181381a2a9aSdr 		return (ENXIO);
2182381a2a9aSdr 	}
2183381a2a9aSdr 
2184381a2a9aSdr 	/* Hold write lock for event */
2185381a2a9aSdr 	CVW_ENTER_WRITE(&hei->hei_lock);
2186381a2a9aSdr 
2187381a2a9aSdr 	hi = hook_find(hei, h);
2188381a2a9aSdr 	if (hi == NULL) {
2189381a2a9aSdr 		CVW_EXIT_WRITE(&hei->hei_lock);
21907ddc9b1aSDarren Reed 		CVW_EXIT_WRITE(&hfi->hfi_lock);
2191381a2a9aSdr 		return (ENXIO);
2192381a2a9aSdr 	}
2193381a2a9aSdr 
21944a9b8375SDarren Reed 	if (hook_wait_setflag(&hei->hei_waiter, FWF_DEL_WAIT_MASK,
21957ddc9b1aSDarren Reed 	    FWF_DEL_WANTED, FWF_DEL_ACTIVE) == -1) {
21967ddc9b1aSDarren Reed 		CVW_EXIT_WRITE(&hei->hei_lock);
21977ddc9b1aSDarren Reed 		CVW_EXIT_WRITE(&hfi->hfi_lock);
21987ddc9b1aSDarren Reed 		return (ENOENT);
21997ddc9b1aSDarren Reed 	}
22007ddc9b1aSDarren Reed 
2201381a2a9aSdr 	/* Remove from hook list */
2202381a2a9aSdr 	TAILQ_REMOVE(&hei->hei_head, hi, hi_entry);
22037ddc9b1aSDarren Reed 
22047ddc9b1aSDarren Reed 	free_event = B_FALSE;
2205381a2a9aSdr 	if (TAILQ_EMPTY(&hei->hei_head)) {
2206381a2a9aSdr 		hei->hei_event->he_interested = B_FALSE;
22077ddc9b1aSDarren Reed 		/*
22087ddc9b1aSDarren Reed 		 * If the delete pending flag has been set and there are
22097ddc9b1aSDarren Reed 		 * no notifiers on the event (and we've removed the last
22107ddc9b1aSDarren Reed 		 * hook) then we need to free this event after we're done.
22117ddc9b1aSDarren Reed 		 */
22127ddc9b1aSDarren Reed 		if (hei->hei_condemned && TAILQ_EMPTY(&hei->hei_nhead))
22137ddc9b1aSDarren Reed 			free_event = B_TRUE;
2214381a2a9aSdr 	}
22157ddc9b1aSDarren Reed 	hei->hei_kstats.hooks_removed.value.ui64++;
2216381a2a9aSdr 
2217381a2a9aSdr 	CVW_EXIT_WRITE(&hei->hei_lock);
22187ddc9b1aSDarren Reed 	CVW_EXIT_WRITE(&hfi->hfi_lock);
22197ddc9b1aSDarren Reed 	/*
22207ddc9b1aSDarren Reed 	 * While the FWF_DEL_ACTIVE flag is set, the hook_event_int_t
22217ddc9b1aSDarren Reed 	 * will not be free'd and thus the hook_family_int_t wil not
22227ddc9b1aSDarren Reed 	 * be free'd either.
22237ddc9b1aSDarren Reed 	 */
22247ddc9b1aSDarren Reed 	hook_event_notify_run(hei, hfi, event, h->h_name, HN_UNREGISTER);
22257ddc9b1aSDarren Reed 	hook_wait_unsetflag(&hei->hei_waiter, FWF_DEL_ACTIVE);
22267ddc9b1aSDarren Reed 
22277ddc9b1aSDarren Reed 	hook_int_free(hi, hfi->hfi_stack->hks_netstackid);
22287ddc9b1aSDarren Reed 
22297ddc9b1aSDarren Reed 	if (free_event)
22307ddc9b1aSDarren Reed 		hook_event_free(hei, hfi);
2231381a2a9aSdr 
2232381a2a9aSdr 	return (0);
2233381a2a9aSdr }
2234381a2a9aSdr 
22357ddc9b1aSDarren Reed /*
22367ddc9b1aSDarren Reed  * Function:	hook_find_byname
22377ddc9b1aSDarren Reed  * Returns:	internal hook pointer - NULL = Not match
22387ddc9b1aSDarren Reed  * Parameters:	hei(I) - internal event pointer
22397ddc9b1aSDarren Reed  *		name(I)- hook name
22407ddc9b1aSDarren Reed  *
22417ddc9b1aSDarren Reed  * Search an event's list of hooks to see if there is a hook present that
22427ddc9b1aSDarren Reed  * has a matching name to the one being looked for.
22437ddc9b1aSDarren Reed  */
22447ddc9b1aSDarren Reed static hook_int_t *
hook_find_byname(hook_int_head_t * head,char * name)22457ddc9b1aSDarren Reed hook_find_byname(hook_int_head_t *head, char *name)
22467ddc9b1aSDarren Reed {
22477ddc9b1aSDarren Reed 	hook_int_t *hi;
22487ddc9b1aSDarren Reed 
22497ddc9b1aSDarren Reed 	TAILQ_FOREACH(hi, head, hi_entry) {
22507ddc9b1aSDarren Reed 		if (strcmp(hi->hi_hook.h_name, name) == 0)
22517ddc9b1aSDarren Reed 			return (hi);
22527ddc9b1aSDarren Reed 	}
22537ddc9b1aSDarren Reed 
22547ddc9b1aSDarren Reed 	return (NULL);
22557ddc9b1aSDarren Reed }
2256381a2a9aSdr 
2257381a2a9aSdr /*
2258381a2a9aSdr  * Function:	hook_find
2259381a2a9aSdr  * Returns:	internal hook pointer - NULL = Not match
2260381a2a9aSdr  * Parameters:	hei(I) - internal event pointer
22614a9b8375SDarren Reed  *		h(I)   - hook pointer
2262381a2a9aSdr  *
22637ddc9b1aSDarren Reed  * Search an event's list of hooks to see if there is already one that
22647ddc9b1aSDarren Reed  * matches the hook being passed in.  Currently the only criteria for a
22657ddc9b1aSDarren Reed  * successful search here is for the names to be the same.
2266381a2a9aSdr  */
2267381a2a9aSdr static hook_int_t *
hook_find(hook_event_int_t * hei,hook_t * h)2268381a2a9aSdr hook_find(hook_event_int_t *hei, hook_t *h)
2269381a2a9aSdr {
2270381a2a9aSdr 
2271381a2a9aSdr 	ASSERT(hei != NULL);
2272381a2a9aSdr 	ASSERT(h != NULL);
2273381a2a9aSdr 
22747ddc9b1aSDarren Reed 	return (hook_find_byname(&hei->hei_head, h->h_name));
2275381a2a9aSdr }
2276381a2a9aSdr 
2277381a2a9aSdr /*
2278381a2a9aSdr  * Function:	hook_copy
2279381a2a9aSdr  * Returns:	internal hook pointer - NULL = Failed
2280381a2a9aSdr  * Parameters:	src(I) - hook pointer
2281381a2a9aSdr  *
2282381a2a9aSdr  * Allocate internal hook block and duplicate incoming hook.
2283381a2a9aSdr  * No locks should be held across this function as it may sleep.
22847ddc9b1aSDarren Reed  * Because hook_copy() is responsible for the creation of the internal
22857ddc9b1aSDarren Reed  * hook structure that is used here, it takes on population the structure
22867ddc9b1aSDarren Reed  * with the kstat information.  Note that while the kstat bits are
22877ddc9b1aSDarren Reed  * seeded here, their installation of the kstats is handled elsewhere.
2288381a2a9aSdr  */
2289381a2a9aSdr static hook_int_t *
hook_copy(hook_t * src)2290381a2a9aSdr hook_copy(hook_t *src)
2291381a2a9aSdr {
2292381a2a9aSdr 	hook_int_t *new;
2293381a2a9aSdr 	hook_t *dst;
22947ddc9b1aSDarren Reed 	int len;
2295381a2a9aSdr 
2296381a2a9aSdr 	ASSERT(src != NULL);
2297381a2a9aSdr 	ASSERT(src->h_name != NULL);
2298381a2a9aSdr 
2299381a2a9aSdr 	new = (hook_int_t *)kmem_zalloc(sizeof (*new), KM_SLEEP);
2300381a2a9aSdr 
2301381a2a9aSdr 	/* Copy body */
2302381a2a9aSdr 	dst = &new->hi_hook;
2303381a2a9aSdr 	*dst = *src;
2304381a2a9aSdr 
2305381a2a9aSdr 	/* Copy name */
23067ddc9b1aSDarren Reed 	len = strlen(src->h_name);
23077ddc9b1aSDarren Reed 	dst->h_name = (char *)kmem_alloc(len + 1, KM_SLEEP);
2308381a2a9aSdr 	(void) strcpy(dst->h_name, src->h_name);
2309381a2a9aSdr 
23107ddc9b1aSDarren Reed 	/*
23117ddc9b1aSDarren Reed 	 * This is initialised in this manner to make it safer to use the
23127ddc9b1aSDarren Reed 	 * same pointer in the kstats field.
23137ddc9b1aSDarren Reed 	 */
23147ddc9b1aSDarren Reed 	dst->h_hintvalue = (uintptr_t)"";
23157ddc9b1aSDarren Reed 
23167ddc9b1aSDarren Reed 	if (dst->h_hint == HH_BEFORE || dst->h_hint == HH_AFTER) {
23177ddc9b1aSDarren Reed 		len = strlen((char *)src->h_hintvalue);
23187ddc9b1aSDarren Reed 		if (len > 0) {
23197ddc9b1aSDarren Reed 			dst->h_hintvalue = (uintptr_t)kmem_alloc(len + 1,
23207ddc9b1aSDarren Reed 			    KM_SLEEP);
23217ddc9b1aSDarren Reed 			(void) strcpy((char *)dst->h_hintvalue,
23227ddc9b1aSDarren Reed 			    (char *)src->h_hintvalue);
23237ddc9b1aSDarren Reed 		}
23247ddc9b1aSDarren Reed 	}
23257ddc9b1aSDarren Reed 
2326381a2a9aSdr 	return (new);
2327381a2a9aSdr }
2328381a2a9aSdr 
2329381a2a9aSdr /*
23307ddc9b1aSDarren Reed  * Function:	hook_init_kstats
23317ddc9b1aSDarren Reed  * Returns:	None
23327ddc9b1aSDarren Reed  * Parameters:  hfi(I) - pointer to the family that owns the event.
23337ddc9b1aSDarren Reed  *              hei(I) - pointer to the event that owns this hook
23347ddc9b1aSDarren Reed  *              hi(I)  - pointer to the hook for which we create kstats for
23357ddc9b1aSDarren Reed  *
23367ddc9b1aSDarren Reed  * Each hook that is registered with this framework has its own kstats
23377ddc9b1aSDarren Reed  * set up so that we can provide an easy way in which to observe the
23387ddc9b1aSDarren Reed  * look of hooks (using the kstat command.) The position is set to 0
23397ddc9b1aSDarren Reed  * here but is recalculated after we know the insertion has been a
23407ddc9b1aSDarren Reed  * success.
23417ddc9b1aSDarren Reed  */
23427ddc9b1aSDarren Reed static void
hook_init_kstats(hook_family_int_t * hfi,hook_event_int_t * hei,hook_int_t * hi)23437ddc9b1aSDarren Reed hook_init_kstats(hook_family_int_t *hfi, hook_event_int_t *hei, hook_int_t *hi)
23447ddc9b1aSDarren Reed {
23457ddc9b1aSDarren Reed 	hook_hook_kstat_t template = {
23467ddc9b1aSDarren Reed 		{ "version",			KSTAT_DATA_INT32 },
23477ddc9b1aSDarren Reed 		{ "flags",			KSTAT_DATA_UINT32 },
23487ddc9b1aSDarren Reed 		{ "hint",			KSTAT_DATA_INT32 },
2349652fb50dSRob Gulewich 		{ "hint_value",			KSTAT_DATA_STRING },
23507ddc9b1aSDarren Reed 		{ "position",			KSTAT_DATA_INT32 },
23517ddc9b1aSDarren Reed 		{ "hook_hits",			KSTAT_DATA_UINT64 }
23527ddc9b1aSDarren Reed 	};
23537ddc9b1aSDarren Reed 	hook_stack_t *hks;
23547ddc9b1aSDarren Reed 	size_t kslen;
23557ddc9b1aSDarren Reed 	int position;
23567ddc9b1aSDarren Reed 	hook_int_t *h;
23577ddc9b1aSDarren Reed 
23587ddc9b1aSDarren Reed 	kslen = strlen(hfi->hfi_family.hf_name) +
23597ddc9b1aSDarren Reed 	    strlen(hei->hei_event->he_name) + 2;
23607ddc9b1aSDarren Reed 
23617ddc9b1aSDarren Reed 	hi->hi_ksname = (char *)kmem_zalloc(kslen, KM_SLEEP);
23627ddc9b1aSDarren Reed 	(void) snprintf(hi->hi_ksname, kslen, "%s/%s",
23637ddc9b1aSDarren Reed 	    hfi->hfi_family.hf_name, hei->hei_event->he_name);
23647ddc9b1aSDarren Reed 
23657ddc9b1aSDarren Reed 	hks = hfi->hfi_stack;
23667ddc9b1aSDarren Reed 	hi->hi_kstatp = kstat_create_netstack(hi->hi_ksname, 0,
23677ddc9b1aSDarren Reed 	    hi->hi_hook.h_name, "hook", KSTAT_TYPE_NAMED,
23687ddc9b1aSDarren Reed 	    sizeof (hi->hi_kstats) / sizeof (kstat_named_t),
23697ddc9b1aSDarren Reed 	    KSTAT_FLAG_VIRTUAL, hks->hks_netstackid);
23707ddc9b1aSDarren Reed 
23717ddc9b1aSDarren Reed 	/* Initialise the kstats for the structure */
23727ddc9b1aSDarren Reed 	bcopy(&template, &hi->hi_kstats, sizeof (template));
23737ddc9b1aSDarren Reed 	hi->hi_kstats.hook_version.value.i32 = hi->hi_hook.h_version;
23747ddc9b1aSDarren Reed 	hi->hi_kstats.hook_flags.value.ui32 = hi->hi_hook.h_flags;
23757ddc9b1aSDarren Reed 	hi->hi_kstats.hook_hint.value.i32 = hi->hi_hook.h_hint;
23767ddc9b1aSDarren Reed 	hi->hi_kstats.hook_position.value.i32 = 0;
23777ddc9b1aSDarren Reed 	hi->hi_kstats.hook_hits.value.ui64 = 0;
23787ddc9b1aSDarren Reed 
23797ddc9b1aSDarren Reed 	switch (hi->hi_hook.h_hint) {
23807ddc9b1aSDarren Reed 	case HH_BEFORE :
23817ddc9b1aSDarren Reed 	case HH_AFTER :
2382652fb50dSRob Gulewich 		kstat_named_setstr(&(hi->hi_kstats.hook_hintvalue),
2383652fb50dSRob Gulewich 		    (const char *)hi->hi_hook.h_hintvalue);
23847ddc9b1aSDarren Reed 		break;
23857ddc9b1aSDarren Reed 	default :
2386652fb50dSRob Gulewich 		kstat_named_setstr(&(hi->hi_kstats.hook_hintvalue),
2387652fb50dSRob Gulewich 		    hook_hintvalue_none);
23887ddc9b1aSDarren Reed 		break;
23897ddc9b1aSDarren Reed 	}
23907ddc9b1aSDarren Reed 
23917ddc9b1aSDarren Reed 	if (hi->hi_kstatp != NULL) {
23927ddc9b1aSDarren Reed 		hi->hi_kstatp->ks_data = (void *)&hi->hi_kstats;
23937ddc9b1aSDarren Reed 		hi->hi_kstatp->ks_private =
23947ddc9b1aSDarren Reed 		    (void *)(uintptr_t)hks->hks_netstackid;
2395652fb50dSRob Gulewich 		hi->hi_kstatp->ks_data_size +=
2396652fb50dSRob Gulewich 		    KSTAT_NAMED_STR_BUFLEN(&(hi->hi_kstats.hook_hintvalue)) + 1;
23977ddc9b1aSDarren Reed 
23987ddc9b1aSDarren Reed 		kstat_install(hi->hi_kstatp);
23997ddc9b1aSDarren Reed 	}
24007ddc9b1aSDarren Reed 
24017ddc9b1aSDarren Reed 	position = 1;
24027ddc9b1aSDarren Reed 	TAILQ_FOREACH(h, &hei->hei_head, hi_entry) {
24037ddc9b1aSDarren Reed 		h->hi_kstats.hook_position.value.ui32 = position++;
24047ddc9b1aSDarren Reed 	}
24057ddc9b1aSDarren Reed }
24067ddc9b1aSDarren Reed 
24077ddc9b1aSDarren Reed /*
24087ddc9b1aSDarren Reed  * Function:	hook_int_free
2409381a2a9aSdr  * Returns:	None
2410381a2a9aSdr  * Parameters:	hi(I) - internal hook pointer
2411381a2a9aSdr  *
24124a9b8375SDarren Reed  * Free memory allocated to support a hook.
2413381a2a9aSdr  */
2414381a2a9aSdr static void
hook_int_free(hook_int_t * hi,netstackid_t stackid)24157ddc9b1aSDarren Reed hook_int_free(hook_int_t *hi, netstackid_t stackid)
2416381a2a9aSdr {
24177ddc9b1aSDarren Reed 	int len;
24187ddc9b1aSDarren Reed 
2419381a2a9aSdr 	ASSERT(hi != NULL);
2420381a2a9aSdr 
2421381a2a9aSdr 	/* Free name space */
2422381a2a9aSdr 	if (hi->hi_hook.h_name != NULL) {
2423381a2a9aSdr 		kmem_free(hi->hi_hook.h_name, strlen(hi->hi_hook.h_name) + 1);
2424381a2a9aSdr 	}
24257ddc9b1aSDarren Reed 	if (hi->hi_ksname != NULL) {
24267ddc9b1aSDarren Reed 		kmem_free(hi->hi_ksname, strlen(hi->hi_ksname) + 1);
24277ddc9b1aSDarren Reed 	}
24287ddc9b1aSDarren Reed 
24297ddc9b1aSDarren Reed 	/* Free the name used with the before/after hints. */
24307ddc9b1aSDarren Reed 	switch (hi->hi_hook.h_hint) {
24317ddc9b1aSDarren Reed 	case HH_BEFORE :
24327ddc9b1aSDarren Reed 	case HH_AFTER :
24337ddc9b1aSDarren Reed 		len = strlen((char *)hi->hi_hook.h_hintvalue);
24347ddc9b1aSDarren Reed 		if (len > 0)
24357ddc9b1aSDarren Reed 			kmem_free((void *)hi->hi_hook.h_hintvalue, len + 1);
24367ddc9b1aSDarren Reed 		break;
24377ddc9b1aSDarren Reed 	default :
24387ddc9b1aSDarren Reed 		break;
24397ddc9b1aSDarren Reed 	}
24407ddc9b1aSDarren Reed 
24417ddc9b1aSDarren Reed 	if (hi->hi_kstatp != NULL)
24427ddc9b1aSDarren Reed 		kstat_delete_netstack(hi->hi_kstatp, stackid);
2443381a2a9aSdr 
2444381a2a9aSdr 	/* Free container */
2445381a2a9aSdr 	kmem_free(hi, sizeof (*hi));
2446381a2a9aSdr }
24477ddc9b1aSDarren Reed 
24487ddc9b1aSDarren Reed /*
24497ddc9b1aSDarren Reed  * Function:	hook_alloc
24504a9b8375SDarren Reed  * Returns:	hook_t *   - pointer to new hook structure
24517ddc9b1aSDarren Reed  * Parameters:	version(I) - version number of the API when compiled
24527ddc9b1aSDarren Reed  *
24537ddc9b1aSDarren Reed  * This function serves as the interface for consumers to obtain a hook_t
24547ddc9b1aSDarren Reed  * structure.  At this point in time, there is only a single "version" of
24557ddc9b1aSDarren Reed  * it, leading to a straight forward function.  In a perfect world the
24567ddc9b1aSDarren Reed  * h_vesion would be a protected data structure member, but C isn't that
24577ddc9b1aSDarren Reed  * advanced...
24587ddc9b1aSDarren Reed  */
24597ddc9b1aSDarren Reed hook_t *
hook_alloc(const int h_version)24607ddc9b1aSDarren Reed hook_alloc(const int h_version)
24617ddc9b1aSDarren Reed {
24627ddc9b1aSDarren Reed 	hook_t *h;
24637ddc9b1aSDarren Reed 
24647ddc9b1aSDarren Reed 	h = kmem_zalloc(sizeof (hook_t), KM_SLEEP);
24657ddc9b1aSDarren Reed 	h->h_version = h_version;
24667ddc9b1aSDarren Reed 	return (h);
24677ddc9b1aSDarren Reed }
24687ddc9b1aSDarren Reed 
24697ddc9b1aSDarren Reed /*
24707ddc9b1aSDarren Reed  * Function:	hook_free
24717ddc9b1aSDarren Reed  * Returns:	None
24727ddc9b1aSDarren Reed  * Parameters:	h(I) - external hook pointer
24737ddc9b1aSDarren Reed  *
24747ddc9b1aSDarren Reed  * This function only free's memory allocated with hook_alloc(), so that if
24757ddc9b1aSDarren Reed  * (for example) kernel memory was allocated for h_name, this needs to be
24767ddc9b1aSDarren Reed  * free'd before calling hook_free().
24777ddc9b1aSDarren Reed  */
24787ddc9b1aSDarren Reed void
hook_free(hook_t * h)24797ddc9b1aSDarren Reed hook_free(hook_t *h)
24807ddc9b1aSDarren Reed {
24817ddc9b1aSDarren Reed 	kmem_free(h, sizeof (*h));
24827ddc9b1aSDarren Reed }
24837ddc9b1aSDarren Reed 
24847ddc9b1aSDarren Reed /*
24857ddc9b1aSDarren Reed  * Function:	hook_notify_register
24864a9b8375SDarren Reed  * Returns:	int         - 0 = success, else failure
24874a9b8375SDarren Reed  * Parameters:	head(I)     - top of the list of callbacks
24887ddc9b1aSDarren Reed  *              callback(I) - function to be called
24897ddc9b1aSDarren Reed  *              arg(I)      - arg to pass back to the function
24907ddc9b1aSDarren Reed  *
24917ddc9b1aSDarren Reed  * This function implements the modification of the list of callbacks
24927ddc9b1aSDarren Reed  * that are registered when someone wants to be advised of a change
24937ddc9b1aSDarren Reed  * that has happened.
24947ddc9b1aSDarren Reed  */
24957ddc9b1aSDarren Reed static int
hook_notify_register(hook_notify_head_t * head,hook_notify_fn_t callback,void * arg)24964a9b8375SDarren Reed hook_notify_register(hook_notify_head_t *head, hook_notify_fn_t callback,
24974a9b8375SDarren Reed     void *arg)
24987ddc9b1aSDarren Reed {
24997ddc9b1aSDarren Reed 	hook_notify_t *hn;
25007ddc9b1aSDarren Reed 
25017ddc9b1aSDarren Reed 	TAILQ_FOREACH(hn, head, hn_entry) {
25027ddc9b1aSDarren Reed 		if (hn->hn_func == callback) {
25037ddc9b1aSDarren Reed 			return (EEXIST);
25047ddc9b1aSDarren Reed 		}
25057ddc9b1aSDarren Reed 	}
25067ddc9b1aSDarren Reed 
25077ddc9b1aSDarren Reed 	hn = (hook_notify_t *)kmem_alloc(sizeof (*hn), KM_SLEEP);
25087ddc9b1aSDarren Reed 	hn->hn_func = callback;
25097ddc9b1aSDarren Reed 	hn->hn_arg = arg;
25107ddc9b1aSDarren Reed 	TAILQ_INSERT_TAIL(head, hn, hn_entry);
25117ddc9b1aSDarren Reed 
25127ddc9b1aSDarren Reed 	return (0);
25137ddc9b1aSDarren Reed }
25147ddc9b1aSDarren Reed 
25157ddc9b1aSDarren Reed /*
25164a9b8375SDarren Reed  * Function:	hook_notify_unregister
25174a9b8375SDarren Reed  * Returns:	int         - 0 = success, else failure
25184a9b8375SDarren Reed  * Parameters:	stackid(I)  - netstack identifier
25197ddc9b1aSDarren Reed  *              callback(I) - function to be called
25204a9b8375SDarren Reed  *              parg(O)     - pointer to storage for pointer
25217ddc9b1aSDarren Reed  *
25224a9b8375SDarren Reed  * When calling this function, the provision of a valid pointer in parg
25234a9b8375SDarren Reed  * allows the caller to be made aware of what argument the hook function
25244a9b8375SDarren Reed  * was expecting. This then allows the simulation of HN_UNREGISTER events
25254a9b8375SDarren Reed  * when a notify-unregister is performed.
25267ddc9b1aSDarren Reed  */
25277ddc9b1aSDarren Reed static int
hook_notify_unregister(hook_notify_head_t * head,hook_notify_fn_t callback,void ** parg)25284a9b8375SDarren Reed hook_notify_unregister(hook_notify_head_t *head,
25294a9b8375SDarren Reed     hook_notify_fn_t callback, void **parg)
25307ddc9b1aSDarren Reed {
25317ddc9b1aSDarren Reed 	hook_notify_t *hn;
25327ddc9b1aSDarren Reed 
25334a9b8375SDarren Reed 	ASSERT(parg != NULL);
25347ddc9b1aSDarren Reed 
25357ddc9b1aSDarren Reed 	TAILQ_FOREACH(hn, head, hn_entry) {
25367ddc9b1aSDarren Reed 		if (hn->hn_func == callback)
25377ddc9b1aSDarren Reed 			break;
25387ddc9b1aSDarren Reed 	}
25394a9b8375SDarren Reed 
25404a9b8375SDarren Reed 	if (hn == NULL)
25417ddc9b1aSDarren Reed 		return (ESRCH);
25427ddc9b1aSDarren Reed 
25434a9b8375SDarren Reed 	*parg = hn->hn_arg;
25447ddc9b1aSDarren Reed 
25454a9b8375SDarren Reed 	TAILQ_REMOVE(head, hn, hn_entry);
25467ddc9b1aSDarren Reed 
25477ddc9b1aSDarren Reed 	kmem_free(hn, sizeof (*hn));
25487ddc9b1aSDarren Reed 
25497ddc9b1aSDarren Reed 	return (0);
25507ddc9b1aSDarren Reed }
25517ddc9b1aSDarren Reed 
25527ddc9b1aSDarren Reed /*
25537ddc9b1aSDarren Reed  * Function:	hook_notify_run
25547ddc9b1aSDarren Reed  * Returns:	None
25557ddc9b1aSDarren Reed  * Parameters:	head(I)   - top of the list of callbacks
25567ddc9b1aSDarren Reed  *              family(I) - name of the hook family that owns the event
25577ddc9b1aSDarren Reed  *              event(I)  - name of the event being changed
25587ddc9b1aSDarren Reed  *              name(I)   - name of the object causing change
25597ddc9b1aSDarren Reed  *              cmd(I)    - either HN_UNREGISTER or HN_REGISTER
25607ddc9b1aSDarren Reed  *
25617ddc9b1aSDarren Reed  * This function walks through the list of registered callbacks and
25627ddc9b1aSDarren Reed  * executes each one, passing back the arg supplied when registered
25637ddc9b1aSDarren Reed  * and the name of the family (that owns the event), event (the thing
25647ddc9b1aSDarren Reed  * to which we're making a change) and finally a name that describes
25657ddc9b1aSDarren Reed  * what is being added or removed, as indicated by cmd.
25667ddc9b1aSDarren Reed  *
25677ddc9b1aSDarren Reed  * This function does not acquire or release any lock as it is required
25687ddc9b1aSDarren Reed  * that code calling it do so before hand.  The use of hook_notify_head_t
25697ddc9b1aSDarren Reed  * is protected by the use of flagwait_t in the structures that own this
25707ddc9b1aSDarren Reed  * list and with the use of the FWF_ADD/DEL_ACTIVE flags.
25717ddc9b1aSDarren Reed  */
25727ddc9b1aSDarren Reed static void
hook_notify_run(hook_notify_head_t * head,char * family,char * event,char * name,hook_notify_cmd_t cmd)25737ddc9b1aSDarren Reed hook_notify_run(hook_notify_head_t *head, char *family, char *event,
25747ddc9b1aSDarren Reed     char *name, hook_notify_cmd_t cmd)
25757ddc9b1aSDarren Reed {
25767ddc9b1aSDarren Reed 	hook_notify_t *hn;
25777ddc9b1aSDarren Reed 
25787ddc9b1aSDarren Reed 	TAILQ_FOREACH(hn, head, hn_entry) {
25797ddc9b1aSDarren Reed 		(*hn->hn_func)(cmd, hn->hn_arg, family, event, name);
25807ddc9b1aSDarren Reed 	}
25817ddc9b1aSDarren Reed }
2582