/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.
 */

#include <arpa/inet.h>
#include <assert.h>
#include <libdllink.h>
#include <libdlstat.h>
#include <libnwam.h>
#include <libscf.h>
#include <netinet/in.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <sys/types.h>
#include <values.h>

#include "conditions.h"
#include "events.h"
#include "objects.h"
#include "ncp.h"
#include "ncu.h"
#include "util.h"

/*
 * ncp.c - handles NCP actions.
 */

char active_ncp[NWAM_MAX_NAME_LEN];
nwam_ncp_handle_t active_ncph = NULL;
int64_t current_ncu_priority_group = INVALID_PRIORITY_GROUP;
/*
 * active_ncp_mutex protects active_ncp, active_ncph and
 * current_ncu_priority_group.
 */
pthread_mutex_t active_ncp_mutex = PTHREAD_MUTEX_INITIALIZER;

/*
 * The variable ncu_wait_time specifies how long to wait to obtain a
 * DHCP lease before giving up on that NCU and moving on to the next/lower
 * priority-group.
 */
uint64_t ncu_wait_time = NCU_WAIT_TIME_DEFAULT;

/*
 * Specifies if this is the first time the NCP has been enabled. True
 * on startup so that we can differentiate between when we start up
 * with a given NCP versus when we are asked to reenable it.
 */
boolean_t initial_ncp_enable = B_TRUE;

/*
 * nwamd_ncp_handle_enable_event() should be called in the event handling
 * loop in response to an _ENABLE event, triggered as a result of an
 * nwam_ncp_enable() call from a libnwam consumer.  To enable the new NCP,
 * we first call nwamd_fini_ncus() on the old NCP.  This results in enqueueing
 * of a set of _FINI events for each NCU.  These events are handled and in
 * order to tear down config, (online*, uninitialized) state change events
 * are created and consumed directly by the fini event handler (these events
 * are not enqueued as this would result in state events for the old NCP
 * appearing after the new NCP has been enabled.  After the _FINI events are
 * enqueued, we enqueue an NCP _OBJECT_STATE event for the new NCP.  Since
 * it is enqueued after the _FINI events, we are guaranteed no events for the
 * old NCP will appear after the new NCP is activated.
 */
void
nwamd_ncp_handle_enable_event(nwamd_event_t event)
{
	char *new_ncp = event->event_object;
	nwam_ncp_handle_t new_ncph;
	nwam_error_t err;

	if (new_ncp[0] == '\0')
		return;

	(void) pthread_mutex_lock(&active_ncp_mutex);
	if (strcmp(active_ncp, new_ncp) == 0 && !initial_ncp_enable) {
		nlog(LOG_DEBUG, "nwamd_ncp_handle_enable_event: "
		    "%s is already active", new_ncp);
		(void) pthread_mutex_unlock(&active_ncp_mutex);
		return;
	}
	(void) pthread_mutex_unlock(&active_ncp_mutex);

	nlog(LOG_DEBUG, "nwamd_ncp_handle_enable_event: activating NCP %s",
	    new_ncp);

	/*
	 * To activate new NCP, run nwamd_fini_ncus(), reset the active
	 * priority-group, set the active_ncp property and refresh the
	 * daemon.  The refresh action will trigger a re-read of the NCUs
	 * for the activated NCP.
	 */

	nwamd_fini_ncus();

	if ((err = nwam_ncp_read(new_ncp, 0, &new_ncph))
	    == NWAM_ENTITY_NOT_FOUND) {
		err = nwam_ncp_create(new_ncp, 0, &new_ncph);
	}

	if (err == NWAM_SUCCESS) {
		nwam_ncp_free(new_ncph);
		nwamd_object_set_state(NWAM_OBJECT_TYPE_NCP, new_ncp,
		    NWAM_STATE_ONLINE, NWAM_AUX_STATE_ACTIVE);
	} else if (initial_ncp_enable) {
		/*
		 * We weren't able to enable the NCP when nwamd starts up,
		 * retry in a few seconds.
		 */
		nwamd_event_t retry_event = nwamd_event_init_object_action
		    (NWAM_OBJECT_TYPE_NCP, new_ncp, NULL, NWAM_ACTION_ENABLE);
		if (retry_event == NULL) {
			nlog(LOG_ERR, "nwamd_ncp_handle_enable_event: "
			    "could not create retry event to enable %s NCP",
			    new_ncp);
			return;
		}

		nlog(LOG_ERR, "nwamd_ncp_handle_enable_event: "
		    "failed to enable %s NCP, retrying in %d seconds",
		    new_ncp, NWAMD_READONLY_RETRY_INTERVAL);
		nwamd_event_enqueue_timed(retry_event,
		    NWAMD_READONLY_RETRY_INTERVAL);
	} else {
		nlog(LOG_ERR, "nwamd_ncp_handle_enable_event: error %s",
		    nwam_strerror(err));
		return;
	}
}

