/*
 * 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 (c) 2000, 2010, Oracle and/or its affiliates. All rights reserved.
 */

#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <limits.h>
#include <thread.h>
#include <wait.h>
#include <synch.h>
#include <syslog.h>
#include <libintl.h>
#include <sys/stat.h>
#include <sys/sunddi.h>

#include <libsysevent.h>

#include "sysevent_signal.h"
#include "../devfsadm/devfsadm.h"

/*
 * SLM for devfsadmd device configuration daemon
 */

extern char *root_dir;
extern void syseventd_print();

sysevent_handle_t *sysevent_hp;

/* Alternate root declarations during install */
static int use_alt_root = 0;

static int devfsadmdeliver_event(sysevent_t *ev, int flag);

static struct slm_mod_ops devfsadm_mod_ops = {
	SE_MAJOR_VERSION, SE_MINOR_VERSION, 10, devfsadmdeliver_event};

typedef struct ev_queue {
	struct ev_queue *evq_next;
	sysevent_t	*evq_ev;
} ev_queue_t;

static mutex_t evq_lock;
static cond_t evq_cv;
static ev_queue_t *eventq_head;
static ev_queue_t *eventq_tail;

#define	DELIVERY_FAILED	\
	gettext("devfsadmd not responding, /dev may not be current")

#define	DELIVERY_RESUMED \
	gettext("devfsadmd now responding again")

/*
 * Retry error recovery when attempting to send an event to devfsadmd
 */
#define	RETRY_DAEMON_RESTART	0
#define	RETRY_MSG_THRESHOLD	60
#define	RETRY_DAEMON_INTERVAL	60

static int
system1(const char *s_path, const char *s)
{
	struct sigaction cbuf, ibuf, qbuf, ignore, dfl;
	sigset_t mask, savemask;
	struct stat st;
	pid_t pid;
	int status, w;

	/* Check the requested command */
	if (s == NULL) {
		errno = EINVAL;
		return (-1);
	}

	/* Check the ability to execute devfsadmd from this process */
	if (stat(s_path, &st) < 0) {
		return (-1);
	}
	if (((geteuid() == st.st_uid) && ((st.st_mode & S_IXUSR) == 0)) ||
	    ((getegid() == st.st_gid) && ((st.st_mode & S_IXGRP) == 0)) ||
	    ((st.st_mode & S_IXOTH) == 0)) {
		errno = EPERM;
		return (-1);
	}

	/*
	 * Block SIGCHLD and set up a default handler for the duration of the
	 * system1 call.
	 */
	(void) sigemptyset(&mask);
	(void) sigaddset(&mask, SIGCHLD);
	(void) sigprocmask(SIG_BLOCK, &mask, &savemask);
	(void) memset(&dfl, 0, sizeof (dfl));
	dfl.sa_handler = SIG_DFL;
	(void) sigaction(SIGCHLD, &dfl, &cbuf);

	/* Fork off the child process (using fork1(), because it's MT-safe) */
	switch (pid = fork1()) {
		case -1:
			/* Error */
			(void) sigaction(SIGCHLD, &cbuf, NULL);
			(void) sigprocmask(SIG_SETMASK, &savemask, NULL);
			return (-1);
		case 0:
			/* Set-up an initial signal mask for the child */
			(void) sigemptyset(&mask);
			(void) sigprocmask(SIG_SETMASK, &mask, NULL);
			closefrom(3);
			(void) execl(s_path, s, (char *)0);
			_exit(-1);
			break;
		default:
			/* Parent */
			break;
	}

	(void) memset(&ignore, 0, sizeof (ignore));
	ignore.sa_handler = SIG_IGN;
	(void) sigaction(SIGINT, &ignore, &ibuf);
	(void) sigaction(SIGQUIT, &ignore, &qbuf);

	do {
		w = waitpid(pid, &status, 0);
	} while (w == -1 && errno == EINTR);

	(void) sigaction(SIGINT, &ibuf, NULL);
	(void) sigaction(SIGQUIT, &qbuf, NULL);
	(void) sigaction(SIGCHLD, &cbuf, NULL);
	(void) sigprocmask(SIG_SETMASK, &savemask, NULL);

	return ((w == -1)? w: status);
}

/*
 * devfsadmdeliver_event - called by syseventd to deliver an event buffer.
 *			The event buffer is subsequently delivered to
 *			devfsadmd.  If devfsadmd, is not responding to the
 *			delivery attempt, we will try to startup the
 *			daemon.  MT protection is provided by syseventd
 *			and the client lock.  This insures sequential
 *			event delivery and protection from re-entrance.
 */
/*ARGSUSED*/
static int
devfsadmdeliver_event(sysevent_t *ev, int flag)
{
	int ev_size;
	ev_queue_t *new_evq;

	/* Not initialized */
	if (sysevent_hp == NULL) {
		return (0);
	}

	/* Quick return for uninteresting events */
	if (strcmp(sysevent_get_class_name(ev), EC_DEVFS) != 0) {
		return (0);
	}

	/* Queue event for delivery to devfsadmd */
	new_evq = (ev_queue_t *)calloc(1, sizeof (ev_queue_t));
	if (new_evq == NULL) {
		return (EAGAIN);
	}

	ev_size = sysevent_get_size(ev);
	new_evq->evq_ev = (sysevent_t *)malloc(ev_size);
	if (new_evq->evq_ev == NULL) {
		free(new_evq);
		return (EAGAIN);
	}
	bcopy(ev, new_evq->evq_ev, ev_size);

	(void) mutex_lock(&evq_lock);
	if (eventq_head == NULL) {
		eventq_head = new_evq;
	} else {
		eventq_tail->evq_next = new_evq;
	}
	eventq_tail = new_evq;

	(void) cond_signal(&evq_cv);
	(void) mutex_unlock(&evq_lock);

	return (0);
}

static int cleanup;
thread_t deliver_thr_id;

void *
devfsadmd_deliver_thr(void *arg __unused)
{
	int retry = 0;
	int msg_emitted = 0;
	ev_queue_t *evqp;

	(void) mutex_lock(&evq_lock);
	for (;;) {
		while (eventq_head == NULL) {
			(void) cond_wait(&evq_cv, &evq_lock);
			if (cleanup && eventq_head == NULL) {
				(void) cond_signal(&evq_cv);
				(void) mutex_unlock(&evq_lock);
				return (NULL);
			}
		}

		/* Send events on to devfsadmd */
		evqp = eventq_head;
		while (evqp) {
			(void) mutex_unlock(&evq_lock);
			retry = 0;
			while (sysevent_send_event(sysevent_hp,
			    evqp->evq_ev) != 0) {
				/*
				 * Invoke devfsadm to handle node creation
				 * but not for an alternate root.
				 */
				if (use_alt_root != 0)
					break;
				/*
				 * daemon unresponsive -
				 * restart daemon and retry once more
				 */
				if ((errno == EBADF || errno == ENOENT) &&
				    (retry == RETRY_DAEMON_RESTART) ||
				    ((retry % RETRY_DAEMON_INTERVAL) == 0)) {
					(void) system1(
					    DEVFSADMD_START_PATH,
					    DEVFSADMD_START);
				}
				if (retry == RETRY_MSG_THRESHOLD) {
					syslog(LOG_ERR, DELIVERY_FAILED);
					msg_emitted = 1;
				}
				(void) sleep(1);
				++retry;
				continue;
			}

			/*
			 * Event delivered: remove from queue
			 * and reset delivery retry state.
			 */
			if (msg_emitted) {
				syslog(LOG_ERR, DELIVERY_RESUMED);
				msg_emitted = 0;
			}
			retry = 0;
			(void) mutex_lock(&evq_lock);
			if (eventq_head != NULL) {
				eventq_head = eventq_head->evq_next;
				if (eventq_head == NULL)
					eventq_tail = NULL;
			}
			free(evqp->evq_ev);
			free(evqp);
			evqp = eventq_head;
		}
		if (cleanup) {
			(void) cond_signal(&evq_cv);
			(void) mutex_unlock(&evq_lock);
			return (NULL);
		}
	}

	/* NOTREACHED */
}

struct slm_mod_ops *
slm_init()
{
	char alt_door[MAXPATHLEN];

	if (strcmp(root_dir, "") == 0) {
		/* Initialize the private sysevent handle */
		sysevent_hp = sysevent_open_channel_alt(DEVFSADM_SERVICE_DOOR);
	} else {

		/* Try alternate door during install time */
		if (snprintf(alt_door, MAXPATHLEN, "%s%s", "/tmp",
		    DEVFSADM_SERVICE_DOOR) >= MAXPATHLEN)
			return (NULL);

		sysevent_hp = sysevent_open_channel_alt(alt_door);
		use_alt_root = 1;
	}
	if (sysevent_hp == NULL) {
		syseventd_print(0, "Unable to allocate sysevent handle"
		    " for devfsadm module\n");
		return (NULL);
	}

	if (sysevent_bind_publisher(sysevent_hp) != 0) {
		if (errno == EBUSY) {
			sysevent_cleanup_publishers(sysevent_hp);
			if (sysevent_bind_publisher(sysevent_hp) != 0) {
				(void) sysevent_close_channel(sysevent_hp);
				return (NULL);
			}
		}
	}

	sysevent_cleanup_subscribers(sysevent_hp);
	cleanup = 0;
	eventq_head = NULL;
	eventq_tail = NULL;

	(void) mutex_init(&evq_lock, USYNC_THREAD, NULL);
	(void) cond_init(&evq_cv, USYNC_THREAD, NULL);

	if (thr_create(NULL, 0, devfsadmd_deliver_thr,
	    NULL, THR_BOUND, &deliver_thr_id) != 0) {
		(void) mutex_destroy(&evq_lock);
		(void) cond_destroy(&evq_cv);
		sysevent_close_channel(sysevent_hp);
		return (NULL);
	}

	return (&devfsadm_mod_ops);
}

void
slm_fini()
{
	/* Wait for all events to be flushed out to devfsadmd */
	(void) mutex_lock(&evq_lock);
	cleanup = 1;
	(void) cond_signal(&evq_cv);
	(void) cond_wait(&evq_cv, &evq_lock);
	(void) mutex_unlock(&evq_lock);

	/* Wait for delivery thread to exit */
	(void) thr_join(deliver_thr_id, NULL, NULL);

	(void) mutex_destroy(&evq_lock);
	(void) cond_destroy(&evq_cv);

	sysevent_close_channel(sysevent_hp);
	sysevent_hp = NULL;
}