patch cleanup
6659 nvlist_free(NULL) is a no-op

   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 (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 /*
  22  * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
  23  * Use is subject to license terms.
  24  */
  25 
  26 #pragma ident   "%Z%%M% %I%     %E% SMI"
  27 
  28 #include "librcm_impl.h"
  29 #include "librcm_event.h"
  30 
  31 #ifdef  DEBUG
  32 static int rcm_debug = 1;
  33 #define dprintf(args) if (rcm_debug) (void) fprintf args
  34 #else
  35 #define dprintf(args) /* nothing */
  36 #endif  /* DEBUG */
  37 
  38 static int extract_info(nvlist_t *, rcm_info_t **);
  39 static int rcm_daemon_is_alive();
  40 static int rcm_common(int, rcm_handle_t *, char **, uint_t, void *,
  41     rcm_info_t **);
  42 static int rcm_direct_call(int, rcm_handle_t *, char **, uint_t, void *,
  43     rcm_info_t **);
  44 static int rcm_daemon_call(int, rcm_handle_t *, char **, uint_t, void *,
  45     rcm_info_t **);
  46 static int rcm_generate_nvlist(int, rcm_handle_t *, char **, uint_t, void *,
  47     char **, size_t *);
  48 static int rcm_check_permission(void);
  49 
  50 /*
  51  * Allocate a handle structure
  52  */
  53 /*ARGSUSED2*/
  54 int
  55 rcm_alloc_handle(char *modname, uint_t flag, void *arg, rcm_handle_t **hdp)
  56 {
  57         rcm_handle_t *hd;
  58         void *temp;
  59         char namebuf[MAXPATHLEN];
  60 
  61         if ((hdp == NULL) || (flag & ~RCM_ALLOC_HDL_MASK)) {
  62                 errno = EINVAL;
  63                 return (RCM_FAILURE);
  64         }
  65 
  66         if (rcm_check_permission() == 0) {
  67                 errno = EPERM;
  68                 return (RCM_FAILURE);
  69         }
  70 
  71         if ((hd = calloc(1, sizeof (*hd))) == NULL) {
  72                 return (RCM_FAILURE);
  73         }
  74 
  75         if (modname) {
  76                 (void) snprintf(namebuf, MAXPATHLEN, "%s%s", modname,
  77                         RCM_MODULE_SUFFIX);
  78 
  79                 if ((hd->modname = strdup(namebuf)) == NULL) {
  80                         free(hd);
  81                         return (RCM_FAILURE);
  82                 }
  83 
  84                 if ((temp = rcm_module_open(namebuf)) == NULL) {
  85                         free(hd->modname);
  86                         free(hd);
  87                         errno = EINVAL;
  88                         return (RCM_FAILURE);
  89                 }
  90 
  91                 rcm_module_close(temp);
  92         }
  93 
  94         if (flag & RCM_NOPID) {
  95                 hd->pid = (pid_t)0;
  96         } else {
  97                 hd->pid = (pid_t)getpid();
  98         }
  99 
 100         *hdp = hd;
 101         return (RCM_SUCCESS);
 102 }
 103 
 104 /* free handle structure */
 105 int
 106 rcm_free_handle(rcm_handle_t *hd)
 107 {
 108         if (hd == NULL) {
 109                 errno = EINVAL;
 110                 return (RCM_FAILURE);
 111         }
 112 
 113         if (hd->modname) {
 114                 free(hd->modname);
 115         }
 116 
 117         free(hd);
 118         return (RCM_SUCCESS);
 119 }
 120 
 121 
 122 /*
 123  * Operations which require daemon processing
 124  */
 125 
 126 /* get registration and DR information from rcm_daemon */
 127 int
 128 rcm_get_info(rcm_handle_t *hd, char *rsrcname, uint_t flag, rcm_info_t **infop)
 129 {
 130         char *rsrcnames[2];
 131 
 132         if ((flag & ~RCM_GET_INFO_MASK) || (infop == NULL)) {
 133                 errno = EINVAL;
 134                 return (RCM_FAILURE);
 135         }
 136 
 137         /*
 138          * rsrcname may be NULL if requesting dr operations or modinfo
 139          */
 140         if ((rsrcname == NULL) &&
 141             ((flag & RCM_DR_OPERATION|RCM_MOD_INFO) == 0)) {
 142                 errno = EINVAL;
 143                 return (RCM_FAILURE);
 144         }
 145 
 146         rsrcnames[0] = rsrcname;
 147         rsrcnames[1] = NULL;
 148 
 149         return (rcm_common(CMD_GETINFO, hd, rsrcnames, flag, NULL, infop));
 150 }
 151 
 152 /* get registration and DR information from rcm_daemon (list version) */
 153 int
 154 rcm_get_info_list(rcm_handle_t *hd, char **rsrcnames, uint_t flag,
 155     rcm_info_t **infop)
 156 {
 157         /* Requesting the current DR operations with a *list() is invalid */
 158         if ((flag & RCM_DR_OPERATION) || (flag & RCM_MOD_INFO)) {
 159                 errno = EINVAL;
 160                 return (RCM_FAILURE);
 161         }
 162 
 163         return (rcm_common(CMD_GETINFO, hd, rsrcnames, flag, NULL, infop));
 164 }
 165 
 166 /* request to offline a resource before DR removal */
 167 int
 168 rcm_request_offline(rcm_handle_t *hd, char *rsrcname, uint_t flag,
 169     rcm_info_t **infop)
 170 {
 171         char *rsrcnames[2];
 172 
 173         rsrcnames[0] = rsrcname;
 174         rsrcnames[1] = NULL;
 175 
 176         return (rcm_request_offline_list(hd, rsrcnames, flag, infop));
 177 }
 178 
 179 /* request to offline a resource before DR removal (list version) */
 180 int
 181 rcm_request_offline_list(rcm_handle_t *hd, char **rsrcnames, uint_t flag,
 182     rcm_info_t **infop)
 183 {
 184         if (flag & ~RCM_REQUEST_MASK) {
 185                 errno = EINVAL;
 186                 return (RCM_FAILURE);
 187         }
 188 
 189         return (rcm_common(CMD_OFFLINE, hd, rsrcnames, flag, NULL, infop));
 190 }
 191 
 192 /* cancel offline request and allow apps to use rsrcname */
 193 int
 194 rcm_notify_online(rcm_handle_t *hd, char *rsrcname, uint_t flag,
 195     rcm_info_t **infop)
 196 {
 197         char *rsrcnames[2];
 198 
 199         rsrcnames[0] = rsrcname;
 200         rsrcnames[1] = NULL;
 201 
 202         return (rcm_notify_online_list(hd, rsrcnames, flag, infop));
 203 }
 204 
 205 /* cancel offline and allow apps to use resources (list version) */
 206 int
 207 rcm_notify_online_list(rcm_handle_t *hd, char **rsrcnames, uint_t flag,
 208     rcm_info_t **infop)
 209 {
 210         if (flag & ~RCM_NOTIFY_MASK) {
 211                 errno = EINVAL;
 212                 return (RCM_FAILURE);
 213         }
 214 
 215         return (rcm_common(CMD_ONLINE, hd, rsrcnames, flag, NULL, infop));
 216 }
 217 
 218 /* notify that rsrcname has been removed */
 219 int
 220 rcm_notify_remove(rcm_handle_t *hd, char *rsrcname, uint_t flag,
 221     rcm_info_t **infop)
 222 {
 223         char *rsrcnames[2];
 224 
 225         rsrcnames[0] = rsrcname;
 226         rsrcnames[1] = NULL;
 227 
 228         return (rcm_notify_remove_list(hd, rsrcnames, flag, infop));
 229 }
 230 
 231 /* notify that resrouces have been removed (list form) */
 232 int
 233 rcm_notify_remove_list(rcm_handle_t *hd, char **rsrcnames, uint_t flag,
 234     rcm_info_t **infop)
 235 {
 236         if (flag & ~RCM_NOTIFY_MASK) {
 237                 errno = EINVAL;
 238                 return (RCM_FAILURE);
 239         }
 240 
 241         return (rcm_common(CMD_REMOVE, hd, rsrcnames, flag, NULL, infop));
 242 }
 243 
 244 /* request for permission to suspend resource of interval time */
 245 int
 246 rcm_request_suspend(rcm_handle_t *hd, char *rsrcname, uint_t flag,
 247     timespec_t *interval, rcm_info_t **infop)
 248 {
 249         char *rsrcnames[2];
 250 
 251         rsrcnames[0] = rsrcname;
 252         rsrcnames[1] = NULL;
 253 
 254         return (rcm_request_suspend_list(hd, rsrcnames, flag, interval, infop));
 255 }
 256 
 257 /* request for permission to suspend resource of interval time (list form) */
 258 int
 259 rcm_request_suspend_list(rcm_handle_t *hd, char **rsrcnames, uint_t flag,
 260     timespec_t *interval, rcm_info_t **infop)
 261 {
 262         if ((flag & ~RCM_REQUEST_MASK) || (interval == NULL) ||
 263             (interval->tv_sec < 0) || (interval->tv_nsec < 0)) {
 264                 errno = EINVAL;
 265                 return (RCM_FAILURE);
 266         }
 267 
 268         return (rcm_common(CMD_SUSPEND, hd, rsrcnames, flag, (void *)interval,
 269             infop));
 270 }
 271 
 272 /* notify apps of the completion of resource suspension */
 273 int
 274 rcm_notify_resume(rcm_handle_t *hd, char *rsrcname, uint_t flag,
 275     rcm_info_t **infop)
 276 {
 277         char *rsrcnames[2];
 278 
 279         rsrcnames[0] = rsrcname;
 280         rsrcnames[1] = NULL;
 281 
 282         return (rcm_notify_resume_list(hd, rsrcnames, flag, infop));
 283 }
 284 
 285 /* notify apps of the completion of resource suspension (list form) */
 286 int
 287 rcm_notify_resume_list(rcm_handle_t *hd, char **rsrcnames, uint_t flag,
 288     rcm_info_t **infop)
 289 {
 290         if (flag & ~(RCM_NOTIFY_MASK | RCM_SUSPENDED)) {
 291                 errno = EINVAL;
 292                 return (RCM_FAILURE);
 293         }
 294 
 295         return (rcm_common(CMD_RESUME, hd, rsrcnames, flag, NULL, infop));
 296 }
 297 
 298 /* request a capacity change from apps */
 299 int
 300 rcm_request_capacity_change(rcm_handle_t *hd, char *rsrcname, uint_t flag,
 301     nvlist_t *nvl, rcm_info_t **infop)
 302 {
 303         int rv;
 304         char *rsrcnames[2];
 305 
 306         if ((nvl == NULL) || (flag & ~RCM_REQUEST_MASK)) {
 307                 errno = EINVAL;
 308                 return (RCM_FAILURE);
 309         }
 310 
 311         rsrcnames[0] = rsrcname;
 312         rsrcnames[1] = NULL;
 313 
 314         rv = rcm_common(CMD_REQUEST_CHANGE, hd, rsrcnames, flag, (void *)nvl,
 315             infop);
 316 
 317         return (rv);
 318 }
 319 
 320 /* notify apps of a capacity change */
 321 int
 322 rcm_notify_capacity_change(rcm_handle_t *hd, char *rsrcname, uint_t flag,
 323     nvlist_t *nvl, rcm_info_t **infop)
 324 {
 325         int rv;
 326         char *rsrcnames[2];
 327 
 328         if ((nvl == NULL) || (flag & ~RCM_REQUEST_MASK)) {
 329                 errno = EINVAL;
 330                 return (RCM_FAILURE);
 331         }
 332 
 333         rsrcnames[0] = rsrcname;
 334         rsrcnames[1] = NULL;
 335 
 336         rv = rcm_common(CMD_NOTIFY_CHANGE, hd, rsrcnames, flag, (void *)nvl,
 337             infop);
 338 
 339         return (rv);
 340 }
 341 
 342 /* notify apps of an event */
 343 int
 344 rcm_notify_event(rcm_handle_t *hd, char *rsrcname, uint_t flag, nvlist_t *nvl,
 345     rcm_info_t **infop)
 346 {
 347         int rv;
 348         char *rsrcnames[2];
 349 
 350         /* No flags are defined yet for rcm_notify_event() */
 351         if ((nvl == NULL) || (flag != 0)) {
 352                 errno = EINVAL;
 353                 return (RCM_FAILURE);
 354         }
 355 
 356         rsrcnames[0] = rsrcname;
 357         rsrcnames[1] = NULL;
 358 
 359         rv = rcm_common(CMD_EVENT, hd, rsrcnames, 0, (void *)nvl, infop);
 360 
 361         return (rv);
 362 }
 363 
 364 /*
 365  * Register to receive capacity changes. This requires a module to exist in
 366  * module directory. It should be called prior to using a new resource.
 367  */
 368 /* ARGSUSED */
 369 int
 370 rcm_register_capacity(rcm_handle_t *hd, char *rsrcname, uint_t flag,
 371     rcm_info_t **infop)
 372 {
 373         char *rsrcnames[2];
 374 
 375         if (flag & ~RCM_REGISTER_MASK) {
 376                 errno = EINVAL;
 377                 return (RCM_FAILURE);
 378         }
 379 
 380         flag |= RCM_REGISTER_CAPACITY;
 381 
 382         rsrcnames[0] = rsrcname;
 383         rsrcnames[1] = NULL;
 384 
 385         return (rcm_common(CMD_REGISTER, hd, rsrcnames, flag, NULL, NULL));
 386 }
 387 
 388 /* unregister interest in capacity changes */
 389 int
 390 rcm_unregister_capacity(rcm_handle_t *hd, char *rsrcname, uint_t flag)
 391 {
 392         char *rsrcnames[2];
 393 
 394         if (flag & ~RCM_REGISTER_MASK) {
 395                 errno = EINVAL;
 396                 return (RCM_FAILURE);
 397         }
 398 
 399         flag |= RCM_REGISTER_CAPACITY;
 400 
 401         rsrcnames[0] = rsrcname;
 402         rsrcnames[1] = NULL;
 403 
 404         return (rcm_common(CMD_UNREGISTER, hd, rsrcnames, flag, NULL, NULL));
 405 }
 406 
 407 /*
 408  * Register to receive events. This requires a module to exist in module
 409  * directory. It should be called prior to using a new resource.
 410  */
 411 /* ARGSUSED */
 412 int
 413 rcm_register_event(rcm_handle_t *hd, char *rsrcname, uint_t flag,
 414     rcm_info_t **infop)
 415 {
 416         char *rsrcnames[2];
 417 
 418         if (flag & ~RCM_REGISTER_MASK) {
 419                 errno = EINVAL;
 420                 return (RCM_FAILURE);
 421         }
 422 
 423         flag |= RCM_REGISTER_EVENT;
 424 
 425         rsrcnames[0] = rsrcname;
 426         rsrcnames[1] = NULL;
 427 
 428         return (rcm_common(CMD_REGISTER, hd, rsrcnames, flag, NULL, NULL));
 429 }
 430 
 431 /* unregister interest in events */
 432 int
 433 rcm_unregister_event(rcm_handle_t *hd, char *rsrcname, uint_t flag)
 434 {
 435         char *rsrcnames[2];
 436 
 437         if (flag & ~RCM_REGISTER_MASK) {
 438                 errno = EINVAL;
 439                 return (RCM_FAILURE);
 440         }
 441 
 442         flag |= RCM_REGISTER_EVENT;
 443 
 444         rsrcnames[0] = rsrcname;
 445         rsrcnames[1] = NULL;
 446 
 447         return (rcm_common(CMD_UNREGISTER, hd, rsrcnames, flag, NULL, NULL));
 448 }
 449 
 450 /*
 451  * Register interest in a resource. This requires a module to exist in module
 452  * directory. It should be called prior to using a new resource.
 453  *
 454  * Registration may be denied if it is presently locked by a DR operation.
 455  */
 456 /* ARGSUSED */
 457 int
 458 rcm_register_interest(rcm_handle_t *hd, char *rsrcname, uint_t flag,
 459     rcm_info_t **infop)
 460 {
 461         char *rsrcnames[2];
 462 
 463         if (flag & ~RCM_REGISTER_MASK) {
 464                 errno = EINVAL;
 465                 return (RCM_FAILURE);
 466         }
 467 
 468         flag |= RCM_REGISTER_DR;
 469 
 470         rsrcnames[0] = rsrcname;
 471         rsrcnames[1] = NULL;
 472 
 473         return (rcm_common(CMD_REGISTER, hd, rsrcnames, flag, NULL, NULL));
 474 }
 475 
 476 /* unregister interest in rsrcname */
 477 int
 478 rcm_unregister_interest(rcm_handle_t *hd, char *rsrcname, uint_t flag)
 479 {
 480         char *rsrcnames[2];
 481 
 482         if (flag & ~RCM_REGISTER_MASK) {
 483                 errno = EINVAL;
 484                 return (RCM_FAILURE);
 485         }
 486 
 487         flag |= RCM_REGISTER_DR;
 488 
 489         rsrcnames[0] = rsrcname;
 490         rsrcnames[1] = NULL;
 491 
 492         return (rcm_common(CMD_UNREGISTER, hd, rsrcnames, flag, NULL, NULL));
 493 }
 494 
 495 /* get the current state of a resource */
 496 int
 497 rcm_get_rsrcstate(rcm_handle_t *hd, char *rsrcname, int *statep)
 498 {
 499         int result;
 500         int flag = 0;
 501         rcm_info_t *infop = NULL;
 502         rcm_info_tuple_t *tuple = NULL;
 503         char *rsrcnames[2];
 504 
 505         if (statep == NULL) {
 506                 errno = EINVAL;
 507                 return (RCM_FAILURE);
 508         }
 509 
 510         rsrcnames[0] = rsrcname;
 511         rsrcnames[1] = NULL;
 512 
 513         result = rcm_common(CMD_GETSTATE, hd, rsrcnames, flag, NULL, &infop);
 514 
 515         /*
 516          * A successful result implies the presence of exactly one RCM info
 517          * tuple containing the state of this resource (a combination of each
 518          * client's resources).  If that's not true, change the result to
 519          * RCM_FAILURE.
 520          */
 521         if (result == RCM_SUCCESS) {
 522                 if ((infop == NULL) ||
 523                     ((tuple = rcm_info_next(infop, NULL)) == NULL) ||
 524                     (rcm_info_next(infop, tuple) != NULL)) {
 525                         result = RCM_FAILURE;
 526                 } else if (infop && tuple) {
 527                         *statep = rcm_info_state(tuple);
 528                 }
 529         }
 530 
 531         if (infop)
 532                 rcm_free_info(infop);
 533 
 534         return (result);
 535 }
 536 
 537 /*
 538  * RCM helper functions exposed to librcm callers.
 539  */
 540 
 541 /* Free linked list of registration info */
 542 void
 543 rcm_free_info(rcm_info_t *info)
 544 {
 545         while (info) {
 546                 rcm_info_t *tmp = info->next;
 547 
 548                 if (info->info)
 549                         nvlist_free(info->info);
 550                 free(info);
 551 
 552                 info = tmp;
 553         }
 554 }
 555 
 556 /* return the next tuple in the info structure */
 557 rcm_info_tuple_t *
 558 rcm_info_next(rcm_info_t *info, rcm_info_tuple_t *tuple)
 559 {
 560         if (info == NULL) {
 561                 errno = EINVAL;
 562                 return (NULL);
 563         }
 564 
 565         if (tuple == NULL) {
 566                 return ((rcm_info_tuple_t *)info);
 567         }
 568         return ((rcm_info_tuple_t *)tuple->next);
 569 }
 570 
 571 /* return resource name */
 572 const char *
 573 rcm_info_rsrc(rcm_info_tuple_t *tuple)
 574 {
 575         char *rsrcname = NULL;
 576 
 577         if (tuple == NULL || tuple->info == NULL) {
 578                 errno = EINVAL;
 579                 return (NULL);
 580         }
 581 
 582         if (errno = nvlist_lookup_string(tuple->info, RCM_RSRCNAME, &rsrcname))
 583                 return (NULL);
 584 
 585         return (rsrcname);
 586 }
 587 
 588 const char *
 589 rcm_info_info(rcm_info_tuple_t *tuple)
 590 {
 591         char *info = NULL;
 592 
 593         if (tuple == NULL || tuple->info == NULL) {
 594                 errno = EINVAL;
 595                 return (NULL);
 596         }
 597 
 598         if (errno = nvlist_lookup_string(tuple->info, RCM_CLIENT_INFO, &info))
 599                 return (NULL);
 600 
 601         return (info);
 602 }
 603 
 604 const char *
 605 rcm_info_error(rcm_info_tuple_t *tuple)
 606 {
 607         char *errstr = NULL;
 608 
 609         if (tuple == NULL || tuple->info == NULL) {
 610                 errno = EINVAL;
 611                 return (NULL);
 612         }
 613 
 614         if (errno = nvlist_lookup_string(tuple->info, RCM_CLIENT_ERROR,
 615             &errstr))
 616                 return (NULL);
 617 
 618         return (errstr);
 619 }
 620 
 621 /* return info string in the tuple */
 622 const char *
 623 rcm_info_modname(rcm_info_tuple_t *tuple)
 624 {
 625         char *modname = NULL;
 626 
 627         if (tuple == NULL || tuple->info == NULL) {
 628                 errno = EINVAL;
 629                 return (NULL);
 630         }
 631 
 632         if (errno = nvlist_lookup_string(tuple->info, RCM_CLIENT_MODNAME,
 633             &modname))
 634                 return (NULL);
 635 
 636         return (modname);
 637 }
 638 
 639 /* return client pid in the tuple */
 640 pid_t
 641 rcm_info_pid(rcm_info_tuple_t *tuple)
 642 {
 643         uint64_t pid64 = (uint64_t)0;
 644 
 645         if (tuple == NULL || tuple->info == NULL) {
 646                 errno = EINVAL;
 647                 return ((pid_t)0);
 648         }
 649 
 650         if (errno = nvlist_lookup_uint64(tuple->info, RCM_CLIENT_ID, &pid64))
 651                 return ((pid_t)0);
 652 
 653         return ((pid_t)pid64);
 654 }
 655 
 656 /* return client state in the tuple */
 657 int
 658 rcm_info_state(rcm_info_tuple_t *tuple)
 659 {
 660         int state;
 661 
 662         if (tuple == NULL || tuple->info == NULL) {
 663                 errno = EINVAL;
 664                 return (RCM_STATE_UNKNOWN);
 665         }
 666 
 667         if (errno = nvlist_lookup_int32(tuple->info, RCM_RSRCSTATE, &state))
 668                 return (RCM_STATE_UNKNOWN);
 669 
 670         return (state);
 671 }
 672 
 673 /* return the generic properties in the tuple */
 674 nvlist_t *
 675 rcm_info_properties(rcm_info_tuple_t *tuple)
 676 {
 677         char *buf;
 678         uint_t buflen;
 679         nvlist_t *nvl;
 680 
 681         if (tuple == NULL || tuple->info == NULL) {
 682                 errno = EINVAL;
 683                 return (NULL);
 684         }
 685 
 686         if (errno = nvlist_lookup_byte_array(tuple->info, RCM_CLIENT_PROPERTIES,
 687             (uchar_t **)&buf, &buflen))
 688                 return (NULL);
 689 
 690         if (errno = nvlist_unpack(buf, buflen, &nvl, 0)) {
 691                 free(buf);
 692                 return (NULL);
 693         }
 694 
 695         return (nvl);
 696 }
 697 
 698 /*
 699  * return operation sequence number
 700  *
 701  * This is private. Called by rcmctl only for testing purposes.
 702  */
 703 int
 704 rcm_info_seqnum(rcm_info_tuple_t *tuple)
 705 {
 706         int seqnum;
 707 
 708         if (tuple == NULL || tuple->info == NULL) {
 709                 errno = EINVAL;
 710                 return (-1);
 711         }
 712 
 713         if (errno = nvlist_lookup_int32(tuple->info, RCM_SEQ_NUM, &seqnum))
 714                 return (-1);
 715 
 716         return (seqnum);
 717 }
 718 
 719 
 720 /*
 721  * The following interfaces are PRIVATE to the RCM framework. They are not
 722  * declared static because they are called by rcm_daemon.
 723  */
 724 
 725 /*
 726  * Invoke shell to execute command in MT safe manner.
 727  * Returns wait status or -1 on error.
 728  */
 729 int
 730 rcm_exec_cmd(char *cmd)
 731 {
 732         pid_t pid;
 733         int status, w;
 734         char *argvec[] = {"sh", "-c", NULL, NULL};
 735 
 736         argvec[2] = cmd;
 737         if ((pid = fork1()) == 0) {
 738                 (void) execv("/bin/sh", argvec);
 739                 _exit(127);
 740         } else if (pid == -1) {
 741                 return (-1);
 742         }
 743 
 744         do {
 745                 w = waitpid(pid, &status, 0);
 746         } while (w == -1 && errno == EINTR);
 747 
 748         return ((w == -1) ? w : status);
 749 }
 750 
 751 /* Append info at the very end */
 752 int
 753 rcm_append_info(rcm_info_t **head, rcm_info_t *info)
 754 {
 755         rcm_info_t *tuple;
 756 
 757         if (head == NULL) {
 758                 errno = EINVAL;
 759                 return (RCM_FAILURE);
 760         }
 761 
 762         if ((tuple = *head) == NULL) {
 763                 *head = info;
 764                 return (RCM_SUCCESS);
 765         }
 766 
 767         while (tuple->next) {
 768                 tuple = tuple->next;
 769         }
 770         tuple->next = info;
 771         return (RCM_SUCCESS);
 772 }
 773 
 774 /* get rcm module and rcm script directory names */
 775 
 776 #define N_MODULE_DIR    3       /* search 3 directories for modules */
 777 #define MODULE_DIR_HW   "/usr/platform/%s/lib/rcm/modules/"
 778 #define MODULE_DIR_GEN  "/usr/lib/rcm/modules/"
 779 
 780 #define N_SCRIPT_DIR    4       /* search 4 directories for scripts */
 781 #define SCRIPT_DIR_HW   "/usr/platform/%s/lib/rcm/scripts/"
 782 #define SCRIPT_DIR_GEN  "/usr/lib/rcm/scripts/"
 783 #define SCRIPT_DIR_ETC  "/etc/rcm/scripts/"
 784 
 785 
 786 char *
 787 rcm_module_dir(uint_t dirnum)
 788 {
 789         if (dirnum < N_MODULE_DIR)
 790                 return (rcm_dir(dirnum, NULL));
 791         else
 792                 return (NULL);
 793 }
 794 
 795 char *
 796 rcm_script_dir(uint_t dirnum)
 797 {
 798         if (dirnum < N_SCRIPT_DIR)
 799                 return (rcm_dir(dirnum + N_MODULE_DIR, NULL));
 800         else
 801                 return (NULL);
 802 }
 803 
 804 char *
 805 rcm_dir(uint_t dirnum, int *rcm_script)
 806 {
 807         static char dir_name[N_MODULE_DIR + N_SCRIPT_DIR][MAXPATHLEN];
 808 
 809         char infobuf[MAXPATHLEN];
 810 
 811         if (dirnum >= (N_MODULE_DIR + N_SCRIPT_DIR))
 812                 return (NULL);
 813 
 814         if (dir_name[0][0] == '\0') {
 815                 /*
 816                  * construct the module directory names
 817                  */
 818                 if (sysinfo(SI_PLATFORM, infobuf, MAXPATHLEN) == -1) {
 819                         dprintf((stderr, "sysinfo %s\n", strerror(errno)));
 820                         return (NULL);
 821                 } else {
 822                         if (snprintf(dir_name[0], MAXPATHLEN, MODULE_DIR_HW,
 823                             infobuf) >= MAXPATHLEN ||
 824                             snprintf(dir_name[N_MODULE_DIR + 1], MAXPATHLEN,
 825                             SCRIPT_DIR_HW, infobuf) >= MAXPATHLEN) {
 826                                 dprintf((stderr,
 827                                     "invalid module or script directory for "
 828                                     "platform %s\n", infobuf));
 829                                 return (NULL);
 830                         }
 831                 }
 832 
 833                 if (sysinfo(SI_MACHINE, infobuf, MAXPATHLEN) == -1) {
 834                         dprintf((stderr, "sysinfo %s\n", strerror(errno)));
 835                         return (NULL);
 836                 } else {
 837                         if (snprintf(dir_name[1], MAXPATHLEN, MODULE_DIR_HW,
 838                             infobuf) >= MAXPATHLEN ||
 839                             snprintf(dir_name[N_MODULE_DIR + 2], MAXPATHLEN,
 840                             SCRIPT_DIR_HW, infobuf) >= MAXPATHLEN) {
 841                                 dprintf((stderr,
 842                                     "invalid module or script directory for "
 843                                     "machine type %s\n", infobuf));
 844                                 return (NULL);
 845                         }
 846                 }
 847 
 848                 if (strlcpy(dir_name[2], MODULE_DIR_GEN, MAXPATHLEN) >=
 849                     MAXPATHLEN ||
 850                     strlcpy(dir_name[N_MODULE_DIR + 3], SCRIPT_DIR_GEN,
 851                     MAXPATHLEN) >= MAXPATHLEN ||
 852                     strlcpy(dir_name[N_MODULE_DIR + 0], SCRIPT_DIR_ETC,
 853                     MAXPATHLEN) >= MAXPATHLEN) {
 854                         dprintf((stderr,
 855                             "invalid module or script generic directory\n"));
 856                         return (NULL);
 857                 }
 858         }
 859 
 860         if (rcm_script)
 861                 *rcm_script = (dirnum < N_MODULE_DIR) ? 0 : 1;
 862 
 863         return (dir_name[dirnum]);
 864 }
 865 
 866 /*
 867  * Find the directory where the script is located.
 868  * If the script is found return a pointer to the directory where the
 869  * script was found otherwise return NULL.
 870  */
 871 char *
 872 rcm_get_script_dir(char *script_name)
 873 {
 874         uint_t i;
 875         char *dir_name;
 876         char path[MAXPATHLEN];
 877         struct stat stats;
 878 
 879         for (i = 0; (dir_name = rcm_script_dir(i)) != NULL; i++) {
 880                 if (snprintf(path, MAXPATHLEN, "%s%s", dir_name, script_name)
 881                     >= MAXPATHLEN) {
 882                         dprintf((stderr, "invalid script %s skipped\n",
 883                             script_name));
 884                         continue;
 885                 }
 886                 if (stat(path, &stats) == 0)
 887                         return (dir_name);
 888         }
 889 
 890         return (NULL);
 891 }
 892 
 893 /*
 894  * Returns 1 if the filename is an rcm script.
 895  * Returns 0 if the filename is an rcm module.
 896  */
 897 int
 898 rcm_is_script(char *filename)
 899 {
 900         char *tmp;
 901 
 902         if (((tmp = strstr(filename, RCM_MODULE_SUFFIX)) != NULL) &&
 903                 (tmp[strlen(RCM_MODULE_SUFFIX)] == '\0'))
 904                 return (0);
 905         else
 906                 return (1);
 907 }
 908 
 909 /* Locate the module and call dlopen */
 910 void *
 911 rcm_module_open(char *modname)
 912 {
 913         unsigned i;
 914         char *dir_name;
 915         void *dlhandle = NULL;
 916         char modpath[MAXPATHLEN];
 917 
 918 #ifdef DEBUG
 919         struct stat sbuf;
 920 #endif
 921 
 922         /*
 923          * dlopen the module
 924          */
 925         for (i = 0; (dir_name = rcm_module_dir(i)) != NULL; i++) {
 926                 if (snprintf(modpath, MAXPATHLEN, "%s%s", dir_name, modname)
 927                     >= MAXPATHLEN) {
 928                         dprintf((stderr, "invalid module %s skipped\n",
 929                             modname));
 930                         continue;
 931                 }
 932 
 933                 if ((dlhandle = dlopen(modpath, RTLD_LAZY)) != NULL) {
 934                         return (dlhandle);
 935                 }
 936 
 937                 dprintf((stderr, "failure (dlopen=%s)\n", dlerror()));
 938 #ifdef DEBUG
 939                 if (stat(modpath, &sbuf) == 0) {
 940                         (void) fprintf(stderr, "%s is not a valid module\n",
 941                             modpath);
 942                 }
 943 #endif
 944         }
 945 
 946         dprintf((stderr, "module %s not found\n", modname));
 947         return (NULL);
 948 }
 949 
 950 /* dlclose module */
 951 void
 952 rcm_module_close(void *dlhandle)
 953 {
 954         if (dlclose(dlhandle) == 0)
 955                 return;
 956 
 957         dprintf((stderr, "dlclose: %s\n", dlerror()));
 958 }
 959 
 960 
 961 /*
 962  * stub implementation of rcm_log_message allows dlopen of rcm modules
 963  * to proceed in absence of rcm_daemon.
 964  *
 965  * This definition is interposed by the definition in rcm_daemon because of the
 966  * default search order implemented by the linker and dlsym(). All RCM modules
 967  * will see the daemon version when loaded by the rcm_daemon.
 968  */
 969 /* ARGSUSED */
 970 void
 971 rcm_log_message(int level, char *message, ...)
 972 {
 973         dprintf((stderr, "rcm_log_message stub\n"));
 974 }
 975 
 976 /*
 977  * Helper functions
 978  */
 979 
 980 /*
 981  * Common routine for all rcm calls which require daemon processing
 982  */
 983 static int
 984 rcm_common(int cmd, rcm_handle_t *hd, char **rsrcnames, uint_t flag, void *arg,
 985     rcm_info_t **infop)
 986 {
 987         int i;
 988 
 989         if (hd == NULL) {
 990                 errno = EINVAL;
 991                 return (RCM_FAILURE);
 992         }
 993 
 994         if (getuid() != 0) {
 995                 errno = EPERM;
 996                 return (RCM_FAILURE);
 997         }
 998 
 999         if ((flag & (RCM_DR_OPERATION | RCM_MOD_INFO)) == 0) {
1000                 if ((rsrcnames == NULL) || (rsrcnames[0] == NULL)) {
1001                         errno = EINVAL;
1002                         return (RCM_FAILURE);
1003                 }
1004 
1005                 for (i = 0; rsrcnames[i] != NULL; i++) {
1006                         if (*rsrcnames[i] == '\0') {
1007                                 errno = EINVAL;
1008                                 return (RCM_FAILURE);
1009                         }
1010                 }
1011         }
1012 
1013         /*
1014          * Check if handle is allocated by rcm_daemon. If so, this call came
1015          * from an RCM module, so we make a direct call into rcm_daemon.
1016          */
1017         if (hd->lrcm_ops != NULL) {
1018                 return (rcm_direct_call(cmd, hd, rsrcnames, flag, arg, infop));
1019         }
1020 
1021         /*
1022          * When not called from a RCM module (i.e. no recursion), zero the
1023          * pointer just in case caller did not do so. For recursive calls,
1024          * we want to append rcm_info_t after infop; zero it may cause
1025          * memory leaks.
1026          */
1027         if (infop) {
1028                 *infop = NULL;
1029         }
1030 
1031         /*
1032          * Now call into the daemon.
1033          */
1034         return (rcm_daemon_call(cmd, hd, rsrcnames, flag, arg, infop));
1035 }
1036 
1037 /*
1038  * Caller is an RCM module, call directly into rcm_daemon.
1039  */
1040 static int
1041 rcm_direct_call(int cmd, rcm_handle_t *hd, char **rsrcnames, uint_t flag,
1042     void *arg, rcm_info_t **infop)
1043 {
1044         int error;
1045 
1046         librcm_ops_t *ops = (librcm_ops_t *)hd->lrcm_ops;
1047         switch (cmd) {
1048         case CMD_GETINFO:
1049                 error = ops->librcm_getinfo(rsrcnames, flag, hd->seq_num,
1050                     infop);
1051                 break;
1052 
1053         case CMD_OFFLINE:
1054                 error = ops->librcm_offline(rsrcnames, hd->pid, flag,
1055                     hd->seq_num, infop);
1056                 break;
1057 
1058         case CMD_ONLINE:
1059                 error = ops->librcm_online(rsrcnames, hd->pid, flag,
1060                     hd->seq_num, infop);
1061                 break;
1062 
1063         case CMD_REMOVE:
1064                 error = ops->librcm_remove(rsrcnames, hd->pid, flag,
1065                     hd->seq_num, infop);
1066                 break;
1067 
1068         case CMD_SUSPEND:
1069                 error = ops->librcm_suspend(rsrcnames, hd->pid, flag,
1070                     hd->seq_num, (timespec_t *)arg, infop);
1071                 break;
1072 
1073         case CMD_RESUME:
1074                 error = ops->librcm_resume(rsrcnames, hd->pid, flag,
1075                     hd->seq_num, infop);
1076                 break;
1077 
1078         case CMD_REGISTER:
1079                 error = ops->librcm_regis(hd->modname, rsrcnames[0], hd->pid,
1080                     flag, infop);
1081                 break;
1082 
1083         case CMD_UNREGISTER:
1084                 error = ops->librcm_unregis(hd->modname, rsrcnames[0], hd->pid,
1085                     flag);
1086                 break;
1087 
1088         case CMD_REQUEST_CHANGE:
1089                 error = ops->librcm_request_change(rsrcnames[0], hd->pid, flag,
1090                     hd->seq_num, (nvlist_t *)arg, infop);
1091                 break;
1092 
1093         case CMD_NOTIFY_CHANGE:
1094                 error = ops->librcm_notify_change(rsrcnames[0], hd->pid, flag,
1095                     hd->seq_num, (nvlist_t *)arg, infop);
1096                 break;
1097 
1098         case CMD_EVENT:
1099                 error = ops->librcm_notify_event(rsrcnames[0], hd->pid, flag,
1100                     hd->seq_num, (nvlist_t *)arg, infop);
1101                 break;
1102 
1103         case CMD_GETSTATE:
1104                 error = ops->librcm_getstate(rsrcnames[0], hd->pid, infop);
1105                 break;
1106 
1107         default:
1108                 dprintf((stderr, "invalid command: %d\n", cmd));
1109                 error = EFAULT;
1110         }
1111 
1112         if (error > 0) {
1113                 errno = error;
1114                 error = RCM_FAILURE;
1115         }
1116         return (error);
1117 }
1118 
1119 /*
1120  * Call into rcm_daemon door to process the request
1121  */
1122 static int
1123 rcm_daemon_call(int cmd, rcm_handle_t *hd, char **rsrcnames, uint_t flag,
1124     void *arg, rcm_info_t **infop)
1125 {
1126         int errno_found;
1127         int daemon_errno = 0;
1128         int error = RCM_SUCCESS;
1129         int delay = 300;
1130         int maxdelay = 10000;   /* 10 seconds */
1131         char *nvl_packed = NULL;
1132         size_t nvl_size = 0;
1133         nvlist_t *ret = NULL;
1134         nvpair_t *nvp;
1135         size_t rsize = 0;
1136         rcm_info_t *info = NULL;
1137 
1138         errno = 0;
1139 
1140         /*
1141          * Decide whether to start the daemon
1142          */
1143         switch (cmd) {
1144         case CMD_GETINFO:
1145         case CMD_OFFLINE:
1146         case CMD_ONLINE:
1147         case CMD_REMOVE:
1148         case CMD_SUSPEND:
1149         case CMD_RESUME:
1150         case CMD_REGISTER:
1151         case CMD_UNREGISTER:
1152         case CMD_EVENT:
1153         case CMD_REQUEST_CHANGE:
1154         case CMD_NOTIFY_CHANGE:
1155         case CMD_GETSTATE:
1156                 break;
1157 
1158         default:
1159                 errno = EFAULT;
1160                 return (RCM_FAILURE);
1161         }
1162 
1163         if (rcm_daemon_is_alive() != 1) {
1164                 dprintf((stderr, "failed to start rcm_daemon\n"));
1165                 errno = EFAULT;
1166                 return (RCM_FAILURE);
1167         }
1168 
1169         /*
1170          * Generate a packed nvlist for the request
1171          */
1172         if (rcm_generate_nvlist(cmd, hd, rsrcnames, flag, arg, &nvl_packed,
1173             &nvl_size) < 0) {
1174                 dprintf((stderr, "error in nvlist generation\n"));
1175                 errno = EFAULT;
1176                 return (RCM_FAILURE);
1177         }
1178 
1179         /*
1180          * Make the door call and get a return event. We go into a retry loop
1181          * when RCM_ET_EAGAIN is returned.
1182          */
1183 retry:
1184         if (get_event_service(RCM_SERVICE_DOOR, (void *)nvl_packed, nvl_size,
1185             (void **)&ret, &rsize) < 0) {
1186                 dprintf((stderr, "rcm_daemon call failed: %s\n",
1187                     strerror(errno)));
1188                 free(nvl_packed);
1189                 return (RCM_FAILURE);
1190         }
1191 
1192         assert(ret != NULL);
1193 
1194         /*
1195          * nvlist_lookup_* routines don't work because the returned nvlist
1196          * was nvlist_alloc'ed without the NV_UNIQUE_NAME flag.  Implement
1197          * a sequential search manually, which is fine since there is only
1198          * one RCM_RESULT value in the nvlist.
1199          */
1200         errno_found = 0;
1201         nvp = NULL;
1202         while (nvp = nvlist_next_nvpair(ret, nvp)) {
1203                 if (strcmp(nvpair_name(nvp), RCM_RESULT) == 0) {
1204                         if (errno = nvpair_value_int32(nvp, &daemon_errno)) {
1205                                 error = RCM_FAILURE;
1206                                 goto out;
1207                         }
1208                         errno_found++;
1209                         break;
1210                 }
1211         }
1212         if (errno_found == 0) {
1213                 errno = EFAULT;
1214                 error = RCM_FAILURE;
1215                 goto out;
1216         }
1217 
1218         if (daemon_errno == EAGAIN) {
1219                 /*
1220                  * Wait and retry
1221                  */
1222                 dprintf((stderr, "retry door_call\n"));
1223 
1224                 if (delay > maxdelay) {
1225                         errno = EAGAIN;
1226                         error = RCM_FAILURE;
1227                         goto out;
1228                 }
1229 
1230                 (void) poll(NULL, 0, delay);
1231                 delay *= 2;             /* exponential back off */
1232                 nvlist_free(ret);
1233                 goto retry;
1234         }
1235 
1236         /*
1237          * The door call succeeded. Now extract info from returned event.
1238          */
1239         if (extract_info(ret, &info) != 0) {
1240                 dprintf((stderr, "error in extracting event data\n"));
1241                 errno = EFAULT;
1242                 error = RCM_FAILURE;
1243                 goto out;
1244         }
1245 
1246         if (infop)
1247                 *infop = info;
1248         else
1249                 rcm_free_info(info);
1250 
1251         if (daemon_errno) {
1252                 if (daemon_errno > 0) {
1253                         errno = daemon_errno;
1254                         error = RCM_FAILURE;
1255                 } else {
1256                         error = daemon_errno;
1257                 }
1258         }
1259 
1260 out:
1261         if (nvl_packed)
1262                 free(nvl_packed);
1263         if (ret)
1264                 nvlist_free(ret);
1265         dprintf((stderr, "daemon call is done. error = %d, errno = %s\n", error,
1266             strerror(errno)));
1267         return (error);
1268 }
1269 
1270 /*
1271  * Extract registration info from event data.
1272  * Return 0 on success and -1 on failure.
1273  */
1274 static int
1275 extract_info(nvlist_t *nvl, rcm_info_t **infop)
1276 {
1277         rcm_info_t *info = NULL;
1278         rcm_info_t *prev = NULL;
1279         rcm_info_t *tmp = NULL;
1280         char *buf;
1281         uint_t buflen;
1282         nvpair_t *nvp = NULL;
1283 
1284         while (nvp = nvlist_next_nvpair(nvl, nvp)) {
1285 
1286                 buf = NULL;
1287                 buflen = 0;
1288 
1289                 if (strcmp(nvpair_name(nvp), RCM_RESULT_INFO) != 0)
1290                         continue;
1291 
1292                 if ((tmp = calloc(1, sizeof (*tmp))) == NULL) {
1293                         dprintf((stderr, "out of memory\n"));
1294                         goto fail;
1295                 }
1296 
1297                 if (errno = nvpair_value_byte_array(nvp, (uchar_t **)&buf,
1298                     &buflen)) {
1299                         free(tmp);
1300                         dprintf((stderr, "failed (nvpair_value=%s)\n",
1301                             strerror(errno)));
1302                         goto fail;
1303                 }
1304                 if (errno = nvlist_unpack(buf, buflen, &(tmp->info), 0)) {
1305                         free(tmp);
1306                         dprintf((stderr, "failed (nvlist_unpack=%s)\n",
1307                             strerror(errno)));
1308                         goto fail;
1309                 }
1310 
1311                 if (info == NULL) {
1312                         prev = info = tmp;
1313                 } else {
1314                         prev->next = tmp;
1315                         prev = tmp;
1316                 }
1317         }
1318 
1319         *infop = info;
1320         return (0);
1321 
1322 fail:
1323         rcm_free_info(info);
1324         *infop = NULL;
1325         return (-1);
1326 }
1327 
1328 /* Generate a packed nvlist for communicating with RCM daemon */
1329 static int
1330 rcm_generate_nvlist(int cmd, rcm_handle_t *hd, char **rsrcnames, uint_t flag,
1331     void *arg, char **nvl_packed, size_t *nvl_size)
1332 {
1333         int nrsrcnames;
1334         char *buf = NULL;
1335         size_t buflen = 0;
1336         nvlist_t *nvl = NULL;
1337 
1338         assert((nvl_packed != NULL) && (nvl_size != NULL));
1339 
1340         *nvl_size = 0;
1341         *nvl_packed = NULL;
1342 
1343         /* Allocate an empty nvlist */
1344         if ((errno = nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0)) > 0) {
1345                 dprintf((stderr, "failed (nvlist_alloc=%s).\n",
1346                     strerror(errno)));
1347                 return (-1);
1348         }
1349 
1350         /* Stuff in all the arguments for the daemon call */
1351         if (nvlist_add_int32(nvl, RCM_CMD, cmd) != 0) {
1352                 dprintf((stderr, "failed (nvlist_add(CMD)=%s).\n",
1353                     strerror(errno)));
1354                 goto fail;
1355         }
1356         if (rsrcnames) {
1357                 nrsrcnames = 0;
1358                 while (rsrcnames[nrsrcnames] != NULL)
1359                         nrsrcnames++;
1360                 if (nvlist_add_string_array(nvl, RCM_RSRCNAMES, rsrcnames,
1361                     nrsrcnames) != 0) {
1362                         dprintf((stderr, "failed (nvlist_add(RSRCNAMES)=%s).\n",
1363                             strerror(errno)));
1364                         goto fail;
1365                 }
1366         }
1367         if (hd->modname) {
1368                 if (nvlist_add_string(nvl, RCM_CLIENT_MODNAME, hd->modname)
1369                     != 0) {
1370                         dprintf((stderr,
1371                             "failed (nvlist_add(CLIENT_MODNAME)=%s).\n",
1372                             strerror(errno)));
1373                         goto fail;
1374                 }
1375         }
1376         if (hd->pid) {
1377                 if (nvlist_add_uint64(nvl, RCM_CLIENT_ID, hd->pid) != 0) {
1378                         dprintf((stderr, "failed (nvlist_add(CLIENT_ID)=%s).\n",
1379                             strerror(errno)));
1380                         goto fail;
1381                 }
1382         }
1383         if (flag) {
1384                 if (nvlist_add_uint32(nvl, RCM_REQUEST_FLAG, flag) != 0) {
1385                         dprintf((stderr,
1386                             "failed (nvlist_add(REQUEST_FLAG)=%s).\n",
1387                             strerror(errno)));
1388                         goto fail;
1389                 }
1390         }
1391         if (arg && cmd == CMD_SUSPEND) {
1392                 if (nvlist_add_byte_array(nvl, RCM_SUSPEND_INTERVAL,
1393                     (uchar_t *)arg, sizeof (timespec_t)) != 0) {
1394                         dprintf((stderr,
1395                             "failed (nvlist_add(SUSPEND_INTERVAL)=%s).\n",
1396                             strerror(errno)));
1397                         goto fail;
1398                 }
1399         }
1400         if (arg &&
1401             ((cmd == CMD_REQUEST_CHANGE) || (cmd == CMD_NOTIFY_CHANGE))) {
1402                 if (errno = nvlist_pack(arg, &buf, &buflen, NV_ENCODE_NATIVE,
1403                     0)) {
1404                         dprintf((stderr,
1405                             "failed (nvlist_pack(CHANGE_DATA)=%s).\n",
1406                             strerror(errno)));
1407                         goto fail;
1408                 }
1409                 if (nvlist_add_byte_array(nvl, RCM_CHANGE_DATA, (uchar_t *)buf,
1410                     buflen) != 0) {
1411                         dprintf((stderr,
1412                             "failed (nvlist_add(CHANGE_DATA)=%s).\n",
1413                             strerror(errno)));
1414                         goto fail;
1415                 }
1416         }
1417         if (arg && cmd == CMD_EVENT) {
1418                 if (errno = nvlist_pack(arg, &buf, &buflen, NV_ENCODE_NATIVE,
1419                     0)) {
1420                         dprintf((stderr,
1421                             "failed (nvlist_pack(CHANGE_DATA)=%s).\n",
1422                             strerror(errno)));
1423                         goto fail;
1424                 }
1425                 if (nvlist_add_byte_array(nvl, RCM_EVENT_DATA, (uchar_t *)buf,
1426                     buflen) != 0) {
1427                         dprintf((stderr,
1428                             "failed (nvlist_add(EVENT_DATA)=%s).\n",
1429                             strerror(errno)));
1430                         goto fail;
1431                 }
1432         }
1433 
1434         /* Pack the nvlist */
1435         if (errno = nvlist_pack(nvl, nvl_packed, nvl_size, NV_ENCODE_NATIVE,
1436             0)) {
1437                 dprintf((stderr, "failed (nvlist_pack=%s).\n",
1438                     strerror(errno)));
1439                 goto fail;
1440         }
1441 
1442         /* If an argument was packed intermediately, free the buffer */
1443         if (buf)
1444                 free(buf);
1445 
1446         /* Free the unpacked version of the nvlist and return the packed list */
1447         nvlist_free(nvl);
1448         return (0);
1449 
1450 fail:
1451         if (buf)
1452                 free(buf);
1453         if (nvl)
1454                 nvlist_free(nvl);
1455         if (*nvl_packed)
1456                 free(*nvl_packed);
1457         *nvl_packed = NULL;
1458         *nvl_size = 0;
1459         return (-1);
1460 }
1461 
1462 /* check if rcm_daemon is up and running */
1463 static int
1464 rcm_daemon_is_alive()
1465 {
1466         int lasttry;
1467         struct stat st;
1468         nvlist_t *nvl;
1469         char *buf = NULL;
1470         size_t buflen = 0;
1471         int delay = 300;
1472         const int maxdelay = 10000;     /* 10 sec */
1473 
1474         /* generate a packed nvlist for the door knocking */
1475         if (errno = nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0)) {
1476                 dprintf((stderr, "nvlist_alloc failed: %s\n", strerror(errno)));
1477                 return (0);
1478         }
1479         if (errno = nvlist_add_int32(nvl, RCM_CMD, CMD_KNOCK)) {
1480                 dprintf((stderr, "nvlist_add failed: %s\n", strerror(errno)));
1481                 nvlist_free(nvl);
1482                 return (0);
1483         }
1484         if (errno = nvlist_pack(nvl, &buf, &buflen, NV_ENCODE_NATIVE, 0)) {
1485                 dprintf((stderr, "nvlist_pack failed: %s\n", strerror(errno)));
1486                 nvlist_free(nvl);
1487                 return (0);
1488         }
1489         nvlist_free(nvl);
1490 
1491         /*
1492          * check the door and knock on it
1493          */
1494         if ((stat(RCM_SERVICE_DOOR, &st) == 0) &&
1495             (get_event_service(RCM_SERVICE_DOOR, (void *)buf, buflen, NULL,
1496             NULL) == 0)) {
1497                 free(buf);
1498                 return (1);     /* daemon is alive */
1499         }
1500 
1501         /*
1502          * Attempt to start the daemon.
1503          * If caller has SIGCHLD set to SIG_IGN or its SA_NOCLDWAIT
1504          * flag set, waitpid(2) (hence rcm_exec_cmd) will fail.
1505          * get_event_service will determine if the rcm_daemon started.
1506          */
1507         dprintf((stderr, "exec: %s\n", RCM_DAEMON_START));
1508         (void) rcm_exec_cmd(RCM_DAEMON_START);
1509 
1510         /*
1511          * Wait for daemon to respond, timeout at 10 sec
1512          */
1513         while (((lasttry = get_event_service(RCM_SERVICE_DOOR, (void *)buf,
1514             buflen, NULL, NULL)) != 0) &&
1515             ((errno == EBADF) || (errno == ESRCH))) {
1516                 if (delay > maxdelay) {
1517                         break;
1518                 }
1519                 (void) poll(NULL, 0, delay);
1520                 delay *= 2;
1521         }
1522 
1523         free(buf);
1524         if (lasttry == 0)
1525                 return (1);
1526         return (0);
1527 }
1528 
1529 /*
1530  * Check permission.
1531  *
1532  * The policy is root only for now. Need to relax this when interface level
1533  * is raised.
1534  */
1535 static int
1536 rcm_check_permission(void)
1537 {
1538         return (getuid() == 0);
1539 }
1540 
1541 /*
1542  * Project private function - for use by RCM MSTC tests
1543  *
1544  * Get the client name (rcm module name or script name) corresponding to
1545  * the given rcm handle.
1546  */
1547 const char *
1548 rcm_get_client_name(rcm_handle_t *hd)
1549 {
1550         return (hd->modname);
1551 }
--- EOF ---