void
nwamd_ncp_handle_action_event(nwamd_event_t event)
{
	switch (event->event_msg->nwe_data.nwe_object_action.nwe_action) {
	case NWAM_ACTION_ENABLE:
		nwamd_ncp_handle_enable_event(event);
		break;
	case NWAM_ACTION_ADD:
	case NWAM_ACTION_DESTROY:
		/* nothing to do */
		break;
	default:
		nlog(LOG_INFO, "nwam_ncp_handle_action_event: "
		    "unexpected action");
		nwamd_event_do_not_send(event);
		break;
	}
}

/*
 * The only state events we create are (online, active) events which are
 * generated as part of an NCP enable action (see above).
 */
void
nwamd_ncp_handle_state_event(nwamd_event_t event)
{
	char *new_ncp = event->event_object;
	nwam_ncp_handle_t new_ncph, old_ncph;
	nwam_error_t err;

	/* The NCP to be activated should always exist. */
	if ((err = nwam_ncp_read(new_ncp, 0, &new_ncph)) != NWAM_SUCCESS) {
		nlog(LOG_ERR, "nwamd_ncp_handle_state_event: "
		    "cannot read NCP %s: : %s", new_ncp, nwam_strerror(err));
		nwamd_event_do_not_send(event);
		return;
	}

	/*
	 * To activate new NCP, reset the active priority-group, set the
	 * active_ncp property and refresh the daemon.  The refresh action will
	 * trigger a re-read of the NCUs for the activated NCP.
	 */
	(void) pthread_mutex_lock(&active_ncp_mutex);
	old_ncph = active_ncph;
	active_ncph = new_ncph;
	nwam_ncp_free(old_ncph);
	current_ncu_priority_group = INVALID_PRIORITY_GROUP;
	(void) strlcpy(active_ncp, event->event_object,
	    sizeof (active_ncp));
	(void) pthread_mutex_unlock(&active_ncp_mutex);
	(void) nwamd_set_string_property(OUR_FMRI, OUR_PG,
	    OUR_ACTIVE_NCP_PROP_NAME, new_ncp);
	(void) smf_refresh_instance(OUR_FMRI);
	initial_ncp_enable = B_FALSE;
}

int
nwamd_ncp_action(const char *ncp, nwam_action_t action)
{
	nwamd_event_t event = nwamd_event_init_object_action
	    (NWAM_OBJECT_TYPE_NCP, ncp, NULL, action);
	if (event == NULL)
		return (1);
	nwamd_event_enqueue(event);
	return (0);
}

/*
 * Below this point are routines handling NCU prioritization
 * policy for the active NCP.
 */

struct priority_group_cbarg {
	uint64_t minpriority;
	uint64_t currpriority;
	boolean_t found;
};

