tc/tc_core.c

   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
  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(unsigned rate, unsigned size)
  60 {
  61         return tc_core_time2tick(TIME_UNITS_PER_SEC*((double)size/rate));
  62 }
  63
  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  */
  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 }