libmeta/common/meta_smf.c

/*
 * 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 2006 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * Service Management Facility (SMF) interfaces.
 */

#include <stdio.h>
#include <libscf.h>
#include <meta.h>

static void enable(char *svc_names[], md_error_t *ep);
static void disable(char *svc_names[], md_error_t *ep);
static int enabled(char *svc_name);
static int online(char *svc_names[], char **names);
static void wait_online(char *svc_names[]);
static int is_online(char *svc_name);

static char
*svm_core_svcs[] = {
    "system/metainit:default",
    "system/metasync:default",
    "system/mdmonitor:default",
    "network/rpc/meta:default",
    NULL
};

static char
*svm_diskset_svcs[] = {
    "network/rpc/metamed:default",
    "network/rpc/metamh:default",
    NULL
};

static char
*svm_mn_diskset_svcs[] = {
    "network/rpc/mdcomm:default",
    NULL
};

/*
 * Enable the specified SVM services through the SMF.
 */
int
meta_smf_enable(uint_t flags, md_error_t *ep)
{
    if (flags & META_SMF_CORE) {
        enable(svm_core_svcs, ep);
        wait_online(svm_core_svcs);
    }

    if (flags & META_SMF_DISKSET) {
        enable(svm_diskset_svcs, ep);
        wait_online(svm_diskset_svcs);
    }

    if (flags & META_SMF_MN_DISKSET) {
        enable(svm_mn_diskset_svcs, ep);
        wait_online(svm_mn_diskset_svcs);
    }

    if (ep != NULL)
        return ((mdisok(ep)) ? 0 : -1);
    else
        return (0);
}

/*
 * Disable the specified SVM services through the SMF.
 */
int
meta_smf_disable(uint_t flags, md_error_t *ep)
{
    if (flags & META_SMF_CORE) {
        disable(svm_core_svcs, ep);
    }

    if (flags & META_SMF_DISKSET) {
        disable(svm_diskset_svcs, ep);
    }

    if (flags & META_SMF_MN_DISKSET) {
        disable(svm_mn_diskset_svcs, ep);
    }

    if (ep != NULL)
        return ((mdisok(ep)) ? 0 : -1);
    else
        return (0);
}

/*
 * Determine if desired services are online.  If all services in the
 * classes specified by flags are online, 1 is returned.  Otherwise
 * 0 is returned.
 */

int
meta_smf_isonline(uint_t flags, md_error_t *ep)
{
    int ret = 1;
    char    *names = NULL;

    if (flags & META_SMF_CORE) {
        if (online(svm_core_svcs, &names) == 0)
            ret = 0;
    }
    if (flags & META_SMF_DISKSET) {
        if (online(svm_diskset_svcs, &names) == 0)
            ret = 0;
    }
    if (flags & META_SMF_MN_DISKSET) {
        if (online(svm_mn_diskset_svcs, &names) == 0)
            ret = 0;
    }

    if (ret == 0) {
        (void) mderror(ep, MDE_SMF_NO_SERVICE, names);
        Free(names);
    }

    return (ret);
}

/*
 * Return a bitmask of the META_SMF_* flags indicating which services should be
 * online given the current SVM configuration.
 */