/* Callback used to find next pg in NCP that is >= start_pg */
static int
find_next_priority_group_cb(nwamd_object_t object, void *data)
{
	struct priority_group_cbarg *cbarg = data;
	uint64_t priority;
	nwamd_ncu_t *ncu = object->nwamd_object_data;

	if (ncu->ncu_node.u_link.nwamd_link_activation_mode !=
	    NWAM_ACTIVATION_MODE_PRIORITIZED)
		return (0);

	priority = ncu->ncu_node.u_link.nwamd_link_priority_group;

	if (priority >= cbarg->minpriority && priority < cbarg->currpriority) {
		cbarg->found = B_TRUE;
		cbarg->currpriority = priority;
	}
	return (0);
}

/* Set current_pg to next pg in NCP that is >= start_pg */
boolean_t
nwamd_ncp_find_next_priority_group(int64_t minpriority,
    int64_t *nextpriorityp)
{
	struct priority_group_cbarg cbarg;

	cbarg.minpriority = minpriority;
	cbarg.currpriority = MAXINT;
	cbarg.found = B_FALSE;

	(void) nwamd_walk_objects(NWAM_OBJECT_TYPE_NCU,
	    find_next_priority_group_cb, &cbarg);

	if (cbarg.found) {
		nlog(LOG_DEBUG, "nwamd_ncp_find_next_priority_group: "
		    "next priority group >= %lld is %lld",
		    minpriority, cbarg.currpriority);
		*nextpriorityp = cbarg.currpriority;
		return (B_TRUE);
	} else {
		nlog(LOG_DEBUG, "nwamd_ncp_find_next_priority_group: "
		    "no priority groups >= %lld exist", minpriority);
		return (B_FALSE);
	}
}

/*
 * Struct for walking NCUs in the selected priority group.  We count
 * how many of the exclusive, all and shared NCUs are online, and
 * if activate_or_deactivate is true, we either activate or deactivate
 * (depending on the value of activate) offline/online NCUs.
 */
struct nwamd_ncu_check_walk_arg {
	boolean_t manual;	/* enable manual NCUs only */
	int64_t priority_group; /* interested priority-group for this walk */
	uint64_t exclusive_ncus;
	uint64_t exclusive_online_ncus;
	uint64_t shared_ncus;
	uint64_t shared_online_ncus;
	uint64_t all_ncus;
	uint64_t all_online_ncus;
	boolean_t activate_or_deactivate;
	boolean_t activate;
};

/*
 * This function serves a number of purposes:
 * - it supports activation/deactivation of manual NCUs in the current NCP
 * (when wa->manual is true, wa->activate determines if we activate or
 * deactivate the current NCU)
 * - it supports checking/activation of a particular priority group in
 * the active NCP. This works as follows:
 *
 * Count up numbers of exclusive, shared and all NCUs, and how many of each
 * are online.  If an NCU is waiting for IP address to be assigned, it is
 * also considered online.  If activate_or_deactivate is true, we also
 * either activate (if activate is true) or deactivate prioritized NCUs
 * that are offline or online.
 */
