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


#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <sys/param.h>
#include "startd.h"

/*
 * The service deathrow mechanism addresses the problem of removing services
 * from a non accessible SMF repository. In this case, we can't simply use the
 * "SVCCFG_REPOSITORY=$ROOT/etc/svc/repository.db svccfg delete service_fmri"
 * command as the alternate repository format is not committed and could be
 * incompatible with the local SMF commands version.
 *
 * The idea is to manage a file (/etc/svc/deathrow) on the alternate root
 * directory that lists the FMRIs that need to disappear from the repository
 * when the system that uses this root directory boots up.
 * r.manifest and i.manifest update the file /etc/svc/deathrow in the alternate
 * root case.
 *
 * When svc.startd daemon launches, it first reads the /etc/svc/deathrow file
 * and for all FMRIs listed in this file, the service is not configured and
 * dependencies on it are forced satisfied (during svc.startd init time only).
 *
 * Than manifest-import service will actually, as first task, delete the
 * unconfigured services found in the /etc/svc/deathrow file and the
 * manifest hash entry from the repository.
 *
 */

#define SVC_DEATHROW_FILE   "/etc/svc/deathrow"

/*
 * These data structures are unprotected because they
 * are modified by a single thread, at startup time.
 * After initialization, these data structures are
 * used only in read mode, thus requiring no protection.
 */

/* list of deathrow fmris, created from the file SVC_DEATHROW_FILE */
typedef struct deathrow {
    char *fmri;
    uu_list_node_t deathrow_link;
} deathrow_t;

static uu_list_pool_t *deathrow_pool;
static uu_list_t *deathrow_list;

static boolean_t deathrow_handling_status = B_FALSE;

static deathrow_t *fmri_in_deathrow_internal(const char *);
static void deathrow_add(const char *);

static void
deathrow_handling_start()
{
    assert(deathrow_handling_status == B_FALSE);
    deathrow_handling_status = B_TRUE;
}

static void
deathrow_handling_stop()
{
    assert(deathrow_handling_status == B_TRUE);
    deathrow_handling_status = B_FALSE;
}

void
deathrow_init()
{
    FILE *file;
    char *line;
    char *fmri;
    char *manifest;
    char *pkgname;
    size_t line_size, sz;
    unsigned int line_parsed = 0;

    log_framework(LOG_DEBUG, "Deathrow init\n");

    while ((file = fopen(SVC_DEATHROW_FILE, "r")) == NULL) {
        if (errno == EINTR) {
            continue;
        }
        if (errno != ENOENT) {
            log_framework(LOG_ERR,
                "Deathrow not processed. "
                "Error opening file (%s): %s\n",
                SVC_DEATHROW_FILE, strerror(errno));
        }
        return;
    }

    deathrow_pool = uu_list_pool_create("deathrow",
        sizeof (deathrow_t), offsetof(deathrow_t, deathrow_link),
        NULL, UU_LIST_POOL_DEBUG);
    if (deathrow_pool == NULL) {
        uu_die("deathrow_init couldn't create deathrow_pool");
    }

    deathrow_list = uu_list_create(deathrow_pool,  deathrow_list, 0);
    if (deathrow_list == NULL) {
        uu_die("deathrow_init couldn't create deathrow_list");
    }

    /*
     * A deathrow file line looks like:
     * <fmri>< ><manifest path>< ><package name><\n>
     * (field separator is a space character)
     */
    line_size = max_scf_fmri_size + 3 + MAXPATHLEN + MAXNAMELEN;
    line = (char *)startd_alloc(line_size);
    *line = '\0';

    while (fgets(line, line_size, file) != NULL) {
        line_parsed++;
        fmri = NULL;
        manifest = NULL;
        pkgname = NULL;
        sz = strlen(line);
        if (sz > 0) {
            /* remove linefeed */
            if (line[sz - 1] == '\n') {
                line[sz - 1] = '\0';
            }
            manifest = strchr(line, ' ');
            if (manifest != NULL) {
                fmri = line;
                *manifest = '\0';
                manifest++;
                pkgname = strchr(manifest, ' ');
                if (pkgname != NULL) {
                    *pkgname = '\0';
                    pkgname++;
                }
            }
        }
        if (fmri != NULL && strlen(fmri) > 0 &&
            strlen(fmri) < max_scf_fmri_size &&
            manifest != NULL && strlen(manifest) > 0 &&
            pkgname != NULL && strlen(pkgname) > 0) {
            log_framework(LOG_DEBUG,
                "Deathrow parser <%s><%s><%s>\n",
                fmri, manifest, pkgname);
            if (fmri_in_deathrow_internal(fmri) == NULL) {
                /* fmri is not in list, add fmri */
                deathrow_add(fmri);
            }
        } else {
            log_framework(LOG_ERR,
                "Deathrow error processing file (%s). "
                "Skipping line %u.\n",
                SVC_DEATHROW_FILE, line_parsed);
        }
        *line = '\0';
    }
    startd_free(line, line_size);
    (void) fclose(file);

    if (uu_list_first(deathrow_list) != NULL) {
        deathrow_handling_start();
    }
}

void
deathrow_fini()
{
    deathrow_t *d;
    void *cookie = NULL;

    if (deathrow_handling_status == B_FALSE) {
        log_framework(LOG_DEBUG, "Deathrow fini\n");
        return;
    }
    deathrow_handling_stop();

    while ((d = uu_list_teardown(deathrow_list, &cookie)) != NULL) {
        startd_free(d->fmri, strlen(d->fmri) + 1);
        startd_free(d, sizeof (deathrow_t));
    }

    uu_list_destroy(deathrow_list);
    uu_list_pool_destroy(deathrow_pool);
    deathrow_pool = NULL;
    deathrow_list = NULL;
    log_framework(LOG_DEBUG, "Deathrow fini\n");
}

static void
deathrow_add(const char *fmri)
{
    deathrow_t *d;

    assert(fmri != NULL);

    d = startd_alloc(sizeof (deathrow_t));
    d->fmri = startd_alloc(strlen(fmri) + 1);
    (void) strcpy(d->fmri, fmri);
    uu_list_node_init(d, &d->deathrow_link, deathrow_pool);
    (void) uu_list_insert_after(deathrow_list, NULL, d);

    log_framework(LOG_DEBUG, "Deathrow added <%s>\n", d->fmri);
}

static deathrow_t *
fmri_in_deathrow_internal(const char *fmri)
{
    deathrow_t *d;

    assert(fmri != NULL);
    assert(deathrow_pool != NULL);
    assert(deathrow_list != NULL);

    for ((d = uu_list_first(deathrow_list)); d != NULL;
        d = uu_list_next(deathrow_list, d)) {
        if (strcmp(fmri, d->fmri) == 0) {
            return (d);
        }
    }
    return (NULL);
}

boolean_t
is_fmri_in_deathrow(const char *fmri)
{
    if (deathrow_handling_status == B_FALSE) {
        return (B_FALSE);
    }
    return ((fmri_in_deathrow_internal(fmri) != NULL) ? B_TRUE : B_FALSE);
}