Print this page
patch tsoome-feedback

Split Close
Expand all
Collapse all
          --- old/usr/src/cmd/dcs/sparc/sun4u/rsrc_info.c
          +++ new/usr/src/cmd/dcs/sparc/sun4u/rsrc_info.c
↓ open down ↓ 15 lines elided ↑ open up ↑
  16   16   * fields enclosed by brackets "[]" replaced with your own identifying
  17   17   * information: Portions Copyright [yyyy] [name of copyright owner]
  18   18   *
  19   19   * CDDL HEADER END
  20   20   */
  21   21  /*
  22   22   * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
  23   23   * Use is subject to license terms.
  24   24   */
  25   25  
  26      -#pragma ident   "%Z%%M% %I%     %E% SMI"
  27      -
  28   26  /*
  29   27   * Routines for traversing and packing/unpacking the handle
  30   28   * returned from ri_init.
  31   29   */
  32   30  
  33   31  #include <stdlib.h>
  34   32  #include <strings.h>
  35   33  #include "rsrc_info.h"
  36   34  #include "rsrc_info_impl.h"
  37   35  
↓ open down ↓ 37 lines elided ↑ open up ↑
  75   73          free(hdl);
  76   74  }
  77   75  
  78   76  static void
  79   77  ri_ap_free(ri_ap_t *ap)
  80   78  {
  81   79          ri_dev_t        *dev;
  82   80  
  83   81          assert(ap != NULL);
  84   82  
  85      -        if (ap->conf_props != NULL)
  86      -                nvlist_free(ap->conf_props);
       83 +        nvlist_free(ap->conf_props);
  87   84  
  88   85          while ((dev = ap->cpus) != NULL) {
  89   86                  ap->cpus = dev->next;
  90   87                  ri_dev_free(dev);
  91   88          }
  92   89          while ((dev = ap->mems) != NULL) {
  93   90                  ap->mems = dev->next;
  94   91                  ri_dev_free(dev);
  95   92          }
  96   93          while ((dev = ap->ios) != NULL) {
↓ open down ↓ 16 lines elided ↑ open up ↑
 113  110                  ri_client_free(client);
 114  111          }
 115  112          free(dev);
 116  113  }
 117  114  
 118  115  void
 119  116  ri_client_free(ri_client_t *client)
 120  117  {
 121  118          assert(client != NULL);
 122  119  
 123      -        if (client->usg_props != NULL)
 124      -                nvlist_free(client->usg_props);
 125      -        if (client->v_props != NULL)
 126      -                nvlist_free(client->v_props);
      120 +        nvlist_free(client->usg_props);
      121 +        nvlist_free(client->v_props);
 127  122          free(client);
 128  123  }
 129  124  
 130  125  /*
 131  126   * Pack everything contained in the handle up inside out.
 132  127   */
 133  128  int
 134  129  ri_pack(ri_hdl_t *hdl, caddr_t *bufp, size_t *sizep, int encoding)
 135  130  {
 136  131          nvlist_t        *nvl = NULL;
↓ open down ↓ 52 lines elided ↑ open up ↑
 189  184          }
 190  185  
 191  186          nvlist_free(nvl);
 192  187          *bufp = buf;
 193  188          *sizep = size;
 194  189  
 195  190          return (RI_SUCCESS);
 196  191  
 197  192  fail:
 198  193          s_free(buf);
 199      -        if (nvl != NULL)
 200      -                nvlist_free(nvl);
      194 +        nvlist_free(nvl);
 201  195  
 202  196          return (RI_FAILURE);
 203  197  }
 204  198  
 205  199  /*
 206  200   * Pack a list of attachment point handles.
 207  201   */
 208  202  static int
 209  203  ap_list_pack(ri_ap_t *aplist, char **bufp, size_t *sizep, int encoding)
 210  204  {
↓ open down ↓ 32 lines elided ↑ open up ↑
 243  237          }
 244  238  
 245  239          nvlist_free(nvl);
 246  240          *bufp = buf;
 247  241          *sizep = size;
 248  242  
 249  243          return (0);
 250  244  
 251  245  fail:
 252  246          s_free(buf);
 253      -        if (nvl != NULL)
 254      -                nvlist_free(nvl);
      247 +        nvlist_free(nvl);
 255  248  
 256  249          return (-1);
 257  250  }
 258  251  
 259  252  /*
 260  253   * Pack a list of ri_dev_t's.
 261  254   */
 262  255  static int
 263  256  dev_list_pack(ri_dev_t *devlist, char **bufp, size_t *sizep, int encoding)
 264  257  {
↓ open down ↓ 32 lines elided ↑ open up ↑
 297  290          }
 298  291  
 299  292          nvlist_free(nvl);
 300  293          *bufp = buf;
 301  294          *sizep = size;
 302  295  
 303  296          return (0);
 304  297  
 305  298  fail:
 306  299          s_free(buf);
 307      -        if (nvl != NULL)
 308      -                nvlist_free(nvl);
      300 +        nvlist_free(nvl);
 309  301  
 310  302          return (-1);
 311  303  }
 312  304  
 313  305  /*
 314  306   * Pack a list of ri_client_t's.
 315  307   */
 316  308  static int
 317  309  client_list_pack(ri_client_t *client_list, char **bufp, size_t *sizep,
 318  310      int encoding)
