lib/nwamd/ncp.c

	ncp.c revision f6da83d4178694e7113b71d1e452f15b296f73d8
/*
 * 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_link.nwamd_link_activation_mode !=
        NWAM_ACTIVATION_MODE_PRIORITIZED)
        return (0);

    priority = ncu->ncu_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_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_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_link.nwamd_link_priority_group;
    priority_mode = ncu->ncu_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);
}