static int
nwamd_ncu_check_or_activate(nwamd_object_t object, void *data)
{
	struct nwamd_ncu_check_walk_arg *wa = data;
	nwamd_ncu_t *ncu;
	uint64_t priority_group, priority_mode;
	nwamd_object_t if_obj;
	nwam_state_t state, if_state;
	nwam_aux_state_t aux_state, if_aux_state;
	char *name;

	state = object->nwamd_object_state;
	aux_state = object->nwamd_object_aux_state;
	name = object->nwamd_object_name;
	ncu = object->nwamd_object_data;

	/* skip NCUs in UNINITIALIZED state */
	if (state == NWAM_STATE_UNINITIALIZED) {
		nlog(LOG_DEBUG, "nwamd_ncu_check_or_activate: "
		    "skipping uninitialized ncu %s", name);
		return (0);
	}
	if (!wa->manual && wa->priority_group == INVALID_PRIORITY_GROUP)
		return (0);

	if (ncu->ncu_type != NWAM_NCU_TYPE_LINK) {
		nlog(LOG_DEBUG, "nwamd_ncu_check_or_activate: "
		    "skipping interface NCU %s", name);
		return (0);
	}
	if (!wa->manual && ncu->ncu_node.u_link.nwamd_link_activation_mode !=
	    NWAM_ACTIVATION_MODE_PRIORITIZED) {
		nlog(LOG_DEBUG, "nwamd_ncu_check_or_activate: "
		    "skipping non-prioritized NCU %s", name);
		return (0);
	}
	if (wa->manual && ncu->ncu_node.u_link.nwamd_link_activation_mode !=
	    NWAM_ACTIVATION_MODE_MANUAL) {
		nlog(LOG_DEBUG, "nwamd_ncu_check_or_activate: "
		    "skipping non-manual NCU %s", name);
		return (0);
	}

	priority_group = ncu->ncu_node.u_link.nwamd_link_priority_group;
	priority_mode = ncu->ncu_node.u_link.nwamd_link_priority_mode;
	/* Only work with NCUs in the requested priority-group */
	if (!wa->manual && priority_group != wa->priority_group) {
		nlog(LOG_DEBUG, "nwamd_ncu_check_or_activate: "
		    "skipping NCU %s in different priority-group", name);
		return (0);
	}
	/* Get the state of the corresponding interface NCU */
	if ((if_obj = nwamd_ncu_object_find(NWAM_NCU_TYPE_INTERFACE,
	    ncu->ncu_name)) == NULL) {
		nlog(LOG_ERR, "nwamd_ncu_check_or_activate: "
		    "interface NCU of %s not found, skipping", name);
		return (0);
	}
	if_state = if_obj->nwamd_object_state;
	if_aux_state = if_obj->nwamd_object_aux_state;
	nwamd_object_release(if_obj);

	nlog(LOG_DEBUG, "nwamd_ncu_check_or_activate: %s ncu %s",
	    wa->activate_or_deactivate ?
	    (wa->activate ? "activating" : "deactivating") :
	    "checking", name);

	if (wa->manual) {
		if (wa->activate_or_deactivate && wa->activate) {
			if (state == NWAM_STATE_OFFLINE && ncu->ncu_enabled) {
				nlog(LOG_DEBUG, "nwamd_ncu_check_or_activate: "
				    "moving NCU %s to offline* from offline",
				    name);
				nwamd_object_set_state(NWAM_OBJECT_TYPE_NCU,
				    name, NWAM_STATE_OFFLINE_TO_ONLINE,
				    NWAM_AUX_STATE_INITIALIZED);
			}
			if (state != NWAM_STATE_DISABLED &&
			    !ncu->ncu_enabled) {
				nlog(LOG_DEBUG, "nwamd_ncu_check_or_activate: "
				    "moving NCU %s to online* (disabling)",
				    name);
				nwamd_object_set_state(NWAM_OBJECT_TYPE_NCU,
				    name, NWAM_STATE_ONLINE_TO_OFFLINE,
				    NWAM_AUX_STATE_MANUAL_DISABLE);
			}
		}
		return (0);
	}
	switch (priority_mode) {
	case NWAM_PRIORITY_MODE_EXCLUSIVE:
		wa->exclusive_ncus++;
		if (state == NWAM_STATE_ONLINE &&
		    (if_state == NWAM_STATE_ONLINE ||
		    if_aux_state == NWAM_AUX_STATE_IF_WAITING_FOR_ADDR))
			wa->exclusive_online_ncus++;

		/*
		 * For exclusive NCUs, we activate offline NCUs as long
		 * as no other exclusive NCUs are active.
		 */
		if (wa->activate_or_deactivate && wa->activate) {
			if (state == NWAM_STATE_OFFLINE &&
			    wa->exclusive_online_ncus == 0) {
				nlog(LOG_DEBUG, "nwamd_ncu_check_or_activate: "
				    "moving NCU %s to offline* from offline",
				    name);
				nwamd_object_set_state(NWAM_OBJECT_TYPE_NCU,
				    name, NWAM_STATE_OFFLINE_TO_ONLINE,
				    NWAM_AUX_STATE_INITIALIZED);
			}
		}
		if (wa->activate_or_deactivate && !wa->activate) {
			if (aux_state != NWAM_AUX_STATE_CONDITIONS_NOT_MET) {
				nlog(LOG_DEBUG, "nwamd_ncu_check_or_activate: "
				    "deactivating NCU %s", name);
				nwamd_object_set_state(NWAM_OBJECT_TYPE_NCU,
				    name, NWAM_STATE_ONLINE_TO_OFFLINE,
				    NWAM_AUX_STATE_CONDITIONS_NOT_MET);
			}
		}
		/*
		 * If we are activating or checking the priority group and
		 * too many exclusive NCUs are online, take this NCU down.
		 */
		if ((wa->activate_or_deactivate && wa->activate) ||
		    !wa->activate_or_deactivate) {
			if (state == NWAM_STATE_ONLINE &&
			    if_state == NWAM_STATE_ONLINE &&
			    wa->exclusive_online_ncus > 1) {
				nlog(LOG_DEBUG, "nwamd_ncu_check_or_activate: "
				    "moving NCU %s to online* since another "
				    "NCU is already active",
				    name);
				nwamd_object_set_state(NWAM_OBJECT_TYPE_NCU,
				    name, NWAM_STATE_ONLINE_TO_OFFLINE,
				    NWAM_AUX_STATE_CONDITIONS_NOT_MET);
			}
		}
		break;
	case NWAM_PRIORITY_MODE_SHARED:
		wa->shared_ncus++;
		if (state == NWAM_STATE_ONLINE &&
		    (if_state == NWAM_STATE_ONLINE ||
		    if_aux_state == NWAM_AUX_STATE_IF_WAITING_FOR_ADDR))
			wa->shared_online_ncus++;

		if (wa->activate_or_deactivate && wa->activate) {
			if (state == NWAM_STATE_OFFLINE) {
				nlog(LOG_DEBUG, "nwamd_ncu_check_or_activate: "
				    "activating NCU %s", name);
				nwamd_object_set_state(NWAM_OBJECT_TYPE_NCU,
				    name, NWAM_STATE_OFFLINE_TO_ONLINE,
				    NWAM_AUX_STATE_INITIALIZED);
			}
		}
		if (wa->activate_or_deactivate && !wa->activate) {
			if (aux_state != NWAM_AUX_STATE_CONDITIONS_NOT_MET) {
				nlog(LOG_DEBUG, "nwamd_ncu_check_or_activate: "
				    "deactivating NCU %s", name);
				nwamd_object_set_state(NWAM_OBJECT_TYPE_NCU,
				    name, NWAM_STATE_ONLINE_TO_OFFLINE,
				    NWAM_AUX_STATE_CONDITIONS_NOT_MET);
			}
		}
		break;
	case NWAM_PRIORITY_MODE_ALL:
		wa->all_ncus++;
		if (state == NWAM_STATE_ONLINE &&
		    (if_state == NWAM_STATE_ONLINE ||
		    if_aux_state == NWAM_AUX_STATE_IF_WAITING_FOR_ADDR))
			wa->all_online_ncus++;

		/*
		 * For "all" NCUs, activate/deactivate all offline/online
		 * NCUs.
		 */
		if (wa->activate_or_deactivate && wa->activate) {
			if (state == NWAM_STATE_OFFLINE) {
				nlog(LOG_DEBUG, "nwamd_ncu_check_or_activate: "
				    "activating NCU %s", name);
				nwamd_object_set_state(NWAM_OBJECT_TYPE_NCU,
				    name, NWAM_STATE_OFFLINE_TO_ONLINE,
				    NWAM_AUX_STATE_INITIALIZED);
			}
		}
		if (wa->activate_or_deactivate && !wa->activate) {
			if (aux_state != NWAM_AUX_STATE_CONDITIONS_NOT_MET) {
				nlog(LOG_DEBUG, "nwamd_ncu_check_or_activate: "
				    "deactivating NCU %s", name);
				nwamd_object_set_state(NWAM_OBJECT_TYPE_NCU,
				    name, NWAM_STATE_ONLINE_TO_OFFLINE,
				    NWAM_AUX_STATE_CONDITIONS_NOT_MET);
			}
		}

		break;
	default:
		nlog(LOG_ERR, "nwamd_ncu_check_or_activate: "
		    "invalid priority-mode");
		break;
	}

	return (0);
}

