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(unsigned rate,unsigned size)59 unsigned tc_calc_xmittime(unsigned rate, unsigned size)
60 {
61 return tc_core_time2tick(TIME_UNITS_PER_SEC*((double)size/rate));
62 }
63
tc_calc_xmitsize(unsigned rate,unsigned ticks)64 unsigned tc_calc_xmitsize(unsigned 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 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 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 /*
106 rtab[pkt_len>>cell_log] = pkt_xmit_time
107 */
108
tc_calc_rtable(struct tc_ratespec * r,__u32 * rtab,int cell_log,unsigned mtu,enum link_layer linklayer)109 int tc_calc_rtable(struct tc_ratespec *r, __u32 *rtab,
110 int cell_log, unsigned mtu,
111 enum link_layer linklayer)
112 {
113 int i;
114 unsigned sz;
115 unsigned bps = r->rate;
116 unsigned mpu = r->mpu;
117
118 if (mtu == 0)
119 mtu = 2047;
120
121 if (cell_log < 0) {
122 cell_log = 0;
123 while ((mtu >> cell_log) > 255)
124 cell_log++;
125 }
126
127 for (i=0; i<256; i++) {
128 sz = tc_adjust_size((i + 1) << cell_log, mpu, linklayer);
129 rtab[i] = tc_calc_xmittime(bps, sz);
130 }
131
132 r->cell_align=-1; // Due to the sz calc
133 r->cell_log=cell_log;
134 return cell_log;
135 }
136
137 /*
138 stab[pkt_len>>cell_log] = pkt_xmit_size>>size_log
139 */
140
tc_calc_size_table(struct tc_sizespec * s,__u16 ** stab)141 int tc_calc_size_table(struct tc_sizespec *s, __u16 **stab)
142 {
143 int i;
144 enum link_layer linklayer = s->linklayer;
145 unsigned int sz;
146
147 if (linklayer <= LINKLAYER_ETHERNET && s->mpu == 0) {
148 /* don't need data table in this case (only overhead set) */
149 s->mtu = 0;
150 s->tsize = 0;
151 s->cell_log = 0;
152 s->cell_align = 0;
153 *stab = NULL;
154 return 0;
155 }
156
157 if (s->mtu == 0)
158 s->mtu = 2047;
159 if (s->tsize == 0)
160 s->tsize = 512;
161
162 s->cell_log = 0;
163 while ((s->mtu >> s->cell_log) > s->tsize - 1)
164 s->cell_log++;
165
166 *stab = malloc(s->tsize * sizeof(__u16));
167 if (!*stab)
168 return -1;
169
170 again:
171 for (i = s->tsize - 1; i >= 0; i--) {
172 sz = tc_adjust_size((i + 1) << s->cell_log, s->mpu, linklayer);
173 if ((sz >> s->size_log) > UINT16_MAX) {
174 s->size_log++;
175 goto again;
176 }
177 (*stab)[i] = sz >> s->size_log;
178 }
179
180 s->cell_align = -1; // Due to the sz calc
181 return 0;
182 }
183
tc_core_init()184 int tc_core_init()
185 {
186 FILE *fp;
187 __u32 clock_res;
188 __u32 t2us;
189 __u32 us2t;
190
191 fp = fopen("/proc/net/psched", "r");
192 if (fp == NULL)
193 return -1;
194
195 if (fscanf(fp, "%08x%08x%08x", &t2us, &us2t, &clock_res) != 3) {
196 fclose(fp);
197 return -1;
198 }
199 fclose(fp);
200
201 /* compatibility hack: for old iproute binaries (ignoring
202 * the kernel clock resolution) the kernel advertises a
203 * tick multiplier of 1000 in case of nano-second resolution,
204 * which really is 1. */
205 if (clock_res == 1000000000)
206 t2us = us2t;
207
208 clock_factor = (double)clock_res / TIME_UNITS_PER_SEC;
209 tick_in_usec = (double)t2us / us2t * clock_factor;
210 return 0;
211 }
212