stat/common/walkers.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident   "%Z%%M% %I% %E% SMI"

#include "statcommon.h"

#include <string.h>
#include <errno.h>

/* max size of report change annotations */
#define LIST_SIZE 512

static char cpus_added[LIST_SIZE];
static char cpus_removed[LIST_SIZE];

static int
cpu_walk(struct snapshot *old, struct snapshot *new,
    snapshot_cb cb, void *data)
{
    int changed = 0;
    int i;

    /* CPUs can change state but not re-order */
    for (i = 0; i < new->s_nr_cpus; i++) {
        struct cpu_snapshot *cpu = NULL;
        struct cpu_snapshot *newcpu = &new->s_cpus[i];
        if (old)
            cpu = &old->s_cpus[i];
        cb(cpu, newcpu, data);
        if (cpu == NULL)
            changed = 1;
        else {
            /*
             * We only care about off/on line transitions
             */
            if ((CPU_ACTIVE(cpu) && !CPU_ACTIVE(newcpu)) ||
                (!CPU_ACTIVE(cpu) && CPU_ACTIVE(newcpu)))
                changed = 1;
            if ((new->s_types & SNAP_PSETS) &&
                cpu->cs_pset_id != newcpu->cs_pset_id)
                changed = 1;
        }

    }

    return (changed);
}

static int
pset_walk(struct snapshot *old, struct snapshot *new,
    snapshot_cb cb, void *data)
{
    int i = 0;
    int j = 0;
    int changed = 0;

    while (old && i < old->s_nr_psets && j < new->s_nr_psets) {
        if (old->s_psets[i].ps_id < new->s_psets[j].ps_id) {
            cb(&old->s_psets[i], NULL, data);
            i++;
            changed = 1;
        } else if (old->s_psets[i].ps_id > new->s_psets[j].ps_id) {
            cb(NULL, &new->s_psets[j], data);
            j++;
            changed = 1;
        } else {
            cb(&old->s_psets[i], &new->s_psets[j], data);
            i++;
            j++;
        }
    }

    while (old && i < old->s_nr_psets) {
        cb(&old->s_psets[i], NULL, data);
        i++;
        changed = 1;
    }

    while (j < new->s_nr_psets) {
        cb(NULL, &new->s_psets[j], data);
        j++;
        changed = 1;
    }

    return (changed);
}

static int
iodev_walk(struct iodev_snapshot *d1, struct iodev_snapshot *d2,
    snapshot_cb cb, void *data)
{
    int changed = 0;

    while (d1 && d2) {
        if (strcmp(d1->is_name, d2->is_name) < 0) {
            changed = 1;
            cb(d1, NULL, data);
            (void) iodev_walk(d1->is_children, NULL, cb, data);
            d1 = d1->is_next;
        } else if (strcmp(d1->is_name, d2->is_name) > 0) {
            changed = 1;
            cb(NULL, d2, data);
            (void) iodev_walk(NULL, d2->is_children, cb, data);
            d2 = d2->is_next;
        } else {
            cb(d1, d2, data);
            changed |= iodev_walk(d1->is_children,
                    d2->is_children, cb, data);
            d1 = d1->is_next;
            d2 = d2->is_next;
        }
    }

    while (d1) {
        changed = 1;
        cb(d1, NULL, data);
        (void) iodev_walk(d1->is_children, NULL, cb, data);
        d1 = d1->is_next;
    }

    while (d2) {
        changed = 1;
        cb(NULL, d2, data);
        (void) iodev_walk(NULL, d2->is_children, cb, data);
        d2 = d2->is_next;
    }

    return (changed);
}

int
snapshot_walk(enum snapshot_types type, struct snapshot *old,
    struct snapshot *new, snapshot_cb cb, void *data)
{
    int changed = 0;

    switch (type) {
    case SNAP_CPUS:
        changed = cpu_walk(old, new, cb, data);
        break;

    case SNAP_PSETS:
        changed = pset_walk(old, new, cb, data);
        break;

    case SNAP_CONTROLLERS:
    case SNAP_IODEVS:
    case SNAP_IOPATHS_LI:
    case SNAP_IOPATHS_LTI:
        changed = iodev_walk(old ? old->s_iodevs : NULL,
            new->s_iodevs, cb, data);
        break;

    default:
        break;
    }

    return (changed);
}

static void
add_nr_to_list(char *buf, unsigned long nr)
{
    char tmp[LIST_SIZE];

    (void) snprintf(tmp, LIST_SIZE, "%lu", nr);

    if (strlen(buf))
        (void) strlcat(buf, ", ", LIST_SIZE);

    (void) strlcat(buf, tmp, LIST_SIZE);
}

static void
cpu_report(void *v1, void *v2, void *data)
{
    int *pset = (int *)data;
    struct cpu_snapshot *c1 = (struct cpu_snapshot *)v1;
    struct cpu_snapshot *c2 = (struct cpu_snapshot *)v2;

    if (*pset && c1->cs_pset_id != c2->cs_pset_id) {
        (void) printf("<<processor %d moved from pset: %d to: %d>>\n",
            c1->cs_id, c1->cs_pset_id, c2->cs_pset_id);
    }

    if (c1->cs_state == c2->cs_state)
        return;

    if (CPU_ONLINE(c1->cs_state) && !CPU_ONLINE(c2->cs_state))
        add_nr_to_list(cpus_removed, c1->cs_id);

    if (!CPU_ONLINE(c1->cs_state) && CPU_ONLINE(c2->cs_state))
        add_nr_to_list(cpus_added, c2->cs_id);
}