void
nwamd_ncp_activate_priority_group(int64_t priority)
{
	struct nwamd_ncu_check_walk_arg wa;
	nwamd_event_t check_event, priority_event;

	if (priority == INVALID_PRIORITY_GROUP)
		return;

	(void) pthread_mutex_lock(&active_ncp_mutex);
	if (priority == current_ncu_priority_group) {
		(void) pthread_mutex_unlock(&active_ncp_mutex);
		return;
	}
	(void) pthread_mutex_unlock(&active_ncp_mutex);

	nlog(LOG_DEBUG, "nwamd_ncp_activate_priority_group: "
	    "activating priority group %lld", priority);

	wa.manual = B_FALSE;
	wa.priority_group = priority;
	wa.exclusive_ncus = 0;
	wa.exclusive_online_ncus = 0;
	wa.shared_ncus = 0;
	wa.shared_online_ncus = 0;
	wa.all_ncus = 0;
	wa.all_online_ncus = 0;
	wa.activate_or_deactivate = B_TRUE;
	wa.activate = B_TRUE;

	if (nwamd_walk_objects(NWAM_OBJECT_TYPE_NCU,
	    nwamd_ncu_check_or_activate, &wa) != 0) {
		nlog(LOG_ERR, "nwamd_ncp_activate_priority_group: "
		    "nwamd_walk_objects() failed");
		return;
	}

	/*
	 * Enqueue event to update current_ncu_priority_group and send to
	 * any event listeners.
	 */
	priority_event = nwamd_event_init_priority_group_change(priority);
	if (priority_event == NULL)
		return;
	nwamd_event_enqueue(priority_event);

	/*
	 * Now we've activated a new priority group, enqueue an event
	 * to check up on the state of this priority group.
	 */
	check_event = nwamd_event_init_ncu_check();
	if (check_event == NULL)
		return;
	nwamd_event_enqueue_timed(check_event, ncu_wait_time);
}

