org[shemminger]!shemminger | 9e9d615 | 2004-06-07 22:04:51 +0000 | [diff] [blame] | 1 | /* |
| 2 | * q_htb.c HTB. |
| 3 | * |
| 4 | * This program is free software; you can redistribute it and/or |
| 5 | * modify it under the terms of the GNU General Public License |
| 6 | * as published by the Free Software Foundation; either version |
| 7 | * 2 of the License, or (at your option) any later version. |
| 8 | * |
| 9 | * Authors: Martin Devera, devik@cdi.cz |
| 10 | * |
| 11 | */ |
| 12 | |
| 13 | #include <stdio.h> |
| 14 | #include <stdlib.h> |
| 15 | #include <unistd.h> |
| 16 | #include <syslog.h> |
| 17 | #include <fcntl.h> |
| 18 | #include <sys/socket.h> |
| 19 | #include <netinet/in.h> |
| 20 | #include <arpa/inet.h> |
| 21 | #include <string.h> |
| 22 | |
| 23 | #include "utils.h" |
| 24 | #include "tc_util.h" |
| 25 | |
| 26 | #define HTB_TC_VER 0x30003 |
| 27 | #if HTB_TC_VER >> 16 != TC_HTB_PROTOVER |
| 28 | #error "Different kernel and TC HTB versions" |
| 29 | #endif |
| 30 | |
| 31 | static void explain(void) |
| 32 | { |
| 33 | fprintf(stderr, "Usage: ... qdisc add ... htb [default N] [r2q N]\n" |
Eric Dumazet | b43f331 | 2013-09-13 09:10:01 -0700 | [diff] [blame] | 34 | " [direct_qlen P]\n" |
org[shemminger]!shemminger | 9e9d615 | 2004-06-07 22:04:51 +0000 | [diff] [blame] | 35 | " default minor id of class to which unclassified packets are sent {0}\n" |
| 36 | " r2q DRR quantums are computed as rate in Bps/r2q {10}\n" |
| 37 | " debug string of 16 numbers each 0-3 {0}\n\n" |
Eric Dumazet | b43f331 | 2013-09-13 09:10:01 -0700 | [diff] [blame] | 38 | " direct_qlen Limit of the direct queue {in packets}\n" |
osdl.net!shemminger | a166d24 | 2004-07-30 20:26:15 +0000 | [diff] [blame] | 39 | "... class add ... htb rate R1 [burst B1] [mpu B] [overhead O]\n" |
| 40 | " [prio P] [slot S] [pslot PS]\n" |
org[shemminger]!shemminger | 9e9d615 | 2004-06-07 22:04:51 +0000 | [diff] [blame] | 41 | " [ceil R2] [cburst B2] [mtu MTU] [quantum Q]\n" |
| 42 | " rate rate allocated to this class (class can still borrow)\n" |
| 43 | " burst max bytes burst which can be accumulated during idle period {computed}\n" |
osdl.net!shemminger | a166d24 | 2004-07-30 20:26:15 +0000 | [diff] [blame] | 44 | " mpu minimum packet size used in rate computations\n" |
| 45 | " overhead per-packet size overhead used in rate computations\n" |
Jesper Dangaard Brouer | 292f29b | 2008-04-09 23:01:01 +0200 | [diff] [blame] | 46 | " linklay adapting to a linklayer e.g. atm\n" |
org[shemminger]!shemminger | 9e9d615 | 2004-06-07 22:04:51 +0000 | [diff] [blame] | 47 | " ceil definite upper class rate (no borrows) {rate}\n" |
| 48 | " cburst burst but for ceil {computed}\n" |
| 49 | " mtu max packet size we create rate map for {1600}\n" |
| 50 | " prio priority of leaf; lower are served first {0}\n" |
| 51 | " quantum how much bytes to serve from leaf at once {use r2q}\n" |
Stephen Hemminger | 32a121c | 2016-03-21 11:48:36 -0700 | [diff] [blame] | 52 | "\nTC HTB version %d.%d\n", HTB_TC_VER>>16, HTB_TC_VER&0xffff |
org[shemminger]!shemminger | 9e9d615 | 2004-06-07 22:04:51 +0000 | [diff] [blame] | 53 | ); |
| 54 | } |
| 55 | |
| 56 | static void explain1(char *arg) |
| 57 | { |
| 58 | fprintf(stderr, "Illegal \"%s\"\n", arg); |
| 59 | explain(); |
| 60 | } |
| 61 | |
| 62 | |
org[shemminger]!shemminger | 9e9d615 | 2004-06-07 22:04:51 +0000 | [diff] [blame] | 63 | static int htb_parse_opt(struct qdisc_util *qu, int argc, char **argv, struct nlmsghdr *n) |
| 64 | { |
Hiroaki SHIMODA | 4d4da09 | 2014-03-08 22:10:03 +0900 | [diff] [blame] | 65 | unsigned int direct_qlen = ~0U; |
Phil Sutter | d17b136 | 2016-07-18 16:48:42 +0200 | [diff] [blame] | 66 | struct tc_htb_glob opt = { |
| 67 | .rate2quantum = 10, |
| 68 | .version = 3, |
| 69 | }; |
org[shemminger]!shemminger | 9e9d615 | 2004-06-07 22:04:51 +0000 | [diff] [blame] | 70 | struct rtattr *tail; |
Stephen Hemminger | 32a121c | 2016-03-21 11:48:36 -0700 | [diff] [blame] | 71 | unsigned int i; char *p; |
| 72 | |
org[shemminger]!shemminger | 9e9d615 | 2004-06-07 22:04:51 +0000 | [diff] [blame] | 73 | while (argc > 0) { |
| 74 | if (matches(*argv, "r2q") == 0) { |
Stephen Hemminger | 22fa92e | 2013-06-07 08:54:45 -0700 | [diff] [blame] | 75 | NEXT_ARG(); |
| 76 | if (get_u32(&opt.rate2quantum, *argv, 10)) { |
| 77 | explain1("r2q"); return -1; |
| 78 | } |
org[shemminger]!shemminger | 9e9d615 | 2004-06-07 22:04:51 +0000 | [diff] [blame] | 79 | } else if (matches(*argv, "default") == 0) { |
Stephen Hemminger | 22fa92e | 2013-06-07 08:54:45 -0700 | [diff] [blame] | 80 | NEXT_ARG(); |
| 81 | if (get_u32(&opt.defcls, *argv, 16)) { |
| 82 | explain1("default"); return -1; |
| 83 | } |
org[shemminger]!shemminger | 9e9d615 | 2004-06-07 22:04:51 +0000 | [diff] [blame] | 84 | } else if (matches(*argv, "debug") == 0) { |
Stephen Hemminger | 22fa92e | 2013-06-07 08:54:45 -0700 | [diff] [blame] | 85 | NEXT_ARG(); p = *argv; |
Stephen Hemminger | 32a121c | 2016-03-21 11:48:36 -0700 | [diff] [blame] | 86 | for (i = 0; i < 16; i++, p++) { |
| 87 | if (*p < '0' || *p > '3') break; |
Stephen Hemminger | 22fa92e | 2013-06-07 08:54:45 -0700 | [diff] [blame] | 88 | opt.debug |= (*p-'0')<<(2*i); |
| 89 | } |
Hiroaki SHIMODA | 4d4da09 | 2014-03-08 22:10:03 +0900 | [diff] [blame] | 90 | } else if (matches(*argv, "direct_qlen") == 0) { |
| 91 | NEXT_ARG(); |
| 92 | if (get_u32(&direct_qlen, *argv, 10)) { |
| 93 | explain1("direct_qlen"); return -1; |
| 94 | } |
org[shemminger]!shemminger | 9e9d615 | 2004-06-07 22:04:51 +0000 | [diff] [blame] | 95 | } else { |
| 96 | fprintf(stderr, "What is \"%s\"?\n", *argv); |
| 97 | explain(); |
| 98 | return -1; |
| 99 | } |
| 100 | argc--; argv++; |
| 101 | } |
6!tgraf | 1b52a76 | 2005-01-18 01:24:18 +0000 | [diff] [blame] | 102 | tail = NLMSG_TAIL(n); |
org[shemminger]!shemminger | 9e9d615 | 2004-06-07 22:04:51 +0000 | [diff] [blame] | 103 | addattr_l(n, 1024, TCA_OPTIONS, NULL, 0); |
| 104 | addattr_l(n, 2024, TCA_HTB_INIT, &opt, NLMSG_ALIGN(sizeof(opt))); |
Hiroaki SHIMODA | 4d4da09 | 2014-03-08 22:10:03 +0900 | [diff] [blame] | 105 | if (direct_qlen != ~0U) |
| 106 | addattr_l(n, 2024, TCA_HTB_DIRECT_QLEN, |
| 107 | &direct_qlen, sizeof(direct_qlen)); |
6!tgraf | 1b52a76 | 2005-01-18 01:24:18 +0000 | [diff] [blame] | 108 | tail->rta_len = (void *) NLMSG_TAIL(n) - (void *) tail; |
org[shemminger]!shemminger | 9e9d615 | 2004-06-07 22:04:51 +0000 | [diff] [blame] | 109 | return 0; |
| 110 | } |
| 111 | |
| 112 | static int htb_parse_class_opt(struct qdisc_util *qu, int argc, char **argv, struct nlmsghdr *n) |
| 113 | { |
Stephen Hemminger | 32a121c | 2016-03-21 11:48:36 -0700 | [diff] [blame] | 114 | int ok = 0; |
Phil Sutter | d17b136 | 2016-07-18 16:48:42 +0200 | [diff] [blame] | 115 | struct tc_htb_opt opt = {}; |
Stephen Hemminger | 32a121c | 2016-03-21 11:48:36 -0700 | [diff] [blame] | 116 | __u32 rtab[256], ctab[256]; |
| 117 | unsigned buffer = 0, cbuffer = 0; |
| 118 | int cell_log = -1, ccell_log = -1; |
Phil Sutter | d17b136 | 2016-07-18 16:48:42 +0200 | [diff] [blame] | 119 | unsigned int mtu = 1600; /* eth packet len */ |
Jesper Dangaard Brouer | bccd014 | 2007-09-11 16:59:58 +0200 | [diff] [blame] | 120 | unsigned short mpu = 0; |
| 121 | unsigned short overhead = 0; |
Jesper Dangaard Brouer | 292f29b | 2008-04-09 23:01:01 +0200 | [diff] [blame] | 122 | unsigned int linklayer = LINKLAYER_ETHERNET; /* Assume ethernet */ |
org[shemminger]!shemminger | 9e9d615 | 2004-06-07 22:04:51 +0000 | [diff] [blame] | 123 | struct rtattr *tail; |
Eric Dumazet | 8334bb3 | 2013-11-12 14:34:07 -0800 | [diff] [blame] | 124 | __u64 ceil64 = 0, rate64 = 0; |
org[shemminger]!shemminger | 9e9d615 | 2004-06-07 22:04:51 +0000 | [diff] [blame] | 125 | |
org[shemminger]!shemminger | 9e9d615 | 2004-06-07 22:04:51 +0000 | [diff] [blame] | 126 | while (argc > 0) { |
| 127 | if (matches(*argv, "prio") == 0) { |
| 128 | NEXT_ARG(); |
| 129 | if (get_u32(&opt.prio, *argv, 10)) { |
| 130 | explain1("prio"); return -1; |
| 131 | } |
| 132 | ok++; |
| 133 | } else if (matches(*argv, "mtu") == 0) { |
| 134 | NEXT_ARG(); |
| 135 | if (get_u32(&mtu, *argv, 10)) { |
| 136 | explain1("mtu"); return -1; |
| 137 | } |
osdl.net!shemminger | a166d24 | 2004-07-30 20:26:15 +0000 | [diff] [blame] | 138 | } else if (matches(*argv, "mpu") == 0) { |
| 139 | NEXT_ARG(); |
Jesper Dangaard Brouer | bccd014 | 2007-09-11 16:59:58 +0200 | [diff] [blame] | 140 | if (get_u16(&mpu, *argv, 10)) { |
osdl.net!shemminger | a166d24 | 2004-07-30 20:26:15 +0000 | [diff] [blame] | 141 | explain1("mpu"); return -1; |
| 142 | } |
| 143 | } else if (matches(*argv, "overhead") == 0) { |
| 144 | NEXT_ARG(); |
Jesper Dangaard Brouer | bccd014 | 2007-09-11 16:59:58 +0200 | [diff] [blame] | 145 | if (get_u16(&overhead, *argv, 10)) { |
osdl.net!shemminger | a166d24 | 2004-07-30 20:26:15 +0000 | [diff] [blame] | 146 | explain1("overhead"); return -1; |
| 147 | } |
Jesper Dangaard Brouer | 292f29b | 2008-04-09 23:01:01 +0200 | [diff] [blame] | 148 | } else if (matches(*argv, "linklayer") == 0) { |
| 149 | NEXT_ARG(); |
| 150 | if (get_linklayer(&linklayer, *argv)) { |
| 151 | explain1("linklayer"); return -1; |
| 152 | } |
org[shemminger]!shemminger | 9e9d615 | 2004-06-07 22:04:51 +0000 | [diff] [blame] | 153 | } else if (matches(*argv, "quantum") == 0) { |
| 154 | NEXT_ARG(); |
| 155 | if (get_u32(&opt.quantum, *argv, 10)) { |
| 156 | explain1("quantum"); return -1; |
| 157 | } |
| 158 | } else if (matches(*argv, "burst") == 0 || |
Stephen Hemminger | 22fa92e | 2013-06-07 08:54:45 -0700 | [diff] [blame] | 159 | strcmp(*argv, "buffer") == 0 || |
| 160 | strcmp(*argv, "maxburst") == 0) { |
org[shemminger]!shemminger | 9e9d615 | 2004-06-07 22:04:51 +0000 | [diff] [blame] | 161 | NEXT_ARG(); |
| 162 | if (get_size_and_cell(&buffer, &cell_log, *argv) < 0) { |
| 163 | explain1("buffer"); |
| 164 | return -1; |
| 165 | } |
| 166 | ok++; |
| 167 | } else if (matches(*argv, "cburst") == 0 || |
Stephen Hemminger | 22fa92e | 2013-06-07 08:54:45 -0700 | [diff] [blame] | 168 | strcmp(*argv, "cbuffer") == 0 || |
| 169 | strcmp(*argv, "cmaxburst") == 0) { |
org[shemminger]!shemminger | 9e9d615 | 2004-06-07 22:04:51 +0000 | [diff] [blame] | 170 | NEXT_ARG(); |
| 171 | if (get_size_and_cell(&cbuffer, &ccell_log, *argv) < 0) { |
| 172 | explain1("cbuffer"); |
| 173 | return -1; |
| 174 | } |
| 175 | ok++; |
| 176 | } else if (strcmp(*argv, "ceil") == 0) { |
| 177 | NEXT_ARG(); |
Eric Dumazet | 8334bb3 | 2013-11-12 14:34:07 -0800 | [diff] [blame] | 178 | if (ceil64) { |
org[shemminger]!shemminger | 9e9d615 | 2004-06-07 22:04:51 +0000 | [diff] [blame] | 179 | fprintf(stderr, "Double \"ceil\" spec\n"); |
| 180 | return -1; |
| 181 | } |
Eric Dumazet | 8334bb3 | 2013-11-12 14:34:07 -0800 | [diff] [blame] | 182 | if (get_rate64(&ceil64, *argv)) { |
org[shemminger]!shemminger | 9e9d615 | 2004-06-07 22:04:51 +0000 | [diff] [blame] | 183 | explain1("ceil"); |
| 184 | return -1; |
| 185 | } |
| 186 | ok++; |
| 187 | } else if (strcmp(*argv, "rate") == 0) { |
| 188 | NEXT_ARG(); |
Eric Dumazet | 8334bb3 | 2013-11-12 14:34:07 -0800 | [diff] [blame] | 189 | if (rate64) { |
org[shemminger]!shemminger | 9e9d615 | 2004-06-07 22:04:51 +0000 | [diff] [blame] | 190 | fprintf(stderr, "Double \"rate\" spec\n"); |
| 191 | return -1; |
| 192 | } |
Eric Dumazet | 8334bb3 | 2013-11-12 14:34:07 -0800 | [diff] [blame] | 193 | if (get_rate64(&rate64, *argv)) { |
org[shemminger]!shemminger | 9e9d615 | 2004-06-07 22:04:51 +0000 | [diff] [blame] | 194 | explain1("rate"); |
| 195 | return -1; |
| 196 | } |
| 197 | ok++; |
| 198 | } else if (strcmp(*argv, "help") == 0) { |
| 199 | explain(); |
| 200 | return -1; |
| 201 | } else { |
| 202 | fprintf(stderr, "What is \"%s\"?\n", *argv); |
| 203 | explain(); |
| 204 | return -1; |
| 205 | } |
| 206 | argc--; argv++; |
| 207 | } |
| 208 | |
Stephen Hemminger | 22fa92e | 2013-06-07 08:54:45 -0700 | [diff] [blame] | 209 | /* if (!ok) |
org[shemminger]!shemminger | 9e9d615 | 2004-06-07 22:04:51 +0000 | [diff] [blame] | 210 | return 0;*/ |
| 211 | |
Eric Dumazet | 8334bb3 | 2013-11-12 14:34:07 -0800 | [diff] [blame] | 212 | if (!rate64) { |
org[shemminger]!shemminger | 9e9d615 | 2004-06-07 22:04:51 +0000 | [diff] [blame] | 213 | fprintf(stderr, "\"rate\" is required.\n"); |
| 214 | return -1; |
| 215 | } |
| 216 | /* if ceil params are missing, use the same as rate */ |
Eric Dumazet | 8334bb3 | 2013-11-12 14:34:07 -0800 | [diff] [blame] | 217 | if (!ceil64) |
| 218 | ceil64 = rate64; |
| 219 | |
| 220 | opt.rate.rate = (rate64 >= (1ULL << 32)) ? ~0U : rate64; |
| 221 | opt.ceil.rate = (ceil64 >= (1ULL << 32)) ? ~0U : ceil64; |
org[shemminger]!shemminger | 9e9d615 | 2004-06-07 22:04:51 +0000 | [diff] [blame] | 222 | |
| 223 | /* compute minimal allowed burst from rate; mtu is added here to make |
| 224 | sute that buffer is larger than mtu and to have some safeguard space */ |
Eric Dumazet | 8334bb3 | 2013-11-12 14:34:07 -0800 | [diff] [blame] | 225 | if (!buffer) |
| 226 | buffer = rate64 / get_hz() + mtu; |
| 227 | if (!cbuffer) |
| 228 | cbuffer = ceil64 / get_hz() + mtu; |
org[shemminger]!shemminger | 9e9d615 | 2004-06-07 22:04:51 +0000 | [diff] [blame] | 229 | |
Jesper Dangaard Brouer | bccd014 | 2007-09-11 16:59:58 +0200 | [diff] [blame] | 230 | opt.ceil.overhead = overhead; |
| 231 | opt.rate.overhead = overhead; |
| 232 | |
| 233 | opt.ceil.mpu = mpu; |
| 234 | opt.rate.mpu = mpu; |
osdl.net!shemminger | a166d24 | 2004-07-30 20:26:15 +0000 | [diff] [blame] | 235 | |
Jesper Dangaard Brouer | 292f29b | 2008-04-09 23:01:01 +0200 | [diff] [blame] | 236 | if (tc_calc_rtable(&opt.rate, rtab, cell_log, mtu, linklayer) < 0) { |
org[shemminger]!shemminger | 9e9d615 | 2004-06-07 22:04:51 +0000 | [diff] [blame] | 237 | fprintf(stderr, "htb: failed to calculate rate table.\n"); |
| 238 | return -1; |
| 239 | } |
Eric Dumazet | 8334bb3 | 2013-11-12 14:34:07 -0800 | [diff] [blame] | 240 | opt.buffer = tc_calc_xmittime(rate64, buffer); |
Stephen Hemminger | ae665a5 | 2006-12-05 10:10:22 -0800 | [diff] [blame] | 241 | |
Jesper Dangaard Brouer | 292f29b | 2008-04-09 23:01:01 +0200 | [diff] [blame] | 242 | if (tc_calc_rtable(&opt.ceil, ctab, ccell_log, mtu, linklayer) < 0) { |
org[shemminger]!shemminger | 9e9d615 | 2004-06-07 22:04:51 +0000 | [diff] [blame] | 243 | fprintf(stderr, "htb: failed to calculate ceil rate table.\n"); |
| 244 | return -1; |
| 245 | } |
Eric Dumazet | 8334bb3 | 2013-11-12 14:34:07 -0800 | [diff] [blame] | 246 | opt.cbuffer = tc_calc_xmittime(ceil64, cbuffer); |
org[shemminger]!shemminger | 9e9d615 | 2004-06-07 22:04:51 +0000 | [diff] [blame] | 247 | |
6!tgraf | 1b52a76 | 2005-01-18 01:24:18 +0000 | [diff] [blame] | 248 | tail = NLMSG_TAIL(n); |
org[shemminger]!shemminger | 9e9d615 | 2004-06-07 22:04:51 +0000 | [diff] [blame] | 249 | addattr_l(n, 1024, TCA_OPTIONS, NULL, 0); |
Eric Dumazet | 8334bb3 | 2013-11-12 14:34:07 -0800 | [diff] [blame] | 250 | |
| 251 | if (rate64 >= (1ULL << 32)) |
| 252 | addattr_l(n, 1124, TCA_HTB_RATE64, &rate64, sizeof(rate64)); |
| 253 | |
| 254 | if (ceil64 >= (1ULL << 32)) |
| 255 | addattr_l(n, 1224, TCA_HTB_CEIL64, &ceil64, sizeof(ceil64)); |
| 256 | |
org[shemminger]!shemminger | 9e9d615 | 2004-06-07 22:04:51 +0000 | [diff] [blame] | 257 | addattr_l(n, 2024, TCA_HTB_PARMS, &opt, sizeof(opt)); |
| 258 | addattr_l(n, 3024, TCA_HTB_RTAB, rtab, 1024); |
| 259 | addattr_l(n, 4024, TCA_HTB_CTAB, ctab, 1024); |
6!tgraf | 1b52a76 | 2005-01-18 01:24:18 +0000 | [diff] [blame] | 260 | tail->rta_len = (void *) NLMSG_TAIL(n) - (void *) tail; |
org[shemminger]!shemminger | 9e9d615 | 2004-06-07 22:04:51 +0000 | [diff] [blame] | 261 | return 0; |
| 262 | } |
| 263 | |
| 264 | static int htb_print_opt(struct qdisc_util *qu, FILE *f, struct rtattr *opt) |
| 265 | { |
Eric Dumazet | b43f331 | 2013-09-13 09:10:01 -0700 | [diff] [blame] | 266 | struct rtattr *tb[TCA_HTB_MAX + 1]; |
org[shemminger]!shemminger | 9e9d615 | 2004-06-07 22:04:51 +0000 | [diff] [blame] | 267 | struct tc_htb_opt *hopt; |
| 268 | struct tc_htb_glob *gopt; |
Stephen Hemminger | 32a121c | 2016-03-21 11:48:36 -0700 | [diff] [blame] | 269 | double buffer, cbuffer; |
Jesper Dangaard Brouer | 3e92ff5 | 2013-08-30 14:02:10 +0200 | [diff] [blame] | 270 | unsigned int linklayer; |
Eric Dumazet | 8334bb3 | 2013-11-12 14:34:07 -0800 | [diff] [blame] | 271 | __u64 rate64, ceil64; |
Stephen Hemminger | 32a121c | 2016-03-21 11:48:36 -0700 | [diff] [blame] | 272 | |
org[shemminger]!shemminger | 9e9d615 | 2004-06-07 22:04:51 +0000 | [diff] [blame] | 273 | SPRINT_BUF(b1); |
| 274 | SPRINT_BUF(b2); |
Dmitrii Shcherbakov | 467f9fc | 2015-12-19 18:26:03 +0300 | [diff] [blame] | 275 | SPRINT_BUF(b3); |
org[shemminger]!shemminger | 9e9d615 | 2004-06-07 22:04:51 +0000 | [diff] [blame] | 276 | |
| 277 | if (opt == NULL) |
| 278 | return 0; |
| 279 | |
Eric Dumazet | b43f331 | 2013-09-13 09:10:01 -0700 | [diff] [blame] | 280 | parse_rtattr_nested(tb, TCA_HTB_MAX, opt); |
org[shemminger]!shemminger | 9e9d615 | 2004-06-07 22:04:51 +0000 | [diff] [blame] | 281 | |
| 282 | if (tb[TCA_HTB_PARMS]) { |
Stephen Hemminger | 22fa92e | 2013-06-07 08:54:45 -0700 | [diff] [blame] | 283 | hopt = RTA_DATA(tb[TCA_HTB_PARMS]); |
| 284 | if (RTA_PAYLOAD(tb[TCA_HTB_PARMS]) < sizeof(*hopt)) return -1; |
org[shemminger]!shemminger | 9e9d615 | 2004-06-07 22:04:51 +0000 | [diff] [blame] | 285 | |
| 286 | if (!hopt->level) { |
| 287 | fprintf(f, "prio %d ", (int)hopt->prio); |
| 288 | if (show_details) |
| 289 | fprintf(f, "quantum %d ", (int)hopt->quantum); |
| 290 | } |
Eric Dumazet | 8334bb3 | 2013-11-12 14:34:07 -0800 | [diff] [blame] | 291 | |
| 292 | rate64 = hopt->rate.rate; |
| 293 | if (tb[TCA_HTB_RATE64] && |
| 294 | RTA_PAYLOAD(tb[TCA_HTB_RATE64]) >= sizeof(rate64)) { |
| 295 | rate64 = rta_getattr_u64(tb[TCA_HTB_RATE64]); |
| 296 | } |
| 297 | |
| 298 | ceil64 = hopt->ceil.rate; |
| 299 | if (tb[TCA_HTB_CEIL64] && |
| 300 | RTA_PAYLOAD(tb[TCA_HTB_CEIL64]) >= sizeof(ceil64)) |
| 301 | ceil64 = rta_getattr_u64(tb[TCA_HTB_CEIL64]); |
| 302 | |
| 303 | fprintf(f, "rate %s ", sprint_rate(rate64, b1)); |
Stephen Hemminger | 22fa92e | 2013-06-07 08:54:45 -0700 | [diff] [blame] | 304 | if (hopt->rate.overhead) |
| 305 | fprintf(f, "overhead %u ", hopt->rate.overhead); |
Eric Dumazet | 8334bb3 | 2013-11-12 14:34:07 -0800 | [diff] [blame] | 306 | buffer = tc_calc_xmitsize(rate64, hopt->buffer); |
| 307 | |
| 308 | fprintf(f, "ceil %s ", sprint_rate(ceil64, b1)); |
| 309 | cbuffer = tc_calc_xmitsize(ceil64, hopt->cbuffer); |
Jesper Dangaard Brouer | 3e92ff5 | 2013-08-30 14:02:10 +0200 | [diff] [blame] | 310 | linklayer = (hopt->rate.linklayer & TC_LINKLAYER_MASK); |
| 311 | if (linklayer > TC_LINKLAYER_ETHERNET || show_details) |
Dmitrii Shcherbakov | 467f9fc | 2015-12-19 18:26:03 +0300 | [diff] [blame] | 312 | fprintf(f, "linklayer %s ", sprint_linklayer(linklayer, b3)); |
Stephen Hemminger | 22fa92e | 2013-06-07 08:54:45 -0700 | [diff] [blame] | 313 | if (show_details) { |
Dmitrii Shcherbakov | 1aea7fe | 2015-12-19 18:25:52 +0300 | [diff] [blame] | 314 | fprintf(f, "burst %s/%u mpu %s ", |
Stephen Hemminger | 22fa92e | 2013-06-07 08:54:45 -0700 | [diff] [blame] | 315 | sprint_size(buffer, b1), |
| 316 | 1<<hopt->rate.cell_log, |
Dmitrii Shcherbakov | 1aea7fe | 2015-12-19 18:25:52 +0300 | [diff] [blame] | 317 | sprint_size(hopt->rate.mpu, b2)); |
| 318 | fprintf(f, "cburst %s/%u mpu %s ", |
Stephen Hemminger | 22fa92e | 2013-06-07 08:54:45 -0700 | [diff] [blame] | 319 | sprint_size(cbuffer, b1), |
| 320 | 1<<hopt->ceil.cell_log, |
Dmitrii Shcherbakov | 1aea7fe | 2015-12-19 18:25:52 +0300 | [diff] [blame] | 321 | sprint_size(hopt->ceil.mpu, b2)); |
Stephen Hemminger | 22fa92e | 2013-06-07 08:54:45 -0700 | [diff] [blame] | 322 | fprintf(f, "level %d ", (int)hopt->level); |
| 323 | } else { |
| 324 | fprintf(f, "burst %s ", sprint_size(buffer, b1)); |
| 325 | fprintf(f, "cburst %s ", sprint_size(cbuffer, b1)); |
| 326 | } |
| 327 | if (show_raw) |
| 328 | fprintf(f, "buffer [%08x] cbuffer [%08x] ", |
Stephen Hemminger | 32a121c | 2016-03-21 11:48:36 -0700 | [diff] [blame] | 329 | hopt->buffer, hopt->cbuffer); |
org[shemminger]!shemminger | 9e9d615 | 2004-06-07 22:04:51 +0000 | [diff] [blame] | 330 | } |
| 331 | if (tb[TCA_HTB_INIT]) { |
Stephen Hemminger | 22fa92e | 2013-06-07 08:54:45 -0700 | [diff] [blame] | 332 | gopt = RTA_DATA(tb[TCA_HTB_INIT]); |
| 333 | if (RTA_PAYLOAD(tb[TCA_HTB_INIT]) < sizeof(*gopt)) return -1; |
org[shemminger]!shemminger | 9e9d615 | 2004-06-07 22:04:51 +0000 | [diff] [blame] | 334 | |
Stephen Hemminger | 22fa92e | 2013-06-07 08:54:45 -0700 | [diff] [blame] | 335 | fprintf(f, "r2q %d default %x direct_packets_stat %u", |
Stephen Hemminger | 32a121c | 2016-03-21 11:48:36 -0700 | [diff] [blame] | 336 | gopt->rate2quantum, gopt->defcls, gopt->direct_pkts); |
org[shemminger]!shemminger | 9e9d615 | 2004-06-07 22:04:51 +0000 | [diff] [blame] | 337 | if (show_details) |
Stephen Hemminger | 32a121c | 2016-03-21 11:48:36 -0700 | [diff] [blame] | 338 | fprintf(f, " ver %d.%d", gopt->version >> 16, gopt->version & 0xffff); |
org[shemminger]!shemminger | 9e9d615 | 2004-06-07 22:04:51 +0000 | [diff] [blame] | 339 | } |
Eric Dumazet | b43f331 | 2013-09-13 09:10:01 -0700 | [diff] [blame] | 340 | if (tb[TCA_HTB_DIRECT_QLEN] && |
| 341 | RTA_PAYLOAD(tb[TCA_HTB_DIRECT_QLEN]) >= sizeof(__u32)) { |
| 342 | __u32 direct_qlen = rta_getattr_u32(tb[TCA_HTB_DIRECT_QLEN]); |
| 343 | |
| 344 | fprintf(f, " direct_qlen %u", direct_qlen); |
| 345 | } |
org[shemminger]!shemminger | 9e9d615 | 2004-06-07 22:04:51 +0000 | [diff] [blame] | 346 | return 0; |
| 347 | } |
| 348 | |
| 349 | static int htb_print_xstats(struct qdisc_util *qu, FILE *f, struct rtattr *xstats) |
| 350 | { |
| 351 | struct tc_htb_xstats *st; |
Stephen Hemminger | 32a121c | 2016-03-21 11:48:36 -0700 | [diff] [blame] | 352 | |
org[shemminger]!shemminger | 9e9d615 | 2004-06-07 22:04:51 +0000 | [diff] [blame] | 353 | if (xstats == NULL) |
| 354 | return 0; |
| 355 | |
| 356 | if (RTA_PAYLOAD(xstats) < sizeof(*st)) |
| 357 | return -1; |
| 358 | |
| 359 | st = RTA_DATA(xstats); |
Stephen Hemminger | ae665a5 | 2006-12-05 10:10:22 -0800 | [diff] [blame] | 360 | fprintf(f, " lended: %u borrowed: %u giants: %u\n", |
Stephen Hemminger | 32a121c | 2016-03-21 11:48:36 -0700 | [diff] [blame] | 361 | st->lends, st->borrows, st->giants); |
| 362 | fprintf(f, " tokens: %d ctokens: %d\n", st->tokens, st->ctokens); |
org[shemminger]!shemminger | 9e9d615 | 2004-06-07 22:04:51 +0000 | [diff] [blame] | 363 | return 0; |
| 364 | } |
| 365 | |
net[shemminger]!kaber | 95812b5 | 2004-09-28 18:35:49 +0000 | [diff] [blame] | 366 | struct qdisc_util htb_qdisc_util = { |
Stephen Hemminger | 32a121c | 2016-03-21 11:48:36 -0700 | [diff] [blame] | 367 | .id = "htb", |
osdl.net!shemminger | f2f99e2 | 2004-08-31 17:45:21 +0000 | [diff] [blame] | 368 | .parse_qopt = htb_parse_opt, |
| 369 | .print_qopt = htb_print_opt, |
Stephen Hemminger | 32a121c | 2016-03-21 11:48:36 -0700 | [diff] [blame] | 370 | .print_xstats = htb_print_xstats, |
osdl.net!shemminger | f2f99e2 | 2004-08-31 17:45:21 +0000 | [diff] [blame] | 371 | .parse_copt = htb_parse_class_opt, |
| 372 | .print_copt = htb_print_opt, |
org[shemminger]!shemminger | 9e9d615 | 2004-06-07 22:04:51 +0000 | [diff] [blame] | 373 | }; |