GENIEducation/SampleAssignments/TcpAssignment/ForInstructors: tcp_exp_answer_v2.c

#include <net/tcp.h>
#include <linux/module.h>

int sysctl_tcp_max_ssthresh = 0;

/* In theory this is tp->snd_cwnd += 1 / tp->snd_cwnd (or alternative w) */
void tcp_cong_avoid_ai(struct tcp_sock *tp, u32 w)
{
        if (tp->snd_cwnd_cnt >= w) {
                if (tp->snd_cwnd < tp->snd_cwnd_clamp)
                        tp->snd_cwnd++;
                tp->snd_cwnd_cnt = 0;
        } else {
                tp->snd_cwnd_cnt++;
        }
}

static void exp_slow_start(struct tcp_sock *tp)
{
    /* Handle cwnd manipulation for slow start here */
        int cnt; /* increase in packets */
        unsigned int delta = 0;
        u32 snd_cwnd = tp->snd_cwnd;

        if (unlikely(!snd_cwnd)) {
                printk("snd_cwnd is nul, please report this bug.\n");
                snd_cwnd = 1U;
        }

        if (sysctl_tcp_max_ssthresh > 0 && tp->snd_cwnd > sysctl_tcp_max_ssthresh)
                cnt = sysctl_tcp_max_ssthresh >> 1;     /* limited slow start */
        else
                cnt = snd_cwnd * 2;     /* changed by Shufeng - exponential factor 3 increase */

        tp->snd_cwnd_cnt += cnt;
        while (tp->snd_cwnd_cnt >= snd_cwnd) {
                tp->snd_cwnd_cnt -= snd_cwnd;
                delta++;
        }
        tp->snd_cwnd = min(snd_cwnd + delta, tp->snd_cwnd_clamp);
}

static void exp_cong_avoid(struct sock *sk, u32 adk, u32 in_flight)
{
    /* Handle cwnd manipulation for congestion avoidance here */
        struct tcp_sock *tp = tcp_sk(sk);

        if (!tcp_is_cwnd_limited(sk, in_flight))
                return;

        /* In "safe" area, increase. */
        if (tp->snd_cwnd <= tp->snd_ssthresh)
                exp_slow_start(tp);
        /* In dangerous area, increase slowly. */
        else
                tcp_cong_avoid_ai(tp, tp->snd_cwnd);
}

static u32 exp_ssthresh(struct sock *sk)
{
    /* Compute the appropriate value of ssthresh here */
        const struct tcp_sock *tp = tcp_sk(sk);
        return max(tp->snd_cwnd*3/4, 2U); //changed by Shufeng
}


//See  http://lwn.net/Articles/128681/ for more information
/*
 * The start() method initializes the algorithm when a new batch of data
 * is being transmitted; this can happen for new sockets, or when one
 * has been idle for a while.
 *
 * The ssthresh() method calculates the "slow start threshold"; when the
 * congestion window is below that threshold, the connection is in slow
 * start mode rather than full congestion avoidance mode. This method is
 * called when congestion occurs.
 *
 * The actual initial window may be set by min_cwnd() to be less than
 * the threshold value as a starting point for the slow start algorithm.
 * 
 * When an acknowledgment arrives from the remote end, the cong_avoid()
 * method is invoked; it may respond to successful packet delivery by
 * enlarging the congestion window.
 * 
 * rtt_sample() tells the algorithm about a measured round-trip time -
 * the time taken between sending a packet and receiving the
 * corresponding acknowledgment.
 * 
 * set_state() indicates that the TCP state of the socket has changed.
 * 
 * Various events of interest can be communicated to the algorithm via
 * cwnd_event().
 * 
 * Sometimes, transient situations can cause the congestion window to be
 * reduced; the undo_cwnd() method can be called when such a situation
 * is detected to restore a larger window.
 * 
 * The get_info() method can be used to make congestion avoidance
 * information available to user space.
 */
static struct tcp_congestion_ops tcp_exp __read_mostly = {
    .init       = NULL,
    .ssthresh   = exp_ssthresh,
    .cong_avoid = exp_cong_avoid,
    .min_cwnd   = tcp_reno_min_cwnd,
    
    .owner      = THIS_MODULE,
    .name       = "exp"
};

static int __init exp_register(void)
{
        return tcp_register_congestion_control(&tcp_exp);
}

static void __exit exp_unregister(void)
{
        tcp_unregister_congestion_control(&tcp_exp);
}

module_init(exp_register);
module_exit(exp_unregister);

MODULE_AUTHOR("Shufeng Huang");
MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("Experimental TCP");