• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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@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 
tc_core_time2big(unsigned time)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 
tc_core_time2tick(unsigned time)39 unsigned tc_core_time2tick(unsigned time)
40 {
41 	return time*tick_in_usec;
42 }
43 
tc_core_tick2time(unsigned tick)44 unsigned tc_core_tick2time(unsigned tick)
45 {
46 	return tick/tick_in_usec;
47 }
48 
tc_core_time2ktime(unsigned time)49 unsigned tc_core_time2ktime(unsigned time)
50 {
51 	return time * clock_factor;
52 }
53 
tc_core_ktime2time(unsigned ktime)54 unsigned tc_core_ktime2time(unsigned ktime)
55 {
56 	return ktime / clock_factor;
57 }
58 
tc_calc_xmittime(__u64 rate,unsigned size)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 
tc_calc_xmitsize(__u64 rate,unsigned ticks)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@diku.dk>
78  */
tc_align_to_atm(unsigned size)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 
tc_adjust_size(unsigned sz,unsigned mpu,enum link_layer linklayer)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 
tc_calc_rtable(struct tc_ratespec * r,__u32 * rtab,int cell_log,unsigned mtu,enum link_layer linklayer)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 
tc_calc_size_table(struct tc_sizespec * s,__u16 ** stab)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 
tc_core_init(void)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