usr/src/cmd/ldmad/mdesc_lib.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 2010 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  */
  26
  27 #include <strings.h>
  28 #include <stdio.h>
  29 #include <unistd.h>
  30 #include <stdlib.h>
  31 #include <strings.h>
  32 #include <note.h>
  33 #include <errno.h>
  34 #include <sys/mdesc.h>
  35 #include <sys/mdesc_impl.h>
  36 #include <sys/sysmacros.h>
  37 #include "mdesc_mutable.h"
  38
  39 static void md_free_prop(mmd_t *mdp, md_prop_t *propp);
  40 static void md_free_string(mmd_t *mdp, md_string_t *msp);
  41 static void md_free_data_block(mmd_t *mdp, md_data_block_t *mdbp);
  42
  43 static uint32_t
  44 md_byte_hash(uint8_t *bp, int len)
  45 {
  46         uint32_t hash = 0;
  47         int i;
  48
  49         for (i = 0; i < len; i++) {
  50                 /* 5 bit rotation */
  51                 hash = (hash >> 27) | (hash << 5) | bp[i];
  52         }
  53
  54         return (hash);
  55 }
  56
  57 static md_string_t *
  58 md_find_string(mmd_t *mdp, char *strp, uint32_t *hashp)
  59 {
  60         md_string_t *msp;
  61         uint32_t hash;
  62
  63         hash = md_byte_hash((uint8_t *)strp, strlen(strp));
  64
  65         if (hashp != NULL)
  66                 *hashp = hash;
  67
  68         CHAIN_ITER(mdp->string_list, msp) {
  69                 if (msp->hash == hash && strcmp(msp->strp, strp) == 0)
  70                         return (msp);
  71         }
  72
  73         return (NULL);
  74 }
  75
  76 static md_string_t *
  77 md_new_string(mmd_t *mdp, char *strp)
  78 {
  79         md_string_t *msp;
  80         uint32_t hash;
  81
  82         msp = md_find_string(mdp, strp, &hash);
  83         if (msp == NULL) {
  84                 msp = calloc(1, sizeof (md_string_t));
  85                 if (msp == NULL)
  86                         return (NULL);
  87                 msp->strp = strdup(strp);
  88                 if (msp->strp == NULL) {
  89                         free(msp);
  90                         return (NULL);
  91                 }
  92                 msp->size = strlen(strp) + 1;
  93                 msp->hash = hash;
  94                 msp->ref_cnt = 0;
  95                 msp->build_offset = MD_OFFSET_UNDEF;
  96                 CHAIN_ADD(mdp->string_list, msp);
  97         }
  98         msp->ref_cnt++;
  99
 100         return (msp);
 101 }
 102
 103 static md_data_block_t *
 104 md_find_data_block(mmd_t *mdp, uint8_t *datap, int len, uint32_t *hashp)
 105 {
 106         md_data_block_t *dbp;
 107         uint32_t hash;
 108
 109         hash = md_byte_hash(datap, len);
 110
 111         if (hashp != NULL)
 112                 *hashp = hash;
 113
 114         CHAIN_ITER(mdp->data_block_list, dbp) {
 115                 if (dbp->size == len &&
 116                     dbp->hash == hash && bcmp(dbp->datap, datap, len) == 0)
 117                         return (dbp);
 118         }
 119
 120         return (NULL);
 121 }
 122
 123 static md_data_block_t *
 124 md_new_data_block(mmd_t *mdp, uint8_t *bufp, int len)
 125 {
 126         md_data_block_t *dbp;
 127         uint32_t        hash;
 128
 129         dbp = md_find_data_block(mdp, bufp, len, &hash);
 130         if (dbp == NULL) {
 131                 dbp = calloc(1, sizeof (md_data_block_t));
 132                 if (dbp == NULL)
 133                         return (NULL);
 134                 dbp->datap = malloc(len);
 135                 if (dbp->datap == NULL) {
 136                         free(dbp);
 137                         return (NULL);
 138                 }
 139                 (void) memcpy(dbp->datap, bufp, len);
 140                 dbp->size = len;
 141                 dbp->hash = hash;
 142                 dbp->ref_cnt = 0;
 143                 dbp->build_offset = MD_OFFSET_UNDEF;
 144                 CHAIN_ADD(mdp->data_block_list, dbp);
 145         }
 146         dbp->ref_cnt++;
 147
 148         return (dbp);
 149 }
 150
 151 md_node_t *
 152 md_new_node(mmd_t *mdp, char *sp)
 153 {
 154         md_node_t *nodep;
 155
 156         nodep = calloc(1, sizeof (md_node_t));
 157         if (nodep == NULL)
 158                 return (NULL);
 159         nodep->typep = md_new_string(mdp, sp);
 160         if (nodep->typep == NULL) {
 161                 free(nodep);
 162                 return (NULL);
 163         }
 164         CHAIN_ADD(mdp->node_list, nodep);
 165
 166         return (nodep);
 167 }
 168
 169 static md_prop_t *
 170 md_new_property(mmd_t *mdp, md_node_t *nodep, uint8_t type, char *sp)
 171 {
 172         md_prop_t *propp;
 173
 174         propp = calloc(1, sizeof (md_prop_t));
 175         if (propp == NULL)
 176                 return (NULL);
 177         propp->type = type;
 178         propp->sp = md_new_string(mdp, sp);
 179         if (propp->sp == NULL) {
 180                 free(propp);
 181                 return (NULL);
 182         }
 183
 184         CHAIN_ADD(nodep->prop_list, propp);
 185
 186         return (propp);
 187 }
 188
 189 int
 190 md_add_value_property(mmd_t *mdp, md_node_t *nodep, char *sp, uint64_t value)
 191 {
 192         md_prop_t *propp;
 193
 194         propp = md_new_property(mdp, nodep, MDET_PROP_VAL, sp);
 195         if (propp == NULL)
 196                 return (ENOMEM);
 197         propp->d.value = value;
 198         return (0);
 199 }
 200
 201 int
 202 md_add_string_property(mmd_t *mdp, md_node_t *nodep, char *sp, char *bufp)
 203 {
 204         md_prop_t *propp;
 205         md_data_block_t *dbp;
 206
 207         dbp = md_new_data_block(mdp, (uint8_t *)bufp, strlen(bufp) + 1);
 208         if (dbp == NULL)
 209                 return (ENOMEM);
 210         propp = md_new_property(mdp, nodep, MDET_PROP_STR, sp);
 211         if (propp == NULL) {
 212                 md_free_data_block(mdp, dbp);
 213                 return (NULL);
 214         }
 215         propp->d.dbp = dbp;
 216         return (0);
 217 }
 218
 219 int
 220 md_add_data_property(mmd_t *mdp, md_node_t *nodep, char *sp, int len,
 221     uint8_t *bufp)
 222 {
 223         md_prop_t *propp;
 224         md_data_block_t *dbp;
 225
 226         dbp = md_new_data_block(mdp, bufp, len);
 227         if (dbp == NULL)
 228                 return (ENOMEM);
 229
 230         propp = md_new_property(mdp, nodep, MDET_PROP_DAT, sp);
 231         if (propp == NULL) {
 232                 md_free_data_block(mdp, dbp);
 233                 return (ENOMEM);
 234         }
 235         propp->d.dbp = dbp;
 236         return (0);
 237 }
 238
 239 static int
 240 md_add_arc_property(mmd_t *mdp, md_node_t *nodep, char *arcnamep,
 241     md_node_t *tgtnodep)
 242 {
 243         md_prop_t *propp;
 244
 245         propp = md_new_property(mdp, nodep, MDET_PROP_ARC, arcnamep);
 246         if (propp == NULL)
 247                 return (ENOMEM);
 248         propp->d.arc.is_ptr = B_TRUE;
 249         propp->d.arc.val.nodep = tgtnodep;
 250         return (0);
 251 }
 252
 253 md_node_t *
 254 md_link_new_node(mmd_t *mdp, char *nodenamep, md_node_t *parentnodep,
 255     char *linktonewp, char *linkbackp)
 256 {
 257         md_node_t *nodep;
 258
 259         nodep = md_new_node(mdp, nodenamep);
 260         if (nodep == NULL)
 261                 return (NULL);
 262
 263         ASSERT(linktonewp != NULL);
 264         ASSERT(parentnodep != NULL && !parentnodep->deleted);
 265
 266         if (md_add_arc_property(mdp, parentnodep, linktonewp, nodep) != 0) {
 267                 return (NULL);
 268         }
 269
 270         if (linkbackp != NULL) {
 271                 if (md_add_arc_property(mdp,
 272                     nodep, linkbackp, parentnodep) != 0) {
 273                         return (NULL);
 274                 }
 275         }
 276
 277         return (nodep);
 278 }
 279
 280 void
 281 md_destroy(mmd_t *mdp)
 282 {
 283         md_node_t *nodep;
 284
 285         for (nodep = CHAIN_START(mdp->node_list); nodep != NULL; ) {
 286                 md_node_t *tmp_nodep;
 287
 288                 tmp_nodep = nodep->nextp;
 289                 md_free_node(mdp, nodep);
 290
 291                 nodep = tmp_nodep;
 292         }
 293
 294         /* should have deleted all the string refs by here */
 295         ASSERT(CHAIN_LENGTH(mdp->string_list) == 0);
 296         free(mdp);
 297 }
 298
 299 void
 300 md_free_node(mmd_t *mdp, md_node_t *nodep)
 301 {
 302         md_prop_t *propp;
 303
 304         if (nodep->typep != NULL)
 305                 md_free_string(mdp, nodep->typep);
 306
 307         for (propp = CHAIN_START(nodep->prop_list); propp != NULL; ) {
 308                 md_prop_t *tmp_propp;
 309
 310                 tmp_propp = propp->nextp;
 311                 md_free_prop(mdp, propp);
 312
 313                 propp = tmp_propp;
 314         }
 315
 316         free(nodep);
 317 }
 318
 319 static void
 320 md_free_prop(mmd_t *mdp, md_prop_t *propp)
 321 {
 322         if (propp->sp != NULL)
 323                 md_free_string(mdp, propp->sp);
 324
 325         switch (propp->type) {
 326         case MDET_PROP_VAL:
 327                 break;
 328
 329         case MDET_PROP_ARC:
 330                 break;
 331
 332         case MDET_PROP_STR:
 333         case MDET_PROP_DAT:
 334                 md_free_data_block(mdp, propp->d.dbp);
 335                 break;
 336
 337         default:
 338                 ASSERT(B_FALSE);
 339         }
 340
 341         free(propp);
 342 }
 343
 344 static void
 345 md_free_string(mmd_t *mdp, md_string_t *msp)
 346 {
 347         ASSERT(msp->ref_cnt > 0);
 348
 349         msp->ref_cnt--;
 350
 351         if (msp->ref_cnt == 0) {
 352                 free(msp->strp);
 353                 mdp->string_list.startp = msp->nextp;
 354                 free(msp);
 355         }
 356 }
 357
 358 static void
 359 md_free_data_block(mmd_t *mdp, md_data_block_t *mdbp)
 360 {
 361         ASSERT(mdbp->ref_cnt > 0);
 362
 363         mdbp->ref_cnt--;
 364
 365         if (mdbp->ref_cnt == 0) {
 366                 free(mdbp->datap);
 367                 mdp->data_block_list.startp = mdbp->nextp;
 368                 free(mdbp);
 369         }
 370 }
 371
 372 mmd_t *
 373 md_new_md(void)
 374 {
 375         return ((mmd_t *)calloc(1, sizeof (mmd_t)));
 376 }
 377
 378 static void
 379 md_fix_name(md_element_t *mdep, md_prop_t *propp)
 380 {
 381         mdep->name_len = htomd8(propp->sp->size - 1);
 382         mdep->name_offset = htomd32(propp->sp->build_offset);
 383 }
 384
 385 void
 386 create_mde(md_element_t *mdep, int type, md_node_t *nodep, md_prop_t *propp)
 387 {
 388         (void) memset(mdep, 0, MD_ELEMENT_SIZE);
 389         mdep->tag = htomd8(type);
 390
 391         switch (type) {
 392         case MDET_NODE:
 393                 mdep->d.prop_idx = htomd32(nodep->next_index);
 394                 mdep->name_len = htomd8(nodep->typep->size - 1);
 395                 mdep->name_offset = htomd32(nodep->typep->build_offset);
 396                 break;
 397
 398         case MDET_PROP_ARC:
 399                 ASSERT(propp->d.arc.is_ptr);
 400                 mdep->d.prop_idx = htomd64(propp->d.arc.val.nodep->build_index);
 401                 md_fix_name(mdep, propp);
 402                 break;
 403
 404         case MDET_PROP_VAL:
 405                 mdep->d.prop_val = htomd64(propp->d.value);
 406                 md_fix_name(mdep, propp);
 407                 break;
 408
 409         case MDET_PROP_STR:
 410         case MDET_PROP_DAT:
 411                 mdep->d.prop_data.offset = htomd32(propp->d.dbp->build_offset);
 412                 mdep->d.prop_data.len = htomd32(propp->d.dbp->size);
 413                 md_fix_name(mdep, propp);
 414                 break;
 415
 416         case MDET_NULL:
 417         case MDET_NODE_END:
 418         case MDET_LIST_END:
 419                 break;
 420
 421         default:
 422                 ASSERT(B_FALSE);
 423         }
 424 }
 425
 426 int
 427 md_gen_bin(mmd_t *mdp, uint8_t **bufvalp)
 428 {
 429         uint32_t offset;
 430         md_node_t *nodep;
 431         md_data_block_t *mdbp;
 432         md_string_t *msp;
 433         md_header_t *mdhp;
 434         md_element_t *mdep;
 435         uint32_t strings_size;
 436         uint32_t data_block_size;
 437         int total_size;
 438         uint8_t *bufferp;
 439         uint8_t *string_bufferp;
 440         uint8_t *data_block_bufferp;
 441
 442         /*
 443          * Skip through strings to compute offsets.
 444          */
 445         offset = 0;
 446         for (msp = CHAIN_START(mdp->string_list); msp != NULL;
 447             msp = msp->nextp) {
 448                 msp->build_offset = offset;
 449                 offset += msp->size;
 450         }
 451         strings_size = P2ROUNDUP(offset, MD_ALIGNMENT_SIZE);
 452
 453         /*
 454          * Skip through data blocks to compute offsets.
 455          */
 456
 457         offset = 0;
 458         for (mdbp = CHAIN_START(mdp->data_block_list); mdbp != NULL;
 459             mdbp = mdbp->nextp) {
 460                 mdbp->build_offset = offset;
 461                 offset += mdbp->size;
 462                 offset = P2ROUNDUP(offset, MD_ALIGNMENT_SIZE);
 463         }
 464         data_block_size = P2ROUNDUP(offset, MD_ALIGNMENT_SIZE);
 465
 466         /*
 467          * Compute the MD elements required to build the element list.
 468          * For each node there is a node start and end, and one
 469          * element for each property.
 470          */
 471
 472         offset = 0;
 473         for (nodep = CHAIN_START(mdp->node_list); nodep != NULL;
 474             nodep = nodep->nextp) {
 475                 nodep->build_index = offset;
 476                 offset += 2 + CHAIN_LENGTH(nodep->prop_list);
 477                 nodep->next_index = offset;
 478         }
 479         offset += 1;    /* add the LIST_END element */
 480
 481         total_size = MD_HEADER_SIZE + offset * MD_ELEMENT_SIZE +
 482             strings_size + data_block_size;
 483
 484         /*
 485          * Allocate output buffer.
 486          */
 487
 488         bufferp = calloc(total_size, sizeof (uint8_t));
 489         if (bufferp == NULL)
 490                 return (0);
 491
 492         /* LINTED */
 493         mdhp = (md_header_t *)bufferp;
 494
 495         string_bufferp = bufferp + MD_HEADER_SIZE + offset * MD_ELEMENT_SIZE;
 496         data_block_bufferp = string_bufferp + strings_size;
 497
 498         mdhp->transport_version = htomd32(MD_TRANSPORT_VERSION);
 499         mdhp->node_blk_sz = htomd32(offset * MD_ELEMENT_SIZE);
 500         mdhp->name_blk_sz = htomd32(strings_size);
 501         mdhp->data_blk_sz = htomd32(data_block_size);
 502
 503         /*
 504          * Build the element list.
 505          * For each node there is a node start and end, and one
 506          * element for each property.
 507          */
 508
 509         offset = 0;
 510         /* LINTED */
 511         mdep = (md_element_t *)(bufferp + MD_HEADER_SIZE);
 512         for (nodep = CHAIN_START(mdp->node_list); nodep != NULL;
 513             nodep = nodep->nextp) {
 514                 md_prop_t *propp;
 515
 516                 create_mde(mdep, MDET_NODE, nodep, NULL);
 517                 mdep++;
 518
 519                 for (propp = CHAIN_START(nodep->prop_list); propp != NULL;
 520                     propp = propp->nextp) {
 521                         create_mde(mdep, propp->type, nodep, propp);
 522                         mdep++;
 523                 }
 524
 525                 create_mde(mdep, MDET_NODE_END, NULL, NULL);
 526                 mdep++;
 527         }
 528
 529         create_mde(mdep, MDET_LIST_END, NULL, NULL);
 530         mdep++;
 531
 532         /*
 533          * Quick sanity check.
 534          */
 535
 536         ASSERT(((uint8_t *)mdep) == ((uint8_t *)string_bufferp));
 537
 538         /*
 539          * Skip through strings and stash them..
 540          */
 541
 542         offset = 0;
 543         for (msp = CHAIN_START(mdp->string_list); msp != NULL;
 544             msp = msp->nextp) {
 545                 (void) memcpy(string_bufferp + msp->build_offset, msp->strp,
 546                     msp->size);
 547         }
 548
 549         /*
 550          * Skip through data blocks and stash them.
 551          */
 552
 553         offset = 0;
 554         for (mdbp = CHAIN_START(mdp->data_block_list); mdbp != NULL;
 555             mdbp = mdbp->nextp) {
 556                 (void) memcpy(data_block_bufferp + mdbp->build_offset,
 557                     mdbp->datap, mdbp->size);
 558         }
 559
 560         *bufvalp = bufferp;
 561         return (total_size);
 562 }