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 <errno.h> 32 #include <string.h> 33 #include <door.h> 34 #include <fcntl.h> 35 #include <syslog.h> 36 #include <sys/sunddi.h> 37 #include <libsysevent.h> 38 #include <picl.h> 39 #include <pthread.h> 40 #include "piclevent.h" 41 #include <sys/sysevent/eventdefs.h> 42 #include <sys/sysevent/dr.h> 43 44 #define PICLSLM_DOOR_FAILED gettext("PICL SLM door create failed\n") 45 46 /* 47 * syseventd event handler 48 */ 49 static int piclslm_debug = 0; 50 static int piclslm_deliver_event(sysevent_t *ev, int flag); 51 static int door_fd = -1; 52 53 typedef struct nvlist_queue { 54 char *nvq_item; /* packed nvlist */ 55 size_t nvq_sz; /* buf size */ 56 struct nvlist_queue *nvq_next; 57 } nvlist_queue_t; 58 59 static nvlist_queue_t *nvq_head; 60 static nvlist_queue_t *nvq_tail; 61 62 static mutex_t nvq_lock; 63 static cond_t nvq_cv; 64 static thread_t piclslm_deliver_thr_id; 65 static int cleanup; 66 67 static struct slm_mod_ops piclslm_mod_ops = { 68 SE_MAJOR_VERSION, SE_MINOR_VERSION, SE_MAX_RETRY_LIMIT, 69 piclslm_deliver_event}; 70 71 72 static void 73 init_queue(void) 74 { 75 nvq_head = NULL; 76 nvq_tail = NULL; 77 } 78 79 static int 80 add_to_queue(char *nvl, size_t sz) 81 { 82 nvlist_queue_t *new_nvq; 83 84 new_nvq = malloc(sizeof (*new_nvq)); 85 if (new_nvq == NULL) 86 return (-1); 87 88 new_nvq->nvq_item = nvl; 89 new_nvq->nvq_sz = sz; 90 new_nvq->nvq_next = NULL; 91 92 if (nvq_head == NULL) 93 nvq_head = new_nvq; 94 else 95 nvq_tail->nvq_next = new_nvq; 96 nvq_tail = new_nvq; 97 98 return (0); 99 } 100 101 static nvlist_queue_t * 102 remove_from_queue(void) 103 { 104 nvlist_queue_t *nvqp; 105 106 if (nvq_head == NULL) 107 return (NULL); 108 109 nvqp = nvq_head; 110 nvq_head = nvq_head->nvq_next; 111 if (nvq_head == NULL) 112 nvq_tail = NULL; 113 return (nvqp); 114 } 115 116 static void 117 free_nvqueue(nvlist_queue_t *nvqp) 118 { 119 free(nvqp->nvq_item); 120 free(nvqp); 121 } 122 123 /* 124 * deliver the event to the plugin if the door exists 125 */ 126 static void 127 post_piclevent(char *pack_buf, size_t nvl_size) 128 { 129 door_arg_t darg; 130 131 darg.data_ptr = pack_buf; 132 darg.data_size = nvl_size; 133 darg.desc_ptr = NULL; 134 darg.desc_num = 0; 135 darg.rbuf = NULL; 136 darg.rsize = 0; 137 138 if (door_fd < 0 || door_call(door_fd, &darg) < 0) { 139 if (door_fd >= 0) { 140 if (errno != EBADF) { 141 return; 142 } 143 144 /* 145 * It's not a valid door file descriptor. 146 * Close and reopen the door and try again 147 * as "picld" may have restarted. 148 */ 149 (void) close(door_fd); 150 } 151 152 door_fd = open(PICLEVENT_DOOR, O_RDONLY); 153 if (piclslm_debug) 154 syslog(LOG_INFO, 155 "picl_slm: opened door %s door_fd: %d\n", 156 PICLEVENT_DOOR, door_fd); 157 if (door_fd < 0 || door_call(door_fd, &darg) < 0) { 158 return; 159 } 160 } 161 if (piclslm_debug) 162 syslog(LOG_INFO, 163 "picl_slm: sent sysevent door:%d pack_buf:%p size:0x%x\n", 164 door_fd, pack_buf, nvl_size); 165 } 166 167 /*ARGSUSED*/ 168 static void * 169 piclslm_deliver_thr(void *args) 170 { 171 nvlist_queue_t *nvqp; 172 173 for (;;) { 174 (void) mutex_lock(&nvq_lock); 175 while (nvq_head == NULL && cleanup == 0) { 176 (void) cond_wait(&nvq_cv, &nvq_lock); 177 } 178 nvqp = remove_from_queue(); 179 (void) mutex_unlock(&nvq_lock); 180 while (nvqp) { 181 post_piclevent(nvqp->nvq_item, nvqp->nvq_sz); 182 free_nvqueue(nvqp); 183 (void) mutex_lock(&nvq_lock); 184 nvqp = remove_from_queue(); 185 (void) mutex_unlock(&nvq_lock); 186 } 187 if (cleanup) 188 return (NULL); 189 } 190 /*NOTREACHED*/ 191 } 192 193 /* 194 * returns 0 if arguments successfully added to nvl, EINVAL if arguments missing 195 * from ev and EAGAIN if nvlist_add_string() fails 196 */ 197 static int 198 piclslm_add_ec_devfs_args(nvlist_t *nvl, sysevent_t *ev) 199 { 200 sysevent_value_t se_val; 201 202 if (sysevent_lookup_attr(ev, DEVFS_PATHNAME, SE_DATA_TYPE_STRING, 203 &se_val) != 0 || se_val.value.sv_string == NULL) { 204 return (EINVAL); 205 } 206 if (nvlist_add_string(nvl, PICLEVENTARG_DEVFS_PATH, 207 se_val.value.sv_string)) { 208 return (EAGAIN); 209 } 210 return (0); 211 } 212 213 /* 214 * returns 0 if arguments successfully added to nvl, EINVAL if arguments missing 215 * from ev and EAGAIN if nvlist_add_string() fails 216 */ 217 static int 218 piclslm_add_ec_dr_args(nvlist_t *nvl, sysevent_t *ev) 219 { 220 sysevent_value_t se_val; 221 222 if (sysevent_lookup_attr(ev, DR_AP_ID, SE_DATA_TYPE_STRING, 223 &se_val) != 0 || se_val.value.sv_string == NULL) { 224 return (EINVAL); 225 } 226 if (nvlist_add_string(nvl, PICLEVENTARG_AP_ID, 227 se_val.value.sv_string)) { 228 return (EAGAIN); 229 } 230 if (sysevent_lookup_attr(ev, DR_HINT, SE_DATA_TYPE_STRING, 231 &se_val) != 0 || se_val.value.sv_string == NULL) { 232 if (nvlist_add_string(nvl, PICLEVENTARG_HINT, "")) 233 return (EAGAIN); 234 } else { 235 if (nvlist_add_string(nvl, PICLEVENTARG_HINT, 236 se_val.value.sv_string)) 237 return (EAGAIN); 238 } 239 return (0); 240 } 241 242 /* 243 * returns 0 if arguments successfully added to nvl, EINVAL if arguments missing 244 * from ev and EAGAIN if nvlist_add_string() fails 245 */ 246 static int 247 piclslm_add_ec_dr_req_args(nvlist_t *nvl, sysevent_t *ev) 248 { 249 nvlist_t *nvlist = NULL; 250 char *ap_id = NULL; 251 char *dr_req = NULL; 252 253 if (sysevent_get_attr_list(ev, &nvlist)) { 254 return (EAGAIN); 255 } 256 257 if (nvlist_lookup_string(nvlist, DR_AP_ID, &ap_id) != 0 || 258 ap_id == NULL) { 259 nvlist_free(nvlist); 260 return (EINVAL); 261 } 262 263 if (nvlist_add_string(nvl, PICLEVENTARG_AP_ID, ap_id)) { 264 nvlist_free(nvlist); 265 return (EAGAIN); 266 } 267 268 dr_req = NULL; 269 if (nvlist_lookup_string(nvlist, DR_REQ_TYPE, &dr_req) != 0) 270 dr_req = ""; 271 272 if (nvlist_add_string(nvl, PICLEVENTARG_DR_REQ_TYPE, 273 dr_req)) { 274 nvlist_free(nvlist); 275 return (EAGAIN); 276 } 277 278 if (piclslm_debug) 279 syslog(LOG_DEBUG, "piclevent: dr_req_type = %s on %s\n", 280 (dr_req ? dr_req : "Investigate"), ap_id); 281 282 nvlist_free(nvlist); 283 return (0); 284 } 285 286 /* 287 * piclslm_deliver_event - called by syseventd to deliver an event buffer. 288 * The event buffer is subsequently delivered to 289 * picld. If picld, is not responding to the 290 * delivery attempt, we will ignore it. 291 */ 292 /*ARGSUSED*/ 293 static int 294 piclslm_deliver_event(sysevent_t *ev, int flag) 295 { 296 sysevent_t *dupev; 297 nvlist_t *nvl; 298 char *ec; 299 char *esc; 300 char *ename; 301 int retval; 302 char *pack_buf; 303 size_t nvl_size; 304 int rval; 305 306 /* 307 * Filter out uninteresting events 308 */ 309 ec = sysevent_get_class_name(ev); 310 esc = sysevent_get_subclass_name(ev); 311 if (piclslm_debug) 312 syslog(LOG_INFO, 313 "picl_slm: got sysevent ev:%p class:%s subclass:%s\n", 314 ev, (ec) ? ec : "NULL", (esc) ? esc : "NULL"); 315 if ((ec == NULL) || (esc == NULL)) { 316 return (0); 317 } else if (strcmp(ec, EC_DEVFS) == 0) { 318 if (strcmp(esc, ESC_DEVFS_DEVI_ADD) == 0) 319 ename = strdup(PICLEVENT_SYSEVENT_DEVICE_ADDED); 320 else if (strcmp(esc, ESC_DEVFS_DEVI_REMOVE) == 0) 321 ename = strdup(PICLEVENT_SYSEVENT_DEVICE_REMOVED); 322 else 323 return (0); 324 } else if (strcmp(ec, EC_DR) == 0) { 325 if (strcmp(esc, ESC_DR_AP_STATE_CHANGE) == 0) 326 ename = strdup(PICLEVENT_DR_AP_STATE_CHANGE); 327 else if (strcmp(esc, ESC_DR_REQ) == 0) 328 ename = strdup(PICLEVENT_DR_REQ); 329 else 330 return (0); 331 } else { 332 return (0); 333 } 334 335 if (ename == NULL) 336 return (EAGAIN); 337 338 /* 339 * Make a copy to expand attribute list 340 */ 341 dupev = sysevent_dup(ev); 342 if (dupev == NULL) { 343 free(ename); 344 return (EAGAIN); 345 } 346 347 if (nvlist_alloc(&nvl, NV_UNIQUE_NAME_TYPE, NULL)) { 348 free(ename); 349 sysevent_free(dupev); 350 return (EAGAIN); 351 } 352 353 if (strcmp(ec, EC_DEVFS) == 0) { 354 rval = piclslm_add_ec_devfs_args(nvl, dupev); 355 } else if (strcmp(ec, EC_DR) == 0) { 356 if (strcmp(esc, ESC_DR_REQ) == 0) { 357 rval = piclslm_add_ec_dr_req_args(nvl, dupev); 358 } else { 359 rval = piclslm_add_ec_dr_args(nvl, dupev); 360 } 361 } 362 363 if (rval != 0) { 364 free(ename); 365 nvlist_free(nvl); 366 sysevent_free(dupev); 367 return ((rval == EAGAIN) ? EAGAIN : 0); 368 } 369 370 pack_buf = NULL; 371 if (nvlist_add_string(nvl, PICLEVENTARG_EVENT_NAME, ename) || 372 nvlist_add_string(nvl, PICLEVENTARG_DATA_TYPE, 373 PICLEVENTARG_PICLEVENT_DATA) || 374 nvlist_pack(nvl, &pack_buf, &nvl_size, NV_ENCODE_NATIVE, NULL)) { 375 free(ename); 376 nvlist_free(nvl); 377 sysevent_free(dupev); 378 return (EAGAIN); 379 } 380 381 /* 382 * Add nvlist_t to queue 383 */ 384 (void) mutex_lock(&nvq_lock); 385 retval = add_to_queue(pack_buf, nvl_size); 386 (void) cond_signal(&nvq_cv); 387 (void) mutex_unlock(&nvq_lock); 388 389 nvlist_free(nvl); 390 sysevent_free(dupev); 391 free(ename); 392 return (retval < 0 ? EAGAIN : 0); 393 } 394 395 struct slm_mod_ops * 396 slm_init(void) 397 { 398 cleanup = 0; 399 400 init_queue(); 401 402 (void) mutex_init(&nvq_lock, USYNC_THREAD, NULL); 403 (void) cond_init(&nvq_cv, USYNC_THREAD, NULL); 404 405 if (thr_create(NULL, NULL, piclslm_deliver_thr, 406 NULL, THR_BOUND, &piclslm_deliver_thr_id) != 0) { 407 (void) mutex_destroy(&nvq_lock); 408 (void) cond_destroy(&nvq_cv); 409 return (NULL); 410 } 411 return (&piclslm_mod_ops); 412 } 413 414 void 415 slm_fini(void) 416 { 417 /* 418 * Wait for all events to be sent 419 */ 420 (void) mutex_lock(&nvq_lock); 421 cleanup = 1; 422 (void) cond_signal(&nvq_cv); 423 (void) mutex_unlock(&nvq_lock); 424 425 /* Wait for delivery thread to exit */ 426 (void) thr_join(piclslm_deliver_thr_id, NULL, NULL); 427 428 (void) mutex_destroy(&nvq_lock); 429 (void) cond_destroy(&nvq_cv); 430 431 if (door_fd >= 0) 432 (void) close(door_fd); 433 door_fd = -1; 434 } 435