usr/src/cmd/stat/common/walkers.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 2006 Sun Microsystems, Inc.  All rights reserved.
  23  * Use is subject to license terms.
  24  */
  25
  26 #pragma ident   "%Z%%M% %I%     %E% SMI"
  27
  28 #include "statcommon.h"
  29
  30 #include <string.h>
  31 #include <errno.h>
  32
  33 /* max size of report change annotations */
  34 #define LIST_SIZE 512
  35
  36 static char cpus_added[LIST_SIZE];
  37 static char cpus_removed[LIST_SIZE];
  38
  39 static int
  40 cpu_walk(struct snapshot *old, struct snapshot *new,
  41     snapshot_cb cb, void *data)
  42 {
  43         int changed = 0;
  44         int i;
  45
  46         /* CPUs can change state but not re-order */
  47         for (i = 0; i < new->s_nr_cpus; i++) {
  48                 struct cpu_snapshot *cpu = NULL;
  49                 struct cpu_snapshot *newcpu = &new->s_cpus[i];
  50                 if (old)
  51                         cpu = &old->s_cpus[i];
  52                 cb(cpu, newcpu, data);
  53                 if (cpu == NULL)
  54                         changed = 1;
  55                 else {
  56                         /*
  57                          * We only care about off/on line transitions
  58                          */
  59                         if ((CPU_ACTIVE(cpu) && !CPU_ACTIVE(newcpu)) ||
  60                             (!CPU_ACTIVE(cpu) && CPU_ACTIVE(newcpu)))
  61                                 changed = 1;
  62                         if ((new->s_types & SNAP_PSETS) &&
  63                                 cpu->cs_pset_id != newcpu->cs_pset_id)
  64                                 changed = 1;
  65                 }
  66
  67         }
  68
  69         return (changed);
  70 }
  71
  72 static int
  73 pset_walk(struct snapshot *old, struct snapshot *new,
  74     snapshot_cb cb, void *data)
  75 {
  76         int i = 0;
  77         int j = 0;
  78         int changed = 0;
  79
  80         while (old && i < old->s_nr_psets && j < new->s_nr_psets) {
  81                 if (old->s_psets[i].ps_id < new->s_psets[j].ps_id) {
  82                         cb(&old->s_psets[i], NULL, data);
  83                         i++;
  84                         changed = 1;
  85                 } else if (old->s_psets[i].ps_id > new->s_psets[j].ps_id) {
  86                         cb(NULL, &new->s_psets[j], data);
  87                         j++;
  88                         changed = 1;
  89                 } else {
  90                         cb(&old->s_psets[i], &new->s_psets[j], data);
  91                         i++;
  92                         j++;
  93                 }
  94         }
  95
  96         while (old && i < old->s_nr_psets) {
  97                 cb(&old->s_psets[i], NULL, data);
  98                 i++;
  99                 changed = 1;
 100         }
 101
 102         while (j < new->s_nr_psets) {
 103                 cb(NULL, &new->s_psets[j], data);
 104                 j++;
 105                 changed = 1;
 106         }
 107
 108         return (changed);
 109 }
 110
 111 static int
 112 iodev_walk(struct iodev_snapshot *d1, struct iodev_snapshot *d2,
 113     snapshot_cb cb, void *data)
 114 {
 115         int changed = 0;
 116
 117         while (d1 && d2) {
 118                 if (strcmp(d1->is_name, d2->is_name) < 0) {
 119                         changed = 1;
 120                         cb(d1, NULL, data);
 121                         (void) iodev_walk(d1->is_children, NULL, cb, data);
 122                         d1 = d1->is_next;
 123                 } else if (strcmp(d1->is_name, d2->is_name) > 0) {
 124                         changed = 1;
 125                         cb(NULL, d2, data);
 126                         (void) iodev_walk(NULL, d2->is_children, cb, data);
 127                         d2 = d2->is_next;
 128                 } else {
 129                         cb(d1, d2, data);
 130                         changed |= iodev_walk(d1->is_children,
 131                                         d2->is_children, cb, data);
 132                         d1 = d1->is_next;
 133                         d2 = d2->is_next;
 134                 }
 135         }
 136
 137         while (d1) {
 138                 changed = 1;
 139                 cb(d1, NULL, data);
 140                 (void) iodev_walk(d1->is_children, NULL, cb, data);
 141                 d1 = d1->is_next;
 142         }
 143
 144         while (d2) {
 145                 changed = 1;
 146                 cb(NULL, d2, data);
 147                 (void) iodev_walk(NULL, d2->is_children, cb, data);
 148                 d2 = d2->is_next;
 149         }
 150
 151         return (changed);
 152 }
 153
 154 int
 155 snapshot_walk(enum snapshot_types type, struct snapshot *old,
 156     struct snapshot *new, snapshot_cb cb, void *data)
 157 {
 158         int changed = 0;
 159
 160         switch (type) {
 161         case SNAP_CPUS:
 162                 changed = cpu_walk(old, new, cb, data);
 163                 break;
 164
 165         case SNAP_PSETS:
 166                 changed = pset_walk(old, new, cb, data);
 167                 break;
 168
 169         case SNAP_CONTROLLERS:
 170         case SNAP_IODEVS:
 171         case SNAP_IOPATHS_LI:
 172         case SNAP_IOPATHS_LTI:
 173                 changed = iodev_walk(old ? old->s_iodevs : NULL,
 174                     new->s_iodevs, cb, data);
 175                 break;
 176
 177         default:
 178                 break;
 179         }
 180
 181         return (changed);
 182 }
 183
 184 static void
 185 add_nr_to_list(char *buf, unsigned long nr)
 186 {
 187         char tmp[LIST_SIZE];
 188
 189         (void) snprintf(tmp, LIST_SIZE, "%lu", nr);
 190
 191         if (strlen(buf))
 192                 (void) strlcat(buf, ", ", LIST_SIZE);
 193
 194         (void) strlcat(buf, tmp, LIST_SIZE);
 195 }
 196
 197 static void
 198 cpu_report(void *v1, void *v2, void *data)
 199 {
 200         int *pset = (int *)data;
 201         struct cpu_snapshot *c1 = (struct cpu_snapshot *)v1;
 202         struct cpu_snapshot *c2 = (struct cpu_snapshot *)v2;
 203
 204         if (*pset && c1->cs_pset_id != c2->cs_pset_id) {
 205                 (void) printf("<<processor %d moved from pset: %d to: %d>>\n",
 206                     c1->cs_id, c1->cs_pset_id, c2->cs_pset_id);
 207         }
 208
 209         if (c1->cs_state == c2->cs_state)
 210                 return;
 211
 212         if (CPU_ONLINE(c1->cs_state) && !CPU_ONLINE(c2->cs_state))
 213                 add_nr_to_list(cpus_removed, c1->cs_id);
 214
 215         if (!CPU_ONLINE(c1->cs_state) && CPU_ONLINE(c2->cs_state))
 216                 add_nr_to_list(cpus_added, c2->cs_id);
 217 }
 218
 219 /*ARGSUSED*/
 220 static void
 221 pset_report(void *v1, void *v2, void *data)
 222 {
 223         struct pset_snapshot *p1 = (struct pset_snapshot *)v1;
 224         struct pset_snapshot *p2 = (struct pset_snapshot *)v2;
 225
 226         if (p2 == NULL) {
 227                 (void) printf("<<pset destroyed: %u>>\n", p1->ps_id);
 228                 return;
 229         }
 230
 231         if (p1 == NULL)
 232                 (void) printf("<<pset created: %u>>\n", p2->ps_id);
 233 }
 234
 235 static void
 236 get_child_list(struct iodev_snapshot *iodev, char *buf)
 237 {
 238         char tmp[LIST_SIZE];
 239         struct iodev_snapshot *pos = iodev->is_children;
 240
 241         while (pos) {
 242                 if (pos->is_type == IODEV_PARTITION) {
 243                         add_nr_to_list(buf, pos->is_id.id);
 244                 } else if (pos->is_type == IODEV_DISK) {
 245                         if (strlen(buf))
 246                                 (void) strlcat(buf, ", ", LIST_SIZE);
 247                         (void) strlcat(buf, "t", LIST_SIZE);
 248                         (void) strlcat(buf, pos->is_id.tid, LIST_SIZE);
 249                         (void) strlcat(buf, "d", LIST_SIZE);
 250                         *tmp = '\0';
 251                         add_nr_to_list(tmp, pos->is_id.id);
 252                         (void) strlcat(buf, tmp, LIST_SIZE);
 253                 }
 254                 pos = pos->is_next;
 255         }
 256 }
 257
 258 static void
 259 iodev_changed(struct iodev_snapshot *iodev, int added)
 260 {
 261         char tmp[LIST_SIZE];
 262         int is_disk = iodev->is_type == IODEV_DISK;
 263         char *name = iodev->is_name;
 264
 265         if (iodev->is_pretty)
 266                 name = iodev->is_pretty;
 267
 268         switch (iodev->is_type) {
 269         case IODEV_IOPATH_LT:
 270         case IODEV_IOPATH_LI:
 271         case IODEV_IOPATH_LTI:
 272                 (void) printf("<<multi-path %s: %s>>\n",
 273                     added ? "added" : "removed", name);
 274                 break;
 275         case IODEV_PARTITION:
 276                 (void) printf("<<partition %s: %s>>\n",
 277                     added ? "added" : "removed", name);
 278                 break;
 279         case IODEV_NFS:
 280                 (void) printf("<<NFS %s: %s>>\n",
 281                     added ? "mounted" : "unmounted", name);
 282                 break;
 283         case IODEV_TAPE:
 284                 (void) printf("<<device %s: %s>>\n",
 285                     added ? "added" : "removed", name);
 286                 break;
 287         case IODEV_CONTROLLER:
 288         case IODEV_DISK:
 289                 *tmp = '\0';
 290                 get_child_list(iodev, tmp);
 291                 (void) printf("<<%s %s: %s", is_disk ? "disk" : "controller",
 292                     added ? "added" : "removed", name);
 293                 if (!*tmp) {
 294                         (void) printf(">>\n");
 295                         return;
 296                 }
 297                 (void) printf(" (%s %s)>>\n", is_disk ? "slices" : "disks",
 298                     tmp);
 299                 break;
 300         };
 301 }
 302
 303 static void
 304 iodev_report(struct iodev_snapshot *d1, struct iodev_snapshot *d2)
 305 {
 306         while (d1 && d2) {
 307                 if (iodev_cmp(d1, d2) < 0) {
 308                         iodev_changed(d1, 0);
 309                         d1 = d1->is_next;
 310                 } else if (iodev_cmp(d1, d2) > 0) {
 311                         iodev_changed(d2, 1);
 312                         d2 = d2->is_next;
 313                 } else {
 314                         iodev_report(d1->is_children, d2->is_children);
 315                         d1 = d1->is_next;
 316                         d2 = d2->is_next;
 317                 }
 318         }
 319
 320         while (d1) {
 321                 iodev_changed(d1, 0);
 322                 d1 = d1->is_next;
 323         }
 324
 325         while (d2) {
 326                 iodev_changed(d2, 1);
 327                 d2 = d2->is_next;
 328         }
 329 }
 330
 331 void
 332 snapshot_report_changes(struct snapshot *old, struct snapshot *new)
 333 {
 334         int pset;
 335
 336         if (old == NULL || new == NULL)
 337                 return;
 338
 339         if (old->s_types != new->s_types)
 340                 return;
 341
 342         pset = old->s_types & SNAP_PSETS;
 343
 344         cpus_removed[0] = '\0';
 345         cpus_added[0] = '\0';
 346
 347         if (old->s_types & SNAP_CPUS)
 348                 (void) snapshot_walk(SNAP_CPUS, old, new, cpu_report, &pset);
 349
 350         if (cpus_added[0]) {
 351                 (void) printf("<<processors added: %s>>\n",
 352                     cpus_added);
 353         }
 354         if (cpus_removed[0]) {
 355                 (void) printf("<<processors removed: %s>>\n",
 356                     cpus_removed);
 357         }
 358         if (pset) {
 359                 (void) snapshot_walk(SNAP_PSETS, old, new,
 360                     pset_report, NULL);
 361         }
 362
 363         iodev_report(old->s_iodevs, new->s_iodevs);
 364 }
 365
 366 /*ARGSUSED*/
 367 static void
 368 dummy_cb(void *v1, void *v2, void *data)
 369 {
 370 }
 371
 372 int
 373 snapshot_has_changed(struct snapshot *old, struct snapshot *new)
 374 {
 375         int ret = 0;
 376         int cpu_mask = SNAP_CPUS | SNAP_PSETS | SNAP_SYSTEM;
 377         int iodev_mask = SNAP_CONTROLLERS | SNAP_IODEVS |
 378                         SNAP_IOPATHS_LI | SNAP_IOPATHS_LTI;
 379
 380         if (old == NULL)
 381                 return (1);
 382
 383         if (new == NULL)
 384                 return (EINVAL);
 385
 386         if (old->s_types != new->s_types)
 387                 return (EINVAL);
 388
 389         if (!ret && (old->s_types & cpu_mask))
 390                 ret = snapshot_walk(SNAP_CPUS, old, new, dummy_cb, NULL);
 391         if (!ret && (old->s_types & SNAP_PSETS))
 392                 ret = snapshot_walk(SNAP_PSETS, old, new, dummy_cb, NULL);
 393         if (!ret && (old->s_types & iodev_mask))
 394                 ret = snapshot_walk(SNAP_IODEVS, old, new, dummy_cb, NULL);
 395
 396         return (ret);
 397 }