int
meta_smf_getmask()
{
    int     mask = 0;
    mdsetname_t *sp = NULL;
    mddb_config_t   c;
    md_error_t  status = mdnullerror;
    md_error_t  *ep = &status;
    int     max_sets;

    /*
     * If there are any local metadbs configured then the core services
     * are needed.
     */
    (void) memset(&c, 0, sizeof (c));
    c.c_setno = MD_LOCAL_SET;
    if (metaioctl(MD_DB_GETDEV, &c, &c.c_mde, NULL) != 0 || c.c_dbcnt == 0)
        return (mask);

    mask |= META_SMF_CORE;

    /*
     * If any disksets configured then the diskset services are needed.
     * Also check for multi-node sets.
     */
    if ((max_sets = get_max_sets(ep)) > 0) {
        int i;

        mdclrerror(ep);
        for (i = 1; i < max_sets; i++) {
            md_set_desc *sd;

            if ((sp = metasetnosetname(i, ep)) == NULL) {
                if (!mdisok(ep) && !mdiserror(ep, MDE_NO_SET) &&
                    !mdiserror(ep, MDE_NOTENOUGH_DB) &&
                    !mdiserror(ep, MDE_SMF_NO_SERVICE) &&
                    ep->info.errclass != MDEC_RPC) {
                    /*
                     * metad rpc program not registered
                     * can't get diskset info
                     */
                    break;
                }

            } else {
                mask |= META_SMF_DISKSET;

                if ((sd = metaget_setdesc(sp, ep)) != NULL) {
                    if (MD_MNSET_DESC(sd)) {
                        mask |= META_SMF_MN_DISKSET;

                        /*
                         * we don't have to check the
                         * rest of the disksets at this
                         * point
                         */
                        break;
                    }
                }
            }

            mdclrerror(ep);
        }
    }

    return (mask);
}

static void
enable(char *svc_names[], md_error_t *ep)
{
    int i;

    for (i = 0; svc_names[i]; i++) {
        if (!enabled(svc_names[i]))
            if (smf_enable_instance(svc_names[i], 0) != 0) {
                if (ep != NULL) {
                    (void) mderror(ep, MDE_SMF_FAIL,
                        svc_names[i]);
                }
            }
    }
}

static void
disable(char *svc_names[], md_error_t *ep)
{
    int i;

    for (i = 0; svc_names[i]; i++) {
        if (enabled(svc_names[i]))
            if (smf_disable_instance(svc_names[i], 0) != 0) {
                if (ep != NULL) {
                    (void) mderror(ep, MDE_SMF_FAIL,
                        svc_names[i]);
                }
            }
    }
}

static int
enabled(char *svc_name)
{
    scf_simple_prop_t   *prop;
    int         rval = 0;

    prop = scf_simple_prop_get(NULL, svc_name, SCF_PG_GENERAL,
        SCF_PROPERTY_ENABLED);

    if (scf_simple_prop_numvalues(prop) == 1) {
        if (*scf_simple_prop_next_boolean(prop) != 0)
            rval = 1;
    }

    scf_simple_prop_free(prop);

    return (rval);
}

/*
 * There can be a delay while the RPC services get going.  Try to
 * make sure the RPC daemons are ready to run before we return.
 * Check 15 times (15 seconds total wait time) and then just
 * return.
 */
static void
wait_online(char *svc_names[])
{
    int i;
    char    *names = NULL;

    for (i = 0; i < 15; i++) {
        if (online(svc_names, &names))
            break;
        (void) sleep(1);
    }

    if (names != NULL)
        Free(names);
}

/*
 * Check to see if all services in the svc_names are online.  If they are
 * all online 1 is returned, otherwise 0 is returned.
 */

static int
online(char *svc_names[], char **names)
{
    int i;
    int rv = 1;

    for (i = 0; svc_names[i]; i++) {
        if (is_online(svc_names[i]) == 0) {
            int sz;
            char *p;

            /*
             * Need space for the name, the new line, the
             * tab and the null terminator.
             */
            sz = strlen(svc_names[i]) + 3;

            if (*names == NULL) {
                p = Malloc(sz);
                (void) snprintf(p, sz, "\n\t%s", svc_names[i]);

            } else {
                /* Add space for existing names */
                sz += strlen(*names);
                p = Malloc(sz);
                (void) snprintf(p, sz, "%s\n\t%s", *names,
                    svc_names[i]);
                Free(*names);
            }

            *names = p;
            rv = 0;
        }
    }
    return (rv);
}

/*
 * Return 1 if the specified service is online.  Otherwise, return 0.
 */
static int
is_online(char *svc_name)
{
    int rval = 0;
    char    *s;

    if ((s = smf_get_state(svc_name)) != NULL) {
        if (strcmp(s, "online") == 0)
            rval = 1;
        free(s);
    }
    return (rval);
}