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
27static double tick_in_usec = 1;
28static double clock_factor = 1;
29
30int tc_core_time2big(unsigned time)
31{
32	__u64 t = time;
33
34	t *= tick_in_usec;
35	return (t >> 32) != 0;
36}
37
38
39unsigned tc_core_time2tick(unsigned time)
40{
41	return time*tick_in_usec;
42}
43
44unsigned tc_core_tick2time(unsigned tick)
45{
46	return tick/tick_in_usec;
47}
48
49unsigned tc_core_time2ktime(unsigned time)
50{
51	return time * clock_factor;
52}
53
54unsigned tc_core_ktime2time(unsigned ktime)
55{
56	return ktime / clock_factor;
57}
58
59unsigned tc_calc_xmittime(__u64 rate, unsigned size)
60{
61	return tc_core_time2tick(TIME_UNITS_PER_SEC*((double)size/(double)rate));
62}
63
64unsigned 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 */
79static 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
90static 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
124int 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
157int 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
186again:
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
200int 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