usr/src/cmd/avs/dsstat/ii_stats.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  * Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
  23  * Use is subject to license terms.
  24  */
  25
  26 #include <stdio.h>
  27 #include <stdlib.h>
  28 #include <string.h>
  29 #include <unistd.h>
  30 #include <errno.h>
  31
  32 #include <sys/mutex.h>
  33
  34 #include <kstat.h>
  35
  36 #include <sys/unistat/spcs_s.h>
  37 #include <sys/nsctl/dsw.h>
  38 #include "../../../uts/common/avs/ns/dsw/dsw_dev.h"
  39 #include <sys/nsctl/dsw_dev.h>
  40
  41 #include "sdbc_stats.h"
  42 #include "ii_stats.h"
  43
  44 #include "dsstat.h"
  45 #include "common.h"
  46 #include "report.h"
  47
  48 static iistat_t *ii_top = NULL;
  49
  50 void ii_add_stat(iistat_t *);
  51 iistat_t *ii_del_stat(iistat_t *);
  52
  53 int ii_value_check(iistat_t *iistat);
  54 int ii_validate(kstat_t *ksp);
  55 int ii_vol_selected(kstat_t *);
  56
  57 /*
  58  * ii_discover() - looks for new statistics to be monitored.
  59  * Verifies that any statistics found are now already being
  60  * monitored.
  61  *
  62  */
  63 int
  64 ii_discover(kstat_ctl_t *kc)
  65 {
  66         static int validated = 0;
  67
  68         kstat_t *ksp;
  69
  70         /* Loop on all kstats */
  71         for (ksp = kc->kc_chain; ksp; ksp = ksp->ks_next) {
  72                 char *kname;
  73                 iistat_t *cur;
  74                 iistat_t *iistat = NULL;
  75                 kstat_t *mst_ksp;
  76                 kstat_t *shd_ksp;
  77                 kstat_t *bmp_ksp;
  78                 kstat_t *ovr_ksp;
  79
  80                 /* Search for II set */
  81                 if (strcmp(ksp->ks_class, II_KSTAT_CLASS) != 0)
  82                         continue;
  83
  84                 if (kstat_read(kc, ksp, NULL) == -1)
  85                         continue;
  86
  87                 /*
  88                  * Validate kstat structure
  89                  */
  90                 if (! validated) {
  91                         if (ii_validate(ksp))
  92                                 return (EINVAL);
  93
  94                         validated++;
  95                 }
  96
  97                 /*
  98                  * Duplicate check
  99                  */
 100                 for (cur = ii_top; cur != NULL; cur = cur->next) {
 101                         char *cur_vname, *tst_vname;
 102                         uint32_t cur_inst, tst_inst;
 103
 104                         cur_vname = cur->pre_set->ks_name;
 105                         cur_inst = cur->pre_set->ks_instance;
 106
 107                         tst_vname = ksp->ks_name;
 108                         tst_inst = ksp->ks_instance;
 109
 110                         if (strcmp(cur_vname, tst_vname) == 0 &&
 111                             cur_inst == tst_inst)
 112                                 goto next;
 113                 }
 114
 115                 /*
 116                  * Initialize new record
 117                  */
 118                 iistat = (iistat_t *)calloc(1, sizeof (iistat_t));
 119
 120                 /*
 121                  * Set kstat
 122                  */
 123                 iistat->pre_set = kstat_retrieve(kc, ksp);
 124
 125                 if (iistat->pre_set == NULL)
 126                         goto next;
 127
 128                 iistat->collected |= GOT_SETSTAT;
 129
 130                 /*
 131                  * Master kstat
 132                  */
 133                 kname = kstat_value(iistat->pre_set, DSW_SKSTAT_MSTIO);
 134
 135                 mst_ksp = kstat_lookup(kc, II_KSTAT_MODULE, -1, kname);
 136                 iistat->pre_mst = kstat_retrieve(kc, mst_ksp);
 137
 138                 if (iistat->pre_mst == NULL)
 139                         goto next;
 140
 141                 iistat->collected |= GOT_MSTSTAT;
 142
 143                 /*
 144                  * Shadow kstat
 145                  */
 146                 kname = kstat_value(iistat->pre_set, DSW_SKSTAT_SHDIO);
 147
 148                 shd_ksp = kstat_lookup(kc, II_KSTAT_MODULE, -1, kname);
 149                 iistat->pre_shd = kstat_retrieve(kc, shd_ksp);
 150
 151                 if (iistat->pre_shd == NULL)
 152                         goto next;
 153
 154                 iistat->collected |= GOT_SHDSTAT;
 155
 156                 /*
 157                  * Bitmap kstat
 158                  */
 159                 kname = kstat_value(iistat->pre_set, DSW_SKSTAT_BMPIO);
 160
 161                 bmp_ksp = kstat_lookup(kc, II_KSTAT_MODULE, -1, kname);
 162                 iistat->pre_bmp = kstat_retrieve(kc, bmp_ksp);
 163
 164                 if (iistat->pre_bmp == NULL)
 165                         goto next;
 166
 167                 iistat->collected |= GOT_BMPSTAT;
 168
 169                 /*
 170                  * Overflow kstat
 171                  */
 172                 kname = kstat_value(iistat->pre_set, DSW_SKSTAT_OVRIO);
 173
 174                 ovr_ksp = kstat_lookup(kc, II_KSTAT_MODULE, -1, kname);
 175                 iistat->pre_ovr = kstat_retrieve(kc, ovr_ksp);
 176
 177                 if (iistat->pre_ovr == NULL)
 178                         goto next;
 179
 180                 iistat->collected |= GOT_OVRSTAT;
 181
 182 next:
 183                 /*
 184                  * Check if we got a complete set of stats
 185                  */
 186                 if (iistat == NULL)
 187                         continue;
 188
 189                 if (IIMG_COMPLETE(iistat->collected)) {
 190                         (void) ii_del_stat(iistat);
 191                         continue;
 192                 }
 193
 194                 /*
 195                  * Add to linked list
 196                  */
 197                 ii_add_stat(iistat);
 198         }
 199
 200         if (ii_top == NULL)
 201                 return (EAGAIN);
 202
 203         return (0);
 204 }
 205
 206 /*
 207  * ii_update() - updates all of the statistics currently being monitored.
 208  *
 209  */
 210 int
 211 ii_update(kstat_ctl_t *kc)
 212 {
 213         iistat_t *cur;
 214
 215         for (cur = ii_top; cur != NULL; cur = cur->next) {
 216                 char volname[KSTAT_STRLEN + 1];
 217                 char *kname;
 218
 219                 kstat_t *ksp = NULL;
 220
 221                 cur->collected = 0;
 222
 223                 /*
 224                  * Age off old stats
 225                  */
 226                 if (cur->cur_set != NULL) {
 227                         kstat_free(cur->pre_set);
 228                         kstat_free(cur->pre_mst);
 229                         kstat_free(cur->pre_shd);
 230                         kstat_free(cur->pre_bmp);
 231
 232                         cur->pre_set = cur->cur_set;
 233                         cur->pre_mst = cur->cur_mst;
 234                         cur->pre_shd = cur->cur_shd;
 235                         cur->pre_bmp = cur->cur_bmp;
 236
 237                         if (cur->cur_ovr != NULL) {
 238                                 kstat_free(cur->pre_ovr);
 239                                 cur->pre_ovr = cur->cur_ovr;
 240                         }
 241                 }
 242
 243                 /*
 244                  * Set kstat
 245                  */
 246                 (void) strncpy(volname, cur->pre_set->ks_name, KSTAT_STRLEN);
 247                 volname[KSTAT_STRLEN] = '\0';
 248
 249                 ksp = kstat_lookup(kc, II_KSTAT_MODULE, -1, volname);
 250
 251                 if ((cur->cur_set = kstat_retrieve(kc, ksp)) == NULL)
 252                         continue;
 253
 254                 cur->collected |= GOT_SETSTAT;
 255
 256                 /*
 257                  * Validate set
 258                  */
 259                 if (strcmp(cur->pre_set->ks_name, cur->cur_set->ks_name) != 0 ||
 260                     cur->pre_set->ks_instance != cur->cur_set->ks_instance)
 261                         continue;
 262
 263                 /*
 264                  * Master kstat
 265                  */
 266                 kname = kstat_value(cur->cur_set, DSW_SKSTAT_MSTIO);
 267
 268                 ksp = kstat_lookup(kc, II_KSTAT_MODULE, -1, kname);
 269
 270                 if ((cur->cur_mst = kstat_retrieve(kc, ksp)) == NULL)
 271                         continue;
 272
 273                 cur->collected |= GOT_MSTSTAT;
 274
 275                 /*
 276                  * Shadow kstat
 277                  */
 278                 kname = kstat_value(cur->cur_set, DSW_SKSTAT_SHDIO);
 279
 280                 ksp = kstat_lookup(kc, II_KSTAT_MODULE, -1, kname);
 281
 282                 if ((cur->cur_shd = kstat_retrieve(kc, ksp)) == NULL)
 283                         continue;
 284
 285                 cur->collected |= GOT_SHDSTAT;
 286
 287                 /*
 288                  * Bitmap kstat
 289                  */
 290                 kname = kstat_value(cur->pre_set, DSW_SKSTAT_BMPIO);
 291
 292                 ksp = kstat_lookup(kc, II_KSTAT_MODULE, -1, kname);
 293
 294                 if ((cur->cur_bmp = kstat_retrieve(kc, ksp)) == NULL)
 295                         continue;
 296
 297                 cur->collected |= GOT_BMPSTAT;
 298
 299                 /*
 300                  * Overflow kstat
 301                  */
 302                 kname = kstat_value(cur->cur_set, DSW_SKSTAT_OVRIO);
 303
 304                 ksp = kstat_lookup(kc, II_KSTAT_MODULE, -1, kname);
 305
 306                 if (ksp == NULL) {
 307                         if (cur->pre_ovr != NULL) {
 308                                 kstat_free(cur->pre_ovr);
 309                                 cur->pre_ovr = NULL;
 310                         }
 311                         if (cur->cur_ovr != NULL) {
 312                                 kstat_free(cur->cur_ovr);
 313                                 cur->cur_ovr = NULL;
 314                         }
 315                         continue;
 316                 }
 317
 318                 if (cur->pre_ovr == NULL) {
 319                         if ((cur->pre_ovr = kstat_retrieve(kc, ksp)) == NULL)
 320                                 continue;
 321                 } else {
 322                         if ((cur->cur_ovr = kstat_retrieve(kc, ksp)) == NULL)
 323                                 continue;
 324                 }
 325
 326                 cur->collected |= GOT_OVRSTAT;
 327         }
 328
 329         return (0);
 330 }
 331
 332 /*
 333  * ii_report() - outputs statistics for the statistics currently being
 334  * monitored.  Deletes statistics for volumes that have been disabled.
 335  *
 336  */
 337 int
 338 ii_report()
 339 {
 340         uint32_t *flags;
 341         int padsz = 0;
 342         char pad[20] = {0};
 343         iistat_t *cur, *pre = NULL;
 344
 345         if (ii_top == NULL) {
 346                 return (0);
 347         }
 348
 349         /* Create padding string for secondary report lines */
 350         if (dflags & FLAGS) {
 351                 padsz += STAT_HDR_SIZE;
 352                 padsz += STAT_HDR_SIZE;
 353         }
 354
 355         if (dflags & PCTS)
 356                 padsz += PCT_HDR_SIZE;
 357
 358         if (padsz) {
 359                 char fmt[20];
 360                 (void) sprintf(fmt, "%%%ds", padsz);
 361                 (void) sprintf(pad, fmt, "");
 362         }
 363
 364         for (cur = ii_top; cur; /* CSTYLED */) {
 365                 int first = 1;
 366                 char data[20] = {0};
 367
 368                 /* Check to see if this is this a complete */
 369                 if (IIMG_COMPLETE(cur->collected)) {
 370                         char *c;
 371                         char vol[(NAMED_LEN * 4) + 1] = {0};
 372                         int offset;
 373                         iistat_t *next;
 374
 375                         /* notify user of set being disabled */
 376                         c = kstat_value(cur->pre_set, DSW_SKSTAT_SETA);
 377                         (void) strncpy(vol, c, NAMED_LEN);
 378                         c = kstat_value(cur->pre_set, DSW_SKSTAT_SETB);
 379                         (void) strncat(vol, c, NAMED_LEN);
 380                         c = kstat_value(cur->pre_set, DSW_SKSTAT_SETC);
 381                         (void) strncat(vol, c, NAMED_LEN);
 382                         c = kstat_value(cur->pre_set, DSW_SKSTAT_SETD);
 383                         (void) strncat(vol, c, NAMED_LEN);
 384
 385                         offset = strlen(vol) - NAMED_LEN;
 386
 387                         if (offset < 0)
 388                                 offset = 0;
 389
 390                         (void) printf(DATA_C16, vol + offset);
 391                         (void) printf(" %s\n", II_DISABLED);
 392
 393                         /* free memory and remove stat from list */
 394                         next = ii_del_stat(cur);
 395
 396                         if (! pre)
 397                                 cur = ii_top = next;
 398                         else
 399                                 cur = pre->next = next;
 400
 401                         continue;
 402                 }
 403
 404                 /* Check to see if the user specified this volume */
 405                 if (! ii_vol_selected(cur->pre_set))
 406                         goto next;
 407
 408                 /* Check to see if zflag applies */
 409                 if (zflag && ii_value_check(cur) == 0)
 410                         goto next;
 411
 412                 /* Calculate flags */
 413                 flags = kstat_value(cur->cur_set, DSW_SKSTAT_FLAGS);
 414
 415                 if (dflags & FLAGS) {
 416
 417                         char c[STAT_HDR_SIZE];
 418                         char vtype[STAT_HDR_SIZE];
 419                         char vstat[STAT_HDR_SIZE];
 420
 421                         if (*flags & DSW_GOLDEN)
 422                                 (void) strcpy(c, II_INDEPENDENT);
 423                         else
 424                                 (void) strcpy(c, II_DEPENDENT);
 425
 426                         (void) sprintf(vtype, DATA_C2, c);
 427                         (void) strcat(data, vtype);
 428
 429                         if (*flags & DSW_COPYINGP)
 430                                 (void) strcpy(c, II_COPYING);
 431                         else
 432                                 (void) strcpy(c, NO_INFO);
 433
 434
 435                         (void) sprintf(vstat, DATA_C2, c);
 436                         (void) strcat(data, vstat);
 437                 }
 438
 439                 /* Calculate sync needed precentage */
 440                 if (dflags & PCTS) {
 441                         char snpct[10];
 442                         uint32_t *chkbits;
 443                         uint32_t *cpybits;
 444                         uint32_t *shdbits;
 445                         uint32_t *volsize;
 446                         float pct;
 447
 448                         cpybits =
 449                             kstat_value(cur->cur_set, DSW_SKSTAT_COPYBITS);
 450
 451                         shdbits =
 452                             kstat_value(cur->cur_set, DSW_SKSTAT_SHDBITS);
 453
 454                         volsize =
 455                             kstat_value(cur->cur_set, DSW_SKSTAT_SIZE);
 456
 457                         *volsize /= DSW_SIZE;
 458
 459                         chkbits = *cpybits >= *shdbits ? cpybits : shdbits;
 460
 461                         pct = ((float)*chkbits / *volsize) * 100.0;
 462
 463                         (void) sprintf(snpct, DATA_F62, pct);
 464
 465                         (void) strcat(data, snpct);
 466                 }
 467
 468                 /* Master statistics */
 469                 if (rflags & IIMG_MST) {
 470                         char *c;
 471                         char vol[(NAMED_LEN * 4) + 1] = {0};
 472                         int offset;
 473
 474                         c = kstat_value(cur->cur_set, DSW_SKSTAT_MSTA);
 475                         (void) strncat(vol, c, NAMED_LEN);
 476                         c = kstat_value(cur->cur_set, DSW_SKSTAT_MSTB);
 477                         (void) strncat(vol, c, NAMED_LEN);
 478                         c = kstat_value(cur->cur_set, DSW_SKSTAT_MSTC);
 479                         (void) strncat(vol, c, NAMED_LEN);
 480                         c = kstat_value(cur->cur_set, DSW_SKSTAT_MSTD);
 481                         (void) strncat(vol, c, NAMED_LEN);
 482
 483                         offset = strlen(vol) - NAMED_LEN;
 484
 485                         if (offset < 0)
 486                                 offset = 0;
 487
 488                         header();
 489                         (void) printf(DATA_C16, vol + offset);
 490                         (void) printf("%s", data);
 491                         (void) printf(ROLE_INF_FMT, II_MASTER);
 492
 493                         if (*flags & DSW_MSTOFFLINE) {
 494                                 (void) printf(" <<offline>>");
 495                                 linesout++;
 496                         } else {
 497                                 io_report(cur->cur_mst, cur->pre_mst,
 498                                     sdbc_getstat(vol + offset));
 499                         }
 500
 501                         (void) printf("\n");
 502
 503                         if (first) {
 504                                 (void) strcpy(data, strlen(pad) > 0 ? pad : "");
 505                                 first = 0;
 506                         }
 507                 }
 508
 509                 /* Shadow statistics */
 510                 if (rflags & IIMG_SHD) {
 511                         char *c;
 512                         char vol[(NAMED_LEN * 4) + 1] = {0};
 513                         int offset;
 514
 515                         c = kstat_value(cur->cur_set, DSW_SKSTAT_SETA);
 516                         (void) strncat(vol, c, NAMED_LEN);
 517                         c = kstat_value(cur->cur_set, DSW_SKSTAT_SETB);
 518                         (void) strncat(vol, c, NAMED_LEN);
 519                         c = kstat_value(cur->cur_set, DSW_SKSTAT_SETC);
 520                         (void) strncat(vol, c, NAMED_LEN);
 521                         c = kstat_value(cur->cur_set, DSW_SKSTAT_SETD);
 522                         (void) strncat(vol, c, NAMED_LEN);
 523
 524                         offset = strlen(vol) - NAMED_LEN;
 525
 526                         if (offset < 0)
 527                                 offset = 0;
 528
 529                         header();
 530                         (void) printf(DATA_C16, vol + offset);
 531                         (void) printf("%s", data);
 532                         (void) printf(ROLE_INF_FMT, II_SHADOW);
 533
 534                         if (*flags & DSW_SHDOFFLINE) {
 535                                 (void) printf(" <<offline>>");
 536                                 linesout++;
 537                         } else {
 538                                 io_report(cur->cur_shd, cur->pre_shd,
 539                                     sdbc_getstat(vol + offset));
 540                         }
 541
 542                         (void) printf("\n");
 543
 544                         if (first) {
 545                                 (void) strcpy(data, strlen(pad) > 0 ? pad : "");
 546                                 first = 0;
 547                         }
 548                 }
 549
 550                 /* Bitmap statistics */
 551                 if (rflags & IIMG_BMP) {
 552                         char *c;
 553                         char vol[(NAMED_LEN * 4) + 1] = {0};
 554                         int offset;
 555
 556                         c = kstat_value(cur->cur_set, DSW_SKSTAT_BMPA);
 557                         (void) strncat(vol, c, NAMED_LEN);
 558                         c = kstat_value(cur->cur_set, DSW_SKSTAT_BMPB);
 559                         (void) strncat(vol, c, NAMED_LEN);
 560                         c = kstat_value(cur->cur_set, DSW_SKSTAT_BMPC);
 561                         (void) strncat(vol, c, NAMED_LEN);
 562                         c = kstat_value(cur->cur_set, DSW_SKSTAT_BMPD);
 563                         (void) strncat(vol, c, NAMED_LEN);
 564
 565                         offset = strlen(vol) - NAMED_LEN;
 566
 567                         if (offset < 0)
 568                                 offset = 0;
 569
 570                         header();
 571                         (void) printf(DATA_C16, vol + offset);
 572                         (void) printf("%s", data);
 573                         (void) printf(ROLE_INF_FMT, II_BITMAP);
 574
 575                         if (*flags & DSW_BMPOFFLINE) {
 576                                 (void) printf(" <<offline>>");
 577                                 linesout++;
 578                         } else {
 579                                 io_report(cur->cur_bmp, cur->pre_bmp,
 580                                     sdbc_getstat(vol + offset));
 581                         }
 582                         (void) printf("\n");
 583
 584                         if (first) {
 585                                 (void) strcpy(data, strlen(pad) > 0 ? pad : "");
 586                                 first = 0;
 587                         }
 588                 }
 589
 590                 /* Overflow statistics */
 591                 if (rflags & IIMG_OVR) {
 592                         char *c;
 593                         char msg[20] = {0};
 594                         char vol[(NAMED_LEN * 4) + 1] = {0};
 595                         int offset;
 596
 597                         if (cur->cur_ovr == NULL && cur->pre_ovr != NULL)
 598                                 (void) strcpy(msg, " <<attached>>");
 599
 600                         if (! (cur->collected & GOT_OVRSTAT))
 601                                 (void) strcpy(msg, " <<not attached>>");
 602
 603                         c = kstat_value(cur->cur_set, DSW_SKSTAT_OVRA);
 604                         (void) strncpy(vol, c, NAMED_LEN);
 605                         c = kstat_value(cur->cur_set, DSW_SKSTAT_OVRB);
 606                         (void) strncat(vol, c, NAMED_LEN);
 607                         c = kstat_value(cur->cur_set, DSW_SKSTAT_OVRC);
 608                         (void) strncat(vol, c, NAMED_LEN);
 609                         c = kstat_value(cur->cur_set, DSW_SKSTAT_OVRD);
 610                         (void) strncat(vol, c, NAMED_LEN);
 611
 612                         offset = strlen(vol) - NAMED_LEN;
 613
 614                         if (offset < 0)
 615                                 offset = 0;
 616
 617                         header();
 618                         (void) printf(DATA_C16, vol + offset);
 619                         (void) printf("%s", data);
 620                         (void) printf(ROLE_INF_FMT, II_OVERFLOW);
 621
 622                         if (strlen(msg)) {
 623                                 (void) printf("%s\n", msg);
 624                                 linesout++;
 625                                 goto next;
 626                         }
 627
 628                         if (*flags & DSW_OVROFFLINE) {
 629                                 (void) printf(" <<offline>>");
 630                                 linesout++;
 631                         } else {
 632                                 io_report(cur->cur_ovr, cur->pre_ovr,
 633                                     sdbc_getstat(vol + offset));
 634                         }
 635
 636                         (void) printf("\n");
 637
 638                         if (first) {
 639                                 (void) strcpy(data, strlen(pad) > 0 ? pad : "");
 640                                 first = 0;
 641                         }
 642                 }
 643
 644
 645 next:
 646                 pre = cur;
 647                 cur = cur->next;
 648         }
 649
 650         return (0);
 651 }
 652
 653 /*
 654  * ii_add_stat() - adds a fully populated iistat_t structure
 655  * to the linked list of currently monitored kstats.  The structure
 656  * will be added in alphabetical order, using the volume name of
 657  * the shadow volume as the key.
 658  *
 659  */
 660 void
 661 ii_add_stat(iistat_t *iistat)
 662 {
 663
 664         iistat_t *cur;
 665
 666         if (ii_top == NULL) {
 667                 ii_top = iistat;
 668                 return;
 669         }
 670
 671         for (cur = ii_top; cur != NULL; cur = cur->next) {
 672                 if (strcmp(cur->pre_set->ks_name,
 673                     iistat->pre_set->ks_name) <= 0) {
 674                         /*
 675                          * If we get to the last item in the list, then just
 676                          * add this one to the end
 677                          */
 678                         if (cur->next == NULL) {
 679                                 cur->next = iistat;
 680                                 return;
 681                         }
 682
 683                         if (strcmp(cur->next->pre_set->ks_name,
 684                             iistat->pre_set->ks_name) > 0) {
 685                                 iistat->next = cur->next;
 686                                 cur->next = iistat;
 687                                 return;
 688                         }
 689                 } else {
 690                         if (cur == ii_top)
 691                                 ii_top = iistat;
 692
 693                         iistat->next = cur;
 694
 695                         return;
 696                 }
 697         }
 698 }
 699
 700 /*
 701  * ii_del_stat() - deallocate memory for the structure being
 702  * passed in.
 703  *
 704  * parameters
 705  *      iistat_t *iistat - structure to be deallocated
 706  *
 707  * returns
 708  *      iistat_t * - pointer to the "next" structures in the
 709  *      linked list. May be NULL if we are removing the last
 710  *      structure in the linked list.
 711  *
 712  */
 713 iistat_t *
 714 ii_del_stat(iistat_t *iistat)
 715 {
 716
 717         iistat_t *next = iistat->next;
 718
 719         kstat_free(iistat->pre_set);
 720         kstat_free(iistat->pre_mst);
 721         kstat_free(iistat->pre_shd);
 722         kstat_free(iistat->pre_bmp);
 723         kstat_free(iistat->pre_ovr);
 724         kstat_free(iistat->cur_set);
 725         kstat_free(iistat->cur_mst);
 726         kstat_free(iistat->cur_shd);
 727         kstat_free(iistat->cur_bmp);
 728         kstat_free(iistat->cur_ovr);
 729
 730         free(iistat);
 731
 732         return (next);
 733 }
 734
 735 int
 736 ii_value_check(iistat_t *iistat)
 737 {
 738         if (IIMG_COMPLETE(iistat->collected))
 739                 return (1);
 740
 741         if (io_value_check(iistat->pre_mst->ks_data,
 742             iistat->cur_mst->ks_data)) {
 743                 return (1);
 744         }
 745
 746         if (io_value_check(iistat->pre_shd->ks_data,
 747             iistat->cur_shd->ks_data)) {
 748                 return (1);
 749         }
 750
 751         if (io_value_check(iistat->pre_bmp->ks_data,
 752             iistat->cur_bmp->ks_data)) {
 753                 return (1);
 754         }
 755
 756         if (iistat->pre_ovr && iistat->cur_ovr) {
 757                 if (io_value_check(iistat->pre_ovr->ks_data,
 758                     iistat->cur_ovr->ks_data)) {
 759                         return (1);
 760                 }
 761         }
 762
 763         return (0);
 764 }
 765
 766 int
 767 ii_validate(kstat_t *ksp)
 768 {
 769         if (! kstat_value(ksp, DSW_SKSTAT_MSTIO) ||
 770             ! kstat_value(ksp, DSW_SKSTAT_SHDIO) ||
 771             ! kstat_value(ksp, DSW_SKSTAT_BMPIO) ||
 772             ! kstat_value(ksp, DSW_SKSTAT_OVRIO) ||
 773             ! kstat_value(ksp, DSW_SKSTAT_FLAGS) ||
 774             ! kstat_value(ksp, DSW_SKSTAT_MSTA) ||
 775             ! kstat_value(ksp, DSW_SKSTAT_SETA) ||
 776             ! kstat_value(ksp, DSW_SKSTAT_BMPA) ||
 777             ! kstat_value(ksp, DSW_SKSTAT_OVRA) ||
 778             ! kstat_value(ksp, DSW_SKSTAT_SHDBITS) ||
 779             ! kstat_value(ksp, DSW_SKSTAT_COPYBITS) ||
 780             ! kstat_value(ksp, DSW_SKSTAT_SIZE))
 781                 return (1);
 782
 783         return (0);
 784 }
 785
 786 int
 787 ii_vol_selected(kstat_t *ksp)
 788 {
 789         vslist_t *vslist = vs_top;
 790
 791         for (vslist = vs_top; vslist != NULL; vslist = vslist->next) {
 792                 char *vn;
 793                 int off = 0;
 794
 795                 vn = ksp->ks_name;
 796
 797                 if ((off = strlen(vn) - NAMED_LEN) <= 0) {
 798                         off = 0;
 799                 }
 800
 801                 if (strcmp(vslist->volname, &vn[off]) == 0) {
 802                         break;
 803                 }
 804         }
 805
 806         if (vs_top != NULL && vslist == NULL) {
 807                 return (0);
 808         } else {
 809                 return (1);
 810         }
 811 }