svc/startd/specials.c

	specials.c revision 21d7f835c9bac5f9e80c72fc972ee5b288845983
/*
 * 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.
 */

#pragma ident   "%Z%%M% %I% %E% SMI"

/*
 * specials.c - knowledge of special services
 *
 * svc.startd(1M) has duties that cannot be carried out without knowledge of the
 * transition of various services, such as the milestones, to their online
 * states.  Hooks are called with the restarter instance's ri_lock held, so
 * operations on all instances (or on the graph) should be performed
 * asynchronously.
 */

#include <sys/statvfs.h>
#include <sys/types.h>
#include <assert.h>
#include <errno.h>
#include <libintl.h>
#include <limits.h>
#include <locale.h>
#include <pthread.h>
#include <signal.h>
#include <stdio.h>
#include <string.h>
#include <strings.h>
#include <time.h>
#include <zone.h>

#include "startd.h"

void
special_null_transition()
{
}

static void
special_fsroot_post_online()
{
    static int once;
    char *locale;

    /*
     * /usr, with timezone and locale data, is now available.
     */
    if (!st->st_log_timezone_known) {
        tzset();
        st->st_log_timezone_known = 1;
    }

    if (!st->st_log_locale_known) {
        locale = st->st_locale;

        (void) setlocale(LC_ALL, "");
        st->st_locale = setlocale(LC_MESSAGES, "");
        if (st->st_locale) {
            st->st_locale = safe_strdup(st->st_locale);
            xstr_sanitize(st->st_locale);
            free(locale);
        } else {
            st->st_locale = locale;
        }

        (void) textdomain(TEXT_DOMAIN);
        st->st_log_locale_known = 1;
    }

    if (once)
        return;

    /*
     * ctime(3C) ends with '\n\0'.
     */
    once++;
    log_framework(LOG_INFO, "system start time was %s",
        ctime(&st->st_start_time.tv_sec));
}

static void
special_fsminimal_post_online()
{
    ulong_t rfsid, vfsid;
    pid_t init_pid;

    log_framework(LOG_DEBUG, "special_fsminimal_post_online hook "
        "executed\n");

    /*
     * Are / and /var really writeable?
     */
    switch (fs_is_read_only("/", &rfsid)) {
    case 1:
        return;     /* still read-only: install / ro root */
    case 0:
        break;
    case -1:
    default:
        log_error(LOG_WARNING, gettext("couldn't check status of "
            "root filesystem: %s\n"), strerror(errno));
        break;
    }

    switch (fs_is_read_only("/var", &vfsid)) {
    case 1:
        if (vfsid != rfsid) {
            log_framework(LOG_WARNING, "/var filesystem "
                "read-only after system/filesystem/minimal\n");
            if (fs_remount("/var"))
                log_framework(LOG_WARNING, "/var "
                    "filesystem remount failed\n");
        }
        break;
    case 0:
        break;
    case -1:
    default:
        log_error(LOG_WARNING, gettext("couldn't check status of "
            "/var filesystem: %s\n"), strerror(errno));
        break;
    }

    /*
     * Clear (dead) entries and record boot time.
     */
    utmpx_clear_old();
    utmpx_write_boottime();

    /*
     * Reinitialize the logs to point to LOG_PREFIX_NORMAL.
     */
    log_init();

    /*
     * Poke init so it will create /etc/initpipe.
     */
    if (zone_getattr(getzoneid(), ZONE_ATTR_INITPID, &init_pid,
        sizeof (init_pid)) != sizeof (init_pid)) {
        log_error(LOG_WARNING, "Could not get pid of init: %s.\n",
            strerror(errno));
    } else {
        if (kill(init_pid, SIGHUP) != 0) {
            switch (errno) {
            case EPERM:
            case ESRCH:
                log_error(LOG_WARNING,
                    "Could not signal init: %s.\n",
                    strerror(errno));
                break;

            case EINVAL:
            default:
                bad_error("kill", errno);
            }
        }
    }

    /*
     * Take pending snapshots and create a svc.startd instance.
     */
    (void) startd_thread_create(restarter_post_fsminimal_thread, NULL);
}

static void
special_single_post_online()
{
    int r;

    log_framework(LOG_DEBUG, "special_single_post_online hook executed\n");

    /*
     * Un-set the special reconfig reboot property.
     */
    r = libscf_set_reconfig(0);
    switch (r) {
    case 0:
    case ENOENT:
        break;

    case EPERM:
    case EACCES:
    case EROFS:
        log_error(LOG_WARNING, "Could not clear reconfiguration "
            "property: %s.\n", strerror(r));
        break;

    default:
        bad_error("libscf_set_reconfig", r);
    }

    if (booting_to_single_user)
        (void) startd_thread_create(single_user_thread, NULL);
}

static service_hook_assn_t special_svcs[] = {
    { "svc:/system/filesystem/root:default",
        special_null_transition,
        special_fsroot_post_online,
        special_null_transition },
    { "svc:/system/filesystem/minimal:default",
        special_null_transition,
        special_fsminimal_post_online,
        special_null_transition },
    { "svc:/milestone/single-user:default",
        special_null_transition,
        special_single_post_online,
        special_null_transition },
};

void
special_online_hooks_get(const char *fmri, instance_hook_t *pre_onp,
    instance_hook_t *post_onp, instance_hook_t *post_offp)
{
    int i;

    for (i = 0; i < sizeof (special_svcs) / sizeof (service_hook_assn_t);
        i++)
        if (strcmp(fmri, special_svcs[i].sh_fmri) == 0) {
            *pre_onp = special_svcs[i].sh_pre_online_hook;
            *post_onp = special_svcs[i].sh_post_online_hook;
            *post_offp = special_svcs[i].sh_post_offline_hook;
            return;
        }

    *pre_onp = *post_onp = *post_offp = special_null_transition;
}