Annotation of embedaddon/bmon/src/item.c, revision 1.1
1.1 ! misho 1: /*
! 2: * item.c Item Management
! 3: *
! 4: * Copyright (c) 2001-2004 Thomas Graf <tgraf@suug.ch>
! 5: *
! 6: * Permission is hereby granted, free of charge, to any person obtaining a
! 7: * copy of this software and associated documentation files (the "Software"),
! 8: * to deal in the Software without restriction, including without limitation
! 9: * the rights to use, copy, modify, merge, publish, distribute, sublicense,
! 10: * and/or sell copies of the Software, and to permit persons to whom the
! 11: * Software is furnished to do so, subject to the following conditions:
! 12: *
! 13: * The above copyright notice and this permission notice shall be included
! 14: * in all copies or substantial portions of the Software.
! 15: *
! 16: * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
! 17: * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
! 18: * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
! 19: * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
! 20: * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
! 21: * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
! 22: * DEALINGS IN THE SOFTWARE.
! 23: */
! 24:
! 25: #include <bmon/bmon.h>
! 26: #include <bmon/node.h>
! 27: #include <bmon/conf.h>
! 28: #include <bmon/item.h>
! 29: #include <bmon/itemtab.h>
! 30: #include <bmon/input.h>
! 31: #include <bmon/graph.h>
! 32: #include <bmon/utils.h>
! 33:
! 34: #define MAX_POLICY 255
! 35: #define SECOND 1.0f
! 36: #define MINUTE 60.0f
! 37: #define HOUR 3600.0f
! 38: #define DAY 86400.0f
! 39:
! 40: static char * allowed_items[MAX_POLICY];
! 41: static char * denied_items[MAX_POLICY];
! 42: static char * allowed_attrs[MAX_POLICY];
! 43: static char * denied_attrs[MAX_POLICY];
! 44: static int allow_all_attrs;
! 45:
! 46: static inline uint8_t attr_hash(int type)
! 47: {
! 48: return (type & 0xFF) % ATTR_HASH_MAX;
! 49: }
! 50:
! 51: stat_attr_t *lookup_attr(item_t *it, int type)
! 52: {
! 53: stat_attr_t *a;
! 54: uint8_t h = attr_hash(type);
! 55:
! 56: for (a = it->i_attrs[h]; a; a = a->a_next)
! 57: if (a->a_type == type)
! 58: return a;
! 59: return NULL;
! 60: }
! 61:
! 62: b_cnt_t attr_get_rx(stat_attr_t *a)
! 63: {
! 64: #ifndef DISABLE_OVERFLOW_WORKAROUND
! 65: return (a->a_rx.r_overflows * OVERFLOW_LIMIT) + a->a_rx.r_total;
! 66: #else
! 67: return a->a_rx.r_total;
! 68: #endif
! 69: }
! 70:
! 71: rate_cnt_t attr_get_rx_rate(stat_attr_t *a)
! 72: {
! 73: return a->a_rx.r_tps;
! 74: }
! 75:
! 76: b_cnt_t attr_get_tx(stat_attr_t *a)
! 77: {
! 78: #ifndef DISABLE_OVERFLOW_WORKAROUND
! 79: return (a->a_tx.r_overflows * OVERFLOW_LIMIT) + a->a_tx.r_total;
! 80: #else
! 81: return a->a_tx.r_total;
! 82: #endif
! 83: }
! 84:
! 85: rate_cnt_t attr_get_tx_rate(stat_attr_t *a)
! 86: {
! 87: return a->a_tx.r_tps;
! 88: }
! 89: void foreach_attr(item_t *i, void (*cb)(stat_attr_t *, void *), void *arg)
! 90: {
! 91: int m;
! 92:
! 93: for (m = 0; m < ATTR_HASH_MAX; m++) {
! 94: stat_attr_t *a;
! 95: for (a = i->i_attrs[m]; a; a = a->a_next)
! 96: cb(a, arg);
! 97: }
! 98: }
! 99:
! 100: static struct attr_type attr_types[] = {
! 101: #define IGNORE_OVERFLOWS 1
! 102: #define IS_RATE 2
! 103: #define __A(_I, _N, _D, _U, _F) { .id = _I, .name = _N, .desc = _D, .flags = _F, .unit = _U }
! 104: __A(BYTES, "bytes", "Bytes", U_BYTES, 0),
! 105: __A(PACKETS, "packets", "Packets", U_NUMBER, 0),
! 106: __A(ERRORS, "errors", "Errors", U_NUMBER, 0),
! 107: __A(DROP, "drop", "Dropped", U_NUMBER, 0),
! 108: __A(FIFO, "fifo", "FIFO Err", U_NUMBER, 0),
! 109: __A(FRAME, "frame", "Frame Err", U_NUMBER, 0),
! 110: __A(COMPRESSED, "compressed", "Compressed", U_NUMBER, 0),
! 111: __A(MULTICAST, "multicast", "Multicast", U_NUMBER, 0),
! 112: __A(BROADCAST, "broadcast", "Broadcast", U_NUMBER, 0),
! 113: __A(LENGTH_ERRORS, "len_err", "Length Err", U_NUMBER, 0),
! 114: __A(OVER_ERRORS, "over_err", "Over Err", U_NUMBER, 0),
! 115: __A(CRC_ERRORS, "crc_err", "CRC Err", U_NUMBER, 0),
! 116: __A(MISSED_ERRORS, "miss_err", "Missed Err", U_NUMBER, 0),
! 117: __A(ABORTED_ERRORS, "abort_err", "Aborted Err", U_NUMBER, 0),
! 118: __A(CARRIER_ERRORS, "carrier_err", "Carrier Err", U_NUMBER, 0),
! 119: __A(HEARTBEAT_ERRORS, "hbeat_err", "HBeat Err", U_NUMBER, 0),
! 120: __A(WINDOW_ERRORS, "win_err", "Window Err", U_NUMBER, 0),
! 121: __A(COLLISIONS, "collisions", "Collisions", U_NUMBER, 0),
! 122: __A(OVERLIMITS, "overlimits", "Overlimits", U_NUMBER, 0),
! 123: __A(BPS, "bps", "Bits/s", U_BYTES, IGNORE_OVERFLOWS | IS_RATE),
! 124: __A(PPS, "pps", "Packets/s", U_NUMBER, IGNORE_OVERFLOWS | IS_RATE),
! 125: __A(QLEN, "qlen", "Queue Len", U_NUMBER, IGNORE_OVERFLOWS | IS_RATE),
! 126: __A(BACKLOG, "backlog", "Backlog", U_NUMBER, IGNORE_OVERFLOWS | IS_RATE),
! 127: __A(REQUEUES, "requeues", "Requeues", U_NUMBER, 0)
! 128: #undef __A
! 129: };
! 130:
! 131: int foreach_attr_type(int (*cb)(struct attr_type *, void *), void *arg)
! 132: {
! 133: int i, ret;
! 134:
! 135: for (i = 0; i < sizeof(attr_types)/sizeof(attr_types[0]); i++) {
! 136: ret = cb(&attr_types[i], arg);
! 137: if (ret < 0)
! 138: return ret;
! 139: }
! 140:
! 141: return 0;
! 142: }
! 143:
! 144: const char * type2name(int type)
! 145: {
! 146: int i;
! 147:
! 148: for (i = 0; i < sizeof(attr_types)/sizeof(attr_types[0]); i++)
! 149: if (attr_types[i].id == type)
! 150: return attr_types[i].name;
! 151:
! 152: return NULL;
! 153: }
! 154:
! 155: int name2type(const char *name)
! 156: {
! 157: int i;
! 158:
! 159: for (i = 0; i < sizeof(attr_types)/sizeof(attr_types[0]); i++)
! 160: if (!strcasecmp(attr_types[i].name, name))
! 161: return attr_types[i].id;
! 162:
! 163: return INT_MAX;
! 164: }
! 165:
! 166: const char * type2desc(int type)
! 167: {
! 168: int i;
! 169: static char str[256];
! 170:
! 171: for (i = 0; i < sizeof(attr_types)/sizeof(attr_types[0]); i++)
! 172: if (attr_types[i].id == type)
! 173: return attr_types[i].desc;
! 174:
! 175: snprintf(str, sizeof(str), "unknown (%d)", type);
! 176: return str;
! 177: }
! 178:
! 179: int attr_ignore_overflows(int type)
! 180: {
! 181: int i;
! 182:
! 183: for (i = 0; i < sizeof(attr_types)/sizeof(attr_types[0]); i++)
! 184: if (attr_types[i].id == type &&
! 185: attr_types[i].flags & IGNORE_OVERFLOWS)
! 186: return 1;
! 187:
! 188: return 0;
! 189: }
! 190:
! 191: int attr_is_rate(int type)
! 192: {
! 193: int i;
! 194:
! 195: for (i = 0; i < sizeof(attr_types)/sizeof(attr_types[0]); i++)
! 196: if (attr_types[i].id == type &&
! 197: attr_types[i].flags & IS_RATE)
! 198: return 1;
! 199:
! 200: return 0;
! 201: }
! 202:
! 203: int attr_unit(int type)
! 204: {
! 205: int i;
! 206:
! 207: for (i = 0; i < sizeof(attr_types)/sizeof(attr_types[0]); i++)
! 208: if (attr_types[i].id == type)
! 209: return attr_types[i].unit;
! 210:
! 211: return 0;
! 212: }
! 213:
! 214: static int match_mask(const char *mask, const char *str)
! 215: {
! 216: int i, n;
! 217: char c;
! 218:
! 219: if (!mask || !str)
! 220: return 0;
! 221:
! 222: for (i = 0, n = 0; mask[i] != '\0'; i++, n++) {
! 223: if (mask[i] == '*') {
! 224: c = tolower(mask[i+1]);
! 225:
! 226: if (c == '\0')
! 227: return 1; /* nothing after wildcard, matches in any case */
! 228:
! 229: /*look for c in str, c is the character after the wildcard */
! 230: for (; tolower(str[n]) != c; n++)
! 231: if (str[n] == '\0')
! 232: return 0; /* character after wildcard was not found */
! 233:
! 234: n--;
! 235: } else if (tolower(mask[i]) != tolower(str[n]))
! 236: return 0;
! 237: }
! 238:
! 239: return str[n] == '\0' ? 1 : 0;
! 240: }
! 241:
! 242: static int item_allowed(const char *name)
! 243: {
! 244: int n;
! 245:
! 246: if (!allowed_items[0] && !denied_items[0])
! 247: return 1;
! 248:
! 249: if (!allowed_items[0]) {
! 250: for (n = 0; n < MAX_POLICY && denied_items[n]; n++)
! 251: if (match_mask(denied_items[n], name))
! 252: return 0;
! 253:
! 254: return 1;
! 255: }
! 256:
! 257: for (n = 0; n < MAX_POLICY && denied_items[n]; n++)
! 258: if (match_mask(denied_items[n], name))
! 259: return 0;
! 260:
! 261: for (n=0; n < MAX_POLICY && allowed_items[n]; n++)
! 262: if (match_mask(allowed_items[n], name))
! 263: return 1;
! 264:
! 265: return 0;
! 266: }
! 267:
! 268: void item_parse_policy(const char *policy)
! 269: {
! 270: static int set = 0;
! 271: int i, a = 0, d = 0, f = 0;
! 272: char *p, *s;
! 273:
! 274: if (set)
! 275: return;
! 276: set = 1;
! 277:
! 278: s = strdup(policy);
! 279:
! 280: for (i = 0, p = s; ; i++) {
! 281: if (s[i] == ',' || s[i] == '\0') {
! 282:
! 283: f = s[i] == '\0' ? 1 : 0;
! 284: s[i] = '\0';
! 285:
! 286: if ('!' == *p) {
! 287: if (d > (MAX_POLICY - 1))
! 288: break;
! 289: denied_items[d++] = strdup(++p);
! 290: } else {
! 291: if(a > (MAX_POLICY - 1))
! 292: break;
! 293: allowed_items[a++] = strdup(p);
! 294: }
! 295:
! 296: if (f)
! 297: break;
! 298:
! 299: p = &s[i+1];
! 300: }
! 301: }
! 302:
! 303: xfree(s);
! 304: }
! 305:
! 306: static inline int collect_history(int type)
! 307: {
! 308: int n;
! 309: const char *name = type2name(type);
! 310:
! 311: if (allow_all_attrs)
! 312: return 1;
! 313:
! 314: if (!allowed_attrs[0] && !denied_attrs[0]) {
! 315: if (!strcmp(name, "bytes") || !strcmp(name, "packets"))
! 316: return 1;
! 317: else
! 318: return 0;
! 319: }
! 320:
! 321: if (!allowed_attrs[0]) {
! 322: for (n = 0; n < MAX_POLICY && denied_attrs[n]; n++)
! 323: if (!strcasecmp(denied_attrs[n], name))
! 324: return 0;
! 325: return 1;
! 326: }
! 327:
! 328: for (n = 0; n < MAX_POLICY && denied_attrs[n]; n++)
! 329: if (!strcasecmp(denied_attrs[n], name))
! 330: return 0;
! 331:
! 332: for (n=0; n < MAX_POLICY && allowed_attrs[n]; n++)
! 333: if (!strcasecmp(allowed_attrs[n], name))
! 334: return 1;
! 335:
! 336: return 0;
! 337: }
! 338:
! 339: void parse_attr_policy(const char *policy)
! 340: {
! 341: static int set = 0;
! 342: int i, a = 0, d = 0, f = 0;
! 343: char *p, *s;
! 344:
! 345: if (set)
! 346: return;
! 347: set = 1;
! 348:
! 349: if (!strcasecmp(policy, "all")) {
! 350: allow_all_attrs = 1;
! 351: return ;
! 352: }
! 353:
! 354: s = strdup(policy);
! 355:
! 356: for (i = 0, p = s; ; i++) {
! 357: if (s[i] == ',' || s[i] == '\0') {
! 358:
! 359: f = s[i] == '\0' ? 1 : 0;
! 360: s[i] = '\0';
! 361:
! 362: if ('!' == *p) {
! 363: if (d > (MAX_POLICY - 1))
! 364: break;
! 365: denied_attrs[d++] = strdup(++p);
! 366: } else {
! 367: if(a > (MAX_POLICY - 1))
! 368: break;
! 369: allowed_attrs[a++] = strdup(p);
! 370: }
! 371:
! 372: if (f)
! 373: break;
! 374:
! 375: p = &s[i+1];
! 376: }
! 377: }
! 378:
! 379: xfree(s);
! 380: }
! 381:
! 382: item_t * lookup_item(node_t *node, const char *name, uint32_t handle,
! 383: item_t *parent)
! 384: {
! 385: int i;
! 386:
! 387: if (NULL == node)
! 388: BUG();
! 389:
! 390: if (NULL == node->n_items) {
! 391: node->n_nitems = 32;
! 392: node->n_items = xcalloc(node->n_nitems, sizeof(item_t));
! 393: }
! 394:
! 395: for (i = 0; i < node->n_nitems; i++)
! 396: if (!strcmp(name, node->n_items[i].i_name) &&
! 397: node->n_items[i].i_handle == handle &&
! 398: node->n_items[i].i_parent == (parent ? parent->i_index : 0))
! 399: return !(node->n_items[i].i_flags & ITEM_FLAG_UPDATED) ?
! 400: &node->n_items[i] : NULL;
! 401:
! 402: if (!handle && !item_allowed(name))
! 403: return NULL;
! 404:
! 405: for (i = 0; i < node->n_nitems; i++)
! 406: if (node->n_items[i].i_name[0] == '\0')
! 407: break;
! 408:
! 409: if (i >= node->n_nitems) {
! 410: int oldsize = node->n_nitems;
! 411: node->n_nitems += 32;
! 412: node->n_items = xrealloc(node->n_items, node->n_nitems * sizeof(item_t));
! 413: memset(node->n_items + oldsize, 0, (node->n_nitems - oldsize) * sizeof(item_t));
! 414: }
! 415:
! 416: memset(&node->n_items[i], 0, sizeof(node->n_items[i]));
! 417: strncpy(node->n_items[i].i_name, name, sizeof(node->n_items[i].i_name) - 1);
! 418: node->n_items[i].i_handle = handle;
! 419: node->n_items[i].i_parent = parent ? parent->i_index : 0;
! 420: node->n_items[i].i_index = i;
! 421: node->n_items[i].i_node = node;
! 422: node->n_items[i].i_lifetime = get_lifetime();
! 423:
! 424: if (!node->n_from)
! 425: node->n_items[i].i_flags |= ITEM_FLAG_LOCAL;
! 426:
! 427: {
! 428: struct it_item *tab = lookup_tab(&node->n_items[i]);
! 429:
! 430: if (tab && tab->ii_desc)
! 431: node->n_items[i].i_desc = tab->ii_desc;
! 432: }
! 433:
! 434: if (parent)
! 435: parent->i_flags |= ITEM_FLAG_HAS_CHILDS;
! 436:
! 437: return &node->n_items[i];
! 438: }
! 439:
! 440: void foreach_child(node_t *node, item_t *parent, void (*cb)(item_t *, void *),
! 441: void *arg)
! 442: {
! 443: int i;
! 444:
! 445: for (i = 0; i < node->n_nitems; i++)
! 446: if (node->n_items[i].i_parent == parent->i_index &&
! 447: node->n_items[i].i_flags & ITEM_FLAG_IS_CHILD)
! 448: cb(&node->n_items[i], arg);
! 449: }
! 450:
! 451: void reset_item(item_t *i)
! 452: {
! 453: i->i_flags &= ~ITEM_FLAG_UPDATED;
! 454: }
! 455:
! 456: void remove_unused_items(item_t *i)
! 457: {
! 458: if (--(i->i_lifetime) <= 0) {
! 459: int m;
! 460: for (m = 0; m < ATTR_HASH_MAX; m++) {
! 461: stat_attr_t *a, *next;
! 462: for (a = i->i_attrs[m]; a; a = next) {
! 463: next = a->a_next;
! 464: free(a);
! 465: }
! 466: }
! 467: if (!(i->i_flags & ITEM_FLAG_LOCAL)) {
! 468: if (i->i_desc)
! 469: free(i->i_desc);
! 470: }
! 471: memset(i, 0, sizeof(item_t));
! 472: }
! 473: }
! 474:
! 475: static void calc_rate(rate_t *rate, timestamp_t *ts, int ignore_overflows)
! 476: {
! 477: float diff;
! 478:
! 479: if (!rate->r_prev_total) {
! 480: rate->r_prev_total = rate->r_total;
! 481: COPY_TS(&rate->r_last_update, ts);
! 482: return;
! 483: }
! 484:
! 485: diff = time_diff(&rate->r_last_update, ts);
! 486:
! 487: if (diff >= get_rate_interval()) {
! 488: if (rate->r_total) {
! 489: rate_cnt_t old_rate;
! 490:
! 491: b_cnt_t t = (rate->r_total - rate->r_prev_total);
! 492: old_rate = rate->r_tps;
! 493:
! 494: #ifndef DISABLE_OVERFLOW_WORKAROUND
! 495: /* HACK:
! 496: *
! 497: * Workaround for counter overflow, all input methods
! 498: * except kstat in 64bit mode use a 32bit counter which
! 499: * tends to overflow. We can work around the problem
! 500: * when assuming that there will be no scenario with
! 501: * 4GiB/s and no more than 1 overflow per second.
! 502: */
! 503: if (t >= OVERFLOW_LIMIT &&
! 504: !rate->r_is64bit &&
! 505: !ignore_overflows) {
! 506: rate->r_tps = OVERFLOW_LIMIT -
! 507: (rate->r_prev_total - rate->r_total);
! 508: rate->r_overflows++;
! 509: } else
! 510: #endif
! 511: rate->r_tps = (rate_cnt_t) t;
! 512:
! 513: rate->r_tps /= diff;
! 514: rate->r_tps = ((rate->r_tps * 3) + old_rate) / 4;
! 515: rate->r_prev_total = rate->r_total;
! 516: }
! 517:
! 518: COPY_TS(&rate->r_last_update, ts);
! 519: }
! 520: }
! 521:
! 522: static inline b_cnt_t get_real_total(rate_t *r, unsigned int prev_overflows,
! 523: b_cnt_t prev_total)
! 524: {
! 525: b_cnt_t res;
! 526: unsigned int new_overflows = (r->r_overflows - prev_overflows);
! 527:
! 528: #ifndef DISABLE_OVERFLOW_WORKAROUND
! 529: if (new_overflows)
! 530: res = (new_overflows * OVERFLOW_LIMIT) + r->r_total - prev_total;
! 531: else
! 532: #endif
! 533: res = r->r_total - prev_total;
! 534:
! 535: return res;
! 536: }
! 537:
! 538: static inline void update_history_data(hist_data_t *hd, rate_t *r,
! 539: int index, double diff)
! 540: {
! 541: double t;
! 542:
! 543: t = (double) get_real_total(r, hd->hd_overflows,
! 544: hd->hd_prev_total) / diff;
! 545: hd->hd_data[index] = (rate_cnt_t) t;
! 546: hd->hd_prev_total = r->r_total;
! 547: hd->hd_overflows = r->r_overflows;
! 548: }
! 549:
! 550: static void update_history_element(hist_elem_t *he, rate_t *rx, rate_t *tx,
! 551: timestamp_t *ts, float unit)
! 552: {
! 553: double diff = time_diff(&he->he_last_update, ts);
! 554:
! 555: if (!he->he_last_update.tv_sec)
! 556: diff = 0.0f;
! 557:
! 558: /* Do not updated histor for graphs with intervals
! 559: * less than the reading interval. */
! 560: if (get_read_interval() > unit)
! 561: goto discard;
! 562:
! 563: /* Discard outdated updates */
! 564: if (diff >= (unit + (get_hb_factor() * unit)))
! 565: goto discard;
! 566:
! 567: if (!he->he_last_update.tv_sec) {
! 568: he->he_rx.hd_prev_total = rx->r_total;
! 569: he->he_tx.hd_prev_total = tx->r_total;
! 570: } else if (get_read_interval() == unit) {
! 571: update_history_data(&he->he_rx, rx, he->he_index, 1.0f);
! 572: update_history_data(&he->he_tx, tx, he->he_index, 1.0f);
! 573: /* The timing code might do shorter intervals than requested to
! 574: * adjust previous intervals being too long */
! 575: } else if (diff >= ((1.0f - get_hb_factor()) * unit)) {
! 576: update_history_data(&he->he_rx, rx, he->he_index, diff);
! 577: update_history_data(&he->he_tx, tx, he->he_index, diff);
! 578: } else {
! 579: /* Silently discard and give it a chance to come back
! 580: * in time. */
! 581: return;
! 582: }
! 583:
! 584: if (he->he_index >= (HISTORY_SIZE - 1))
! 585: he->he_index = 0;
! 586: else
! 587: he->he_index++;
! 588:
! 589: COPY_TS(&he->he_last_update, ts);
! 590:
! 591: return;
! 592: discard:
! 593: while(diff > 0.0f) {
! 594: he->he_rx.hd_data[he->he_index] = UNK_DATA;
! 595: he->he_tx.hd_data[he->he_index] = UNK_DATA;
! 596:
! 597: if (he->he_index >= (HISTORY_SIZE - 1))
! 598: he->he_index = 0;
! 599: else
! 600: he->he_index++;
! 601:
! 602: diff -= unit;
! 603: }
! 604:
! 605: he->he_rx.hd_prev_total = rx->r_total;
! 606: he->he_tx.hd_prev_total = tx->r_total;
! 607:
! 608: he->he_rx.hd_overflows = rx->r_overflows;
! 609: he->he_tx.hd_overflows = tx->r_overflows;
! 610: COPY_TS(&he->he_last_update, ts);
! 611:
! 612: }
! 613:
! 614: static inline void update_history(history_t *hist, rate_t *rx, rate_t *tx,
! 615: timestamp_t *ts)
! 616: {
! 617: if (get_read_interval() != 1.0f)
! 618: update_history_element(&hist->h_read, rx, tx, ts,
! 619: get_read_interval());
! 620: update_history_element(&hist->h_sec, rx, tx, ts, SECOND);
! 621: update_history_element(&hist->h_min, rx, tx, ts, MINUTE);
! 622: update_history_element(&hist->h_hour, rx, tx, ts, HOUR);
! 623: update_history_element(&hist->h_day, rx, tx, ts, DAY);
! 624: }
! 625:
! 626: static void update_attr_hist(stat_attr_t *a, void *arg)
! 627: {
! 628: timestamp_t *ts = (timestamp_t *) arg;
! 629: int ign_of = a->a_flags & ATTR_FLAG_IGNORE_OVERFLOWS;
! 630:
! 631: if (ts == NULL)
! 632: ts = &rtiming.rt_last_read;
! 633:
! 634: if (a->a_flags & ATTR_FLAG_IS_RATE) {
! 635: a->a_rx.r_tps = a->a_rx.r_total;
! 636: a->a_tx.r_tps = a->a_tx.r_total;
! 637: } else {
! 638: calc_rate(&a->a_rx, ts, ign_of);
! 639: calc_rate(&a->a_tx, ts, ign_of);
! 640: }
! 641:
! 642: if (a->a_flags & ATTR_FLAG_HISTORY) {
! 643: stat_attr_hist_t *ah = (stat_attr_hist_t *) a;
! 644: update_history(&ah->a_hist, &ah->a_rx, &ah->a_tx, ts);
! 645: }
! 646: }
! 647:
! 648: void notify_update(item_t *i, timestamp_t *ts)
! 649: {
! 650: struct it_item *tab;
! 651: stat_attr_t *a;
! 652:
! 653: i->i_flags |= ITEM_FLAG_UPDATED;
! 654: foreach_attr(i, &update_attr_hist, ts);
! 655:
! 656: a = lookup_attr(i, i->i_major_attr);
! 657: tab = lookup_tab(i);
! 658:
! 659: if (tab && a) {
! 660: rate_cnt_t rx = attr_get_rx_rate(a);
! 661: rate_cnt_t tx = attr_get_tx_rate(a);
! 662:
! 663: if (tab->ii_rx_max) {
! 664: if (rx)
! 665: i->i_rx_usage = (100.0f / (tab->ii_rx_max / rx));
! 666: else
! 667: i->i_rx_usage = 0;
! 668: } else
! 669: i->i_rx_usage = -1;
! 670:
! 671: if (tab->ii_tx_max) {
! 672: if (tx)
! 673: i->i_tx_usage = (100.0f / (tab->ii_tx_max / tx));
! 674: else
! 675: i->i_tx_usage = 0;
! 676: } else
! 677: i->i_tx_usage = -1;
! 678: } else if (!i->i_node || !i->i_node->n_from) {
! 679: i->i_rx_usage = -1;
! 680: i->i_tx_usage = -1;
! 681: }
! 682: }
! 683:
! 684: void increase_lifetime(item_t *i, int l)
! 685: {
! 686: i->i_lifetime = l*get_lifetime();
! 687: }
! 688:
! 689: void update_attr(item_t *i, int type, b_cnt_t rx, b_cnt_t tx, int flags)
! 690: {
! 691: stat_attr_t *a;
! 692: uint8_t h = attr_hash(type);
! 693:
! 694: for (a = i->i_attrs[h]; a; a = a->a_next)
! 695: if (a->a_type == type)
! 696: goto found;
! 697:
! 698: if (collect_history(type)) {
! 699: a = xcalloc(1, sizeof(stat_attr_hist_t));
! 700: a->a_flags |= ATTR_FLAG_HISTORY;
! 701: } else
! 702: a = xcalloc(1, sizeof(stat_attr_t));
! 703:
! 704: a->a_type = type;
! 705: a->a_unit = attr_unit(a->a_type);
! 706: if (attr_ignore_overflows(a->a_type))
! 707: a->a_flags |= ATTR_FLAG_IGNORE_OVERFLOWS;
! 708: if (attr_is_rate(a->a_type))
! 709: a->a_flags |= ATTR_FLAG_IS_RATE;
! 710:
! 711: a->a_next = i->i_attrs[h];
! 712: i->i_attrs[h] = a;
! 713: i->i_nattrs++;
! 714:
! 715: found:
! 716: if (flags & IS64BIT)
! 717: a->a_rx.r_is64bit = a->a_tx.r_is64bit = 1;
! 718:
! 719: if (flags & RX_PROVIDED) {
! 720: a->a_rx.r_total = rx;
! 721: a->a_flags |= ATTR_FLAG_RX_ENABLED;
! 722: update_ts(&a->a_updated); /* XXX: use read ts */
! 723: }
! 724:
! 725: if (flags & TX_PROVIDED) {
! 726: a->a_tx.r_total = tx;
! 727: a->a_flags |= ATTR_FLAG_TX_ENABLED;
! 728: update_ts(&a->a_updated);
! 729: }
! 730: }
! 731:
! 732:
! 733: item_t * get_item(node_t *node, int index)
! 734: {
! 735: int i;
! 736:
! 737: for (i = 0; i < node->n_nitems; i++)
! 738: if (node->n_items[i].i_index == index)
! 739: return &node->n_items[i];
! 740: return NULL;
! 741: }
! 742:
! 743: stat_attr_t *current_attr(int graph)
! 744: {
! 745: int i, c;
! 746: item_t *it = get_current_item();
! 747: stat_attr_t *a;
! 748:
! 749: if (it == NULL)
! 750: return NULL;
! 751:
! 752: for (i = 0, c = 0; i < ATTR_HASH_MAX; i++)
! 753: for (a = it->i_attrs[i]; a; a = a->a_next, c++)
! 754: if (c == it->i_attr_sel[graph])
! 755: return a;
! 756:
! 757: return NULL;
! 758: }
! 759:
! 760: int first_attr(void)
! 761: {
! 762: int i, c;
! 763: stat_attr_t *a;
! 764: item_t *it = get_current_item();
! 765: if (it == NULL)
! 766: return EMPTY_LIST;
! 767:
! 768: for (i = 0, c = 0; i < ATTR_HASH_MAX; i++) {
! 769: for (a = it->i_attrs[i]; a; a = a->a_next) {
! 770: if (a->a_flags & ATTR_FLAG_HISTORY) {
! 771: it->i_attr_sel[it->i_graph_sel] = c;
! 772: return 0;
! 773: } else
! 774: c++;
! 775: }
! 776: }
! 777:
! 778: return EMPTY_LIST;
! 779: }
! 780:
! 781: int next_attr(void)
! 782: {
! 783: item_t *it = get_current_item();
! 784: if (it == NULL)
! 785: return EMPTY_LIST;
! 786:
! 787: if (it->i_attr_sel[it->i_graph_sel] >= (it->i_nattrs - 1))
! 788: return first_attr();
! 789: else {
! 790: stat_attr_t *a = current_attr(it->i_graph_sel);
! 791: int i, n = it->i_attr_sel[it->i_graph_sel] + 1;
! 792:
! 793: if (a) {
! 794: stat_attr_t *b = a->a_next;
! 795: i = attr_hash(a->a_type);
! 796: if (!b)
! 797: i++;
! 798: for (; i < ATTR_HASH_MAX; i++) {
! 799: for (a = b ? : it->i_attrs[i]; a; a = a->a_next) {
! 800: if (!(a->a_flags & ATTR_FLAG_HISTORY)) {
! 801: n++;
! 802: continue;
! 803: }
! 804: b = NULL;
! 805: it->i_attr_sel[it->i_graph_sel] = n;
! 806: return 0;
! 807: }
! 808: }
! 809: }
! 810:
! 811: return first_attr();
! 812: }
! 813:
! 814: return 0;
! 815: }
! 816:
! 817:
! 818: int set_graph_unit(int unit)
! 819: {
! 820: item_t *it = get_current_item();
! 821: if (it == NULL)
! 822: return EMPTY_LIST;
! 823:
! 824: it->i_unit[it->i_graph_sel] = unit;
! 825:
! 826: return 0;
! 827: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to item.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / bmon / src