Annotation of embedaddon/bmon/src/in_netlink.c, revision 1.1
1.1 ! misho 1: /*
! 2: * in_netlink.c rtnetlink input (Linux)
! 3: *
! 4: * Copyright (c) 2001-2005 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/input.h>
! 27: #include <bmon/node.h>
! 28: #include <bmon/item.h>
! 29: #include <bmon/conf.h>
! 30: #include <bmon/utils.h>
! 31:
! 32: #if defined HAVE_NL && defined SYS_LINUX
! 33:
! 34: static int c_notc = 0;
! 35: static const char *c_mapfile;
! 36:
! 37: struct hmap {
! 38: char *id;
! 39: char *name;
! 40: struct hmap *next;
! 41: };
! 42:
! 43: static struct hmap *map;
! 44:
! 45: #include <netlink/netlink.h>
! 46: #include <netlink/cache.h>
! 47: #include <netlink/helpers.h>
! 48: #include <netlink/route/link.h>
! 49: #include <netlink/route/qdisc.h>
! 50: #include <netlink/route/class.h>
! 51: #include <netlink/route/filter.h>
! 52:
! 53: #include <net/if.h>
! 54:
! 55: static struct nl_handle nl_h = NL_INIT_HANDLE();
! 56: static struct nl_cache link_cache = RTNL_INIT_LINK_CACHE();
! 57: static struct nl_cache *qdisc_cache;
! 58: static struct nl_cache *class_cache;
! 59:
! 60: struct xdata {
! 61: item_t *intf;
! 62: struct rtnl_link *link;
! 63: int level;
! 64: item_t *parent;
! 65: };
! 66:
! 67: static void read_map(const char *file)
! 68: {
! 69: FILE *f;
! 70: char buf[1024];
! 71: int line = 0;
! 72:
! 73: f = fopen(file, "r");
! 74: if (f == NULL)
! 75: quit("Could not open mapfile %s: %s\n", file, strerror(errno));
! 76:
! 77: while (fgets(buf, sizeof(buf), f)) {
! 78: struct hmap *m;
! 79: char *p, *id, *name;
! 80: line++;
! 81: if (*buf == '#' || *buf == '\r' || *buf == '\n')
! 82: continue;
! 83:
! 84: for (p = buf; *p == ' ' || *p == '\t'; p++);
! 85: if (*p == '\0')
! 86: quit("%s: Parse error at line %d: Missing handle\n",
! 87: file, line);
! 88: id = p;
! 89:
! 90: for (; *p != ' ' && *p != '\t' && *p != '\0'; p++);
! 91: if (*p == '\0')
! 92: quit("%s: Parse error at line %d: Missing name\n",
! 93: file, line);
! 94: *p = '\0';
! 95:
! 96: for (++p; *p == ' ' || *p == '\t'; p++);
! 97: name = p;
! 98: for (; *p != ' ' && *p != '\t' && *p != '\0' &&
! 99: *p != '\r' && *p != '\n'; p++);
! 100: *p = '\0';
! 101:
! 102: if (strlen(id) <= 0 || strlen(name) <= 0)
! 103: quit("%s: Parse error at line %d: Invalid id or handle\n",
! 104: file, line);
! 105:
! 106: m = xcalloc(1, sizeof(*m));
! 107: m->id = strdup(id);
! 108: m->name = strdup(name);
! 109: m->next = map;
! 110: map = m;
! 111: }
! 112:
! 113: fclose(f);
! 114: }
! 115:
! 116: static const char *lookup_map(const char *handle)
! 117: {
! 118: struct hmap *m;
! 119:
! 120: for (m = map; m; m = m->next)
! 121: if (!strcmp(handle, m->id))
! 122: return m->name;
! 123:
! 124: return handle;
! 125: }
! 126:
! 127: static void handle_qdisc(struct nl_common *, void *);
! 128:
! 129: #if 0
! 130: static void handle_filter(struct nl_common *c, void *arg)
! 131: {
! 132: struct rtnl_filter *filter = (struct rtnl_filter *) c;
! 133: struct xdata *x = arg;
! 134: item_t *intf;
! 135: char name[IFNAME_MAX];
! 136:
! 137: printf("HAHAH!\n");
! 138:
! 139: if (filter->f_handle) {
! 140: const char *h = lookup_map(nl_handle2str(filter->f_handle));
! 141: snprintf(name, sizeof(name), "f:%s %s", filter->f_kind, h);
! 142: } else
! 143: snprintf(name, sizeof(name), "f:%s", filter->f_kind);
! 144:
! 145: intf = lookup_item(get_local_node(), name, filter->f_handle, x->parent);
! 146:
! 147: if (intf == NULL)
! 148: return;
! 149:
! 150: intf->i_link = x->intf->i_index;
! 151: intf->i_flags |= ITEM_FLAG_IS_CHILD;
! 152: intf->i_level = x->level;
! 153:
! 154: update_attr(intf, PACKETS, 0, 0, 0);
! 155: update_attr(intf, BYTES, 0, 0, 0);
! 156:
! 157: notify_update(intf, NULL);
! 158: increase_lifetime(intf, 1);
! 159: }
! 160: #endif
! 161:
! 162: static void handle_class(struct nl_common *c, void *arg)
! 163: {
! 164: struct rtnl_class *class = (struct rtnl_class *) c;
! 165: struct rtnl_qdisc *leaf;
! 166: struct xdata *x = arg;
! 167: item_t *intf;
! 168: char name[IFNAME_MAX];
! 169: struct xdata xn = {
! 170: .intf = x->intf,
! 171: .link = x->link,
! 172: .level = x->level + 1,
! 173: };
! 174:
! 175: if (class->c_handle) {
! 176: const char *h = lookup_map(nl_handle2str(class->c_handle));
! 177: snprintf(name, sizeof(name), "c:%s(%s)", class->c_kind, h);
! 178: } else
! 179: snprintf(name, sizeof(name), "c:%s", class->c_kind);
! 180:
! 181: intf = lookup_item(get_local_node(), name, class->c_handle, x->parent);
! 182:
! 183: if (intf == NULL)
! 184: return;
! 185:
! 186: xn.parent = intf;
! 187:
! 188: intf->i_link = x->intf->i_index;
! 189: intf->i_flags |= ITEM_FLAG_IS_CHILD;
! 190: intf->i_level = x->level;
! 191: intf->i_major_attr = BYTES;
! 192: intf->i_minor_attr = PACKETS;
! 193:
! 194: update_attr(intf, PACKETS, 0, class->c_stats.tcs_basic.packets, TX_PROVIDED);
! 195: update_attr(intf, BYTES, 0, class->c_stats.tcs_basic.bytes, TX_PROVIDED);
! 196: update_attr(intf, DROP, 0, class->c_stats.tcs_queue.drops, TX_PROVIDED);
! 197: update_attr(intf, OVERLIMITS, 0, class->c_stats.tcs_queue.overlimits, TX_PROVIDED);
! 198: update_attr(intf, BPS, 0, class->c_stats.tcs_rate_est.bps, TX_PROVIDED);
! 199: update_attr(intf, PPS, 0, class->c_stats.tcs_rate_est.pps, TX_PROVIDED);
! 200: update_attr(intf, QLEN, 0, class->c_stats.tcs_queue.qlen, TX_PROVIDED);
! 201: update_attr(intf, BACKLOG, 0, class->c_stats.tcs_queue.backlog, TX_PROVIDED);
! 202: update_attr(intf, REQUEUES, 0, class->c_stats.tcs_queue.requeues, TX_PROVIDED);
! 203:
! 204: notify_update(intf, NULL);
! 205: increase_lifetime(intf, 1);
! 206:
! 207: if ((leaf = rtnl_class_leaf_qdisc(class, qdisc_cache)))
! 208: handle_qdisc((struct nl_common *) leaf, &xn);
! 209: rtnl_class_foreach_child(class, class_cache, &handle_class, &xn);
! 210: #if 0
! 211: rtnl_class_foreach_filter_nocache(&nl_h, class, &handle_filter, &xn);
! 212: #endif
! 213: }
! 214:
! 215: static void handle_qdisc(struct nl_common *c, void *arg)
! 216: {
! 217: struct rtnl_qdisc *qdisc = (struct rtnl_qdisc *) c;
! 218: struct xdata *x = arg;
! 219: item_t *intf;
! 220: char name[IFNAME_MAX];
! 221: struct xdata xn = {
! 222: .intf = x->intf,
! 223: .link = x->link,
! 224: .level = x->level + 1,
! 225: };
! 226:
! 227: if (qdisc->q_handle) {
! 228: const char *h = lookup_map(nl_handle2str(qdisc->q_handle));
! 229: snprintf(name, sizeof(name), "q:%s(%s)", qdisc->q_kind, h);
! 230: } else
! 231: snprintf(name, sizeof(name), "q:%s", qdisc->q_kind);
! 232:
! 233: intf = lookup_item(get_local_node(), name, qdisc->q_handle, x->parent);
! 234: if (intf == NULL)
! 235: return;
! 236:
! 237: xn.parent = intf;
! 238:
! 239: intf->i_link = x->intf->i_index;
! 240: intf->i_flags |= ITEM_FLAG_IS_CHILD;
! 241: intf->i_level = x->level;
! 242: intf->i_major_attr = BYTES;
! 243: intf->i_minor_attr = PACKETS;
! 244:
! 245: if (qdisc->q_handle == 0xffff00) {
! 246: update_attr(intf, BYTES, qdisc->q_stats.tcs_basic.bytes, 0, RX_PROVIDED);
! 247: update_attr(intf, PACKETS, qdisc->q_stats.tcs_basic.packets, 0, RX_PROVIDED);
! 248: update_attr(intf, DROP, qdisc->q_stats.tcs_queue.drops, 0, RX_PROVIDED);
! 249: update_attr(intf, OVERLIMITS, qdisc->q_stats.tcs_queue.overlimits, 0, RX_PROVIDED);
! 250: update_attr(intf, BPS, qdisc->q_stats.tcs_rate_est.bps, 0, RX_PROVIDED);
! 251: update_attr(intf, PPS, qdisc->q_stats.tcs_rate_est.pps, 0, RX_PROVIDED);
! 252: update_attr(intf, QLEN, qdisc->q_stats.tcs_queue.qlen, 0, RX_PROVIDED);
! 253: update_attr(intf, BACKLOG, qdisc->q_stats.tcs_queue.backlog, 0, RX_PROVIDED);
! 254: update_attr(intf, REQUEUES, qdisc->q_stats.tcs_queue.requeues, 0, RX_PROVIDED);
! 255: } else {
! 256: update_attr(intf, BYTES, 0, qdisc->q_stats.tcs_basic.bytes, TX_PROVIDED);
! 257: update_attr(intf, PACKETS, 0, qdisc->q_stats.tcs_basic.packets, TX_PROVIDED);
! 258: update_attr(intf, DROP, 0, qdisc->q_stats.tcs_queue.drops, TX_PROVIDED);
! 259: update_attr(intf, OVERLIMITS, 0, qdisc->q_stats.tcs_queue.overlimits, TX_PROVIDED);
! 260: update_attr(intf, BPS, 0, qdisc->q_stats.tcs_rate_est.bps, TX_PROVIDED);
! 261: update_attr(intf, PPS, 0, qdisc->q_stats.tcs_rate_est.pps, TX_PROVIDED);
! 262: update_attr(intf, QLEN, 0, qdisc->q_stats.tcs_queue.qlen, TX_PROVIDED);
! 263: update_attr(intf, BACKLOG, 0, qdisc->q_stats.tcs_queue.backlog, TX_PROVIDED);
! 264: update_attr(intf, REQUEUES, 0, qdisc->q_stats.tcs_queue.requeues, TX_PROVIDED);
! 265: }
! 266:
! 267: notify_update(intf, NULL);
! 268: increase_lifetime(intf, 1);
! 269:
! 270: rtnl_qdisc_foreach_child(qdisc, class_cache, &handle_class, &xn);
! 271: #if 0
! 272: rtnl_qdisc_foreach_filter_nocache(&nl_h, qdisc, &handle_filter, &xn);
! 273: #endif
! 274: }
! 275:
! 276: static void handle_tc(item_t *intf, struct rtnl_link *link)
! 277: {
! 278: struct rtnl_qdisc *qdisc;
! 279: struct xdata x = {
! 280: .intf = intf,
! 281: .link = link,
! 282: .level = 1,
! 283: .parent = intf,
! 284: };
! 285:
! 286: class_cache = rtnl_class_build_cache(&nl_h, link->l_index);
! 287: if (class_cache == NULL)
! 288: return;
! 289:
! 290: if ((qdisc = rtnl_qdisc_get_root(qdisc_cache, link->l_index)))
! 291: handle_qdisc((struct nl_common *) qdisc, &x);
! 292: else if ((qdisc = rtnl_qdisc_get_by_parent(qdisc_cache, link->l_index, 0)))
! 293: handle_qdisc((struct nl_common *) qdisc, &x);
! 294:
! 295: if ((qdisc = rtnl_qdisc_get_ingress(qdisc_cache, link->l_index)))
! 296: handle_qdisc((struct nl_common *) qdisc, &x);
! 297:
! 298: nl_cache_destroy_and_free(class_cache);
! 299: }
! 300:
! 301: static void do_link(struct nl_common *item, void *arg)
! 302: {
! 303: struct rtnl_link *link = (struct rtnl_link *) item;
! 304: struct rtnl_lstats *st;
! 305: item_t *intf;
! 306:
! 307: if (!link->l_name[0])
! 308: return;
! 309:
! 310: if (get_show_only_running() && !(link->l_flags & IFF_UP))
! 311: return;
! 312:
! 313: intf = lookup_item(get_local_node(), link->l_name, 0, 0);
! 314:
! 315: if (NULL == intf)
! 316: return;
! 317:
! 318: intf->i_major_attr = BYTES;
! 319: intf->i_minor_attr = PACKETS;
! 320:
! 321: st = &link->l_stats;
! 322:
! 323: update_attr(intf, BYTES, st->ls_rx.bytes, st->ls_tx.bytes,
! 324: RX_PROVIDED | TX_PROVIDED);
! 325: update_attr(intf, PACKETS, st->ls_rx.packets, st->ls_tx.packets,
! 326: RX_PROVIDED | TX_PROVIDED);
! 327:
! 328: update_attr(intf, ERRORS, st->ls_rx.errors, st->ls_tx.errors,
! 329: RX_PROVIDED | TX_PROVIDED);
! 330:
! 331: update_attr(intf, DROP, st->ls_rx.dropped, st->ls_tx.dropped,
! 332: RX_PROVIDED | TX_PROVIDED);
! 333:
! 334: update_attr(intf, FIFO, st->ls_rx_fifo_errors,
! 335: st->ls_tx_fifo_errors, RX_PROVIDED | TX_PROVIDED);
! 336:
! 337: update_attr(intf, COMPRESSED, st->ls_rx.compressed,
! 338: st->ls_tx.compressed, RX_PROVIDED | TX_PROVIDED);
! 339:
! 340: update_attr(intf, MULTICAST, st->ls_rx.multicast, 0, RX_PROVIDED);
! 341: update_attr(intf, COLLISIONS, 0, st->ls_tx_collisions, TX_PROVIDED);
! 342: update_attr(intf, LENGTH_ERRORS, st->ls_rx_length_errors, 0, RX_PROVIDED);
! 343: update_attr(intf, OVER_ERRORS, st->ls_rx_over_errors, 0, RX_PROVIDED);
! 344: update_attr(intf, CRC_ERRORS, st->ls_rx_crc_errors, 0, RX_PROVIDED);
! 345: update_attr(intf, FRAME, st->ls_rx_frame_errors, 0, RX_PROVIDED);
! 346: update_attr(intf, MISSED_ERRORS, st->ls_rx_missed_errors, 0, RX_PROVIDED);
! 347: update_attr(intf, ABORTED_ERRORS, 0, st->ls_tx_aborted_errors, TX_PROVIDED);
! 348: update_attr(intf, HEARTBEAT_ERRORS, 0, st->ls_tx_heartbeat_errors,
! 349: TX_PROVIDED);
! 350: update_attr(intf, WINDOW_ERRORS, 0, st->ls_tx_window_errors, TX_PROVIDED);
! 351: update_attr(intf, CARRIER_ERRORS, 0, st->ls_tx_carrier_errors, TX_PROVIDED);
! 352:
! 353: if (!c_notc)
! 354: handle_tc(intf, link);
! 355:
! 356: notify_update(intf, NULL);
! 357: increase_lifetime(intf, 1);
! 358: }
! 359:
! 360: static void netlink_read(void)
! 361: {
! 362: if (nl_cache_update(&nl_h, &link_cache) < 0)
! 363: quit("%s\n", nl_geterror());
! 364:
! 365: if (!c_notc) {
! 366: if (qdisc_cache == NULL) {
! 367: qdisc_cache = rtnl_qdisc_build_cache(&nl_h);
! 368: if (qdisc_cache == NULL)
! 369: c_notc = 1;
! 370: } else {
! 371: if (nl_cache_update(&nl_h, qdisc_cache) < 0)
! 372: c_notc = 1;
! 373: }
! 374: }
! 375:
! 376: nl_cache_foreach(&link_cache, do_link, NULL);
! 377: }
! 378:
! 379: static void netlink_shutdown(void)
! 380: {
! 381: nl_close(&nl_h);
! 382: }
! 383:
! 384: static void netlink_do_init(void)
! 385: {
! 386: if (nl_connect(&nl_h, NETLINK_ROUTE) < 0)
! 387: quit("%s\n", nl_geterror());
! 388:
! 389: nl_use_default_handlers(&nl_h);
! 390: }
! 391:
! 392: static int netlink_probe(void)
! 393: {
! 394: if (nl_connect(&nl_h, NETLINK_ROUTE) < 0)
! 395: return 0;
! 396:
! 397: if (nl_cache_update(&nl_h, &link_cache) < 0) {
! 398: nl_close(&nl_h);
! 399: return 0;
! 400: }
! 401:
! 402: nl_cache_destroy(&link_cache);
! 403: nl_close(&nl_h);
! 404:
! 405: if (c_mapfile)
! 406: read_map(c_mapfile);
! 407:
! 408: return 1;
! 409: }
! 410:
! 411: static void print_help(void)
! 412: {
! 413: printf(
! 414: "netlink - Netlink statistic collector for Linux\n" \
! 415: "\n" \
! 416: " Powerful statistic collector for Linux using netlink sockets\n" \
! 417: " to collect link and traffic control statistics.\n" \
! 418: " Author: Thomas Graf <tgraf@suug.ch>\n" \
! 419: "\n" \
! 420: " Options:\n" \
! 421: " notc Do not collect traffic control statistics\n" \
! 422: " map=FILE Translate handles to map using a mapfile\n" \
! 423: "\n" \
! 424: " Map File format:\n" \
! 425: " # comment\n" \
! 426: " <handle> <name> # midline comment\n");
! 427: }
! 428:
! 429: static void netlink_set_opts(tv_t *attrs)
! 430: {
! 431: while (attrs) {
! 432: if (!strcasecmp(attrs->type, "notc"))
! 433: c_notc = 1;
! 434: else if (!strcasecmp(attrs->type, "map"))
! 435: c_mapfile = attrs->value;
! 436: else if (!strcasecmp(attrs->type, "help")) {
! 437: print_help();
! 438: exit(0);
! 439: }
! 440: attrs = attrs->next;
! 441: }
! 442: }
! 443:
! 444: static struct input_module netlink_ops = {
! 445: .im_name = "netlink",
! 446: .im_read = netlink_read,
! 447: .im_shutdown = netlink_shutdown,
! 448: .im_set_opts = netlink_set_opts,
! 449: .im_probe = netlink_probe,
! 450: .im_init = netlink_do_init,
! 451: };
! 452:
! 453: static void __init netlink_init(void)
! 454: {
! 455: register_input_module(&netlink_ops);
! 456: }
! 457:
! 458: #endif
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to in_netlink.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