usr/src/lib/scsi/libses/common/ses_node.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 (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 /*
  23  * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
  24  */
  25
  26 #include <scsi/libses.h>
  27 #include "ses_impl.h"
  28
  29 #define NEXT_ED(eip)    \
  30         ((ses2_ed_impl_t *)((uint8_t *)(eip) +  \
  31             ((eip)->st_hdr.sehi_ed_len + sizeof (ses2_ed_hdr_impl_t))))
  32
  33 static ses_node_t *
  34 ses_find_enclosure(ses_snap_t *sp, uint64_t number)
  35 {
  36         ses_node_t *np;
  37
  38         for (np = sp->ss_root->sn_first_child; np != NULL;
  39             np = np->sn_next_sibling) {
  40                 ASSERT(np->sn_type == SES_NODE_ENCLOSURE);
  41                 if (np->sn_enc_num == number)
  42                         return ((ses_node_t *)np);
  43         }
  44
  45         return (NULL);
  46 }
  47
  48 /*
  49  * ses_snap_primary_enclosure() finds the primary enclosure for
  50  * the supplied ses_snap_t.
  51  */
  52 ses_node_t *
  53 ses_snap_primary_enclosure(ses_snap_t *sp)
  54 {
  55         return (ses_find_enclosure(sp, 0));
  56 }
  57
  58 void
  59 ses_node_teardown(ses_node_t *np)
  60 {
  61         ses_node_t *rp;
  62
  63         if (np == NULL)
  64                 return;
  65
  66         for (; np != NULL; np = rp) {
  67                 ses_node_teardown(np->sn_first_child);
  68                 rp = np->sn_next_sibling;
  69                 nvlist_free(np->sn_props);
  70                 ses_free(np);
  71         }
  72 }
  73
  74 static ses_node_t *
  75 ses_node_alloc(ses_snap_t *sp, ses_node_t *pnp)
  76 {
  77         ses_node_t *np;
  78
  79         np = ses_zalloc(sizeof (ses_node_t));
  80         if (np == NULL)
  81                 goto fail;
  82         if (nvlist_alloc(&np->sn_props, NV_UNIQUE_NAME, 0) != 0)
  83                 goto fail;
  84
  85         np->sn_snapshot = sp;
  86         np->sn_id = sp->ss_n_nodes++;
  87
  88         if (pnp == NULL) {
  89                 ASSERT(sp->ss_root == NULL);
  90                 sp->ss_root = np;
  91         } else {
  92                 np->sn_parent = pnp;
  93                 np->sn_prev_sibling = pnp->sn_last_child;
  94
  95                 if (pnp->sn_first_child == NULL)
  96                         pnp->sn_first_child = np;
  97                 else
  98                         pnp->sn_last_child->sn_next_sibling = np;
  99
 100                 pnp->sn_last_child = np;
 101         }
 102
 103         return (np);
 104
 105 fail:
 106         ses_free(np);
 107         ses_node_teardown(sp->ss_root);
 108         sp->ss_root = NULL;
 109         return (NULL);
 110 }
 111
 112 /*
 113  * Parse element type descriptor.
 114  */
 115 static int
 116 elem_parse_td(ses2_td_hdr_impl_t *tip, const char *tp, nvlist_t *nvl)
 117 {
 118         int nverr;
 119
 120         if (tp != NULL)
 121                 SES_NV_ADD(fixed_string, nverr, nvl, SES_PROP_CLASS_DESCRIPTION,
 122                     tp, tip->sthi_text_len);
 123
 124         return (0);
 125 }
 126
 127
 128 /*
 129  * Build a skeleton tree of nodes in the given snapshot.  This is the heart of
 130  * libses, and is responsible for parsing the config page into a tree and
 131  * populating nodes with data from the config page.
 132  */
 133 static int
 134 ses_build_snap_skel(ses_snap_t *sp)
 135 {
 136         ses2_ed_impl_t *eip;
 137         ses2_td_hdr_impl_t *tip, *ftip;
 138         ses_node_t *np, *pnp, *cnp, *root;
 139         ses_snap_page_t *pp;
 140         ses2_config_page_impl_t *pip;
 141         int i, j, n_etds = 0;
 142         off_t toff;
 143         char *tp, *text;
 144         int err;
 145         uint64_t idx, eidx;
 146
 147         pp = ses_snap_find_page(sp, SES2_DIAGPAGE_CONFIG, B_FALSE);
 148         if (pp == NULL)
 149                 return (ses_error(ESES_BAD_RESPONSE, "target does not support "
 150                     "configuration diagnostic page"));
 151         pip = (ses2_config_page_impl_t *)pp->ssp_page;
 152
 153         if (pp->ssp_len < offsetof(ses2_config_page_impl_t, scpi_data))
 154                 return (ses_error(ESES_BAD_RESPONSE, "no enclosure "
 155                     "descriptors found"));
 156
 157         /*
 158          * Start with the root of the tree, which is a target node, containing
 159          * just the SCSI inquiry properties.
 160          */
 161         if ((root = ses_node_alloc(sp, sp->ss_root)) == NULL)
 162                 return (-1);
 163
 164         root->sn_type = SES_NODE_TARGET;
 165         SES_NV_ADD(string, err, root->sn_props, SCSI_PROP_VENDOR,
 166             libscsi_vendor(sp->ss_target->st_target));
 167         SES_NV_ADD(string, err, root->sn_props, SCSI_PROP_PRODUCT,
 168             libscsi_product(sp->ss_target->st_target));
 169         SES_NV_ADD(string, err, root->sn_props, SCSI_PROP_REVISION,
 170             libscsi_revision(sp->ss_target->st_target));
 171
 172         for (eip = (ses2_ed_impl_t *)pip->scpi_data, i = 0;
 173             i < pip->scpi_n_subenclosures + 1;
 174             i++, eip = NEXT_ED(eip)) {
 175                 if (!SES_WITHIN_PAGE_STRUCT(eip, pp->ssp_page, pp->ssp_len))
 176                         break;
 177
 178                 n_etds += eip->st_hdr.sehi_n_etd_hdrs;
 179         }
 180         ftip = (ses2_td_hdr_impl_t *)eip;
 181
 182         /*
 183          * There should really be only one Enclosure element possible for a
 184          * give subenclosure ID.  The standard never comes out and says this,
 185          * but it does describe this element as "managing the enclosure itself"
 186          * which implies rather strongly that the subenclosure ID field is that
 187          * of, well, the enclosure itself.  Since an enclosure can't contain
 188          * itself, it follows logically that each subenclosure has at most one
 189          * Enclosure type descriptor elements matching its ID.  Of course, some
 190          * enclosure firmware is buggy, so this may not always work out; in
 191          * this case we just ignore all but the first Enclosure-type element
 192          * with our subenclosure ID.
 193          */
 194         for (eip = (ses2_ed_impl_t *)pip->scpi_data, i = 0;
 195             i < pip->scpi_n_subenclosures + 1;
 196             i++, eip = NEXT_ED(eip)) {
 197                 if (!SES_WITHIN_PAGE_STRUCT(eip, pp->ssp_page, pp->ssp_len))
 198                         break;
 199
 200                 if ((np = ses_node_alloc(sp, root)) == NULL)
 201                         return (-1);
 202
 203                 np->sn_type = SES_NODE_ENCLOSURE;
 204                 np->sn_enc_num = eip->st_hdr.sehi_subenclosure_id;
 205
 206                 if (!SES_WITHIN_PAGE(eip, eip->st_hdr.sehi_ed_len +
 207                     sizeof (ses2_ed_hdr_impl_t),
 208                     pp->ssp_page, pp->ssp_len))
 209                         break;
 210
 211                 if (enc_parse_ed(eip, np->sn_props) != 0)
 212                         return (-1);
 213         }
 214
 215         if (root->sn_first_child == NULL)
 216                 return (ses_error(ESES_BAD_RESPONSE, "no enclosure "
 217                     "descriptors found"));
 218
 219         tp = (char *)(ftip + n_etds);
 220
 221         for (i = 0, toff = 0, idx = eidx = 0; i < n_etds; i++) {
 222                 tip = ftip + i;
 223
 224                 if (!SES_WITHIN_PAGE_STRUCT(tip, pp->ssp_page, pp->ssp_len))
 225                         break;
 226
 227                 pnp = ses_find_enclosure(sp,
 228                     tip->sthi_subenclosure_id);
 229                 if (pnp == NULL) {
 230                         idx += tip->sthi_max_elements + 1;
 231                         eidx += tip->sthi_max_elements;
 232                         toff += tip->sthi_text_len;
 233                         continue;
 234                 }
 235
 236                 if (tip->sthi_element_type == SES_ET_ENCLOSURE) {
 237                         if (tip->sthi_max_elements == 0) {
 238                                 SES_NV_ADD(uint64, err, pnp->sn_props,
 239                                     SES_PROP_ELEMENT_INDEX, idx);
 240                                 pnp->sn_rootidx = idx;
 241                         } else {
 242                                 SES_NV_ADD(uint64, err, pnp->sn_props,
 243                                     SES_PROP_ELEMENT_INDEX, idx + 1);
 244                                 SES_NV_ADD(uint64, err, pnp->sn_props,
 245                                     SES_PROP_ELEMENT_ONLY_INDEX, eidx);
 246                                 pnp->sn_rootidx = idx + 1;
 247                         }
 248
 249                         if (tip->sthi_text_len > 0 &&
 250                             SES_WITHIN_PAGE(tp + toff, tip->sthi_text_len,
 251                             pp->ssp_page, pp->ssp_len)) {
 252                                 text = tp + toff;
 253                                 toff += tip->sthi_text_len;
 254                         } else {
 255                                 text = NULL;
 256                         }
 257
 258                         SES_NV_ADD(uint64, err, pnp->sn_props,
 259                             SES_PROP_ELEMENT_TYPE, SES_ET_ENCLOSURE);
 260                         if (enc_parse_td(tip, text, pnp->sn_props) != 0)
 261                                 return (-1);
 262
 263                         idx += tip->sthi_max_elements + 1;
 264                         eidx += tip->sthi_max_elements;
 265                         continue;
 266                 }
 267
 268                 if ((np = ses_node_alloc(sp, pnp)) == NULL)
 269                         return (-1);
 270
 271                 np->sn_type = SES_NODE_AGGREGATE;
 272                 np->sn_enc_num = tip->sthi_subenclosure_id;
 273                 np->sn_parent = pnp;
 274                 np->sn_rootidx = idx;
 275
 276                 SES_NV_ADD(uint64, err, np->sn_props,
 277                     SES_PROP_ELEMENT_INDEX, idx);
 278                 SES_NV_ADD(uint64, err, np->sn_props,
 279                     SES_PROP_ELEMENT_TYPE, tip->sthi_element_type);
 280
 281                 if (tip->sthi_text_len > 0 &&
 282                     SES_WITHIN_PAGE(tp + toff, tip->sthi_text_len,
 283                     pp->ssp_page, pp->ssp_len)) {
 284                         text = tp + toff;
 285                         toff += tip->sthi_text_len;
 286                 } else {
 287                         text = NULL;
 288                 }
 289
 290                 if (elem_parse_td(tip, text, np->sn_props) != 0)
 291                         return (-1);
 292
 293                 idx += tip->sthi_max_elements + 1;
 294
 295                 if (tip->sthi_max_elements == 0)
 296                         continue;
 297
 298                 for (j = 0; j < tip->sthi_max_elements; j++) {
 299                         cnp = ses_node_alloc(sp, np);
 300                         if (cnp == NULL)
 301                                 return (-1);
 302
 303                         cnp->sn_type = SES_NODE_ELEMENT;
 304                         SES_NV_ADD(uint64, err, cnp->sn_props,
 305                             SES_PROP_ELEMENT_INDEX, np->sn_rootidx + j + 1);
 306                         SES_NV_ADD(uint64, err, cnp->sn_props,
 307                             SES_PROP_ELEMENT_ONLY_INDEX, eidx + j);
 308                         SES_NV_ADD(uint64, err, cnp->sn_props,
 309                             SES_PROP_ELEMENT_CLASS_INDEX, j);
 310                         SES_NV_ADD(uint64, err, cnp->sn_props,
 311                             SES_PROP_ELEMENT_TYPE, tip->sthi_element_type);
 312                 }
 313
 314                 eidx += tip->sthi_max_elements;
 315         }
 316
 317         np->sn_snapshot->ss_n_elem = idx;
 318
 319         return (0);
 320 }
 321
 322 static int
 323 ses_fill_tree(ses_node_t *np)
 324 {
 325         if (np == NULL)
 326                 return (0);
 327
 328         for (; np != NULL; np = np->sn_next_sibling) {
 329                 if (ses_fill_node(np) != 0)
 330                         return (-1);
 331                 if (ses_fill_tree(np->sn_first_child) != 0)
 332                         return (-1);
 333         }
 334
 335         return (0);
 336 }
 337
 338 int
 339 ses_fill_snap(ses_snap_t *sp)
 340 {
 341         if (ses_build_snap_skel(sp) != 0)
 342                 return (-1);
 343
 344         if (ses_fill_tree(sp->ss_root) != 0)
 345                 return (-1);
 346
 347         return (0);
 348 }
 349
 350 ses_node_t *
 351 ses_root_node(ses_snap_t *sp)
 352 {
 353         return (sp->ss_root);
 354 }
 355
 356 ses_node_t *
 357 ses_node_sibling(ses_node_t *np)
 358 {
 359         return (np->sn_next_sibling);
 360 }
 361
 362 ses_node_t *
 363 ses_node_prev_sibling(ses_node_t *np)
 364 {
 365         return (np->sn_prev_sibling);
 366 }
 367
 368 ses_node_t *
 369 ses_node_parent(ses_node_t *np)
 370 {
 371         return (np->sn_parent);
 372 }
 373
 374 ses_node_t *
 375 ses_node_child(ses_node_t *np)
 376 {
 377         return (np->sn_first_child);
 378 }
 379
 380 ses_node_type_t
 381 ses_node_type(ses_node_t *np)
 382 {
 383         return (np->sn_type);
 384 }
 385
 386 ses_snap_t *
 387 ses_node_snapshot(ses_node_t *np)
 388 {
 389         return ((ses_snap_t *)np->sn_snapshot);
 390 }
 391
 392 ses_target_t *
 393 ses_node_target(ses_node_t *np)
 394 {
 395         return (np->sn_snapshot->ss_target);
 396 }
 397
 398 nvlist_t *
 399 ses_node_props(ses_node_t *np)
 400 {
 401         return (np->sn_props);
 402 }
 403
 404 /*
 405  * A node identifier is a (generation, index) tuple that can be used to lookup a
 406  * node within this target at a later point.  This will be valid across
 407  * snapshots, though it will return failure if the generation count has changed.
 408  */
 409 uint64_t
 410 ses_node_id(ses_node_t *np)
 411 {
 412         return (((uint64_t)np->sn_snapshot->ss_generation << 32) |
 413             np->sn_id);
 414 }