1/*-
2 * Copyright (c) 1999 Michael Smith <msmith@freebsd.org>
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 *    notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 *    notice, this list of conditions and the following disclaimer in the
12 *    documentation and/or other materials provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24 * SUCH DAMAGE.
25 */
26
27#include <sys/cdefs.h>
28__FBSDID("$FreeBSD$");
29
30#include <sys/param.h>
31#include <sys/kernel.h>
32#include <sys/lock.h>
33#include <sys/malloc.h>
34#include <sys/mutex.h>
35#include <sys/proc.h>
36#include <sys/systm.h>
37#include <sys/eventhandler.h>
38
39static MALLOC_DEFINE(M_EVENTHANDLER, "eventhandler", "Event handler records");
40
41/* List of 'slow' lists */
42static TAILQ_HEAD(, eventhandler_list)	eventhandler_lists;
43static int				eventhandler_lists_initted = 0;
44static struct mtx			eventhandler_mutex;
45
46struct eventhandler_entry_generic
47{
48    struct eventhandler_entry	ee;
49    void			(* func)(void);
50};
51
52static struct eventhandler_list *_eventhandler_find_list(const char *name);
53
54/*
55 * Initialize the eventhandler mutex and list.
56 */
57static void
58eventhandler_init(void *dummy __unused)
59{
60    TAILQ_INIT(&eventhandler_lists);
61    mtx_init(&eventhandler_mutex, "eventhandler", NULL, MTX_DEF);
62    atomic_store_rel_int(&eventhandler_lists_initted, 1);
63}
64SYSINIT(eventhandlers, SI_SUB_EVENTHANDLER, SI_ORDER_FIRST, eventhandler_init,
65    NULL);
66
67/*
68 * Insertion is O(n) due to the priority scan, but optimises to O(1)
69 * if all priorities are identical.
70 */
71static eventhandler_tag
72eventhandler_register_internal(struct eventhandler_list *list,
73    const char *name, eventhandler_tag epn)
74{
75    struct eventhandler_list		*new_list;
76    struct eventhandler_entry		*ep;
77
78    KASSERT(eventhandler_lists_initted, ("eventhandler registered too early"));
79    KASSERT(epn != NULL, ("%s: cannot register NULL event", __func__));
80
81    /* lock the eventhandler lists */
82    mtx_lock(&eventhandler_mutex);
83
84    /* Do we need to find/create the (slow) list? */
85    if (list == NULL) {
86	/* look for a matching, existing list */
87	list = _eventhandler_find_list(name);
88
89	/* Do we need to create the list? */
90	if (list == NULL) {
91	    mtx_unlock(&eventhandler_mutex);
92
93	    new_list = malloc(sizeof(struct eventhandler_list) +
94		strlen(name) + 1, M_EVENTHANDLER, M_WAITOK);
95
96	    /* If someone else created it already, then use that one. */
97	    mtx_lock(&eventhandler_mutex);
98	    list = _eventhandler_find_list(name);
99	    if (list != NULL) {
100		free(new_list, M_EVENTHANDLER);
101	    } else {
102		CTR2(KTR_EVH, "%s: creating list \"%s\"", __func__, name);
103		list = new_list;
104		list->el_flags = 0;
105		list->el_runcount = 0;
106		bzero(&list->el_lock, sizeof(list->el_lock));
107		list->el_name = (char *)list + sizeof(struct eventhandler_list);
108		strcpy(list->el_name, name);
109		TAILQ_INSERT_HEAD(&eventhandler_lists, list, el_link);
110	    }
111	}
112    }
113    if (!(list->el_flags & EHL_INITTED)) {
114	TAILQ_INIT(&list->el_entries);
115	mtx_init(&list->el_lock, name, "eventhandler list", MTX_DEF);
116	atomic_store_rel_int(&list->el_flags, EHL_INITTED);
117    }
118    mtx_unlock(&eventhandler_mutex);
119
120    KASSERT(epn->ee_priority != EHE_DEAD_PRIORITY,
121	("%s: handler for %s registered with dead priority", __func__, name));
122
123    /* sort it into the list */
124    CTR4(KTR_EVH, "%s: adding item %p (function %p) to \"%s\"", __func__, epn,
125	((struct eventhandler_entry_generic *)epn)->func, name);
126    EHL_LOCK(list);
127    TAILQ_FOREACH(ep, &list->el_entries, ee_link) {
128	if (ep->ee_priority != EHE_DEAD_PRIORITY &&
129	    epn->ee_priority < ep->ee_priority) {
130	    TAILQ_INSERT_BEFORE(ep, epn, ee_link);
131	    break;
132	}
133    }
134    if (ep == NULL)
135	TAILQ_INSERT_TAIL(&list->el_entries, epn, ee_link);
136    EHL_UNLOCK(list);
137    return(epn);
138}
139
140eventhandler_tag
141eventhandler_register(struct eventhandler_list *list, const char *name,
142		      void *func, void *arg, int priority)
143{
144    struct eventhandler_entry_generic	*eg;
145
146    /* allocate an entry for this handler, populate it */
147    eg = malloc(sizeof(struct eventhandler_entry_generic), M_EVENTHANDLER,
148	M_WAITOK | M_ZERO);
149    eg->func = func;
150    eg->ee.ee_arg = arg;
151    eg->ee.ee_priority = priority;
152
153    return (eventhandler_register_internal(list, name, &eg->ee));
154}
155
156#ifdef VIMAGE
157struct eventhandler_entry_generic_vimage
158{
159    struct eventhandler_entry		ee;
160    vimage_iterator_func_t		func;		/* Vimage iterator function. */
161    struct eventhandler_entry_vimage	v_ee;		/* Original func, arg. */
162};
163
164eventhandler_tag
165vimage_eventhandler_register(struct eventhandler_list *list, const char *name,
166    void *func, void *arg, int priority, vimage_iterator_func_t iterfunc)
167{
168    struct eventhandler_entry_generic_vimage	*eg;
169
170    /* allocate an entry for this handler, populate it */
171    eg = malloc(sizeof(struct eventhandler_entry_generic_vimage),
172	M_EVENTHANDLER, M_WAITOK | M_ZERO);
173    eg->func = iterfunc;
174    eg->v_ee.func = func;
175    eg->v_ee.ee_arg = arg;
176    eg->ee.ee_arg = &eg->v_ee;
177    eg->ee.ee_priority = priority;
178
179    return (eventhandler_register_internal(list, name, &eg->ee));
180}
181#endif
182
183void
184eventhandler_deregister(struct eventhandler_list *list, eventhandler_tag tag)
185{
186    struct eventhandler_entry	*ep = tag;
187
188    EHL_LOCK_ASSERT(list, MA_OWNED);
189    if (ep != NULL) {
190	/* remove just this entry */
191	if (list->el_runcount == 0) {
192	    CTR3(KTR_EVH, "%s: removing item %p from \"%s\"", __func__, ep,
193		list->el_name);
194	    TAILQ_REMOVE(&list->el_entries, ep, ee_link);
195	    free(ep, M_EVENTHANDLER);
196	} else {
197	    CTR3(KTR_EVH, "%s: marking item %p from \"%s\" as dead", __func__,
198		ep, list->el_name);
199	    ep->ee_priority = EHE_DEAD_PRIORITY;
200	}
201    } else {
202	/* remove entire list */
203	if (list->el_runcount == 0) {
204	    CTR2(KTR_EVH, "%s: removing all items from \"%s\"", __func__,
205		list->el_name);
206	    while (!TAILQ_EMPTY(&list->el_entries)) {
207		ep = TAILQ_FIRST(&list->el_entries);
208		TAILQ_REMOVE(&list->el_entries, ep, ee_link);
209		free(ep, M_EVENTHANDLER);
210	    }
211	} else {
212	    CTR2(KTR_EVH, "%s: marking all items from \"%s\" as dead",
213		__func__, list->el_name);
214	    TAILQ_FOREACH(ep, &list->el_entries, ee_link)
215		ep->ee_priority = EHE_DEAD_PRIORITY;
216	}
217    }
218    while (list->el_runcount > 0)
219	    mtx_sleep(list, &list->el_lock, 0, "evhrm", 0);
220    EHL_UNLOCK(list);
221}
222
223/*
224 * Internal version for use when eventhandler list is already locked.
225 */
226static struct eventhandler_list *
227_eventhandler_find_list(const char *name)
228{
229    struct eventhandler_list	*list;
230
231    mtx_assert(&eventhandler_mutex, MA_OWNED);
232    TAILQ_FOREACH(list, &eventhandler_lists, el_link) {
233	if (!strcmp(name, list->el_name))
234	    break;
235    }
236    return (list);
237}
238
239/*
240 * Lookup a "slow" list by name.  Returns with the list locked.
241 */
242struct eventhandler_list *
243eventhandler_find_list(const char *name)
244{
245    struct eventhandler_list	*list;
246
247    if (!eventhandler_lists_initted)
248	return(NULL);
249
250    /* scan looking for the requested list */
251    mtx_lock(&eventhandler_mutex);
252    list = _eventhandler_find_list(name);
253    if (list != NULL)
254	EHL_LOCK(list);
255    mtx_unlock(&eventhandler_mutex);
256
257    return(list);
258}
259
260/*
261 * Prune "dead" entries from an eventhandler list.
262 */
263void
264eventhandler_prune_list(struct eventhandler_list *list)
265{
266    struct eventhandler_entry *ep, *en;
267    int pruned = 0;
268
269    CTR2(KTR_EVH, "%s: pruning list \"%s\"", __func__, list->el_name);
270    EHL_LOCK_ASSERT(list, MA_OWNED);
271    TAILQ_FOREACH_SAFE(ep, &list->el_entries, ee_link, en) {
272	if (ep->ee_priority == EHE_DEAD_PRIORITY) {
273	    TAILQ_REMOVE(&list->el_entries, ep, ee_link);
274	    free(ep, M_EVENTHANDLER);
275	    pruned++;
276	}
277    }
278    if (pruned > 0)
279	    wakeup(list);
280}
281