void
nwamd_ncp_deactivate_priority_group(int64_t priority)
{
	struct nwamd_ncu_check_walk_arg wa;

	if (priority == INVALID_PRIORITY_GROUP)
		return;

	nlog(LOG_DEBUG, "nwamd_ncp_deactivate_priority_group: "
	    "deactivating priority group %lld", priority);

	wa.manual = B_FALSE;
	wa.priority_group = priority;
	wa.exclusive_ncus = 0;
	wa.exclusive_online_ncus = 0;
	wa.shared_ncus = 0;
	wa.shared_online_ncus = 0;
	wa.all_ncus = 0;
	wa.all_online_ncus = 0;
	wa.activate_or_deactivate = B_TRUE;
	wa.activate = B_FALSE;

	if (nwamd_walk_objects(NWAM_OBJECT_TYPE_NCU,
	    nwamd_ncu_check_or_activate, &wa) != 0) {
		nlog(LOG_ERR, "nwamd_ncp_deactivate_priority_group: "
		    "nwamd_walk_objects() failed");
		return;
	}
}

/*
 * This function deactivates all priority groups at level 'priority' and lower
 * (which is, numerically, all priorities >= priority).
 */
void
nwamd_ncp_deactivate_priority_group_all(int64_t priority)
{
	if (priority == INVALID_PRIORITY_GROUP)
		return;

	nlog(LOG_DEBUG, "nwamd_ncp_deactivate_priority_group_all: "
	    "deactivating priority group less than or equal to %lld", priority);

	do {
		nwamd_ncp_deactivate_priority_group(priority);
	} while (nwamd_ncp_find_next_priority_group(priority + 1, &priority));
}

