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

#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <pthread.h>
#include <errno.h>
#include <libscf.h>
#ifdef DEBUG
#include <time.h>
#endif
#include <signal.h>
#include <semaphore.h>
#include <sys/wait.h>

#include "isns_server.h"
#include "isns_dseng.h"
#include "isns_msgq.h"
#include "isns_log.h"
#include "isns_cfg.h"
#include "isns_utils.h"
#include "isns_cache.h"
#include "isns_obj.h"
#include "isns_dd.h"
#include "isns_scn.h"
#include "isns_sched.h"
#include "isns_esi.h"
#include "isns_mgmt.h"

/*
 * iSNS Server administrative settings.
 */
uint8_t daemonlize = 0;
int dbg_level = 7;
uint64_t esi_threshold;
uint8_t mgmt_scn;
ctrl_node_t *control_nodes = NULL;
pthread_mutex_t ctrl_node_mtx = PTHREAD_MUTEX_INITIALIZER;
char data_store[MAXPATHLEN];


/* semaphore for handling exit */
static sem_t	isns_child_sem;
static int	isns_child_smf_exit_code;
static pid_t	isns_child_pid;

#if !defined(SMF_EXIT_ERR_OTHER)
#define	SMF_EXIT_ERR_OTHER	-1
#endif

/*
 * Globals for singal handling.  time_to_exit is set by sig_handle()
 * when set the main thread(daemon) and othere threads should exit.
 *
 * semaphone is used to make sure all threads that are created
 * by isns_port_watcher and esi.
 */
boolean_t time_to_exit = B_FALSE;
static uint32_t thr_ref_count;
static pthread_mutex_t thr_count_mtx = PTHREAD_MUTEX_INITIALIZER;
#define	MAX_RETRY_COUNT	10 /* for checking remaining threads before exit. */

/*
 * Door creation flag.
 */
boolean_t door_created = B_FALSE;

/*
 * global system message queue
 */
msg_queue_t *sys_q = NULL;
msg_queue_t *scn_q = NULL;

#ifdef DEBUG
extern void *cli_test(void *argv);
extern dump_db(void);
#endif

extern void sigalrm(int);

/*
 * sigusr2_handler -- SIGUSR2 Handler
 * sigusr2 is exepected only when child is running okay.
 */
/* ARGSUSED */
static void
sigusr2_handler(
	int	sig
)
{
	/* post okay status. */
	isnslog(LOG_DEBUG, "sigusr2_handler",
	    "SIGUSR@ is received.  Parent is existing...");
	isns_child_smf_exit_code = SMF_EXIT_OK;

	(void) sem_post(&isns_child_sem);
}

/*
 * sigchld_handler -- SIGCHLD Handler
 * sigchld is exepected only when there is an error.
 */
/* ARGSUSED */
static void
sigchld_handler(
	int	sig
)
{
	int	status;
	pid_t	ret_pid;

	/* This is the default code. */
	isns_child_smf_exit_code = SMF_EXIT_ERR_OTHER;

	ret_pid = waitpid(isns_child_pid, &status, WNOHANG);

	if (ret_pid == isns_child_pid) {
		if (WIFEXITED(status)) {
			isns_child_smf_exit_code = WEXITSTATUS(status);
		}
	}
	(void) sem_post(&isns_child_sem);
}

/* ARGSUSED */
static void
sighup_handler(
	int	sig
)
{

	isnslog(LOG_DEBUG, "sighup_handle",
	    "SIGHUP is received.  Reloading config...");
	(void) queue_msg_set(sys_q, CONFIG_RELOAD, NULL);
}

/* ARGSUSED */
static void
sigexit_handler(
	int	sig
)
{
	isnslog(LOG_DEBUG, "sigexit_handler",
	    "Signal: %d received and sending server exit.", sig);
	shutdown_server();
}

void
inc_thr_count(
)
{
	(void) pthread_mutex_lock(&thr_count_mtx);

	isnslog(LOG_DEBUG, "inc_thr_count",
	    "increase thread reference count(%d).", thr_ref_count);

	thr_ref_count++;

	(void) pthread_mutex_unlock(&thr_count_mtx);
}

void
dec_thr_count(
)
{
	(void) pthread_mutex_lock(&thr_count_mtx);

	isnslog(LOG_DEBUG, "dec_thr_count",
	    "decrease thread reference count(%d).", thr_ref_count);

	thr_ref_count--;

	(void) pthread_mutex_unlock(&thr_count_mtx);
}