↓ open down ↓ 33 lines elided ↑ open up ↑
 352  344          }
 353  345  
 354  346          nvlist_free(nvl);
 355  347          *bufp = buf;
 356  348          *sizep = size;
 357  349  
 358  350          return (0);
 359  351  
 360  352  fail:
 361  353          s_free(buf);
 362      -        if (nvl != NULL)
 363      -                nvlist_free(nvl);
      354 +        nvlist_free(nvl);
 364  355  
 365  356          return (-1);
 366  357  }
 367  358  
 368  359  static int
 369  360  ap_pack(ri_ap_t *ap, char **bufp, size_t *sizep, int encoding)
 370  361  {
 371  362          nvlist_t        *nvl = NULL;
 372  363          char            *buf = NULL;
 373  364          size_t          size = 0;
↓ open down ↓ 43 lines elided ↑ open up ↑
 417  408          }
 418  409  
 419  410          nvlist_free(nvl);
 420  411          *bufp = buf;
 421  412          *sizep = size;
 422  413  
 423  414          return (0);
 424  415  
 425  416  fail:
 426  417          s_free(buf);
 427      -        if (nvl != NULL)
 428      -                nvlist_free(nvl);
      418 +        nvlist_free(nvl);
 429  419  
 430  420          return (-1);
 431  421  }
 432  422  
 433  423  static int
 434  424  dev_pack(ri_dev_t *dev, char **bufp, size_t *sizep, int encoding)
 435  425  {
 436  426          nvlist_t        *nvl = NULL;
 437  427          char            *buf = NULL;
 438  428          size_t          size = 0;
↓ open down ↓ 24 lines elided ↑ open up ↑
 463  453          }
 464  454  
 465  455          nvlist_free(nvl);
 466  456          *bufp = buf;
 467  457          *sizep = size;
 468  458  
 469  459          return (0);
 470  460  
 471  461  fail:
 472  462          s_free(buf);
 473      -        if (nvl != NULL)
 474      -                nvlist_free(nvl);
      463 +        nvlist_free(nvl);
 475  464  
 476  465          return (-1);
 477  466  }
 478  467  
 479  468  static int
 480  469  client_pack(ri_client_t *client, char **bufp, size_t *sizep, int encoding)
 481  470  {
 482  471          nvlist_t        *nvl = NULL;
 483  472          char            *buf = NULL;
 484  473          size_t          size = 0;
↓ open down ↓ 23 lines elided ↑ open up ↑
 508  497          }
 509  498  
 510  499          nvlist_free(nvl);
 511  500          *bufp = buf;
 512  501          *sizep = size;
 513  502  
 514  503          return (0);
 515  504  
 516  505  fail:
 517  506          s_free(buf);
 518      -        if (nvl != NULL)
 519      -                nvlist_free(nvl);
      507 +        nvlist_free(nvl);
 520  508  
 521  509          return (-1);
 522  510  }
 523  511  
 524  512  /*
 525  513   * Pack nvlist_t and add as byte array to another nvlist_t.
 526  514   */
 527  515  static int
 528  516  pack_add_byte_array(nvlist_t *nvl_packme, char *name, nvlist_t *nvl,
 529  517      int encoding)
