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