/*ARGSUSED*/
static void
pset_report(void *v1, void *v2, void *data)
{
    struct pset_snapshot *p1 = (struct pset_snapshot *)v1;
    struct pset_snapshot *p2 = (struct pset_snapshot *)v2;

    if (p2 == NULL) {
        (void) printf("<<pset destroyed: %u>>\n", p1->ps_id);
        return;
    }

    if (p1 == NULL)
        (void) printf("<<pset created: %u>>\n", p2->ps_id);
}

static void
get_child_list(struct iodev_snapshot *iodev, char *buf)
{
    char tmp[LIST_SIZE];
    struct iodev_snapshot *pos = iodev->is_children;

    while (pos) {
        if (pos->is_type == IODEV_PARTITION) {
            add_nr_to_list(buf, pos->is_id.id);
        } else if (pos->is_type == IODEV_DISK) {
            if (strlen(buf))
                (void) strlcat(buf, ", ", LIST_SIZE);
            (void) strlcat(buf, "t", LIST_SIZE);
            (void) strlcat(buf, pos->is_id.tid, LIST_SIZE);
            (void) strlcat(buf, "d", LIST_SIZE);
            *tmp = '\0';
            add_nr_to_list(tmp, pos->is_id.id);
            (void) strlcat(buf, tmp, LIST_SIZE);
        }
        pos = pos->is_next;
    }
}

static void
iodev_changed(struct iodev_snapshot *iodev, int added)
{
    char tmp[LIST_SIZE];
    int is_disk = iodev->is_type == IODEV_DISK;
    char *name = iodev->is_name;

    if (iodev->is_pretty)
        name = iodev->is_pretty;

    switch (iodev->is_type) {
    case IODEV_IOPATH_LT:
    case IODEV_IOPATH_LI:
    case IODEV_IOPATH_LTI:
        (void) printf("<<multi-path %s: %s>>\n",
            added ? "added" : "removed", name);
        break;
    case IODEV_PARTITION:
        (void) printf("<<partition %s: %s>>\n",
            added ? "added" : "removed", name);
        break;
    case IODEV_NFS:
        (void) printf("<<NFS %s: %s>>\n",
            added ? "mounted" : "unmounted", name);
        break;
    case IODEV_TAPE:
        (void) printf("<<device %s: %s>>\n",
            added ? "added" : "removed", name);
        break;
    case IODEV_CONTROLLER:
    case IODEV_DISK:
        *tmp = '\0';
        get_child_list(iodev, tmp);
        (void) printf("<<%s %s: %s", is_disk ? "disk" : "controller",
            added ? "added" : "removed", name);
        if (!*tmp) {
            (void) printf(">>\n");
            return;
        }
        (void) printf(" (%s %s)>>\n", is_disk ? "slices" : "disks",
            tmp);
        break;
    };
}

static void
iodev_report(struct iodev_snapshot *d1, struct iodev_snapshot *d2)
{
    while (d1 && d2) {
        if (iodev_cmp(d1, d2) < 0) {
            iodev_changed(d1, 0);
            d1 = d1->is_next;
        } else if (iodev_cmp(d1, d2) > 0) {
            iodev_changed(d2, 1);
            d2 = d2->is_next;
        } else {
            iodev_report(d1->is_children, d2->is_children);
            d1 = d1->is_next;
            d2 = d2->is_next;
        }
    }

    while (d1) {
        iodev_changed(d1, 0);
        d1 = d1->is_next;
    }

    while (d2) {
        iodev_changed(d2, 1);
        d2 = d2->is_next;
    }
}

void
snapshot_report_changes(struct snapshot *old, struct snapshot *new)
{
    int pset;

    if (old == NULL || new == NULL)
        return;

    if (old->s_types != new->s_types)
        return;

    pset = old->s_types & SNAP_PSETS;

    cpus_removed[0] = '\0';
    cpus_added[0] = '\0';

    if (old->s_types & SNAP_CPUS)
        (void) snapshot_walk(SNAP_CPUS, old, new, cpu_report, &pset);

    if (cpus_added[0]) {
        (void) printf("<<processors added: %s>>\n",
            cpus_added);
    }
    if (cpus_removed[0]) {
        (void) printf("<<processors removed: %s>>\n",
            cpus_removed);
    }
    if (pset) {
        (void) snapshot_walk(SNAP_PSETS, old, new,
            pset_report, NULL);
    }

    iodev_report(old->s_iodevs, new->s_iodevs);
}

/*ARGSUSED*/
static void
dummy_cb(void *v1, void *v2, void *data)
{
}

int
snapshot_has_changed(struct snapshot *old, struct snapshot *new)
{
    int ret = 0;
    int cpu_mask = SNAP_CPUS | SNAP_PSETS | SNAP_SYSTEM;
    int iodev_mask = SNAP_CONTROLLERS | SNAP_IODEVS |
            SNAP_IOPATHS_LI | SNAP_IOPATHS_LTI;

    if (old == NULL)
        return (1);

    if (new == NULL)
        return (EINVAL);

    if (old->s_types != new->s_types)
        return (EINVAL);

    if (!ret && (old->s_types & cpu_mask))
        ret = snapshot_walk(SNAP_CPUS, old, new, dummy_cb, NULL);
    if (!ret && (old->s_types & SNAP_PSETS))
        ret = snapshot_walk(SNAP_PSETS, old, new, dummy_cb, NULL);
    if (!ret && (old->s_types & iodev_mask))
        ret = snapshot_walk(SNAP_IODEVS, old, new, dummy_cb, NULL);

    return (ret);
}