usr/src/cmd/picl/plugins/sun4u/chicago/envd/piclenvsetup.c

   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 2005 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 /*
  30  * This file contains code for setting up environmental related nodes
  31  * and properties in the PICL tree.
  32  *
  33  */
  34
  35 #include <stdio.h>
  36 #include <fcntl.h>
  37 #include <unistd.h>
  38 #include <syslog.h>
  39 #include <stdlib.h>
  40 #include <limits.h>
  41 #include <errno.h>
  42 #include <sys/open.h>
  43 #include <ctype.h>
  44 #include <string.h>
  45 #include <alloca.h>
  46 #include <libintl.h>
  47 #include <sys/systeminfo.h>
  48 #include <picl.h>
  49 #include <picltree.h>
  50 #include <picld_pluginutil.h>
  51 #include <pthread.h>
  52 #include <sys/utsname.h>
  53 #include <sys/systeminfo.h>
  54 #include "picldefs.h"
  55 #include "envd.h"
  56
  57 /*
  58  * Volatile property read/write function typedef
  59  */
  60 typedef int ptree_vol_rdfunc_t(ptree_rarg_t *parg, void *buf);
  61 typedef int ptree_vol_wrfunc_t(ptree_warg_t *parg, const void *buf);
  62
  63 extern int disk_temp_monitor;
  64 extern env_tuneable_t   tuneables[];
  65 extern  int errno;
  66 extern  int     ntuneables;
  67 #define PROP_FAN_SPEED_UNIT_VALUE       "rpm"
  68
  69 /*
  70  * Sensor node data structure
  71  */
  72 typedef struct {
  73         char            *parent_path;   /* parent path */
  74         char            *sensor_name;   /* sensor name */
  75         env_sensor_t    *sensorp;       /* sensor info */
  76         picl_nodehdl_t  nodeh;          /* sensor node handle */
  77         picl_prophdl_t  proph;          /* "Temperature" property handle */
  78         picl_prophdl_t  target_proph;   /* "TargetTemp" property handle */
  79 } sensor_node_t;
  80
  81 /*
  82  * Sensor nodes array
  83  */
  84 static sensor_node_t sensor_nodes[] = {
  85         {"/platform/ebus@1f,464000/env-monitor@3,0", SENSOR_CPU0,
  86         NULL, NULL, NULL, NULL},
  87         {"/platform/ebus@1f,464000/env-monitor@3,0", SENSOR_CPU1,
  88         NULL, NULL, NULL, NULL},
  89         {"/platform/ebus@1f,464000/env-monitor@3,0", SENSOR_MB,
  90         NULL, NULL, NULL, NULL},
  91         {"/platform/ebus@1f,464000/env-monitor@3,0", SENSOR_ADT7462,
  92         NULL, NULL, NULL, NULL},
  93         {"/platform/ebus@1f,464000/env-monitor@3,0", SENSOR_LM95221,
  94         NULL, NULL, NULL, NULL},
  95         {"/platform/ebus@1f,464000/env-monitor@3,0", SENSOR_FIRE,
  96         NULL, NULL, NULL, NULL},
  97         {"/platform/ebus@1f,464000/env-monitor@3,0", SENSOR_LSI1064,
  98         NULL, NULL, NULL, NULL},
  99         {"/platform/ebus@1f,464000/env-monitor@3,0", SENSOR_FRONT_PANEL,
 100         NULL, NULL, NULL, NULL},
 101         {"/platform/ebus@1f,464000/env-monitor@3,0", SENSOR_PSU,
 102         NULL, NULL, NULL, NULL}
 103 };
 104 #define N_SENSOR_NODES  (sizeof (sensor_nodes)/sizeof (sensor_nodes[0]))
 105
 106 /*
 107  * Fan node data structure
 108  */
 109 typedef struct {
 110         char            *parent_path;   /* parent node path */
 111         char            *fan_name;      /* fan name */
 112         env_fan_t       *fanp;          /* fan information */
 113         char            *speed_unit;    /* speed unit string */
 114         picl_nodehdl_t  nodeh;          /* "fan" node handle */
 115         picl_prophdl_t  proph;          /* "Speed" property handle */
 116 } fan_node_t;
 117
 118 /*
 119  * Fan node array
 120  */
 121 static fan_node_t fan_nodes[] =  {
 122         {"/platform/ebus@1f,464000/env-monitor@3,0", ENV_SYSTEM_FAN0,
 123         NULL, PROP_FAN_SPEED_UNIT_VALUE, NULL, NULL},
 124         {"/platform/ebus@1f,464000/env-monitor@3,0", ENV_SYSTEM_FAN1,
 125         NULL, PROP_FAN_SPEED_UNIT_VALUE, NULL, NULL},
 126         {"/platform/ebus@1f,464000/env-monitor@3,0", ENV_SYSTEM_FAN2,
 127         NULL, PROP_FAN_SPEED_UNIT_VALUE, NULL, NULL},
 128         {"/platform/ebus@1f,464000/env-monitor@3,0", ENV_SYSTEM_FAN3,
 129         NULL, PROP_FAN_SPEED_UNIT_VALUE, NULL, NULL},
 130         {"/platform/ebus@1f,464000/env-monitor@3,0", ENV_SYSTEM_FAN4,
 131         NULL, PROP_FAN_SPEED_UNIT_VALUE, NULL, NULL}
 132 };
 133 #define N_FAN_NODES     (sizeof (fan_nodes)/sizeof (fan_nodes[0]))
 134
 135 /*
 136  * Disk node data structure
 137  */
 138 typedef struct {
 139         char            *parent_path;   /* parent node path */
 140         char            *disk_name;     /* disk name */
 141         env_disk_t      *diskp;         /* disk information */
 142         picl_nodehdl_t  nodeh;          /* "disk" node handle */
 143         picl_prophdl_t  proph;          /* "Temperature" property handle */
 144 } disk_node_t;
 145
 146 /*
 147  * Disk node array
 148  */
 149 static disk_node_t disk_nodes[] =  {
 150         {DISK0_NODE_PATH, ENV_DISK0, NULL, NULL, NULL},
 151         {DISK1_NODE_PATH, ENV_DISK1, NULL, NULL, NULL},
 152         {DISK2_NODE_PATH, ENV_DISK2, NULL, NULL, NULL},
 153         {DISK3_NODE_PATH, ENV_DISK3, NULL, NULL, NULL}
 154 };
 155 #define N_DISK_NODES    (sizeof (disk_nodes)/sizeof (disk_nodes[0]))
 156
 157 /*
 158  * Miscellaneous declarations
 159  */
 160 static void delete_sensor_nodes_and_props(void);
 161 static void delete_disk_nodes_and_props(void);
 162 static void delete_fan_nodes_and_props(void);
 163
 164
 165 /*
 166  * Read function for volatile "Temperature" property
 167  */
 168 static int
 169 get_current_temp(ptree_rarg_t *parg, void *buf)
 170 {
 171         tempr_t         temp;
 172         picl_prophdl_t  proph;
 173         sensor_node_t   *snodep;
 174         int             i;
 175
 176         /*
 177          * Locate the sensor in our sensor_nodes table by matching the
 178          * property handle and get its temperature.
 179          */
 180         proph = parg->proph;
 181         for (i = 0; i < N_SENSOR_NODES; i++) {
 182                 snodep = &sensor_nodes[i];
 183                 if (snodep->proph != proph)
 184                         continue;
 185
 186                 if (get_temperature(snodep->sensorp, &temp) < 0)
 187                         break;
 188                 (void) memcpy(buf, (caddr_t)&temp, sizeof (tempr_t));
 189                 return (PICL_SUCCESS);
 190         }
 191         return (PICL_FAILURE);
 192 }
 193
 194 /*
 195  * Read function for volatile "Temperature" property
 196  */
 197 static int
 198 get_disk_temp(ptree_rarg_t *parg, void *buf)
 199 {
 200         tempr_t         temp;
 201         picl_prophdl_t  proph;
 202         disk_node_t     *dnodep;
 203         int             i;
 204
 205         /*
 206          * Locate the sensor in our sensor_nodes table by matching the
 207          * property handle and get its temperature.
 208          */
 209         proph = parg->proph;
 210         for (i = 0; i < N_DISK_NODES; i++) {
 211                 dnodep = &disk_nodes[i];
 212                 if (dnodep->proph != proph)
 213                         continue;
 214
 215                 if (disk_temperature(dnodep->diskp, &temp) < 0)
 216                         break;
 217                 (void) memcpy(buf, (caddr_t)&temp, sizeof (tempr_t));
 218                 return (PICL_SUCCESS);
 219         }
 220         return (PICL_FAILURE);
 221 }
 222
 223 /*
 224  * Read function for volatile "Speed" property on "fan" class node
 225  */
 226 static int
 227 set_current_speed(ptree_warg_t *parg, const void *buf)
 228 {
 229         fanspeed_t      speed;
 230         picl_prophdl_t  proph;
 231         fan_node_t      *fnodep;
 232         int             i, ret;
 233
 234         /*
 235          * Locate the fan in our fan_nodes table by matching the
 236          * property handle and get fan speed.
 237          */
 238         proph = parg->proph;
 239         for (i = 0; i < N_FAN_NODES; i++) {
 240                 fnodep = &fan_nodes[i];
 241                 if (fnodep->proph != proph)
 242                         continue;
 243                 if (fnodep->fanp->fd == -1)
 244                         continue;
 245
 246                 (void) memcpy((caddr_t)&speed, buf, sizeof (speed));
 247
 248                 ret = set_fan_speed(fnodep->fanp, speed);
 249
 250                 if (ret < 0) {
 251                         if (ret == -1 && errno == EBUSY)
 252                                 return (PICL_NOTWRITABLE);
 253                         if (ret == -2)
 254                                 return (PICL_INVALIDARG);
 255                         break;
 256                 }
 257
 258
 259                 return (PICL_SUCCESS);
 260         }
 261         return (PICL_FAILURE);
 262 }
 263
 264
 265 /*
 266  * Read function for volatile "Speed" property on "fan" class node
 267  */
 268 static int
 269 get_current_speed(ptree_rarg_t *parg, void *buf)
 270 {
 271         fanspeed_t      speed;
 272         picl_prophdl_t  proph;
 273         fan_node_t      *fnodep;
 274         int             i;
 275
 276         /*
 277          * Locate the fan in our fan_nodes table by matching the
 278          * property handle and get fan speed.
 279          */
 280         proph = parg->proph;
 281         for (i = 0; i < N_FAN_NODES; i++) {
 282                 fnodep = &fan_nodes[i];
 283                 if (fnodep->proph != proph)
 284                         continue;
 285                 if (fnodep->fanp->fd == -1)
 286                         continue;
 287                 if (get_fan_speed(fnodep->fanp, &speed) < 0)
 288                         break;
 289
 290                 (void) memcpy(buf, (caddr_t)&speed, sizeof (speed));
 291                 return (PICL_SUCCESS);
 292         }
 293         return (PICL_FAILURE);
 294 }
 295
 296 /*
 297  * Create and add the specified regular property
 298  */
 299
 300 static int
 301 add_regular_prop(picl_nodehdl_t nodeh, char *name, int type, int access,
 302     int size, void *valbuf, picl_prophdl_t *prophp)
 303 {
 304         int                     err;
 305         ptree_propinfo_t        propinfo;
 306         picl_prophdl_t          proph;
 307
 308         err = ptree_init_propinfo(&propinfo, PTREE_PROPINFO_VERSION,
 309             type, access, size, name, NULL, NULL);
 310         if (err != PICL_SUCCESS)
 311                 return (err);
 312
 313         err = ptree_create_and_add_prop(nodeh, &propinfo, valbuf, &proph);
 314         if (err == PICL_SUCCESS && prophp)
 315                 *prophp = proph;
 316         return (err);
 317 }
 318
 319
 320 /*
 321  * Create and add the specified volatile property
 322  */
 323 static int
 324 add_volatile_prop(picl_nodehdl_t nodeh, char *name, int type, int access,
 325     int size, ptree_vol_rdfunc_t *rdfunc, ptree_vol_wrfunc_t *wrfunc,
 326     picl_prophdl_t *prophp)
 327 {
 328         int                     err;
 329         ptree_propinfo_t        propinfo;
 330         picl_prophdl_t          proph;
 331
 332         err = ptree_init_propinfo(&propinfo, PTREE_PROPINFO_VERSION,
 333             type, (access|PICL_VOLATILE), size, name, rdfunc, wrfunc);
 334         if (err != PICL_SUCCESS)
 335                 return (err);
 336
 337         err = ptree_create_and_add_prop(nodeh, &propinfo, NULL, &proph);
 338         if (err == PICL_SUCCESS && prophp)
 339                 *prophp = proph;
 340         return (err);
 341 }
 342
 343 /*
 344  * Add temperature threshold properties
 345  */
 346 static void
 347 add_sensor_thresh_props(picl_nodehdl_t nodeh, es_sensor_blk_t *sensor_blkp)
 348 {
 349         picl_prophdl_t  proph;
 350
 351         (void) add_regular_prop(nodeh, PICL_PROP_LOW_POWER_OFF,
 352             PICL_PTYPE_INT, PICL_READ,
 353             sizeof (sensor_blkp->esb_low_power_off),
 354             &sensor_blkp->esb_low_power_off, &proph);
 355
 356         (void) add_regular_prop(nodeh, PICL_PROP_LOW_SHUTDOWN,
 357             PICL_PTYPE_INT, PICL_READ,
 358             sizeof (sensor_blkp->esb_low_shutdown),
 359             &sensor_blkp->esb_low_shutdown, &proph);
 360
 361         (void) add_regular_prop(nodeh, PICL_PROP_LOW_WARNING,
 362             PICL_PTYPE_INT, PICL_READ,
 363             sizeof (sensor_blkp->esb_low_warning),
 364             &sensor_blkp->esb_low_warning, &proph);
 365
 366         (void) add_regular_prop(nodeh, PICL_PROP_HIGH_WARNING,
 367             PICL_PTYPE_INT, PICL_READ,
 368             sizeof (sensor_blkp->esb_high_warning),
 369             &sensor_blkp->esb_high_warning, &proph);
 370
 371         (void) add_regular_prop(nodeh, PICL_PROP_HIGH_SHUTDOWN,
 372             PICL_PTYPE_INT, PICL_READ,
 373             sizeof (sensor_blkp->esb_high_shutdown),
 374             &sensor_blkp->esb_high_shutdown, &proph);
 375
 376         (void) add_regular_prop(nodeh, PICL_PROP_HIGH_POWER_OFF,
 377             PICL_PTYPE_INT, PICL_READ,
 378             sizeof (sensor_blkp->esb_high_power_off),
 379             &sensor_blkp->esb_high_power_off, &proph);
 380 }
 381
 382
 383 /*
 384  * Go through the sensor_nodes array and create those nodes
 385  * and the Temperature property to report the temperature.
 386  */
 387 static int
 388 add_sensor_nodes_and_props()
 389 {
 390         int             err;
 391         char            *pname, *nodename, *devfs_path;
 392         sensor_node_t   *snodep;
 393         picl_nodehdl_t  nodeh, cnodeh;
 394         picl_prophdl_t  proph;
 395         env_sensor_t    *sensorp;
 396         es_sensor_blk_t *sensor_blkp;
 397         int             i;
 398
 399         for (i = 0; i < N_SENSOR_NODES; i++) {
 400                 snodep = &sensor_nodes[i];
 401                 /*
 402                  * Get the parent nodeh
 403                  */
 404                 err = ptree_get_node_by_path(snodep->parent_path, &nodeh);
 405                 if (err != PICL_SUCCESS) {
 406                 if (env_debug)
 407                         envd_log(LOG_ERR, "failed to get_node_by_path %s\n",
 408                             snodep->parent_path);
 409                         continue;
 410                 }
 411                 sensorp = snodep->sensorp;
 412                 if (sensorp == NULL)
 413                         continue;
 414                 if (sensorp->present == B_FALSE)
 415                         continue;
 416                 /*
 417                  * Create temperature-sensor node
 418                  */
 419                 nodename = snodep->sensor_name;
 420                 err = ptree_create_and_add_node(nodeh, nodename,
 421                     PICL_CLASS_TEMPERATURE_SENSOR, &cnodeh);
 422                 if (env_debug)
 423                         envd_log(LOG_ERR,
 424                             "Creating PICL sensor node '%s' err:%d\n",
 425                             nodename, err);
 426                 if (err != PICL_SUCCESS)
 427                         break;
 428
 429                 /* save node handle */
 430                 snodep->nodeh = cnodeh;
 431
 432                 /*
 433                  * Add "devfs_path" property in child node
 434                  */
 435                 devfs_path = sensorp->devfs_path;
 436                 pname = PICL_PROP_DEVFS_PATH;
 437                 err = add_regular_prop(cnodeh, pname,
 438                     PICL_PTYPE_CHARSTRING, PICL_READ,
 439                     strlen(devfs_path)+1, (void *)devfs_path, &proph);
 440                 if (err != PICL_SUCCESS)
 441                         break;
 442
 443                 /*
 444                  * Now add volatile "temperature" volatile property
 445                  * in this "temperature-sensor" class node.
 446                  */
 447                 pname = PICL_PROP_TEMPERATURE;
 448                 err = add_volatile_prop(cnodeh, pname,
 449                     PICL_PTYPE_INT, PICL_READ, sizeof (tempr_t),
 450                     get_current_temp, NULL, &proph);
 451                 if (err != PICL_SUCCESS)
 452                         break;
 453
 454                 /* Save prop handle */
 455                 snodep->proph = proph;
 456
 457                 /*
 458                  * Add threshold related properties
 459                  */
 460                 sensor_blkp = sensorp->es;
 461                 if (sensor_blkp != NULL)
 462                         add_sensor_thresh_props(cnodeh, sensor_blkp);
 463         }
 464
 465         if (err != PICL_SUCCESS) {
 466                 delete_sensor_nodes_and_props();
 467                 if (env_debug)
 468                         envd_log(LOG_INFO,
 469                             "Can't create prop/node for sensor '%s'\n",
 470                             nodename);
 471                 return (err);
 472         }
 473         return (PICL_SUCCESS);
 474 }
 475
 476 /*
 477  * Delete all sensor nodes and related properties created by the
 478  * add_sensor_prop() for each sensor node in the PICL tree.
 479  */
 480 static void
 481 delete_sensor_nodes_and_props(void)
 482 {
 483         sensor_node_t   *snodep;
 484         int             i;
 485
 486         /*
 487          * Delete/destroy any property created in the sensed device
 488          * as well as the sensor node and all properties under it.
 489          * Note that deleiing/destroying a node deletes/destroys
 490          * all properties within that node.
 491          */
 492
 493         for (i = 0; i < N_SENSOR_NODES; i++) {
 494                 snodep = &sensor_nodes[i];
 495                 if (snodep->nodeh != NULL) {
 496                         /* delete node and all properties under it */
 497                         (void) ptree_delete_node(snodep->nodeh);
 498                         (void) ptree_destroy_node(snodep->nodeh);
 499                         snodep->nodeh = NULL;
 500                         snodep->proph = NULL;
 501                 }
 502         }
 503 }
 504
 505 /*
 506  * Go through the disk_nodes array and create those nodes
 507  * and the Temperature property to report the temperature.
 508  */
 509 static int
 510 add_disk_nodes_and_props()
 511 {
 512         int             err;
 513         char            *pname, *nodename, *devfs_path;
 514         disk_node_t     *dnodep;
 515         picl_nodehdl_t  nodeh, cnodeh;
 516         picl_prophdl_t  proph;
 517         env_disk_t      *diskp;
 518         int             i;
 519
 520         for (i = 0; i < N_DISK_NODES; i++) {
 521                 if (env_debug)
 522                         envd_log(LOG_ERR, "adding disk nodes...\n");
 523                 dnodep = &disk_nodes[i];
 524                 /*
 525                  * Get the parent nodeh
 526                  */
 527                 err = ptree_get_node_by_path(dnodep->parent_path, &nodeh);
 528                 if (err != PICL_SUCCESS) {
 529                         if (env_debug)
 530                                 envd_log(LOG_ERR,
 531                                     "failed to get node for path %s\n",
 532                                     dnodep->parent_path);
 533
 534                         err = PICL_SUCCESS;
 535                         continue;
 536                 }
 537                 diskp = dnodep->diskp;
 538                 if (diskp == NULL)
 539                         continue;
 540                 if (diskp->present == B_FALSE)
 541                         continue;
 542                 /*
 543                  * Create temperature-sensor node
 544                  */
 545                 nodename = dnodep->disk_name;
 546                 err = ptree_create_and_add_node(nodeh, nodename,
 547                     PICL_CLASS_TEMPERATURE_SENSOR, &cnodeh);
 548                 if (env_debug)
 549                         envd_log(LOG_ERR,
 550                             "Creating PICL disk node '%s' err:%d\n",
 551                             nodename, err);
 552                 if (err != PICL_SUCCESS)
 553                         break;
 554
 555                 /* save node handle */
 556                 dnodep->nodeh = cnodeh;
 557
 558                 /*
 559                  * Add "devfs_path" property in child node
 560                  */
 561                 devfs_path = diskp->devfs_path;
 562                 pname = PICL_PROP_DEVFS_PATH;
 563                 err = add_regular_prop(cnodeh, pname,
 564                     PICL_PTYPE_CHARSTRING, PICL_READ,
 565                     strlen(devfs_path)+1, (void *)devfs_path, &proph);
 566                 if (err != PICL_SUCCESS)
 567                         break;
 568
 569                 /*
 570                  * Now add volatile "temperature" volatile property
 571                  * in this "temperature-sensor" class node.
 572                  */
 573                 pname = PICL_PROP_TEMPERATURE;
 574                 err = add_volatile_prop(cnodeh, pname,
 575                     PICL_PTYPE_INT, PICL_READ, sizeof (tempr_t),
 576                     get_disk_temp, NULL, &proph);
 577                 if (err != PICL_SUCCESS)
 578                         break;
 579
 580                 /* Save prop handle */
 581                 dnodep->proph = proph;
 582
 583                 /*
 584                  * Add threshold related properties
 585                  */
 586
 587                 (void) add_regular_prop(cnodeh, PICL_PROP_LOW_SHUTDOWN,
 588                     PICL_PTYPE_INT, PICL_READ,
 589                     sizeof (diskp->low_shutdown),
 590                     (void *)&(diskp->low_shutdown), &proph);
 591
 592                 (void) add_regular_prop(cnodeh, PICL_PROP_LOW_WARNING,
 593                     PICL_PTYPE_INT, PICL_READ,
 594                     sizeof (diskp->low_warning),
 595                     (void *)&(diskp->low_warning), &proph);
 596
 597                 (void) add_regular_prop(cnodeh, PICL_PROP_HIGH_WARNING,
 598                     PICL_PTYPE_INT, PICL_READ,
 599                     sizeof (diskp->high_warning),
 600                     (void *)&(diskp->high_warning), &proph);
 601
 602                 (void) add_regular_prop(cnodeh, PICL_PROP_HIGH_SHUTDOWN,
 603                     PICL_PTYPE_INT, PICL_READ,
 604                     sizeof (diskp->high_shutdown),
 605                     (void *)&(diskp->high_shutdown), &proph);
 606
 607         }
 608         if (err != PICL_SUCCESS) {
 609                 delete_disk_nodes_and_props();
 610                 if (env_debug)
 611                         envd_log(LOG_INFO,
 612                             "Can't create prop/node for disk '%s'\n",
 613                             nodename);
 614                 return (err);
 615         }
 616         return (PICL_SUCCESS);
 617 }
 618
 619 /*
 620  * Delete all disk nodes and related properties created by the
 621  * add_disk_props() for each disk node in the PICL tree.
 622  */
 623 static void
 624 delete_disk_nodes_and_props(void)
 625 {
 626         disk_node_t     *dnodep;
 627         int             i;
 628
 629         /*
 630          * Delete/destroy disk node and all properties under it.
 631          * Note that deleting/destroying a node deletes/destroys
 632          * all properties within that node.
 633          */
 634
 635         for (i = 0; i < N_DISK_NODES; i++) {
 636                 dnodep = &disk_nodes[i];
 637                 if (dnodep->nodeh != NULL) {
 638                         (void) ptree_delete_node(dnodep->nodeh);
 639                         (void) ptree_destroy_node(dnodep->nodeh);
 640                         dnodep->nodeh = NULL;
 641                         dnodep->proph = NULL;
 642                 }
 643         }
 644 }
 645
 646 /*
 647  * For each entry in fan_nodes[] array, do the following:
 648  *      - Create specified "fan" class node.
 649  *      - Create "Speed" volatile propery under "fan" class node.
 650  *      - Create "SpeedUnit" property under "fan" class node.
 651  */
 652 static int
 653 add_fan_nodes_and_props()
 654 {
 655         int             err = PICL_FAILURE;
 656         char            *pname, *nodename, *devfs_path;
 657         env_fan_t       *fanp;
 658         fan_node_t      *fnodep;
 659         picl_nodehdl_t  nodeh, cnodeh;
 660         picl_prophdl_t  proph;
 661         int             i;
 662
 663         for (i = 0; i < N_FAN_NODES; i++) {
 664                 /*
 665                  * Add various fan nodes and properties
 666                  */
 667                 fnodep = &fan_nodes[i];
 668                 if (fnodep == NULL)
 669                         continue;
 670                 if (fnodep->fanp == NULL)
 671                         continue;
 672                 if (fnodep->fanp->present == B_FALSE)
 673                         continue;
 674                 /*
 675                  * get parent nodeh
 676                  */
 677                 err = ptree_get_node_by_path(fnodep->parent_path, &nodeh);
 678                 if (err != PICL_SUCCESS) {
 679                         if (env_debug)
 680                                 envd_log(LOG_ERR,
 681                 "node for %s NOT FOUND.\n", fnodep->parent_path);
 682                         err = PICL_SUCCESS;
 683                         continue;
 684                 }
 685                 /*
 686                  * Create "fan" class node and save node handle
 687                  */
 688                 nodename = fnodep->fan_name;
 689                 err = ptree_create_and_add_node(nodeh, nodename,
 690                     PICL_CLASS_FAN, &cnodeh);
 691                 if (env_debug)
 692                         envd_log(LOG_ERR,
 693                             "Creating PICL fan node '%s' err:%d\n",
 694                             nodename, err);
 695
 696                 if (err != PICL_SUCCESS)
 697                         break;
 698                 fnodep->nodeh = cnodeh;
 699
 700                 /*
 701                  * Add "devfs_path" property in child node
 702                  */
 703                 fanp = fnodep->fanp;
 704                 devfs_path  = fanp->devfs_path;
 705                 pname = PICL_PROP_DEVFS_PATH;
 706                 err = add_regular_prop(cnodeh, pname,
 707                     PICL_PTYPE_CHARSTRING, PICL_READ,
 708                     strlen(devfs_path)+1, (void *)devfs_path, &proph);
 709
 710                 if (err != PICL_SUCCESS)
 711
 712                         break;
 713
 714                 /*
 715                  * Add "Speed" volatile property in this "fan"
 716                  * class node and save prop handle.
 717                  */
 718                 pname = PICL_PROP_FAN_SPEED;
 719
 720                 err = add_volatile_prop(cnodeh, pname, PICL_PTYPE_INT,
 721                     PICL_READ|PICL_WRITE, sizeof (fanspeed_t),
 722                     get_current_speed, set_current_speed, &proph);
 723
 724                 if (err != PICL_SUCCESS)
 725                         break;
 726                 fnodep->proph = proph;
 727
 728                 /*
 729                  * Add other "fan" class properties
 730                  */
 731                 pname = PICL_PROP_FAN_SPEED_UNIT;
 732                 err = add_regular_prop(cnodeh, pname,
 733                     PICL_PTYPE_CHARSTRING, PICL_READ,
 734                     strlen(fnodep->speed_unit)+1,
 735                     (void *)fnodep->speed_unit, &proph);
 736
 737                 if (err != PICL_SUCCESS)
 738                         break;
 739
 740                 pname = PICL_PROP_LOW_WARNING;
 741                 err = add_regular_prop(cnodeh, pname,
 742                     PICL_PTYPE_INT, PICL_READ,
 743                     sizeof (fanspeed_t),
 744                     &(fnodep->fanp->speed_min), &proph);
 745
 746                 if (err != PICL_SUCCESS)
 747                         break;
 748         }
 749         if (err != PICL_SUCCESS) {
 750                 delete_fan_nodes_and_props();
 751                 return (err);
 752         }
 753         return (PICL_SUCCESS);
 754 }
 755
 756
 757 /*
 758  * Delete all fan nodes and related properties created by the
 759  * add_fan_props() for each fan node in the PICL tree.
 760  */
 761 static void
 762 delete_fan_nodes_and_props(void)
 763 {
 764         fan_node_t      *fnodep;
 765         int             i;
 766
 767         /*
 768          * Delete/destroy fan node and all properties under it.
 769          * Note that deleting/destroying a node deletes/destroys
 770          * all properties within that node.
 771          */
 772
 773         for (i = 0; i < N_FAN_NODES; i++) {
 774                 fnodep = &fan_nodes[i];
 775                 if (fnodep->nodeh != NULL) {
 776                         (void) ptree_delete_node(fnodep->nodeh);
 777                         (void) ptree_destroy_node(fnodep->nodeh);
 778                         fnodep->nodeh = NULL;
 779                 }
 780         }
 781 }
 782 /*
 783  * Tuneables publishing functions
 784  */
 785 static int
 786 copy_persistent_tuneable(env_tuneable_t *tune, char *buf)
 787 {
 788
 789         switch (tune->type) {
 790         case PICL_PTYPE_INT : {
 791                 (void) memcpy((int *)tune->value,
 792                     buf, tune->nbytes);
 793                 break;
 794         }
 795         case PICL_PTYPE_CHARSTRING : {
 796                 (void) memcpy((caddr_t)tune->value,
 797                     buf, tune->nbytes);
 798                 break;
 799         }
 800         default : {
 801                 return (PICL_FAILURE);
 802         }
 803         }
 804         return (PICL_SUCCESS);
 805 }
 806
 807 static void
 808 env_parse_tunables(picl_nodehdl_t rooth)
 809 {
 810         char    nmbuf[SYS_NMLN];
 811         char    pname[PATH_MAX];
 812
 813         if (sysinfo(SI_PLATFORM, nmbuf, sizeof (nmbuf)) != -1) {
 814                 (void) snprintf(pname, PATH_MAX, PICLD_PLAT_PLUGIN_DIRF, nmbuf);
 815                 (void) strlcat(pname, TUNABLE_CONF_FILE, PATH_MAX);
 816                 if (access(pname, R_OK) == 0) {
 817                         (void) picld_pluginutil_parse_config_file(rooth, pname);
 818                         return;
 819                 }
 820         }
 821 }
 822
 823 int
 824 env_picl_setup_tuneables(void)
 825 {
 826         int             err;
 827         int             i;
 828         picl_nodehdl_t  nodeh;
 829         picl_nodehdl_t  rooth;
 830         picl_prophdl_t  proph;
 831         env_tuneable_t  *tuneablep;
 832         char            read_buf[BUFSIZ];
 833
 834         if (ptree_get_root(&rooth) != PICL_SUCCESS) {
 835                 return (PICL_FAILURE);
 836         }
 837         err = ptree_create_and_add_node(rooth, PICL_PLUGINS_NODE,
 838             PICL_CLASS_PICL, &nodeh);
 839         if (err != PICL_SUCCESS)
 840                 return (PICL_FAILURE);
 841         err = ptree_create_and_add_node(nodeh, PICL_ENVIRONMENTAL_NODE,
 842             PICL_CLASS_PICL, &nodeh);
 843         if (err != PICL_SUCCESS) {
 844                 return (PICL_FAILURE);
 845         }
 846
 847         /*
 848          * Parse the conf file
 849          */
 850         if (env_debug)
 851                 envd_log(LOG_ERR, "parsing tuneables...\n");
 852         env_parse_tunables(rooth);
 853         for (i = 0; i < ntuneables; i++) {
 854                 if (env_debug)
 855                         envd_log(LOG_ERR, "tuneable %d being added\n", i);
 856                 tuneablep = &tuneables[i];
 857                 err = ptree_get_propval_by_name(nodeh, tuneablep->name,
 858                     read_buf, tuneablep->nbytes);
 859
 860                 if (err != PICL_SUCCESS) {
 861                         /*
 862                          * Add volitle functions to environmental node
 863                          */
 864                         err = add_volatile_prop(nodeh, tuneablep->name,
 865                             tuneablep->type,
 866                             PICL_READ|PICL_WRITE, tuneablep->nbytes,
 867                             tuneablep->rfunc,
 868                             tuneablep->wfunc, &proph);
 869
 870                         tuneablep->proph = proph;
 871                 } else {
 872                         /*
 873                          * property is persistent
 874                          */
 875                         (void) copy_persistent_tuneable(tuneablep,
 876                             read_buf);
 877                 }
 878         }
 879
 880         return  (PICL_SUCCESS);
 881 }
 882
 883 /*
 884  * Find the ENVMODEL_CONF_FILE file.
 885  */
 886 static int
 887 get_envmodel_conf_file(char *outfilename)
 888 {
 889         char    nmbuf[SYS_NMLN];
 890         char    pname[PATH_MAX];
 891
 892         if (sysinfo(SI_PLATFORM, nmbuf, sizeof (nmbuf)) != -1) {
 893                 (void) snprintf(pname, PATH_MAX, PICLD_PLAT_PLUGIN_DIRF, nmbuf);
 894                 (void) strlcat(pname, ENV_CONF_FILE, PATH_MAX);
 895                 if (access(pname, R_OK) == 0) {
 896                         (void) strlcpy(outfilename, pname, PATH_MAX);
 897                         return (0);
 898                 }
 899         }
 900
 901         if (sysinfo(SI_MACHINE, nmbuf, sizeof (nmbuf)) != -1) {
 902                 (void) snprintf(pname, PATH_MAX, PICLD_PLAT_PLUGIN_DIRF, nmbuf);
 903                 (void) strlcat(pname, ENV_CONF_FILE, PATH_MAX);
 904                 if (access(pname, R_OK) == 0) {
 905                         (void) strlcpy(outfilename, pname, PATH_MAX);
 906                         return (0);
 907                 }
 908         }
 909
 910         (void) snprintf(pname, PATH_MAX, "%s/%s", PICLD_COMMON_PLUGIN_DIR,
 911             ENV_CONF_FILE);
 912
 913         if (access(pname, R_OK) == 0) {
 914                 (void) strlcpy(outfilename, pname, PATH_MAX);
 915                 return (0);
 916         }
 917
 918         return (-1);
 919 }
 920
 921 /* Delete all sensor/fan nodes and any properties created by this plugin */
 922 void
 923 env_picl_destroy(void)
 924 {
 925         delete_fan_nodes_and_props();
 926         delete_sensor_nodes_and_props();
 927         delete_disk_nodes_and_props();
 928 }
 929
 930 void
 931 env_picl_setup(void)
 932 {
 933         int             err, sensor_err, fan_err, disk_err;
 934         sensor_node_t   *snodep;
 935         fan_node_t      *fnodep;
 936         disk_node_t     *dnodep;
 937         picl_nodehdl_t  plath;
 938         char            fullfilename[PATH_MAX];
 939         picl_nodehdl_t  rooth;
 940         int             i;
 941
 942
 943         /*
 944          * Initialize sensorp and other fields in the sensor_nodes[] array
 945          */
 946
 947         for (i = 0; i < N_SENSOR_NODES; i++) {
 948                 snodep = &sensor_nodes[i];
 949                 snodep->sensorp = sensor_lookup(snodep->sensor_name);
 950                 snodep->nodeh = NULL;
 951                 snodep->proph = NULL;
 952                 snodep->target_proph = NULL;
 953         }
 954
 955         /*
 956          * Initialize fanp and other fields in the fan_nodes[] array
 957          */
 958         for (i = 0; i < N_FAN_NODES; i++) {
 959                 fnodep = &fan_nodes[i];
 960                 fnodep->fanp = fan_lookup(fnodep->fan_name);
 961                 fnodep->nodeh = NULL;
 962                 fnodep->proph = NULL;
 963         }
 964
 965         /*
 966          * Initialize diskp and other fields in the disk_nodes[] array
 967          */
 968         for (i = 0; i < N_DISK_NODES; i++) {
 969                 dnodep = &disk_nodes[i];
 970                 dnodep->diskp = disk_lookup(dnodep->disk_name);
 971                 dnodep->nodeh = NULL;
 972                 dnodep->proph = NULL;
 973         }
 974
 975         /*
 976          * Get platform handle and populate PICL tree with environmental
 977          * nodes and properties
 978          */
 979         err = ptree_get_node_by_path("/platform", &plath);
 980
 981         if (err == PICL_SUCCESS) {
 982                 sensor_err = add_sensor_nodes_and_props();
 983                 fan_err = add_fan_nodes_and_props();
 984                 if (disk_temp_monitor)
 985                         disk_err = add_disk_nodes_and_props();
 986         }
 987
 988         /*
 989          * We can safely call delete_xxx_nodes_and_props even
 990          * if nodes were not added.
 991          */
 992
 993         if (err != PICL_SUCCESS) {
 994                 if (fan_err != PICL_SUCCESS)
 995                         delete_fan_nodes_and_props();
 996                 if (disk_err != PICL_SUCCESS)
 997                         delete_disk_nodes_and_props();
 998                 if (sensor_err != PICL_SUCCESS)
 999                         delete_sensor_nodes_and_props();
1000
1001         envd_log(LOG_CRIT, ENVD_PICL_SETUP_FAILED);
1002                 return;
1003         }
1004         if (env_debug)
1005                 envd_log(LOG_ERR, "parsing the envmodel.conf file...\n");
1006
1007         /*
1008          * Parse the envmodel.conf file and populate the PICL tree
1009          */
1010         if (get_envmodel_conf_file(fullfilename) < 0)
1011                 envd_log(LOG_CRIT, ENVD_PICL_SETUP_FAILED);
1012         if (ptree_get_root(&rooth) != PICL_SUCCESS)
1013                 envd_log(LOG_CRIT, ENVD_PICL_SETUP_FAILED);
1014         err = picld_pluginutil_parse_config_file(rooth, fullfilename);
1015
1016         if (err != PICL_SUCCESS)
1017                 envd_log(LOG_CRIT, ENVD_PICL_SETUP_FAILED);
1018 }