/*
 * tc_core.c            TC core library.
 *
 *              This program is free software; you can redistribute it and/or
 *              modify it under the terms of the GNU General Public License
 *              as published by the Free Software Foundation; either version
 *              2 of the License, or (at your option) any later version.
 *
 * Authors:     Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
 *
 */

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <unistd.h>
#include <fcntl.h>
#include <math.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <string.h>

#include "utils.h"
#include "tc_core.h"
#include <linux/atm.h>

static double tick_in_usec = 1;
static double clock_factor = 1;

int tc_core_time2big(unsigned int time)
{
        __u64 t = time;

        t *= tick_in_usec;
        return (t >> 32) != 0;
}


unsigned int tc_core_time2tick(unsigned int time)
{
        return time*tick_in_usec;
}

unsigned int tc_core_tick2time(unsigned int tick)
{
        return tick/tick_in_usec;
}

unsigned int tc_core_time2ktime(unsigned int time)
{
        return time * clock_factor;
}

unsigned int tc_core_ktime2time(unsigned int ktime)
{
        return ktime / clock_factor;
}

unsigned int tc_calc_xmittime(__u64 rate, unsigned int size)
{
        return tc_core_time2tick(TIME_UNITS_PER_SEC*((double)size/(double)rate));
}

unsigned int tc_calc_xmitsize(__u64 rate, unsigned int ticks)
{
        return ((double)rate*tc_core_tick2time(ticks))/TIME_UNITS_PER_SEC;
}

/*
 * The align to ATM cells is used for determining the (ATM) SAR
 * alignment overhead at the ATM layer. (SAR = Segmentation And
 * Reassembly).  This is for example needed when scheduling packet on
 * an ADSL connection.  Note that the extra ATM-AAL overhead is _not_
 * included in this calculation. This overhead is added in the kernel
 * before doing the rate table lookup, as this gives better precision
 * (as the table will always be aligned for 48 bytes).
 *  --Hawk, d.7/11-2004. <hawk@diku.dk>
 */
static unsigned int tc_align_to_atm(unsigned int size)
{
        int linksize, cells;

        cells = size / ATM_CELL_PAYLOAD;
        if ((size % ATM_CELL_PAYLOAD) > 0)
                cells++;

        linksize = cells * ATM_CELL_SIZE; /* Use full cell size to add ATM tax */
        return linksize;
}

static unsigned int tc_adjust_size(unsigned int sz, unsigned int mpu, enum link_layer linklayer)
{
        if (sz < mpu)
                sz = mpu;

        switch (linklayer) {
        case LINKLAYER_ATM:
                return tc_align_to_atm(sz);
        case LINKLAYER_ETHERNET:
        default:
                /* No size adjustments on Ethernet */
                return sz;
        }
}

/* Notice, the rate table calculated here, have gotten replaced in the
 * kernel and is no-longer used for lookups.
 *
 * This happened in kernel release v3.8 caused by kernel
 *  - commit 56b765b79 ("htb: improved accuracy at high rates").
 * This change unfortunately caused breakage of tc overhead and
 * linklayer parameters.
 *
 * Kernel overhead handling got fixed in kernel v3.10 by
 * - commit 01cb71d2d47 (net_sched: restore "overhead xxx" handling)
 *
 * Kernel linklayer handling got fixed in kernel v3.11 by
 * - commit 8a8e3d84b17 (net_sched: restore "linklayer atm" handling)
 */

/*
   rtab[pkt_len>>cell_log] = pkt_xmit_time
 */

int tc_calc_rtable(struct tc_ratespec *r, __u32 *rtab,
                   int cell_log, unsigned int mtu,
                   enum link_layer linklayer)
{
        int i;
        unsigned int sz;
        unsigned int bps = r->rate;
        unsigned int mpu = r->mpu;

        if (mtu == 0)
                mtu = 2047;

        if (cell_log < 0) {
                cell_log = 0;
                while ((mtu >> cell_log) > 255)
                        cell_log++;
        }

        for (i = 0; i < 256; i++) {
                sz = tc_adjust_size((i + 1) << cell_log, mpu, linklayer);
                rtab[i] = tc_calc_xmittime(bps, sz);
        }

        r->cell_align =  -1;
        r->cell_log = cell_log;
        r->linklayer = (linklayer & TC_LINKLAYER_MASK);
        return cell_log;
}

int tc_calc_rtable_64(struct tc_ratespec *r, __u32 *rtab,
                   int cell_log, unsigned int mtu,
                   enum link_layer linklayer, __u64 rate)
{
        int i;
        unsigned int sz;
        __u64 bps = rate;
        unsigned int mpu = r->mpu;

        if (mtu == 0)
                mtu = 2047;

        if (cell_log < 0) {
                cell_log = 0;
                while ((mtu >> cell_log) > 255)
                        cell_log++;
        }

        for (i = 0; i < 256; i++) {
                sz = tc_adjust_size((i + 1) << cell_log, mpu, linklayer);
                rtab[i] = tc_calc_xmittime(bps, sz);
        }

        r->cell_align =  -1;
        r->cell_log = cell_log;
        r->linklayer = (linklayer & TC_LINKLAYER_MASK);
        return cell_log;
}

/*
   stab[pkt_len>>cell_log] = pkt_xmit_size>>size_log
 */

int tc_calc_size_table(struct tc_sizespec *s, __u16 **stab)
{
        int i;
        enum link_layer linklayer = s->linklayer;
        unsigned int sz;

        if (linklayer <= LINKLAYER_ETHERNET && s->mpu == 0) {
                /* don't need data table in this case (only overhead set) */
                s->mtu = 0;
                s->tsize = 0;
                s->cell_log = 0;
                s->cell_align = 0;
                *stab = NULL;
                return 0;
        }

        if (s->mtu == 0)
                s->mtu = 2047;
        if (s->tsize == 0)
                s->tsize = 512;

        s->cell_log = 0;
        while ((s->mtu >> s->cell_log) > s->tsize - 1)
                s->cell_log++;

        *stab = malloc(s->tsize * sizeof(__u16));
        if (!*stab)
                return -1;

again:
        for (i = s->tsize - 1; i >= 0; i--) {
                sz = tc_adjust_size((i + 1) << s->cell_log, s->mpu, linklayer);
                if ((sz >> s->size_log) > UINT16_MAX) {
                        s->size_log++;
                        goto again;
                }
                (*stab)[i] = sz >> s->size_log;
        }

        s->cell_align = -1; /* Due to the sz calc */
        return 0;
}

int tc_core_init(void)
{
        FILE *fp;
        __u32 clock_res;
        __u32 t2us;
        __u32 us2t;

        fp = fopen("/proc/net/psched", "r");
        if (fp == NULL)
                return -1;

        if (fscanf(fp, "%08x%08x%08x", &t2us, &us2t, &clock_res) != 3) {
                fclose(fp);
                return -1;
        }
        fclose(fp);

        /* compatibility hack: for old iproute binaries (ignoring
         * the kernel clock resolution) the kernel advertises a
         * tick multiplier of 1000 in case of nano-second resolution,
         * which really is 1. */
        if (clock_res == 1000000000)
                t2us = us2t;

        clock_factor  = (double)clock_res / TIME_UNITS_PER_SEC;
        tick_in_usec = (double)t2us / us2t * clock_factor;
        return 0;
}