1 /* 2 * tc_core.c TC core library. 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: Alexey Kuznetsov, <kuznet (at) ms2.inr.ac.ru> 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 <math.h> 19 #include <sys/socket.h> 20 #include <netinet/in.h> 21 #include <arpa/inet.h> 22 #include <string.h> 23 24 #include "tc_core.h" 25 #include <linux/atm.h> 26 27 static double tick_in_usec = 1; 28 static double clock_factor = 1; 29 30 int tc_core_time2big(unsigned time) 31 { 32 __u64 t = time; 33 34 t *= tick_in_usec; 35 return (t >> 32) != 0; 36 } 37 38 39 unsigned tc_core_time2tick(unsigned time) 40 { 41 return time*tick_in_usec; 42 } 43 44 unsigned tc_core_tick2time(unsigned tick) 45 { 46 return tick/tick_in_usec; 47 } 48 49 unsigned tc_core_time2ktime(unsigned time) 50 { 51 return time * clock_factor; 52 } 53 54 unsigned tc_core_ktime2time(unsigned ktime) 55 { 56 return ktime / clock_factor; 57 } 58 59 unsigned tc_calc_xmittime(__u64 rate, unsigned size) 60 { 61 return tc_core_time2tick(TIME_UNITS_PER_SEC*((double)size/(double)rate)); 62 } 63 64 unsigned tc_calc_xmitsize(__u64 rate, unsigned ticks) 65 { 66 return ((double)rate*tc_core_tick2time(ticks))/TIME_UNITS_PER_SEC; 67 } 68 69 /* 70 * The align to ATM cells is used for determining the (ATM) SAR 71 * alignment overhead at the ATM layer. (SAR = Segmentation And 72 * Reassembly). This is for example needed when scheduling packet on 73 * an ADSL connection. Note that the extra ATM-AAL overhead is _not_ 74 * included in this calculation. This overhead is added in the kernel 75 * before doing the rate table lookup, as this gives better precision 76 * (as the table will always be aligned for 48 bytes). 77 * --Hawk, d.7/11-2004. <hawk (at) diku.dk> 78 */ 79 static unsigned tc_align_to_atm(unsigned size) 80 { 81 int linksize, cells; 82 cells = size / ATM_CELL_PAYLOAD; 83 if ((size % ATM_CELL_PAYLOAD) > 0) 84 cells++; 85 86 linksize = cells * ATM_CELL_SIZE; /* Use full cell size to add ATM tax */ 87 return linksize; 88 } 89 90 static unsigned tc_adjust_size(unsigned sz, unsigned mpu, enum link_layer linklayer) 91 { 92 if (sz < mpu) 93 sz = mpu; 94 95 switch (linklayer) { 96 case LINKLAYER_ATM: 97 return tc_align_to_atm(sz); 98 case LINKLAYER_ETHERNET: 99 default: 100 // No size adjustments on Ethernet 101 return sz; 102 } 103 } 104 105 /* Notice, the rate table calculated here, have gotten replaced in the 106 * kernel and is no-longer used for lookups. 107 * 108 * This happened in kernel release v3.8 caused by kernel 109 * - commit 56b765b79 ("htb: improved accuracy at high rates"). 110 * This change unfortunately caused breakage of tc overhead and 111 * linklayer parameters. 112 * 113 * Kernel overhead handling got fixed in kernel v3.10 by 114 * - commit 01cb71d2d47 (net_sched: restore "overhead xxx" handling) 115 * 116 * Kernel linklayer handling got fixed in kernel v3.11 by 117 * - commit 8a8e3d84b17 (net_sched: restore "linklayer atm" handling) 118 */ 119 120 /* 121 rtab[pkt_len>>cell_log] = pkt_xmit_time 122 */ 123 124 int tc_calc_rtable(struct tc_ratespec *r, __u32 *rtab, 125 int cell_log, unsigned mtu, 126 enum link_layer linklayer) 127 { 128 int i; 129 unsigned sz; 130 unsigned bps = r->rate; 131 unsigned mpu = r->mpu; 132 133 if (mtu == 0) 134 mtu = 2047; 135 136 if (cell_log < 0) { 137 cell_log = 0; 138 while ((mtu >> cell_log) > 255) 139 cell_log++; 140 } 141 142 for (i=0; i<256; i++) { 143 sz = tc_adjust_size((i + 1) << cell_log, mpu, linklayer); 144 rtab[i] = tc_calc_xmittime(bps, sz); 145 } 146 147 r->cell_align=-1; // Due to the sz calc 148 r->cell_log=cell_log; 149 r->linklayer = (linklayer & TC_LINKLAYER_MASK); 150 return cell_log; 151 } 152 153 /* 154 stab[pkt_len>>cell_log] = pkt_xmit_size>>size_log 155 */ 156 157 int tc_calc_size_table(struct tc_sizespec *s, __u16 **stab) 158 { 159 int i; 160 enum link_layer linklayer = s->linklayer; 161 unsigned int sz; 162 163 if (linklayer <= LINKLAYER_ETHERNET && s->mpu == 0) { 164 /* don't need data table in this case (only overhead set) */ 165 s->mtu = 0; 166 s->tsize = 0; 167 s->cell_log = 0; 168 s->cell_align = 0; 169 *stab = NULL; 170 return 0; 171 } 172 173 if (s->mtu == 0) 174 s->mtu = 2047; 175 if (s->tsize == 0) 176 s->tsize = 512; 177 178 s->cell_log = 0; 179 while ((s->mtu >> s->cell_log) > s->tsize - 1) 180 s->cell_log++; 181 182 *stab = malloc(s->tsize * sizeof(__u16)); 183 if (!*stab) 184 return -1; 185 186 again: 187 for (i = s->tsize - 1; i >= 0; i--) { 188 sz = tc_adjust_size((i + 1) << s->cell_log, s->mpu, linklayer); 189 if ((sz >> s->size_log) > UINT16_MAX) { 190 s->size_log++; 191 goto again; 192 } 193 (*stab)[i] = sz >> s->size_log; 194 } 195 196 s->cell_align = -1; // Due to the sz calc 197 return 0; 198 } 199 200 int tc_core_init(void) 201 { 202 FILE *fp; 203 __u32 clock_res; 204 __u32 t2us; 205 __u32 us2t; 206 207 fp = fopen("/proc/net/psched", "r"); 208 if (fp == NULL) 209 return -1; 210 211 if (fscanf(fp, "%08x%08x%08x", &t2us, &us2t, &clock_res) != 3) { 212 fclose(fp); 213 return -1; 214 } 215 fclose(fp); 216 217 /* compatibility hack: for old iproute binaries (ignoring 218 * the kernel clock resolution) the kernel advertises a 219 * tick multiplier of 1000 in case of nano-second resolution, 220 * which really is 1. */ 221 if (clock_res == 1000000000) 222 t2us = us2t; 223 224 clock_factor = (double)clock_res / TIME_UNITS_PER_SEC; 225 tick_in_usec = (double)t2us / us2t * clock_factor; 226 return 0; 227 } 228
