1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License, Version 1.0 only
6 * (the "License"). You may not use this file except in compliance
7 * with the License.
8 *
9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10 * or http://www.opensolaris.org/os/licensing.
11 * See the License for the specific language governing permissions
12 * and limitations under the License.
13 *
14 * When distributing Covered Code, include this CDDL HEADER in each
15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16 * If applicable, add the following below this CDDL HEADER, with the
17 * fields enclosed by brackets "[]" replaced with your own identifying
18 * information: Portions Copyright [yyyy] [name of copyright owner]
19 *
20 * CDDL HEADER END
21 */
22 /*
23 * Copyright 2004 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 #pragma ident "%Z%%M% %I% %E% SMI"
28
29 #include <unistd.h>
30 #include <stdlib.h>
31 #include <string.h>
32 #include <strings.h>
33 #include <stdio.h>
34 #include <limits.h>
35 #include <thread.h>
36 #include <wait.h>
37 #include <synch.h>
38 #include <errno.h>
39 #include <locale.h>
40 #include <sys/stat.h>
41 #include <sys/mnttab.h>
42 #include <sys/sunddi.h>
43 #include <sys/modctl.h>
44 #include <sys/sysevent.h>
45 #include <sys/sysevent_impl.h>
46
47 #include <libsysevent.h>
48
49 #include "message_reg_mod.h"
50
51 /*
52 * SLM for sysevent event subscribers
53 */
54
55 extern char *root_dir;
56 extern void syseventd_print(int level, char *format, ...);
57 extern void syseventd_err_print(char *format, ...);
58
59 sysevent_handle_t *sysevent_hp;
60
61 typedef struct ev_queue {
62 struct ev_queue *evq_next;
63 sysevent_t *evq_ev;
64 } ev_queue_t;
65
66 static mutex_t evq_lock;
67 static cond_t evq_cv;
68 static ev_queue_t *event_q = NULL;
69 static int cleanup;
70 static thread_t deliver_thr_id;
71
72 static int
73 init_channel()
74 {
75 /*
76 * This functionality is not supported in the mini-root
77 * environment, ie install. If root_dir is set, implying
78 * install, we quietly fail.
79 */
80 if (strcmp(root_dir, "") != 0) {
81 return (EACCES);
82 }
83
84 /*
85 * Initialize the private sysevent handle
86 */
87 sysevent_hp = sysevent_open_channel(SYSEVENTD_CHAN);
88 if (sysevent_hp == NULL) {
89 if (errno == EACCES) {
90 syseventd_print(3, "sysevent_reg_mod: "
91 "sysevent_open_channel failed with %s init "
92 "deferred\n", strerror(errno));
93 return (errno);
94 } else {
95 syseventd_err_print(INIT_SUB_OPEN_CHAN_ERR,
96 strerror(errno));
97 return (errno);
98 }
99 }
100
101 if (sysevent_bind_publisher(sysevent_hp) != 0) {
102 /*
103 * Only one publisher allowed on the syseventd channel,
104 * cleanup previously allocated syseventd channel publishers
105 */
106 if (errno == EBUSY) {
107 sysevent_cleanup_publishers(sysevent_hp);
108 if (sysevent_bind_publisher(sysevent_hp) == 0)
109 return (0);
110 }
111
112 syseventd_err_print(INIT_SUB_BIND_PUB_ERR,
113 strerror(errno));
114 sysevent_close_channel(sysevent_hp);
115 sysevent_hp = NULL;
116 return (errno);
117 }
118
119 return (0);
120 }
121
122 static int
123 deliver_event(sysevent_t *ev, int flag)
124 {
125 int ret, ev_size;
126 ev_queue_t *new_evq, *tmp_evq;
127
128 /* Not initialized */
129 if (sysevent_hp == NULL) {
130
131 ret = init_channel();
132 if (ret != 0) {
133 if (ret == EBUSY && flag != SE_NO_RETRY) {
134 return (EAGAIN);
135 } else if (ret == EACCES) {
136 return (0);
137 } else {
138 syseventd_err_print(INIT_SUB_OPEN_CHAN_ERR,
139 strerror(ret));
140 return (0);
141 }
142 }
143 /* Check for stale syseventd subscribers */
144 sysevent_cleanup_subscribers(sysevent_hp);
145 syseventd_print(3, "sysevent_reg_mod: init successful");
146 }
147
148 /* Queue event for delivery to all subscribers */
149 new_evq = (ev_queue_t *)calloc(1, sizeof (ev_queue_t));
150 if (new_evq == NULL) {
151 return (EAGAIN);
152 }
153 ev_size = sysevent_get_size(ev);
154 new_evq->evq_ev = (sysevent_t *)malloc(ev_size);
155 if (new_evq->evq_ev == NULL) {
156 free(new_evq);
157 return (EAGAIN);
158 }
159 bcopy(ev, new_evq->evq_ev, ev_size);
160
161 (void) mutex_lock(&evq_lock);
162 if (event_q == NULL) {
163 event_q = new_evq;
164 } else {
165 tmp_evq = event_q;
166 while (tmp_evq->evq_next != NULL)
167 tmp_evq = tmp_evq->evq_next;
168 tmp_evq->evq_next = new_evq;
169 }
170 syseventd_print(3, "sysevent_reg_mod: queue event 0X%llx\n",
171 sysevent_get_seq(ev));
172
173 (void) cond_signal(&evq_cv);
174 (void) mutex_unlock(&evq_lock);
175
176 return (0);
177 }
178
179 void
180 subscriber_deliver_thr()
181 {
182 ev_queue_t *evqp;
183
184 (void) mutex_lock(&evq_lock);
185 for (;;) {
186 while (event_q == NULL && cleanup == 0) {
187 (void) cond_wait(&evq_cv, &evq_lock);
188 }
189
190 /* Send events on to all current subscribers */
191 evqp = event_q;
192 while (evqp) {
193 (void) mutex_unlock(&evq_lock);
194 syseventd_print(3, "sysevent_reg_mod: sending event "
195 "0X%llx\n", sysevent_get_seq(evqp->evq_ev));
196 if (sysevent_send_event(sysevent_hp,
197 evqp->evq_ev) != 0) {
198 syseventd_print(3, "sysevent_reg_mod: "
199 "failed to send event\n");
200 }
201 syseventd_print(3, "sysevent_reg_mod: event sent "
202 "0X%llx\n", sysevent_get_seq(evqp->evq_ev));
203 (void) mutex_lock(&evq_lock);
204 event_q = evqp->evq_next;
205 free(evqp->evq_ev);
206 free(evqp);
207 evqp = event_q;
208 }
209 if (cleanup) {
210 syseventd_print(3, "sysevent_reg_mod: deliver "
211 "thread exiting\n");
212 (void) mutex_unlock(&evq_lock);
213 (void) thr_exit(NULL);
214 /* NOTREACHED */
215 }
216 }
217
218 /* NOTREACHED */
219 }
220
221 static struct slm_mod_ops sysevent_reg_mod_ops = {
222 SE_MAJOR_VERSION, SE_MINOR_VERSION, SE_MAX_RETRY_LIMIT, deliver_event};
223
224 struct slm_mod_ops *
225 slm_init()
226 {
227 cleanup = 0;
228 sysevent_hp = NULL;
229
230 (void) init_channel();
231
232 (void) mutex_init(&evq_lock, USYNC_THREAD, NULL);
233 (void) cond_init(&evq_cv, USYNC_THREAD, NULL);
234
235 if (thr_create(NULL, NULL, (void *(*)(void *))subscriber_deliver_thr,
236 NULL, 0, &deliver_thr_id) != 0) {
237 syseventd_err_print(INIT_SUB_THR_CREATE_ERR, strerror(errno));
238 return (NULL);
239 }
240
241 return (&sysevent_reg_mod_ops);
242 }
243
244 void
245 slm_fini()
246 {
247 (void) mutex_lock(&evq_lock);
248 cleanup = 1;
249 (void) cond_signal(&evq_cv);
250 (void) mutex_unlock(&evq_lock);
251
252 /* Wait for delivery threads to exit */
253 (void) thr_join(deliver_thr_id, NULL, NULL);
254
255 (void) mutex_destroy(&evq_lock);
256 (void) cond_destroy(&evq_cv);
257
258 sysevent_close_channel(sysevent_hp);
259 sysevent_hp = NULL;
260 }