↓ open down ↓ 80 lines elided ↑ open up ↑
 610  598  
 611  599          if (client_list_unpack(buf, size, &ri_hdl->mem_cap_clients) != 0)
 612  600                  goto fail;
 613  601  
 614  602          *hdlp = ri_hdl;
 615  603  
 616  604          return (0);
 617  605  
 618  606  fail:
 619  607          free(ri_hdl);
 620      -        if (nvl != NULL)
 621      -                nvlist_free(nvl);
      608 +        nvlist_free(nvl);
 622  609  
 623  610          return (-1);
 624  611  }
 625  612  
 626  613  static int
 627  614  ap_list_unpack(char *buf, size_t size, ri_ap_t **aps)
 628  615  {
 629  616          nvpair_t        *nvp = NULL;
 630  617          nvlist_t        *nvl;
 631  618          ri_ap_t         *aplist = NULL;
↓ open down ↓ 32 lines elided ↑ open up ↑
 664  651                          prev = tmp;
 665  652                  }
 666  653          }
 667  654  
 668  655          nvlist_free(nvl);
 669  656          *aps = aplist;
 670  657  
 671  658          return (0);
 672  659  
 673  660  fail:
 674      -        if (nvl != NULL)
 675      -                nvlist_free(nvl);
      661 +        nvlist_free(nvl);
 676  662          if (aplist != NULL) {
 677  663                  while ((tmp = aplist) != NULL) {
 678  664                          aplist = aplist->next;
 679  665                          ri_ap_free(tmp);
 680  666                  }
 681  667          }
 682  668  
 683  669          return (-1);
 684  670  }
 685  671  
↓ open down ↓ 36 lines elided ↑ open up ↑
 722  708                          prev = tmp;
 723  709                  }
 724  710          }
 725  711  
 726  712          nvlist_free(nvl);
 727  713          *devs = devlist;
 728  714  
 729  715          return (0);
 730  716  
 731  717  fail:
 732      -        if (nvl != NULL)
 733      -                nvlist_free(nvl);
      718 +        nvlist_free(nvl);
 734  719          if (devlist != NULL) {
 735  720                  while ((tmp = devlist) != NULL) {
 736  721                          devlist = devlist->next;
 737  722                          ri_dev_free(tmp);
 738  723                  }
 739  724          }
 740  725  
 741  726          return (-1);
 742  727  }
 743  728  
↓ open down ↓ 38 lines elided ↑ open up ↑
 782  767                          prev = tmp;
 783  768                  }
 784  769          }
 785  770  
 786  771          nvlist_free(nvl);
 787  772          *clients = client_list;
 788  773  
 789  774          return (0);
 790  775  
 791  776  fail:
 792      -        if (nvl != NULL)
 793      -                nvlist_free(nvl);
      777 +        nvlist_free(nvl);
 794  778          if (client_list != NULL) {
 795  779                  while ((tmp = client_list) != NULL) {
 796  780                          client_list = client_list->next;
 797  781                          ri_client_free(tmp);
 798  782                  }
 799  783          }
 800  784  
 801  785          return (-1);
 802  786  }
 803  787  
↓ open down ↓ 275 lines elided ↑ open up ↑
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX