sysevent_reg_mod.c revision 7c478bd95313f5f23a4c958a745db2134aa03244
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License, Version 1.0 only
* (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 2004 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <stdio.h>
#include <limits.h>
#include <thread.h>
#include <wait.h>
#include <synch.h>
#include <errno.h>
#include <locale.h>
#include <sys/stat.h>
#include <sys/mnttab.h>
#include <sys/sunddi.h>
#include <sys/modctl.h>
#include <sys/sysevent.h>
#include <sys/sysevent_impl.h>
#include <libsysevent.h>
#include "message_reg_mod.h"
/*
* SLM for sysevent event subscribers
*/
extern char *root_dir;
extern void syseventd_print(int level, char *format, ...);
extern void syseventd_err_print(char *format, ...);
sysevent_handle_t *sysevent_hp;
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 *event_q = NULL;
static int cleanup;
static thread_t deliver_thr_id;
static int
init_channel()
{
/*
* This functionality is not supported in the mini-root
* environment, ie install. If root_dir is set, implying
* install, we quietly fail.
*/
if (strcmp(root_dir, "") != 0) {
return (EACCES);
}
/*
* Initialize the private sysevent handle
*/
sysevent_hp = sysevent_open_channel(SYSEVENTD_CHAN);
if (sysevent_hp == NULL) {
if (errno == EACCES) {
syseventd_print(3, "sysevent_reg_mod: "
"sysevent_open_channel failed with %s init "
"deferred\n", strerror(errno));
return (errno);
} else {
syseventd_err_print(INIT_SUB_OPEN_CHAN_ERR,
strerror(errno));
return (errno);
}
}
if (sysevent_bind_publisher(sysevent_hp) != 0) {
/*
* Only one publisher allowed on the syseventd channel,
* cleanup previously allocated syseventd channel publishers
*/
if (errno == EBUSY) {
sysevent_cleanup_publishers(sysevent_hp);
if (sysevent_bind_publisher(sysevent_hp) == 0)
return (0);
}
syseventd_err_print(INIT_SUB_BIND_PUB_ERR,
strerror(errno));
sysevent_close_channel(sysevent_hp);
sysevent_hp = NULL;
return (errno);
}
return (0);
}
static int
deliver_event(sysevent_t *ev, int flag)
{
int ret, ev_size;
ev_queue_t *new_evq, *tmp_evq;
/* Not initialized */
if (sysevent_hp == NULL) {
ret = init_channel();
if (ret != 0) {
if (ret == EBUSY && flag != SE_NO_RETRY) {
return (EAGAIN);
} else if (ret == EACCES) {
return (0);
} else {
syseventd_err_print(INIT_SUB_OPEN_CHAN_ERR,
strerror(ret));
return (0);
}
}
/* Check for stale syseventd subscribers */
sysevent_cleanup_subscribers(sysevent_hp);
syseventd_print(3, "sysevent_reg_mod: init successful");
}
/* Queue event for delivery to all subscribers */
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 (event_q == NULL) {
event_q = new_evq;
} else {
tmp_evq = event_q;
while (tmp_evq->evq_next != NULL)
tmp_evq = tmp_evq->evq_next;
tmp_evq->evq_next = new_evq;
}
syseventd_print(3, "sysevent_reg_mod: queue event 0X%llx\n",
sysevent_get_seq(ev));
(void) cond_signal(&evq_cv);
(void) mutex_unlock(&evq_lock);
return (0);
}
void
subscriber_deliver_thr()
{
ev_queue_t *evqp;
(void) mutex_lock(&evq_lock);
for (;;) {
while (event_q == NULL && cleanup == 0) {
(void) cond_wait(&evq_cv, &evq_lock);
}
/* Send events on to all current subscribers */
evqp = event_q;
while (evqp) {
(void) mutex_unlock(&evq_lock);
syseventd_print(3, "sysevent_reg_mod: sending event "
"0X%llx\n", sysevent_get_seq(evqp->evq_ev));
if (sysevent_send_event(sysevent_hp,
evqp->evq_ev) != 0) {
syseventd_print(3, "sysevent_reg_mod: "
"failed to send event\n");
}
syseventd_print(3, "sysevent_reg_mod: event sent "
"0X%llx\n", sysevent_get_seq(evqp->evq_ev));
(void) mutex_lock(&evq_lock);
event_q = evqp->evq_next;
free(evqp->evq_ev);
free(evqp);
evqp = event_q;
}
if (cleanup) {
syseventd_print(3, "sysevent_reg_mod: deliver "
"thread exiting\n");
(void) mutex_unlock(&evq_lock);
(void) thr_exit(NULL);
/* NOTREACHED */
}
}
/* NOTREACHED */
}
static struct slm_mod_ops sysevent_reg_mod_ops = {
SE_MAJOR_VERSION, SE_MINOR_VERSION, SE_MAX_RETRY_LIMIT, deliver_event};
struct slm_mod_ops *
slm_init()
{
cleanup = 0;
sysevent_hp = NULL;
(void) init_channel();
(void) mutex_init(&evq_lock, USYNC_THREAD, NULL);
(void) cond_init(&evq_cv, USYNC_THREAD, NULL);
if (thr_create(NULL, NULL, (void *(*)(void *))subscriber_deliver_thr,
NULL, 0, &deliver_thr_id) != 0) {
syseventd_err_print(INIT_SUB_THR_CREATE_ERR, strerror(errno));
return (NULL);
}
return (&sysevent_reg_mod_ops);
}
void
slm_fini()
{
(void) mutex_lock(&evq_lock);
cleanup = 1;
(void) cond_signal(&evq_cv);
(void) mutex_unlock(&evq_lock);
/* Wait for delivery threads 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;
}