usr/src/cmd/nscd/nscd_smfmonitor.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 <stdlib.h>
#include <libscf.h>
#include <string.h>
#include "nscd_switch.h"
#include "nscd_log.h"
#include "nscd_door.h"

extern int	_whoami;

/*
 * Service states monitored by nscd. Protected by
 * readers/writer lock nscd_smf_service_state_lock
 */
nscd_smf_state_t *nscd_smf_service_state;
static rwlock_t nscd_smf_service_state_lock = DEFAULTRWLOCK;
/*
 * init service state table
 */
nscd_rc_t
_nscd_alloc_service_state_table()
{
	int i;

	nscd_smf_service_state = calloc(NSCD_NUM_SMF_FMRI,
	    sizeof (nscd_smf_state_t));

	if (nscd_smf_service_state == NULL)
		return (NSCD_NO_MEMORY);

	for (i = 1; i < NSCD_NUM_SMF_FMRI; i++)
		NSCD_SMF_SVC_STATE(i) = NSCD_SVC_STATE_UNINITED;

	return (NSCD_SUCCESS);
}

static int
query_smf_state(int srci)
{

	int	ret = NSCD_SVC_STATE_UNINITED;
	char	*state = NULL;
	char	*me = "query_smf_state";

	state = smf_get_state(NSCD_SMF_SVC_FMRI(srci));
	if (state == NULL)
		return (ret);

	_NSCD_LOG(NSCD_LOG_SMF_MONITOR, NSCD_LOG_LEVEL_DEBUG)
		(me, "%s -- %s\n", state, NSCD_SMF_SVC_FMRI(srci));

	(void) rw_wrlock(&nscd_smf_service_state_lock);

	if (nscd_smf_service_state[srci].src_name == NULL)
		nscd_smf_service_state[srci].src_name =
		    NSCD_NSW_SRC_NAME(srci);

	if (strcmp(state, SCF_STATE_STRING_UNINIT) == 0)
		NSCD_SMF_SVC_STATE(srci) = SCF_STATE_UNINIT;
	else if (strcmp(state, SCF_STATE_STRING_MAINT) == 0)
		NSCD_SMF_SVC_STATE(srci) = SCF_STATE_MAINT;
	else if (strcmp(state, SCF_STATE_STRING_OFFLINE) == 0)
		NSCD_SMF_SVC_STATE(srci) = SCF_STATE_OFFLINE;
	else if (strcmp(state, SCF_STATE_STRING_DISABLED) == 0)
		NSCD_SMF_SVC_STATE(srci) = SCF_STATE_DISABLED;
	else if (strcmp(state, SCF_STATE_STRING_ONLINE) == 0)
		NSCD_SMF_SVC_STATE(srci) = SCF_STATE_ONLINE;
	else if (strcmp(state, SCF_STATE_STRING_DEGRADED) == 0)
		NSCD_SMF_SVC_STATE(srci) = SCF_STATE_DEGRADED;

	ret = NSCD_SMF_SVC_STATE(srci);
	(void) rw_unlock(&nscd_smf_service_state_lock);

	free(state);
	return (ret);
}

/* ARGSUSED */
static void *
set_smf_state(void *arg)
{

	int	i;
	int	st;

	/*
	 * the forker nscd needs not monitor the state
	 * of the client services
	 */
	if (_whoami == NSCD_FORKER)
		thr_exit(0);

	/*CONSTCOND*/
	while (1) {

		/* skip the first service which is nscd */
		for (i = 1; i < NSCD_NUM_SMF_FMRI; i++) {
			st = query_smf_state(i);
			if (st == NSCD_SVC_STATE_UNINITED)
				break;
		}

		(void) sleep(NSCD_SW_CFG_G.check_smf_state_interval_g);
	}
	/* NOTREACHED */
	/*LINTED E_FUNC_HAS_NO_RETURN_STMT*/
}

nscd_rc_t
_nscd_init_smf_monitor() {

	int	errnum;
	char	*me = "_nscd_init_smf_monitor";

	_NSCD_LOG(NSCD_LOG_SMF_MONITOR, NSCD_LOG_LEVEL_DEBUG)
	(me, "initializing the smf monitor\n");

	/*
	 * start a thread to check the state of the client services
	 */
	if (thr_create(NULL, NULL, set_smf_state,
		NULL, THR_DETACHED, NULL) != 0) {
		errnum = errno;
		_NSCD_LOG(NSCD_LOG_SMF_MONITOR, NSCD_LOG_LEVEL_ERROR)
		(me, "thr_create: %s\n", strerror(errnum));
		return (NSCD_THREAD_CREATE_ERROR);
	}

	return (NSCD_SUCCESS);
}

int
_nscd_get_smf_state(int srci, int dbi, int recheck)
{
	int	s;
	char	*n;

	n = NSCD_NSW_SRC_NAME(srci);

	/* the files, compat, and dns backends are always available */
	if ((*n == 'f' || *n == 'c' || *n == 'd' || *n == 'a') &&
	    (strcmp(NSCD_NSW_SRC_NAME(srci), "files") == 0 ||
	    strcmp(NSCD_NSW_SRC_NAME(srci), "compat") == 0 ||
	    strcmp(NSCD_NSW_SRC_NAME(srci), "ad") == 0 ||
	    strcmp(NSCD_NSW_SRC_NAME(srci), "dns") == 0)) {
		return (SCF_STATE_ONLINE);
	}

	/*
	 * for the printer database and user backend, treat the
	 * backend as a unsupported one, as nscd can not access
	 * the home directory of the user
	 */
	if (*n == 'u' && strcmp(NSCD_NSW_SRC_NAME(srci), "user") == 0) {
		if (strcmp(NSCD_NSW_DB_NAME(dbi), NSS_DBNAM_PRINTERS) == 0)
			return (NSCD_SVC_STATE_UNSUPPORTED_SRC);
		else
			return (SCF_STATE_ONLINE);
	}

	/*
	 * Foreign backend is not supported by nscd unless
	 * the backend supports the nss2 interface (global
	 * symbol _nss_<backname name>_version is present),
	 * tell the switch engine to return NSS_TRYLOCAL
	 * if needed via rc NSCD_SVC_STATE_FOREIGN_SRC.
	 */
	if (srci >= _nscd_cfg_num_nsw_src)
		return (NSCD_SVC_STATE_FOREIGN_SRC);

	if (recheck == 1)
		return (query_smf_state(srci));

	(void) rw_rdlock(&nscd_smf_service_state_lock);
	s = NSCD_SMF_SVC_STATE(srci);
	(void) rw_unlock(&nscd_smf_service_state_lock);

	/*
	 * if the state has been queried at least once but is
	 * still not online, query one more time
	 */
	if (s != NSCD_SVC_STATE_UNINITED && s < SCF_STATE_ONLINE)
		s = query_smf_state(srci);

	return (s);
}