uint32_t
get_thr_count(
)
{
	uint32_t ref;

	(void) pthread_mutex_lock(&thr_count_mtx);

	ref = thr_ref_count;

	(void) pthread_mutex_unlock(&thr_count_mtx);

	isnslog(LOG_DEBUG, "get_thr_count",
	    "checking thread reference count %d.", ref);

	return (ref);
}

void
shutdown_server(
)
{
	isnslog(LOG_DEBUG, "shutdown", "raise exit flag.");
	time_to_exit = B_TRUE;
	(void) queue_msg_set(sys_q, SERVER_EXIT, NULL);
}

int
main(
	/* LINTED E_FUNC_ARG_UNUSED */
	int	argc,
	/* LINTED E_FUNC_ARG_UNUSED */
	char	*argv[]
)
{
	int opt_i = 0;
	pthread_t port_tid, esi_tid, scn_tid;
	uint32_t thr_cnt;
	int i;

#ifdef DEBUG
	time_t t;
	clock_t c;
#endif

#ifdef DEBUG
	if (getopt(argc, argv, "i") == 'i') {
		opt_i = 1; /* interactive mode */
	}
#endif

	/* set locale */
	openlog(ISNS_DAEMON_SYSLOG_PP, LOG_PID | LOG_CONS, LOG_DAEMON);

	/* load administative settings. pick up data location. */
	if (load_config(B_TRUE) != 0) {
		isnslog(LOG_ERR, "main", "administrative settings load error.");
		exit(SMF_EXIT_ERR_OTHER);
	}

	/* A signal handler is set for SIGCHLD. */
	(void) signal(SIGCHLD, sigchld_handler);
	(void) signal(SIGUSR2, sigusr2_handler);
	(void) sigset(SIGALRM, sigalrm);

#ifdef DEBUG
	printf("start daemon\n");
#endif
	if (opt_i == 0 || daemonlize) {
		isnslog(LOG_DEBUG, "main", "now forking... pid %d", getpid());
		daemonlize = 1;
		/* daemonlize */
		isns_child_pid = fork();
		if (isns_child_pid < 0) {
			/*
			 * cannot fork(), terminate the server.
			 */
			exit(SMF_EXIT_ERR_CONFIG);
		}
		if (isns_child_pid > 0) {
			/*
			 * terminate parent.
			 */
			(void) sem_wait(&isns_child_sem);
			(void) sem_destroy(&isns_child_sem);
			isnslog(LOG_DEBUG, "main", "exiting with %d",
				isns_child_smf_exit_code);
			exit(isns_child_smf_exit_code);
		}

		/*
		 * redirect stdout, and stderr to /dev/null.
		 */
		i = open("/dev/null", O_RDWR);
		(void) dup2(i, 1);
		(void) dup2(i, 2);
	} /* end of daemonlize */

#ifdef DEBUG
	printf("calling cache init\n");
#endif
	/* initialize object hash table */
	if (cache_init() != 0) {
		isnslog(LOG_ERR, "main",
		    "object hash table initialization error.");
		exit(SMF_EXIT_ERR_OTHER);
	}

	/* initialize event list */
	if (el_init(10, 60, 6) != 0) {
		isnslog(LOG_ERR, "main",
		"ESI event list initialization error.");
		exit(SMF_EXIT_ERR_OTHER);
	}

	/* initialize iSNS database */
	if (init_data() != 0) {
		isnslog(LOG_ERR, "main",
		    "internal database initialization error");
		exit(SMF_EXIT_ERR_OTHER);
	}

#ifdef DEBUG
	printf("calling load_data\n");
	t = time(NULL);
	c = clock();
#endif

	if (load_data() != 0) {
		isnslog(LOG_ERR, "main", "loading data store failed");
		exit(SMF_EXIT_ERR_OTHER);
	}

#ifdef DEBUG
	t = time(NULL) - t;
	c = clock() - c;
	printf("time %d clock %.4lf -loading data\n",
	    t, c / (double)CLOCKS_PER_SEC);
#endif

#ifdef DEBUG
	printf("sys queue creating...\n");
#endif
	/* create a message queue for system control */
	sys_q = queue_calloc();
	if (!sys_q) {
		exit(SMF_EXIT_ERR_OTHER);
	}

	/* create a message queue for scn thread */
	scn_q = queue_calloc();
	if (!scn_q) {
		exit(SMF_EXIT_ERR_OTHER);
	}

	/* create scn thread */
	/* Check for Default DD/DD-set existence and */
	/* create them if they are not there. */
	if (verify_ddd() != 0) {
		exit(SMF_EXIT_ERR_OTHER);
	}

	/* setup and verify the portal(s) for scn(s) */
	/* after scn registry is loaded from data store. */
	if (verify_scn_portal() != 0) {
		exit(SMF_EXIT_ERR_OTHER);
	}

	/* setup and verify the portal(s) for esi(s) */
	/* after esi list is loaded from data store. */
	if (verify_esi_portal() != 0) {
		exit(SMF_EXIT_ERR_OTHER);
	}

#ifdef DEBUG
	printf("scn queue creating...\n");
#endif

	(void) sigset(SIGHUP, sighup_handler);
	(void) sigset(SIGINT, sigexit_handler);
	(void) sigset(SIGTERM, sigexit_handler);
	(void) sigset(SIGQUIT, sigexit_handler);

	/* create scn thread */
	if (pthread_create(&scn_tid, NULL, scn_proc, NULL) != 0) {
		isnslog(LOG_ERR, "main", "SCN thread creating error.");
		exit(SMF_EXIT_ERR_OTHER);
	}

	/* setup a door for management interface */
	if (setup_mgmt_door(sys_q) != 0) {
		exit(SMF_EXIT_ERR_OTHER);
	}

	/* create server port watcher */
	if (pthread_create(&port_tid, NULL,
	    isns_port_watcher, (void *)sys_q) != 0) {
		isnslog(LOG_ERR, "main", "iSNS port thread creating error.");
		exit(SMF_EXIT_ERR_OTHER);
	}

	/* create entity status inquiry thread */
	if (pthread_create(&esi_tid, NULL,
	    esi_proc, NULL) != 0) {
		isnslog(LOG_ERR, "main", "ESI thread creating error.");
		exit(SMF_EXIT_ERR_OTHER);
	}

#ifdef DEBUG
	if (!daemonlize) {
		(void) pthread_create(&tid,
		    NULL,
		    cli_test,
		    (void *)sys_q);
	}
#endif
	if (opt_i == 0 || daemonlize) {
		isnslog(LOG_DEBUG, "main", "issuing SIGUSR2.. parent pid %d",
		    getppid());
		(void) kill(getppid(), SIGUSR2);
	}

	/* pause */
	for (;;) {
		msg_text_t *msg = queue_msg_get(sys_q);
		switch (msg->id) {
			case DATA_ADD:
			case DATA_UPDATE:
			case DATA_DELETE:
			case DATA_DELETE_ASSOC:
			case DATA_COMMIT:
			case DATA_RETREAT:
				break;
			case REG_EXP:
				/* registration expiring */
				reg_expiring(msg->data);
				break;
			case DEAD_PORTAL:
				portal_dies((uint32_t)msg->data);
				break;
			case SERVER_EXIT:
				/* graceful exit. */
				(void) queue_msg_free(msg);
				isnslog(LOG_DEBUG, "main",
				    "wake up ESI and stop it.");
				(void) get_stopwatch(1);
				isnslog(LOG_DEBUG, "main",
				    "sending SCN stop msg.");
				(void) queue_msg_set(scn_q, SCN_STOP, NULL);
				if (door_created) {
					isnslog(LOG_DEBUG, "main",
					    "closing the door.");
					(void) fdetach(ISNS_DOOR_NAME);
				}
				(void) pthread_join(esi_tid, NULL);
				isnslog(LOG_DEBUG, "main",
				    "esi thread %d exited.", esi_tid);
				(void) pthread_join(port_tid, NULL);
				isnslog(LOG_DEBUG, "main",
				    "port watcher thread %d exited.", port_tid);
				(void) pthread_join(scn_tid, NULL);
				isnslog(LOG_DEBUG, "main",
				    "scn thread %d exited.", scn_tid);

				/* now check any remaining threads. */
				i = 0;
				do {
					thr_cnt = get_thr_count();
					if (thr_cnt == 0) {
						isnslog(LOG_DEBUG, "main",
						    "main thread %d is done.",
						    pthread_self());
						exit(1);
					} else {
						(void) sleep(1);
						i++;
					}
				} while (MAX_RETRY_COUNT > i);
				isnslog(LOG_DEBUG, "main",
				    "main thread %d existing ...",
				    pthread_self());
				exit(1);
				break;
			case CONFIG_RELOAD:
				/* load config again. don't pick data store. */
				(void) load_config(B_FALSE);
				break;
			case SYS_QUIT_OK:
				(void) queue_msg_free(msg);
				exit(0);
			default:
				break;
		}
		(void) queue_msg_free(msg);
	}

	/* LINTED E_STMT_NOT_REACHED */
	return (0);
}