/*
 * Returns 'true' if it found the highest priority group no higher then what
 * is passed that should be activated and sets *priority to that.
 */
boolean_t
nwamd_ncp_check_priority_group(int64_t *priority)
{
	struct nwamd_ncu_check_walk_arg wa;
	boolean_t conditions_met = B_FALSE;

	nlog(LOG_DEBUG, "nwamd_ncp_check_priority_group: "
	    "checking priority group %lld", *priority);

	if (*priority == INVALID_PRIORITY_GROUP) {
		if (!nwamd_ncp_find_next_priority_group(0, priority))
			return (B_FALSE);
	}

	while (!conditions_met) {
		(void) memset(&wa, 0, sizeof (wa));
		wa.manual = B_FALSE;
		wa.priority_group = *priority;
		wa.activate_or_deactivate = B_FALSE;

		if (nwamd_walk_objects(NWAM_OBJECT_TYPE_NCU,
		    nwamd_ncu_check_or_activate, &wa) != 0) {
			nlog(LOG_ERR, "nwamd_ncp_check_priority_group: "
			    "nwamd_walk_objects() failed");
			return (B_FALSE);
		}

		/*
		 * Are activation conditons satisifed? In other words:
		 * - exactly one of the exclusive NCUs is online
		 * - 1 or more shared NCUs are online
		 * - all of the all NCUs are online.
		 * If any of these is untrue, conditions are not satisfied.
		 */
		conditions_met = B_TRUE;
		if (wa.exclusive_ncus > 0 && wa.exclusive_online_ncus != 1)
			conditions_met = B_FALSE;
		if (wa.shared_ncus > 0 && wa.shared_online_ncus == 0)
			conditions_met = B_FALSE;
		if (wa.all_ncus > 0 && wa.all_ncus != wa.all_online_ncus)
			conditions_met = B_FALSE;
		if (wa.exclusive_online_ncus == 0 &&
		    wa.shared_online_ncus == 0 && wa.all_online_ncus == 0)
			conditions_met = B_FALSE;

		if (conditions_met) {
			return (B_TRUE);
		} else {
			/*
			 * If there is a next pg, activate it. If not, do
			 * nothing - we're stuck here unless an event occurs
			 * for our or a higher pg.
			 */
			if (!nwamd_ncp_find_next_priority_group
			    (wa.priority_group + 1, priority)) {
				nlog(LOG_DEBUG, "ran out of prio groups");
				return (B_FALSE);
			}
		}
	}
	return (B_FALSE);
}

void
nwamd_ncp_activate_manual_ncus(void)
{
	struct nwamd_ncu_check_walk_arg wa;

	nlog(LOG_DEBUG, "nwamd_ncp_activate_manual_ncus: activating NCUs");

	wa.manual = B_TRUE;
	wa.activate_or_deactivate = B_TRUE;
	wa.activate = B_TRUE;

	if (nwamd_walk_objects(NWAM_OBJECT_TYPE_NCU,
	    nwamd_ncu_check_or_activate, &wa) != 0) {
		nlog(LOG_ERR, "nwamd_ncp_activate_manual_ncus: "
		    "nwamd_walk_objects() failed");
		return;
	}
}

void
nwamd_create_ncu_check_event(uint64_t when)
{
	nwamd_event_t check_event = nwamd_event_init_ncu_check();
	if (check_event != NULL)
		nwamd_event_enqueue_timed(check_event, when);
}