xref: /titanic_44/usr/src/cmd/cmd-inet/lib/nwamd/events.c (revision a60349c89adffc0902b2353230891d8e7f2b24d9)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 
22 /*
23  * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
24  */
25 
26 #include <atomic.h>
27 #include <errno.h>
28 #include <execinfo.h>
29 #include <libuutil.h>
30 #include <pthread.h>
31 #include <signal.h>
32 #include <stdlib.h>
33 #include <string.h>
34 #include <strings.h>
35 #include <syslog.h>
36 #include <sys/time.h>
37 #include <unistd.h>
38 
39 #include "conditions.h"
40 #include "events.h"
41 #include "objects.h"
42 #include "util.h"
43 
44 /*
45  * events.c - contains routines which create/destroy event sources,
46  * handle the event queue and process events from that queue.
47  */
48 
49 /* Add new event sources here. */
50 struct nwamd_event_source {
51 	char *name;
52 	void (*events_init)(void);
53 	void (*events_fini)(void);
54 } event_sources[] = {
55 	{ "routing_events",
56 	nwamd_routing_events_init, nwamd_routing_events_fini },
57 	{ "sysevent_events",
58 	nwamd_sysevent_events_init, nwamd_sysevent_events_fini },
59 };
60 
61 /* Counter for event ids */
62 static uint64_t event_id_counter = 0;
63 
64 static uu_list_pool_t *event_pool = NULL;
65 static uu_list_t *event_queue = NULL;
66 static pthread_mutex_t event_queue_mutex = PTHREAD_MUTEX_INITIALIZER;
67 static pthread_cond_t event_queue_cond = PTHREAD_COND_INITIALIZER;
68 
69 static int nwamd_event_compare(const void *, const void *, void *);
70 
71 static const char *
72 nwamd_event_name(int event_type)
73 {
74 	if (event_type <= NWAM_EVENT_MAX)
75 		return (nwam_event_type_to_string(event_type));
76 
77 	switch (event_type) {
78 	case NWAM_EVENT_TYPE_OBJECT_INIT:
79 		return ("OBJECT_INIT");
80 	case NWAM_EVENT_TYPE_OBJECT_FINI:
81 		return ("OBJECT_FINI");
82 	case NWAM_EVENT_TYPE_TIMED_CHECK_CONDITIONS:
83 		return ("TIMED_CHECK_CONDITIONS");
84 	case NWAM_EVENT_TYPE_TRIGGERED_CHECK_CONDITIONS:
85 		return ("TRIGGERED_CHECK_CONDITIONS");
86 	case NWAM_EVENT_TYPE_NCU_CHECK:
87 		return ("NCU_CHECK");
88 	case NWAM_EVENT_TYPE_TIMER:
89 		return ("TIMER");
90 	case NWAM_EVENT_TYPE_UPGRADE:
91 		return ("UPGRADE");
92 	case NWAM_EVENT_TYPE_PERIODIC_SCAN:
93 		return ("PERIODIC_SCAN");
94 	case NWAM_EVENT_TYPE_QUEUE_QUIET:
95 		return ("QUEUE_QUIET");
96 	default:
97 		return ("N/A");
98 	}
99 }
100 
101 void
102 nwamd_event_sources_init(void)
103 {
104 	int i;
105 
106 	/*
107 	 * Now we can safely initialize event sources.
108 	 */
109 	for (i = 0;
110 	    i < sizeof (event_sources) / sizeof (struct nwamd_event_source);
111 	    i++) {
112 		if (event_sources[i].events_init != NULL)
113 			event_sources[i].events_init();
114 	}
115 }
116 
117 void
118 nwamd_event_sources_fini(void)
119 {
120 	int i;
121 
122 	for (i = 0;
123 	    i < sizeof (event_sources) / sizeof (struct nwamd_event_source);
124 	    i++) {
125 		if (event_sources[i].events_init != NULL)
126 			event_sources[i].events_fini();
127 	}
128 }
129 
130 /*
131  * Comparison function for events, passed in as callback to
132  * uu_list_pool_create(). Compare by time, so that timer
133  * event queue can be sorted by nearest time to present.
134  */
135 /* ARGSUSED */
136 static int
137 nwamd_event_compare(const void *l_arg, const void *r_arg, void *private)
138 {
139 	nwamd_event_t l = (nwamd_event_t)l_arg;
140 	nwamd_event_t r = (nwamd_event_t)r_arg;
141 	int rv;
142 
143 	rv = l->event_time.tv_sec - r->event_time.tv_sec;
144 	if (rv == 0)
145 		rv = l->event_time.tv_nsec - r->event_time.tv_nsec;
146 
147 	return (rv);
148 }
149 
150 void
151 nwamd_event_queue_init(void)
152 {
153 	event_pool = uu_list_pool_create("event_queue_pool",
154 	    sizeof (struct nwamd_event),
155 	    offsetof(struct nwamd_event, event_node),
156 	    nwamd_event_compare, UU_LIST_POOL_DEBUG);
157 	if (event_pool == NULL)
158 		pfail("uu_list_pool_create failed with error %d", uu_error());
159 	event_queue = uu_list_create(event_pool, NULL, UU_LIST_SORTED);
160 	if (event_queue == NULL)
161 		pfail("uu_list_create failed with error %d", uu_error());
162 }
163 
164 void
165 nwamd_event_queue_fini(void)
166 {
167 	void *cookie = NULL;
168 	nwamd_event_t event;
169 
170 	while ((event = uu_list_teardown(event_queue, &cookie)) != NULL)
171 		nwamd_event_fini(event);
172 	uu_list_destroy(event_queue);
173 	if (event_pool != NULL)
174 		uu_list_pool_destroy(event_pool);
175 }
176 
177 nwamd_event_t
178 nwamd_event_init(int32_t type, nwam_object_type_t object_type,
179     size_t size, const char *object_name)
180 {
181 	nwamd_event_t event;
182 
183 	event = calloc(1, sizeof (struct nwamd_event));
184 	if (event == NULL) {
185 		nlog(LOG_ERR, "nwamd_event_init: could not create %s event for "
186 		    "object %s", nwamd_event_name(type),
187 		    object_name != NULL ? object_name : "<no object>");
188 		return (NULL);
189 	}
190 
191 	/* Is this an externally-visible event? */
192 	if (type <= NWAM_EVENT_MAX) {
193 		event->event_send = B_TRUE;
194 		event->event_msg = calloc(1, sizeof (struct nwam_event) + size);
195 		if (event->event_msg == NULL) {
196 			nlog(LOG_ERR,
197 			    "nwamd_event_init: could not create %s event",
198 			    nwamd_event_name(type));
199 			free(event);
200 			return (NULL);
201 		}
202 		event->event_msg->nwe_type = type;
203 		event->event_msg->nwe_size = sizeof (struct nwam_event) + size;
204 	} else {
205 		event->event_send = B_FALSE;
206 		event->event_msg = NULL;
207 	}
208 
209 	event->event_type = type;
210 
211 	if (object_name != NULL) {
212 		(void) strlcpy(event->event_object, object_name,
213 		    NWAM_MAX_NAME_LEN);
214 		event->event_object_type = object_type;
215 	} else {
216 		event->event_object[0] = '\0';
217 	}
218 
219 	/* Set event id */
220 	event->event_id = atomic_add_64_nv(&event_id_counter, 1);
221 	(void) clock_gettime(CLOCK_REALTIME, &event->event_time);
222 
223 	return (event);
224 }
225 
226 void
227 nwamd_event_do_not_send(nwamd_event_t event)
228 {
229 	nlog(LOG_DEBUG, "nwamd_event_do_not_send: cancelling delivery of "
230 	    "event %s for object %s", nwamd_event_name(event->event_type),
231 	    event->event_object[0] != '\0' ?
232 	    event->event_object : "<no object>");
233 	event->event_send = B_FALSE;
234 }
235 
236 void
237 nwamd_event_fini(nwamd_event_t event)
238 {
239 	if (event != NULL) {
240 		free(event->event_msg);
241 		free(event);
242 	}
243 }
244 
245 nwamd_event_t
246 nwamd_event_init_object_action(nwam_object_type_t object_type,
247     const char *object_name, const char *parent_name,
248     nwam_action_t object_action)
249 {
250 	nwamd_event_t event;
251 
252 	event = nwamd_event_init(NWAM_EVENT_TYPE_OBJECT_ACTION,
253 	    object_type, 0, object_name);
254 	if (event == NULL)
255 		return (NULL);
256 
257 	event->event_msg->nwe_data.nwe_object_action.nwe_action = object_action;
258 	event->event_msg->nwe_data.nwe_object_action.nwe_object_type =
259 	    object_type;
260 	(void) strlcpy(event->event_msg->nwe_data.nwe_object_action.nwe_name,
261 	    object_name,
262 	    sizeof (event->event_msg->nwe_data.nwe_object_action.nwe_name));
263 	if (parent_name == NULL) {
264 		event->event_msg->nwe_data.nwe_object_action.nwe_parent[0] =
265 		    '\0';
266 		return (event);
267 	}
268 	(void) strlcpy
269 	    (event->event_msg->nwe_data.nwe_object_action.nwe_parent,
270 	    parent_name,
271 	    sizeof (event->event_msg->nwe_data.nwe_object_action.nwe_parent));
272 	return (event);
273 }
274 
275 nwamd_event_t
276 nwamd_event_init_object_state(nwam_object_type_t object_type,
277     const char *object_name, nwam_state_t state, nwam_aux_state_t aux_state)
278 {
279 	nwamd_event_t event;
280 
281 	event = nwamd_event_init(NWAM_EVENT_TYPE_OBJECT_STATE,
282 	    object_type, 0, object_name);
283 	if (event == NULL)
284 		return (NULL);
285 
286 	event->event_msg->nwe_data.nwe_object_state.nwe_state = state;
287 	event->event_msg->nwe_data.nwe_object_state.nwe_aux_state = aux_state;
288 	event->event_msg->nwe_data.nwe_object_state.nwe_object_type =
289 	    object_type;
290 	(void) strlcpy(event->event_msg->nwe_data.nwe_object_state.nwe_name,
291 	    object_name,
292 	    sizeof (event->event_msg->nwe_data.nwe_object_state.nwe_name));
293 
294 	return (event);
295 }
296 
297 nwamd_event_t
298 nwamd_event_init_priority_group_change(int64_t priority)
299 {
300 	nwamd_event_t event;
301 
302 	event = nwamd_event_init(NWAM_EVENT_TYPE_PRIORITY_GROUP,
303 	    NWAM_OBJECT_TYPE_UNKNOWN, 0, NULL);
304 	if (event == NULL)
305 		return (NULL);
306 
307 	event->event_msg->nwe_data.nwe_priority_group_info.nwe_priority =
308 	    priority;
309 
310 	return (event);
311 }
312 
313 nwamd_event_t
314 nwamd_event_init_link_action(const char *name, nwam_action_t link_action)
315 {
316 	nwamd_event_t event;
317 	nwam_error_t err;
318 	char *object_name;
319 
320 	if ((err = nwam_ncu_name_to_typed_name(name, NWAM_NCU_TYPE_LINK,
321 	    &object_name)) != NWAM_SUCCESS) {
322 		nlog(LOG_ERR, "nwamd_event_init_link_action: "
323 		    "nwam_ncu_name_to_typed_name: %s",
324 		    nwam_strerror(err));
325 		return (NULL);
326 	}
327 	event = nwamd_event_init(NWAM_EVENT_TYPE_LINK_ACTION,
328 	    NWAM_OBJECT_TYPE_NCU, 0, object_name);
329 	free(object_name);
330 	if (event == NULL)
331 		return (NULL);
332 
333 	(void) strlcpy(event->event_msg->nwe_data.nwe_link_action.nwe_name,
334 	    name,
335 	    sizeof (event->event_msg->nwe_data.nwe_link_action.nwe_name));
336 	event->event_msg->nwe_data.nwe_link_action.nwe_action = link_action;
337 
338 	return (event);
339 }
340 
341 nwamd_event_t
342 nwamd_event_init_link_state(const char *name, boolean_t up)
343 {
344 	nwamd_event_t event;
345 	nwam_error_t err;
346 	char *object_name;
347 
348 	if ((err = nwam_ncu_name_to_typed_name(name, NWAM_NCU_TYPE_LINK,
349 	    &object_name)) != NWAM_SUCCESS) {
350 		nlog(LOG_ERR, "nwamd_event_init_link_state: "
351 		    "nwam_ncu_name_to_typed_name: %s",
352 		    nwam_strerror(err));
353 		return (NULL);
354 	}
355 
356 	event = nwamd_event_init(NWAM_EVENT_TYPE_LINK_STATE,
357 	    NWAM_OBJECT_TYPE_NCU, 0, object_name);
358 	free(object_name);
359 	if (event == NULL)
360 		return (NULL);
361 
362 	(void) strlcpy(event->event_msg->nwe_data.nwe_link_state.nwe_name, name,
363 	    sizeof (event->event_msg->nwe_data.nwe_link_state.nwe_name));
364 	event->event_msg->nwe_data.nwe_link_state.nwe_link_up = up;
365 
366 	return (event);
367 }
368 
369 nwamd_event_t
370 nwamd_event_init_if_state(const char *linkname, uint32_t flags,
371     uint32_t addr_added, struct sockaddr *addr, struct sockaddr *netmask)
372 {
373 	nwamd_event_t event;
374 	nwam_error_t err;
375 	char *object_name;
376 
377 	/* linkname does not contain the lifnum */
378 	if ((err = nwam_ncu_name_to_typed_name(linkname,
379 	    NWAM_NCU_TYPE_INTERFACE, &object_name)) != NWAM_SUCCESS) {
380 		nlog(LOG_ERR, "nwamd_event_init_if_state: "
381 		    "nwam_ncu_name_to_typed_name: %s",
382 		    nwam_strerror(err));
383 		return (NULL);
384 	}
385 
386 	event = nwamd_event_init(NWAM_EVENT_TYPE_IF_STATE,
387 	    NWAM_OBJECT_TYPE_NCU, 0, object_name);
388 	free(object_name);
389 	if (event == NULL)
390 		return (NULL);
391 
392 	(void) strlcpy(event->event_msg->nwe_data.nwe_if_state.nwe_name,
393 	    linkname,
394 	    sizeof (event->event_msg->nwe_data.nwe_if_state.nwe_name));
395 	event->event_msg->nwe_data.nwe_if_state.nwe_flags = flags;
396 	event->event_msg->nwe_data.nwe_if_state.nwe_addr_added = addr_added;
397 	event->event_msg->nwe_data.nwe_if_state.nwe_addr_valid = (addr != NULL);
398 
399 	if (addr != NULL) {
400 		bcopy(addr, &(event->event_msg->nwe_data.nwe_if_state.nwe_addr),
401 		    addr->sa_family == AF_INET ? sizeof (struct sockaddr_in) :
402 		    sizeof (struct sockaddr_in6));
403 	}
404 	if (netmask != NULL) {
405 		bcopy(netmask,
406 		    &(event->event_msg->nwe_data.nwe_if_state.nwe_netmask),
407 		    netmask->sa_family == AF_INET ?
408 		    sizeof (struct sockaddr_in) : sizeof (struct sockaddr_in6));
409 	}
410 
411 	return (event);
412 }
413 
414 nwamd_event_t
415 nwamd_event_init_wlan(const char *name, int32_t type, boolean_t connected,
416     nwam_wlan_t *wlans, uint_t num_wlans)
417 {
418 	size_t size = 0;
419 	char *object_name;
420 	nwamd_event_t event;
421 	nwam_error_t err;
422 
423 	switch (type) {
424 	case NWAM_EVENT_TYPE_WLAN_SCAN_REPORT:
425 	case NWAM_EVENT_TYPE_WLAN_NEED_CHOICE:
426 		size = sizeof (nwam_wlan_t) * (num_wlans - 1);
427 		break;
428 	case NWAM_EVENT_TYPE_WLAN_NEED_KEY:
429 	case NWAM_EVENT_TYPE_WLAN_CONNECTION_REPORT:
430 		break;
431 	default:
432 		nlog(LOG_ERR, "nwamd_event_init_wlan: unexpected "
433 		    "event type %s (%d)", nwamd_event_name(type), type);
434 		return (NULL);
435 	}
436 	if ((err = nwam_ncu_name_to_typed_name(name, NWAM_NCU_TYPE_LINK,
437 	    &object_name)) != NWAM_SUCCESS) {
438 		nlog(LOG_ERR, "nwamd_event_init_wlan: "
439 		    "nwam_ncu_name_to_typed_name: %s",
440 		    nwam_strerror(err));
441 		return (NULL);
442 	}
443 
444 	event = nwamd_event_init(type, NWAM_OBJECT_TYPE_NCU, size, object_name);
445 	free(object_name);
446 	if (event == NULL)
447 		return (NULL);
448 
449 	(void) strlcpy(event->event_msg->nwe_data.nwe_wlan_info.nwe_name, name,
450 	    sizeof (event->event_msg->nwe_data.nwe_wlan_info.nwe_name));
451 	event->event_msg->nwe_data.nwe_wlan_info.nwe_connected = connected;
452 	event->event_msg->nwe_data.nwe_wlan_info.nwe_num_wlans = num_wlans;
453 
454 	/* copy the wlans */
455 	(void) memcpy(event->event_msg->nwe_data.nwe_wlan_info.nwe_wlans, wlans,
456 	    num_wlans * sizeof (nwam_wlan_t));
457 
458 	return (event);
459 }
460 
461 nwamd_event_t
462 nwamd_event_init_ncu_check(void)
463 {
464 	return (nwamd_event_init(NWAM_EVENT_TYPE_NCU_CHECK,
465 	    NWAM_OBJECT_TYPE_NCP, 0, NULL));
466 }
467 
468 nwamd_event_t
469 nwamd_event_init_init(void)
470 {
471 	return (nwamd_event_init(NWAM_EVENT_TYPE_INIT,
472 	    NWAM_OBJECT_TYPE_UNKNOWN, 0, NULL));
473 }
474 
475 nwamd_event_t
476 nwamd_event_init_shutdown(void)
477 {
478 	return (nwamd_event_init(NWAM_EVENT_TYPE_SHUTDOWN,
479 	    NWAM_OBJECT_TYPE_UNKNOWN, 0, NULL));
480 }
481 
482 /*
483  * Add event to the event list.
484  */
485 void
486 nwamd_event_enqueue(nwamd_event_t event)
487 {
488 	nwamd_event_enqueue_timed(event, 0);
489 }
490 
491 /*
492  * Schedule an event to be added to the event list for future processing.
493  * The event will be scheduled in delta_seconds seconds mod schedule delay and
494  * time resolution.
495  */
496 void
497 nwamd_event_enqueue_timed(nwamd_event_t event, int delta_seconds)
498 {
499 	uu_list_index_t idx;
500 
501 	nlog(LOG_DEBUG, "enqueueing event %lld %d (%s) for object %s in %ds",
502 	    event->event_id, event->event_type,
503 	    nwamd_event_name(event->event_type),
504 	    event->event_object[0] != 0 ?  event->event_object : "none",
505 	    delta_seconds);
506 
507 	(void) clock_gettime(CLOCK_REALTIME, &event->event_time);
508 	event->event_time.tv_sec += delta_seconds;
509 
510 	uu_list_node_init(event, &event->event_node, event_pool);
511 
512 	(void) pthread_mutex_lock(&event_queue_mutex);
513 
514 	/*
515 	 * Find appropriate location to insert the event based on time.
516 	 */
517 	(void) uu_list_find(event_queue, event, NULL, &idx);
518 	(void) uu_list_insert(event_queue, event, idx);
519 
520 	(void) pthread_cond_signal(&event_queue_cond);
521 	(void) pthread_mutex_unlock(&event_queue_mutex);
522 }
523 
524 /*
525  * Is the specified event enqueued on the event (or pending event queue)
526  * for execution in when seconds? An object may be specified also.
527  */
528 boolean_t
529 nwamd_event_enqueued(int32_t event_type, nwam_object_type_t object_type,
530     const char *object)
531 {
532 	nwamd_event_t event;
533 
534 	(void) pthread_mutex_lock(&event_queue_mutex);
535 	for (event = uu_list_first(event_queue);
536 	    event != NULL;
537 	    event = uu_list_next(event_queue, event)) {
538 		if (event->event_type != event_type)
539 			continue;
540 		if (object_type != NWAM_OBJECT_TYPE_UNKNOWN &&
541 		    event->event_object_type != object_type)
542 			continue;
543 		if (object != NULL && strcmp(object, event->event_object) != 0)
544 			continue;
545 		(void) pthread_mutex_unlock(&event_queue_mutex);
546 		return (B_TRUE);
547 	}
548 	(void) pthread_mutex_unlock(&event_queue_mutex);
549 
550 	return (B_FALSE);
551 }
552 
553 /*
554  * Is the time in the past.
555  */
556 static boolean_t
557 in_past(struct timespec t)
558 {
559 	struct timespec now;
560 
561 	(void) clock_gettime(CLOCK_REALTIME, &now);
562 	if (t.tv_sec < now.tv_sec)
563 		return (B_TRUE);
564 	if (t.tv_sec > now.tv_sec)
565 		return (B_FALSE);
566 	if (t.tv_nsec < now.tv_nsec)
567 		return (B_TRUE);
568 	return (B_FALSE);
569 }
570 
571 /*
572  * Remove event at head of event list for processing.  This takes a number of
573  * nanoseconds to wait.  If the number is 0 then it blocks.  If there is
574  * nothing on the queue then it returns an event which says that the queue
575  * is quiet.
576  */
577 static nwamd_event_t
578 nwamd_event_dequeue(long nsec)
579 {
580 	nwamd_event_t event;
581 
582 	(void) pthread_mutex_lock(&event_queue_mutex);
583 	event = uu_list_first(event_queue);
584 	if (event == NULL && nsec == 0) {
585 		do {
586 			(void) pthread_cond_wait(&event_queue_cond,
587 			    &event_queue_mutex);
588 		} while ((event = uu_list_first(event_queue)) == NULL);
589 	} else {
590 		struct timespec waitcap;
591 
592 		if (nsec != 0) {
593 			(void) clock_gettime(CLOCK_REALTIME, &waitcap);
594 			waitcap.tv_nsec += nsec;
595 			waitcap.tv_sec += NSEC_TO_SEC(waitcap.tv_nsec);
596 			waitcap.tv_nsec = NSEC_TO_FRACNSEC(waitcap.tv_nsec);
597 		}
598 
599 		/*
600 		 * Keep going as long as the first event hasn't matured and
601 		 * we havn't passed our maximum wait time.
602 		 */
603 		while ((event == NULL || !in_past(event->event_time)) &&
604 		    (nsec == 0 || !in_past(waitcap)))  {
605 			struct timespec eventwait;
606 
607 			/*
608 			 * Three cases:
609 			 *	no maximum waittime - just use the event
610 			 *	both an event and cap - take the least one
611 			 *	just a maximum waittime - use it
612 			 */
613 			if (nsec == 0) {
614 				eventwait = event->event_time;
615 			} else if (event != NULL) {
616 				uint64_t diff;
617 				diff = SEC_TO_NSEC(event->event_time.tv_sec -
618 				    waitcap.tv_sec) +
619 				    event->event_time.tv_nsec - waitcap.tv_nsec;
620 
621 				if (diff > 0)
622 					eventwait = waitcap;
623 				else
624 					eventwait = event->event_time;
625 			} else {
626 				/*
627 				 * Note that if the event is NULL then nsec is
628 				 * nonzero and waitcap is valid.
629 				 */
630 				eventwait = waitcap;
631 			}
632 
633 			(void) pthread_cond_timedwait(&event_queue_cond,
634 			    &event_queue_mutex, &eventwait);
635 			event = uu_list_first(event_queue);
636 		}
637 	}
638 
639 	/*
640 	 * At this point we've met the guard contition of the while loop.
641 	 * The event at the top of the queue might be mature in which case
642 	 * we use it.  Otherwise we hit our cap and we need to enqueue a
643 	 * quiesced queue event.
644 	 */
645 	if (event != NULL && in_past(event->event_time)) {
646 		uu_list_remove(event_queue, event);
647 		uu_list_node_fini(event, &event->event_node, event_pool);
648 	} else {
649 		event = nwamd_event_init(NWAM_EVENT_TYPE_QUEUE_QUIET,
650 		    NWAM_OBJECT_TYPE_UNKNOWN, 0, NULL);
651 	}
652 
653 	if (event != NULL)
654 		nlog(LOG_DEBUG,
655 		    "dequeueing event %lld of type %d (%s) for object %s",
656 		    event->event_id, event->event_type,
657 		    nwamd_event_name(event->event_type),
658 		    event->event_object[0] != 0 ?  event->event_object :
659 		    "none");
660 
661 	(void) pthread_mutex_unlock(&event_queue_mutex);
662 
663 	return (event);
664 }
665 
666 void
667 nwamd_event_send(nwam_event_t event_msg)
668 {
669 	nwam_error_t err;
670 
671 	if (shutting_down && event_msg->nwe_type != NWAM_EVENT_TYPE_SHUTDOWN) {
672 		nlog(LOG_DEBUG, "nwamd_event_send: tossing event as nwamd "
673 		    "is shutting down");
674 		return;
675 	}
676 
677 	err = nwam_event_send(event_msg);
678 
679 	if (err != NWAM_SUCCESS) {
680 		nlog(LOG_ERR, "nwamd_event_send: nwam_event_send: %s",
681 		    nwam_strerror(err));
682 	}
683 }
684 
685 /*
686  * Run state machine for object. Method is run if
687  * - event method is non-null
688  * - event method is valid for current object state (determined by
689  * ORing the current state against the set of valid states for the method).
690  *
691  * If these criteria are met, the method is run.
692  */
693 static void
694 nwamd_event_run_method(nwamd_event_t event)
695 {
696 	nwamd_event_method_t *event_methods;
697 	int i;
698 
699 	event_methods = nwamd_object_event_methods(event->event_object_type);
700 
701 	/* If we're shutting down, only fini events are accepted for objects */
702 	if (shutting_down && event->event_type != NWAM_EVENT_TYPE_OBJECT_FINI) {
703 		nlog(LOG_DEBUG, "nwamd_event_run_method: tossing non-fini "
704 		    "event %s for object %s",
705 		    nwamd_event_name(event->event_type), event->event_object);
706 		return;
707 	}
708 
709 	for (i = 0;
710 	    event_methods[i].event_type != NWAM_EVENT_TYPE_NOOP;
711 	    i++) {
712 		if (event_methods[i].event_type ==
713 		    event->event_type &&
714 		    event_methods[i].event_method != NULL) {
715 			nlog(LOG_DEBUG,
716 			    "(%p) %s: running method for event %s",
717 			    (void *)event, event->event_object,
718 			    nwamd_event_name(event->event_type));
719 			/* run method */
720 			event_methods[i].event_method(event);
721 			return;
722 		}
723 	}
724 	nlog(LOG_DEBUG, "(%p) %s: no matching method for event %d (%s)",
725 	    (void *)event, event->event_object, event->event_type,
726 	    nwamd_event_name(event->event_type));
727 }
728 
729 /*
730  * Called when we are checking to see what should be activated.  First activate
731  * all of the manual NCUs.  Then see if we can find a valid priority group.
732  * If we can, activate it.  Otherwise try all the priority groups starting
733  * with the lowest one that makes sense.
734  */
735 static void
736 nwamd_activate_ncus(void) {
737 	int64_t prio = INVALID_PRIORITY_GROUP;
738 	boolean_t selected;
739 
740 	nwamd_ncp_activate_manual_ncus();
741 	selected = nwamd_ncp_check_priority_group(&prio);
742 	if (selected) {
743 		/*
744 		 * Activate chosen priority group and stop anything going on in
745 		 * lesser priority groups.
746 		 */
747 		nwamd_ncp_activate_priority_group(prio);
748 		nwamd_ncp_deactivate_priority_group_all(prio + 1);
749 	} else {
750 		/*
751 		 * Nothing unique could be started so try them all.  Once one
752 		 * of them gets into a reasonable state then we will prune
753 		 * everything below it (see first part of this conditional).
754 		 */
755 		int64_t oldprio = INVALID_PRIORITY_GROUP;
756 		while (nwamd_ncp_find_next_priority_group(++oldprio, &prio)) {
757 			nwamd_ncp_activate_priority_group(prio);
758 			oldprio = prio;
759 		}
760 	}
761 }
762 
763 /*
764  * Event handler thread
765  *
766  * The complexity in this code comes about from wanting to delay the decision
767  * making process until after bursts of events.  Keep roughly polling (waiting
768  * for .1s) until we see the queue quiet event and then block.
769  */
770 void
771 nwamd_event_handler(void)
772 {
773 	boolean_t got_shutdown_event = B_FALSE;
774 	boolean_t check_conditions = B_FALSE;
775 	boolean_t ncu_check = B_FALSE;
776 	int queue_quiet_time = 0;
777 	nwamd_event_t event;
778 
779 	/*
780 	 * Dequeue events and process them.  In most cases, events have
781 	 * an assocated object type, and we use this to retrieve
782 	 * the function that will process the event.
783 	 */
784 	while (!got_shutdown_event) {
785 		event = nwamd_event_dequeue(queue_quiet_time);
786 		/* keep pulling events as long as they are close together */
787 		queue_quiet_time = SEC_TO_NSEC(1)/10;
788 
789 		/*
790 		 * This is an event with no associated object.
791 		 */
792 		if (event->event_object[0] == '\0') {
793 			switch (event->event_type) {
794 			case NWAM_EVENT_TYPE_NOOP:
795 			case NWAM_EVENT_TYPE_INIT:
796 				/*
797 				 * The only action for an INIT event
798 				 * is to relay it to event listeners,
799 				 * which is done below.
800 				 */
801 				break;
802 			case NWAM_EVENT_TYPE_PRIORITY_GROUP:
803 				(void) pthread_mutex_lock(&active_ncp_mutex);
804 				current_ncu_priority_group =
805 				    event->event_msg->nwe_data.
806 				    nwe_priority_group_info.nwe_priority;
807 				(void) pthread_mutex_unlock(&active_ncp_mutex);
808 				break;
809 			case NWAM_EVENT_TYPE_TIMED_CHECK_CONDITIONS:
810 				if (!shutting_down) {
811 					nwamd_set_timed_check_all_conditions();
812 					check_conditions = B_TRUE;
813 				}
814 				break;
815 			case NWAM_EVENT_TYPE_TRIGGERED_CHECK_CONDITIONS:
816 				if (!shutting_down)
817 					check_conditions = B_TRUE;
818 				break;
819 			case NWAM_EVENT_TYPE_NCU_CHECK:
820 				if (!shutting_down)
821 					ncu_check = B_TRUE;
822 				break;
823 			case NWAM_EVENT_TYPE_UPGRADE:
824 				if (!shutting_down) {
825 					/*
826 					 * Upgrade events have no associated
827 					 * object.
828 					 */
829 					nwamd_event_run_method(event);
830 				}
831 				break;
832 			case NWAM_EVENT_TYPE_SHUTDOWN:
833 				got_shutdown_event = B_TRUE;
834 				break;
835 
836 			/*
837 			 * We want to delay processing of condition and ncu
838 			 * checking until after short bursts of events.  So we
839 			 * keep track of times we've scheduled checking and
840 			 * wait for the queue to quiesce.
841 			 */
842 			case NWAM_EVENT_TYPE_QUEUE_QUIET:
843 				queue_quiet_time = 0; /* now we can block */
844 				if (!shutting_down && check_conditions) {
845 					nwamd_check_all_conditions();
846 					check_conditions = B_FALSE;
847 				}
848 
849 				if (!shutting_down && ncu_check) {
850 					nwamd_activate_ncus();
851 					ncu_check = B_FALSE;
852 				}
853 				break;
854 
855 			default:
856 				nlog(LOG_ERR,
857 				    "event %d (%s)had no object associated "
858 				    "with it", event->event_type,
859 				    nwamd_event_name(event->event_type));
860 				break;
861 			}
862 		} else {
863 			/*
864 			 * Event has an associated object - run event method
865 			 * for that object type (if any).
866 			 */
867 			nwamd_event_run_method(event);
868 		}
869 		/*
870 		 * Send associated message to listeners if event type is
871 		 * externally visible.
872 		 */
873 		if (event->event_send)
874 			nwamd_event_send(event->event_msg);
875 
876 		nwamd_event_fini(event);
877 	}
878 	/* If we get here, we got a shutdown event. */
879 	nwamd_event_queue_fini();
880 	nwamd_object_lists_fini();
881 }
882