1 /*
2 * Copyright (c) 2003, Trent Nelson, <trent@arpa.com>.
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 3. The name of the author may not be used to endorse or promote products
14 * derived from this software without specific prior written permission.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTIFSTAT_ERRUPTION)
23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 * SUCH DAMAGE.
27 */
28
29 #include <sys/types.h>
30 #include <sys/socket.h>
31 #include <sys/sysctl.h>
32 #include <net/if.h>
33 #include <net/if_mib.h>
34
35 #include <stdlib.h>
36 #include <string.h>
37 #include <unistd.h>
38 #include <err.h>
39 #include <errno.h>
40
41 #include <net/altq/altq.h>
42 #include <net/altq/altq_cbq.h>
43 #include <net/altq/altq_priq.h>
44 #include <net/altq/altq_hfsc.h>
45 #include <net/altq/altq_fairq.h>
46
47 #include <net/pf/pfvar.h>
48
49 #include "systat.h"
50 #include "extern.h"
51 #include "convtbl.h"
52
53 static SLIST_HEAD(, qcol) qcols;
54 static SLIST_HEAD(, if_stat) curlist;
55 static int pf_fd = -1;
56 static int qccols;
57 static int TopSection1;
58 static int TopSection2;
59 static int TopSection3;
60
61 struct qcol {
62 SLIST_ENTRY(qcol) link;
63 char *qname;
64 int col;
65 };
66
67 typedef struct qcol qcol_t;
68
69 union class_stats {
70 class_stats_t cbq;
71 struct priq_classstats priq;
72 struct hfsc_classstats hfsc;
73 struct fairq_classstats fairq;
74 };
75
76 struct queue_stats {
77 SLIST_ENTRY(queue_stats) link;
78 struct pfioc_altq pa;
79 struct pfioc_qstats pq;
80 qcol_t *qc;
81 union class_stats ostats;
82 union class_stats nstats;
83 };
84
85 typedef struct queue_stats queue_stats_t;
86
87 struct if_stat {
88 SLIST_ENTRY(if_stat) link;
89 SLIST_HEAD(, queue_stats) queues;
90 char if_name[IF_NAMESIZE];
91 struct ifmibdata if_mib;
92 struct timeval tv;
93 struct timeval tv_lastchanged;
94 u_long if_in_curtraffic;
95 u_long if_out_curtraffic;
96 u_long if_in_traffic_peak;
97 u_long if_out_traffic_peak;
98 u_int if_row; /* Index into ifmib sysctl */
99 u_int row; /* display row (relative) */
100 u_int display;
101 };
102
103 typedef struct if_stat if_stat_t;
104
105 extern u_int curscale;
106
107 static void load_altqs(void);
108 static void print_altq(if_stat_t *p, queue_stats_t *q);
109 static void right_align_string(if_stat_t *);
110 static void getifmibdata(const int, struct ifmibdata *);
111 static void sort_interface_list(void);
112 static u_int getifnum(void);
113
114 #define IFSTAT_ERR(n, s) do { \
115 putchar(' '); \
116 closealtqs(wnd); \
117 err((n), (s)); \
118 } while (0)
119
120 #define TOPLINE 1
121 #define TOPQSTART 20
122 #define TOPQWIDTH 10
123
124 WINDOW *
openaltqs(void)125 openaltqs(void)
126 {
127 if_stat_t *p = NULL;
128 u_int n = 0, i = 0;
129
130 pf_fd = open("/dev/pf", O_RDONLY);
131
132 n = getifnum(); /* NOTE: can return < 0 */
133
134 SLIST_INIT(&curlist);
135 SLIST_INIT(&qcols);
136 for (i = 0; i < n; i++) {
137 p = (if_stat_t *)calloc(1, sizeof(if_stat_t));
138 if (p == NULL)
139 IFSTAT_ERR(1, "out of memory");
140 SLIST_INSERT_HEAD(&curlist, p, link);
141 SLIST_INIT(&p->queues);
142 p->if_row = i+1;
143 getifmibdata(p->if_row, &p->if_mib);
144 right_align_string(p);
145
146 /*
147 * Initially, we only display interfaces that have
148 * received some traffic.
149 */
150 if (p->if_mib.ifmd_data.ifi_ibytes != 0)
151 p->display = 1;
152 }
153 load_altqs();
154
155 sort_interface_list();
156
157 return (subwin(stdscr, LINES-1-5, 0, 5, 0));
158 }
159
160 void
closealtqs(WINDOW * w)161 closealtqs(WINDOW *w)
162 {
163 if_stat_t *node = NULL;
164 queue_stats_t *q;
165
166 while (!SLIST_EMPTY(&curlist)) {
167 node = SLIST_FIRST(&curlist);
168 SLIST_REMOVE_HEAD(&curlist, link);
169 while ((q = SLIST_FIRST(&node->queues)) != NULL) {
170 SLIST_REMOVE_HEAD(&node->queues, link);
171 free(q);
172 }
173 free(node);
174 }
175 while (!SLIST_EMPTY(&qcols)) {
176 qcol_t *qc = SLIST_FIRST(&qcols);
177 SLIST_REMOVE_HEAD(&qcols, link);
178 free(qc->qname);
179 free(qc);
180 }
181 qccols = 0;
182
183 if (w != NULL) {
184 wclear(w);
185 wrefresh(w);
186 delwin(w);
187 }
188
189 if (pf_fd >= 0) {
190 close(pf_fd);
191 pf_fd = -1;
192 }
193
194 return;
195 }
196
197 void
labelaltqs(void)198 labelaltqs(void)
199 {
200 wmove(wnd, TOPLINE, 0);
201 wclrtoeol(wnd);
202 }
203
204 void
showaltqs(void)205 showaltqs(void)
206 {
207 if_stat_t *p = NULL;
208 queue_stats_t *q;
209 qcol_t *qc;
210
211 mvprintw(TopSection1, 0, " PACKETS");
212 mvprintw(TopSection2, 0, " BYTES");
213 mvprintw(TopSection3, 0, " DROPS/QLEN");
214 SLIST_FOREACH(qc, &qcols, link) {
215 mvprintw(TopSection1, TOPQSTART + TOPQWIDTH * qc->col,
216 "%9s", qc->qname);
217 mvprintw(TopSection2, TOPQSTART + TOPQWIDTH * qc->col,
218 "%9s", qc->qname);
219 mvprintw(TopSection3, TOPQSTART + TOPQWIDTH * qc->col,
220 "%9s", qc->qname);
221 }
222
223 SLIST_FOREACH(p, &curlist, link) {
224 if (p->display == 0)
225 continue;
226 mvprintw(TopSection1 + p->row, 0, "%s", p->if_name);
227 mvprintw(TopSection2 + p->row, 0, "%s", p->if_name);
228 mvprintw(TopSection3 + p->row, 0, "%s", p->if_name);
229 SLIST_FOREACH(q, &p->queues, link) {
230 print_altq(p, q);
231 }
232 }
233 }
234
235 int
initaltqs(void)236 initaltqs(void)
237 {
238 TopSection1 = TOPLINE;
239
240 return 1;
241 }
242
243 void
fetchaltqs(void)244 fetchaltqs(void)
245 {
246 struct if_stat *ifp = NULL;
247 struct timeval tv, new_tv, old_tv;
248 double elapsed = 0.0;
249 u_int new_inb, new_outb, old_inb, old_outb = 0;
250 u_int we_need_to_sort_interface_list = 0;
251
252 SLIST_FOREACH(ifp, &curlist, link) {
253 /*
254 * Grab a copy of the old input/output values before we
255 * call getifmibdata().
256 */
257 old_inb = ifp->if_mib.ifmd_data.ifi_ibytes;
258 old_outb = ifp->if_mib.ifmd_data.ifi_obytes;
259 ifp->tv_lastchanged = ifp->if_mib.ifmd_data.ifi_lastchange;
260
261 if (gettimeofday(&new_tv, NULL) != 0)
262 IFSTAT_ERR(2, "error getting time of day");
263 (void)getifmibdata(ifp->if_row, &ifp->if_mib);
264
265
266 new_inb = ifp->if_mib.ifmd_data.ifi_ibytes;
267 new_outb = ifp->if_mib.ifmd_data.ifi_obytes;
268
269 /* Display interface if it's received some traffic. */
270 if (new_inb > 0 && old_inb == 0) {
271 ifp->display = 1;
272 we_need_to_sort_interface_list++;
273 }
274
275 /*
276 * The rest is pretty trivial. Calculate the new values
277 * for our current traffic rates, and while we're there,
278 * see if we have new peak rates.
279 */
280 old_tv = ifp->tv;
281 timersub(&new_tv, &old_tv, &tv);
282 elapsed = tv.tv_sec + (tv.tv_usec * 1e-6);
283
284 ifp->if_in_curtraffic = new_inb - old_inb;
285 ifp->if_out_curtraffic = new_outb - old_outb;
286
287 /*
288 * Rather than divide by the time specified on the comm-
289 * and line, we divide by ``elapsed'' as this is likely
290 * to be more accurate.
291 */
292 ifp->if_in_curtraffic /= elapsed;
293 ifp->if_out_curtraffic /= elapsed;
294
295 if (ifp->if_in_curtraffic > ifp->if_in_traffic_peak)
296 ifp->if_in_traffic_peak = ifp->if_in_curtraffic;
297
298 if (ifp->if_out_curtraffic > ifp->if_out_traffic_peak)
299 ifp->if_out_traffic_peak = ifp->if_out_curtraffic;
300
301 ifp->tv.tv_sec = new_tv.tv_sec;
302 ifp->tv.tv_usec = new_tv.tv_usec;
303
304 }
305
306 load_altqs();
307
308 if (we_need_to_sort_interface_list)
309 sort_interface_list();
310
311 return;
312 }
313
314 /*
315 * We want to right justify our interface names against the first column
316 * (first sixteen or so characters), so we need to do some alignment.
317 */
318 static void
right_align_string(if_stat_t * ifp)319 right_align_string(if_stat_t *ifp)
320 {
321 int str_len = 0, pad_len = 0;
322 char *newstr = NULL, *ptr = NULL;
323
324 if (ifp == NULL || ifp->if_mib.ifmd_name == NULL)
325 return;
326 else {
327 /* string length + '\0' */
328 str_len = strlen(ifp->if_mib.ifmd_name)+1;
329 pad_len = IF_NAMESIZE-(str_len);
330
331 newstr = ifp->if_name;
332 ptr = newstr + pad_len;
333 (void)memset((void *)newstr, (int)' ', IF_NAMESIZE);
334 (void)strncpy(ptr, (const char *)&ifp->if_mib.ifmd_name,
335 str_len);
336 }
337
338 return;
339 }
340
341 /*
342 * This function iterates through our list of interfaces, identifying
343 * those that are to be displayed (ifp->display = 1). For each interf-
344 * rface that we're displaying, we generate an appropriate position for
345 * it on the screen (ifp->row).
346 *
347 * This function is called any time a change is made to an interface's
348 * ``display'' state.
349 */
350 void
sort_interface_list(void)351 sort_interface_list(void)
352 {
353 if_stat_t *ifp;
354 u_int y;
355
356 y = 1;
357 SLIST_FOREACH(ifp, &curlist, link) {
358 if (ifp->display)
359 ifp->row = ++y;
360 }
361 TopSection2 = TopSection1 + y + 4;
362 TopSection3 = TopSection2 + y + 4;
363 }
364
365 static
366 unsigned int
getifnum(void)367 getifnum(void)
368 {
369 u_int data = 0;
370 size_t datalen = 0;
371 static int name[] = { CTL_NET,
372 PF_LINK,
373 NETLINK_GENERIC,
374 IFMIB_SYSTEM,
375 IFMIB_IFCOUNT };
376
377 datalen = sizeof(data);
378 if (sysctl(name, 5, (void *)&data, (size_t *)&datalen, NULL,
379 (size_t)0) != 0)
380 IFSTAT_ERR(1, "sysctl error");
381 return data;
382 }
383
384 static void
getifmibdata(int row,struct ifmibdata * data)385 getifmibdata(int row, struct ifmibdata *data)
386 {
387 size_t datalen = 0;
388 static int name[] = { CTL_NET,
389 PF_LINK,
390 NETLINK_GENERIC,
391 IFMIB_IFDATA,
392 0,
393 IFDATA_GENERAL };
394 datalen = sizeof(*data);
395 name[4] = row;
396
397 if ((sysctl(name, 6, (void *)data, (size_t *)&datalen, NULL,
398 (size_t)0) != 0) && (errno != ENOENT))
399 IFSTAT_ERR(2, "sysctl error getting interface data");
400 }
401
402 static void
load_altqs(void)403 load_altqs(void)
404 {
405 struct pfioc_altq pa;
406 struct pfioc_qstats pq;
407 if_stat_t *p;
408 queue_stats_t *q;
409 qcol_t *qc;
410 int i;
411 int n;
412
413 bzero(&pa, sizeof(pa));
414 bzero(&pq, sizeof(pq));
415
416 if (ioctl(pf_fd, DIOCGETALTQS, &pa))
417 return;
418 n = pa.nr;
419 for (i = 0; i < n; ++i) {
420 pa.nr = i;
421 if (ioctl(pf_fd, DIOCGETALTQ, &pa))
422 return;
423 if (pa.altq.qid <= 0)
424 continue;
425
426 SLIST_FOREACH(p, &curlist, link) {
427 if (strcmp(pa.altq.ifname, p->if_mib.ifmd_name) == 0)
428 break;
429 }
430 if (p == NULL)
431 continue;
432 SLIST_FOREACH(q, &p->queues, link) {
433 if (strcmp(pa.altq.qname, q->pa.altq.qname) == 0)
434 break;
435 }
436 if (q == NULL) {
437 q = calloc(1, sizeof(*q));
438 q->pa = pa;
439 SLIST_INSERT_HEAD(&p->queues, q, link);
440 } else {
441 q->pa.ticket = pa.ticket;
442 }
443 q->ostats = q->nstats;
444 q->pq.nr = i;
445 q->pq.ticket = q->pa.ticket;
446 q->pq.buf = &q->nstats;
447 q->pq.nbytes = sizeof(q->nstats);
448 if (ioctl(pf_fd, DIOCGETQSTATS, &q->pq) < 0) {
449 SLIST_REMOVE(&p->queues, q, queue_stats, link);
450 free(q);
451 }
452 SLIST_FOREACH(qc, &qcols, link) {
453 if (strcmp(q->pa.altq.qname, qc->qname) == 0)
454 break;
455 }
456 if (qc == NULL) {
457 qc = calloc(1, sizeof(*qc));
458 qc->qname = strdup(q->pa.altq.qname);
459 qc->col = qccols++;
460 SLIST_INSERT_HEAD(&qcols, qc, link);
461 }
462 q->qc = qc;
463 }
464 }
465
466 static
467 void
print_altq(if_stat_t * p,queue_stats_t * q)468 print_altq(if_stat_t *p, queue_stats_t *q)
469 {
470 uint64_t xmit_pkts;
471 uint64_t xmit_bytes;
472 uint64_t drop_pkts;
473 uint64_t drop_bytes __unused;
474 uint64_t qlen;
475
476 switch(q->pa.altq.scheduler) {
477 case ALTQT_CBQ:
478 xmit_pkts = q->nstats.cbq.xmit_cnt.packets;
479 xmit_bytes = q->nstats.cbq.xmit_cnt.bytes;
480 drop_pkts = q->nstats.cbq.drop_cnt.packets;
481 drop_bytes = q->nstats.cbq.drop_cnt.bytes;
482 xmit_pkts -= q->ostats.cbq.xmit_cnt.packets;
483 xmit_bytes -= q->ostats.cbq.xmit_cnt.bytes;
484 drop_pkts -= q->ostats.cbq.drop_cnt.packets;
485 drop_bytes -= q->ostats.cbq.drop_cnt.bytes;
486 qlen = 0;
487 break;
488 case ALTQT_PRIQ:
489 xmit_pkts = q->nstats.priq.xmitcnt.packets;
490 xmit_bytes = q->nstats.priq.xmitcnt.bytes;
491 drop_pkts = q->nstats.priq.dropcnt.packets;
492 drop_bytes = q->nstats.priq.dropcnt.bytes;
493 xmit_pkts -= q->ostats.priq.xmitcnt.packets;
494 xmit_bytes -= q->ostats.priq.xmitcnt.bytes;
495 drop_pkts -= q->ostats.priq.dropcnt.packets;
496 drop_bytes -= q->ostats.priq.dropcnt.bytes;
497 qlen = q->nstats.priq.qlength;
498 break;
499 case ALTQT_HFSC:
500 xmit_pkts = q->nstats.hfsc.xmit_cnt.packets;
501 xmit_bytes = q->nstats.hfsc.xmit_cnt.bytes;
502 drop_pkts = q->nstats.hfsc.drop_cnt.packets;
503 drop_bytes = q->nstats.hfsc.drop_cnt.bytes;
504 xmit_pkts -= q->ostats.hfsc.xmit_cnt.packets;
505 xmit_bytes -= q->ostats.hfsc.xmit_cnt.bytes;
506 drop_pkts -= q->ostats.hfsc.drop_cnt.packets;
507 drop_bytes -= q->ostats.hfsc.drop_cnt.bytes;
508 qlen = q->nstats.hfsc.qlength;
509 break;
510 case ALTQT_FAIRQ:
511 xmit_pkts = q->nstats.fairq.xmit_cnt.packets;
512 xmit_bytes = q->nstats.fairq.xmit_cnt.bytes;
513 drop_pkts = q->nstats.fairq.drop_cnt.packets;
514 drop_bytes = q->nstats.fairq.drop_cnt.bytes;
515 xmit_pkts -= q->ostats.fairq.xmit_cnt.packets;
516 xmit_bytes -= q->ostats.fairq.xmit_cnt.bytes;
517 drop_pkts -= q->ostats.fairq.drop_cnt.packets;
518 drop_bytes -= q->ostats.fairq.drop_cnt.bytes;
519 qlen = q->nstats.fairq.qlength;
520 break;
521 default:
522 xmit_pkts = 0;
523 xmit_bytes = 0;
524 drop_pkts = 0;
525 drop_bytes = 0;
526 qlen = 0;
527 break;
528 }
529 if (xmit_pkts == 0)
530 mvprintw(TopSection1 + p->row,
531 TOPQSTART + q->qc->col * TOPQWIDTH - 1,
532 "%10s", "");
533 else
534 mvprintw(TopSection1 + p->row,
535 TOPQSTART + q->qc->col * TOPQWIDTH - 1,
536 "%10jd", (intmax_t)xmit_pkts);
537
538 if (xmit_bytes == 0)
539 mvprintw(TopSection2 + p->row,
540 TOPQSTART + q->qc->col * TOPQWIDTH - 1,
541 "%10s", "");
542 else
543 mvprintw(TopSection2 + p->row,
544 TOPQSTART + q->qc->col * TOPQWIDTH - 1,
545 "%10jd", (intmax_t)xmit_bytes);
546 if (drop_pkts)
547 mvprintw(TopSection3 + p->row,
548 TOPQSTART + q->qc->col * TOPQWIDTH - 1,
549 "%10jd", (intmax_t)drop_pkts);
550 else if (qlen)
551 mvprintw(TopSection3 + p->row,
552 TOPQSTART + q->qc->col * TOPQWIDTH - 1,
553 "%9jdQ", (intmax_t)qlen);
554 else
555 mvprintw(TopSection3 + p->row,
556 TOPQSTART + q->qc->col * TOPQWIDTH - 1,
557 "%10s", "");
558 }
559
560 int
cmdaltqs(const char * cmd,char * args)561 cmdaltqs(const char *cmd, char *args)
562 {
563 int retval = 0;
564
565 retval = ifcmd(cmd, args);
566 /* ifcmd() returns 1 on success */
567 if (retval == 1) {
568 showaltqs();
569 refresh();
570 }
571
572 return retval;
573 }
574