retransmit loop bugfix

[cor_2_6_31.git] / net / cor / cor.h

/*
 *      Connection oriented routing
 *      Copyright (C) 2007-2008 Michael Blizek
 *
 *      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.
 *
 *      This program is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *      GNU General Public License for more details.
 *
 *      You should have received a copy of the GNU General Public License
 *      along with this program; if not, write to the Free Software
 *      Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 *      02110-1301, USA.
 */

#include <asm/atomic.h>

#include <linux/types.h>
#include <linux/netdevice.h>
#include <linux/skbuff.h>
#include <linux/spinlock.h>
#include <linux/workqueue.h>

#include "settings.h"


/* options */
#define PIDOUT_NEWCONN 16
#define PIDOUT_SENDDEF_THRES 8
#define PIDOUT_SENDDEF_COUNT 16



#define ETH_P_COR 0x1022
#define AF_COR 37
#define PF_COR AF_COR

#define SOCKADDRTYPE_PORT 1
struct cor_sockaddr {
        int type;
        
        union {
                __be64 port;
        } addr;
};

#define MAX_CONN_CMD_LEN 4096


#define PACKET_TYPE_ANNOUNCE 1
#define PACKET_TYPE_DATA 2

/*
 * Kernel packet data - these commands are sent by the neighbor
 * The end nodes may cause these commands to be sent, but they see them beyond
 * the first hop.
 */

/* KP_PADDING[1] */
#define KP_PADDING 1

/* KP_[N]ACK[1] sent_conn_id[4] seqno[4]
 * 
 * sent_conn_id means that this is *not* the conn_id we use if we sent something
 * through this conn, but the conn_id that the neighbor used to send us the
 * packet
 */
#define KP_ACK 2

/*
 * KP_SPEED[1] conn_id[4] speedinfo[2]
 * 
 * speedinfo[2] =
 *     buffer_state_value = speedinfo % 181
 *     speed_value = speedinfo / 181
 *
 *     buffer_state = 1024 * pow(2, buffer_state_value/3.0)
 *     speed = 1024 * pow(2, speed_value/12.0)
 *   see the .0 ...
 *
 * This has to be done either with floating points (which is no so nice) or
 * you can calculate:
 *     buffer_state =  pow(2, value/3) *
 *         1024 * pow(pow(2, 1.0/3), buffer_state_value%3)
 *   where 1024 * pow(pow(2, 1.0/4), value%3) can be just a table lookup
 *   (the "1024" should be part of the value in the table, because it increases
 *   the accuracy)
 *
 *   you can do the same with the speed
 *
 *
 * Some values have special meanings:
 *   if speedinfo is the highest possible value(65535), it means both values
 *     are inifinite
 *   if buffer_state_value if > 91, you have to subtract 90 and make the
 *     resulting buffer_state negative
 */
#define KP_SPEED 3

/* NOTE on connection ids:
 * connection ids we send are used for the receive channel
 * connection ids we receive are used for the send channel
 */

/*
 * incoming connection
 * KP_CONNECT[1] conn_id[4]
 */
#define KP_CONNECT 4

/*
 * incoming connection successful,
 * the first conn_id is the same as previously sent/received in KP_CONNECT
 * the second conn_id is generated by us and used for the other direction
 * KP_CONNECT_SUCCESS[1] conn_id[4] conn_id[4]
 */
#define KP_CONNECT_SUCCESS 5

/* KP_CONN_DATA[1] conn_id[4] seqno[4] length[4] data[length] */
#define KP_CONN_DATA 6

/*
 * { KP_RESET_CONN[1] conn_id[4] }
 * We send this, if there is an established connection we want to close.
 */
#define KP_RESET_CONN 7


/*
 * Connection data which in interpreted when connection has no target yet
 * These commands are sent by the end node.
 *
 * Format:
 * cmd[2] length[4] parameter[length]
 * unrecogniced commands are ignored
 * parameters which are longer than expected are ignored as well
 */

/* outgoing connection: CD_CONNECT_NB[2] length[4]
 * addrtypelen[2] addrlen[2] addrtype[addrtypelen] addr[addrlen] */
#define CD_CONNECT_NB 1

/* connection to local open part: CD_CONNECT_PORT[2] length[4] port[8] */
#define CD_CONNECT_PORT 2

/*
 * CD_LIST_NEIGH sends CDR_BINDATA if the command was successful. The response
 * format is:
 * 
 * totalneighs[4] response_rows[4]
 * for every row:
 *   numaddr[2] (addrtypelen[2] addrlen[2] addrtype[addrtypelen] addr[addrlen]
 *       )[numaddr]
 * 
 * Neighbors have to be sorted by uptime, new neighbors first. This is so that
 * the routing daemon can easily find out whether there are new neighbors. It
 * only needs to send a query with offset 0. If the totalneighs stays the same
 * while new were added, a connection to another neighbor was lost.
 */

/* list connected neighbors: CD_LIST_NEIGH[2] length[4] limit[4] offset[4] */
#define CD_LIST_NEIGH 3

/*
 * Connection data response
 * Format is the same as with connection data
 */

/*
 * {CDR_EXECOK[2] || CDR_EXECFAILED[2]}
 * reasoncode[2] reasontextlength[2] reasontext[reasontextlength]
 * reasontextlength may be 0
 */
#define CDR_EXECOK 32768
        #define CDR_EXECOK_OK 33024

#define CDR_EXECFAILED 32769
        #define CDR_EXECFAILED_UNKNOWN_COMMAND 33280
        #define CDR_EXECFAILED_PERMISSION_DENIED 33281
        #define CDR_EXECFAILED_TEMPORARILY_OUT_OF_RESSOURCES 33282
        #define CDR_EXECFAILED_CMD_TOO_SHORT 33283
        #define CDR_EXECFAILED_CMD_TOO_LONG 33284
        #define CDR_EXECFAILED_TARGETADDRTYPE_UNKNOWN 33285
        #define CDR_EXECFAILED_TARGETADDR_DOESNTEXIST 33286
        #define CDR_EXECFAILED_TARGETADDR_PORTCLOSED 33287
        #define CDR_EXECFAILED_LISTENERQUEUE_FULL 33288

/*
 * must be sent after CDR_EXEC{OK|FAILED}
 * CDR_EXEOK_BINDATA[2] bindatalen[4] bindata[bindatalen] */
#define CDR_BINDATA 32770


/* result codes for rcv.c/proc_packet */
#define RC_DROP 0
#define RC_FINISHED 1

#define RC_RCV1_ANNOUNCE 2
#define RC_RCV1_KERNEL 3
#define RC_RCV1_CONN 4

struct ref_counter;

struct ref_counter_def{
        /*
         * implemented by user, frees struct containing the mem_counter when
         * refs == 0
         */
        void (*free)(struct ref_counter *cnt);
};

struct ref_counter{
        spinlock_t lock;
        
        /* initialised with 1 */
        int refs;
        
        /* should be a pointer to a global variable */
        struct ref_counter_def *def;
};

struct htab_entry{
        /* start of next element, *not* next htab_entry */
        void *next;
};

struct htable{
        struct htab_entry **htable;
        __u32 htable_size;
        __u32 cell_size;
        __u32 num_elements;
        
        int (*matches)(void *htentry, void *searcheditem);
        __u32 key_offset;
        __u32 entry_offset;
        __u32 ref_counter_offset;
};

struct neighbor{
        struct list_head nb_list;
        
        struct ref_counter refs;

        struct net_device *dev;
        char mac[MAX_ADDR_LEN];
        
        char *addr;
        __u16 addrlen;

        struct delayed_work cmsg_timer;
        struct mutex cmsg_lock;
        struct list_head control_msgs_out;
        __u64 timeout;
        __u32 length;
        atomic_t kpacket_seqno;

        atomic_t ooo_packets;

        __u32 latency;

        /*
         * connecions which receive data from/send data to this node
         * used when terminating all connections of a neighbor
         */
        struct mutex conn_list_lock;
        struct list_head rcv_conn_list;
        struct list_head snd_conn_list;

        /*
         * the timer has to be inited when adding the neighbor
         * init_timer(struct timer_list * timer);
         * add_timer(struct timer_list * timer);
         */
        spinlock_t retrans_lock;
        struct timer_list retrans_timer;

        /*
         * next_retransmit are linked with
         * skb_procstate->funcstate.retransmit_queue
         * because the sk_buff next/prev fields are needed by the hashtable
         */
        struct sk_buff_head retrans_list;

        struct conn *firstboundconn;
};

struct cor_sched_data{
        spinlock_t lock;
        struct list_head conn_list;
        struct sk_buff_head requeue_queue;
};

#define TYPE_BUF 0
#define TYPE_SKB 1

struct data_buf_item{
        struct list_head buf_list;
        
        union {
                struct {
                        char *buf;
                        __u32 datalen;
                        
                }buf;
                
                struct sk_buff *skb;
        }data;
        
        __u8 type;
};

struct data_buf{
        struct list_head items;
        struct data_buf_item *lastread;
        __u64 first_offset;
        __u64 read_offset;
        
        __u32 totalsize;
        __u32 read_remaining;
        
        __u32 last_read_offset;
        
        __u32 last_buflen;
};

struct connlistener;

struct bindnode{
        struct list_head lh;
        struct connlistener *owner;
        __be64 port;
};

#define SOCKSTATE_LISTENER 1
#define SOCKSTATE_CONN 2

struct sock_hdr {
        /* The first member of connlistener/conn (see sock.c) */
        __u8 sockstate;
};

struct connlistener {
        /* The first member has to be the same as in conn (see sock.c) */
        __u8 sockstate;
        struct bindnode *bn;
        struct mutex lock;
        int queue_maxlen;
        int queue_len;
        struct list_head conn_queue;
        wait_queue_head_t wait;
        
};

/*
 * There are 2 conn objects per bi-directional connection. They refer to each
 * other with in the reversedir field. To distinguish them, the variables on
 * the stack are usually called rconn and sconn. rconn refers to the conn object
 * which has received a command. sconn is the other conn object. This means that
 * in send functions rconn means the connection we want to send the command to.
 */

struct conn{
        /* The first member has to be the same as in connlistener (see sock.c)*/
        __u8 sockstate; 
        
#define SOURCE_NONE 0
#define SOURCE_IN 1
#define SOURCE_SOCK 2

#define TARGET_UNCONNECTED 0
#define TARGET_OUT 1
#define TARGET_SOCK 2

        __u8    sourcetype:4,
                targettype:4;
        __u8 isreset;
        __u8 qdisc_active;
        struct list_head queue_list;
        
        /* todo: convert to kref */
        struct ref_counter refs;
                
        struct mutex rcv_lock;

        /* state */
        __u32 credits;
        /* credit rate */
        __s32 sender_crate;
        __s32 resp_crate;

        union{
                struct{
                        struct neighbor *nb;
                        /* list of all connections from this neighbor */
                        struct list_head nb_list;
                        
                        struct sk_buff_head reorder_queue;
                        
                        struct htab_entry htab_entry;
                        __u32 conn_id;
                        __u32 next_seqno;
                        __u32 ooo_packets;
                }in;

                struct{
                        struct list_head cl_list;
                        wait_queue_head_t wait;
                        struct socket *sock;
                        int flags;
                }sock;
        }source;

        union{
                struct{
                        __u32 paramlen;
                        __u32 cmdread;
                        __u16 cmd;
                        __u8 *cmdparams;
                }unconnected;

                struct{
                        /* has to be first (because it is first in target
                         * kernel too)
                         */
                        struct neighbor *nb;
                        /* list of all connections to this neighbor */
                        struct list_head nb_list;

                        __u32 conn_id;
                        __u32 seqno;
                }out;

                struct{
                        wait_queue_head_t wait;
                }sock;
        }target;
        
        struct data_buf buf;

        struct conn *reversedir;
};

/* inside skb->cb */
struct skb_procstate{
        struct conn *rconn;

        union{
                struct{
                        struct work_struct work;
                }rcv;

                struct{
                        __u32 offset;
                }announce;
                
                struct{
                        __u32 conn_id;
                        __u32 seqno;
                }rcv2;
                
                struct{
                        struct htab_entry htab_entry;
                        struct ref_counter refs;
                        unsigned long timeout;
                        __u32 conn_id;
                        __u32 seqno;
                        struct neighbor *nb;
                }retransmit_queue;
        }funcstate;
};


/* common.c */
extern void ref_counter_decr(struct ref_counter *cnt);

extern int ref_counter_incr(struct ref_counter *cnt);

extern void ref_counter_init(struct ref_counter *cnt,
                struct ref_counter_def *def);

extern char *htable_get(struct htable *ht, __u32 key, void *searcheditem);

extern int htable_delete(struct htable *ht, __u32 key, void *searcheditem);

extern void htable_insert(struct htable *ht, char *newelement, __u32 key);

extern void htable_init(struct htable *ht, int (*matches)(void *htentry,
                void *searcheditem), __u32 entry_offset,
                __u32 ref_counter_offset);

extern struct conn *get_conn(__u32 conn_id);

extern int conn_init_out(struct conn *rconn, struct neighbor *nb);

extern void conn_init_sock_source(struct conn *conn);
extern void conn_init_sock_target(struct conn *conn);

extern void close_port(struct connlistener *listener);

extern struct connlistener *open_port(__be64 port);

extern int connect_port(struct conn *rconn, __be64 port);

extern int connect_neigh(struct conn *rconn,
                __u16 addrtypelen, __u8 *addrtype,
                __u16 addrlen, __u8 *addr);

extern struct conn* alloc_conn(gfp_t allocflags);

extern void reset_conn(struct conn *conn);

/* neighbor.c */
extern struct neighbor *get_neigh_by_mac(struct sk_buff *skb);

extern struct neighbor *find_neigh(__u16 addrtypelen, __u8 *addrtype,
                __u16 addrlen, __u8 *addr);

extern __u32 generate_neigh_list(char *buf, __u32 buflen, __u32 limit,
                __u32 offset);

extern void rcv_announce(struct sk_buff *skb);

extern int __init cor_neighbor_init(void);

/* rcv.c */
extern void drain_ooo_queue(struct conn *rconn);

extern void conn_rcv_buildskb(char *data, __u32 datalen, __u32 conn_id, 
                __u32 seqno);

extern int __init cor_rcv_init(void);

/* kpacket_parse.c */
extern void kernel_packet(struct neighbor *nb, struct sk_buff *skb, __u32 seqno);

/* kpacket_gen.c */
extern void schedule_controlmsg_timerfunc(struct neighbor *nb);

struct control_msg_out;

extern struct control_msg_out *alloc_control_msg(void);

extern void free_control_msg(struct control_msg_out *cm);

extern void send_reset_conn(struct control_msg_out *cm, struct neighbor *nb,
                __u32 conn_id);

extern void send_ack(struct control_msg_out *cm, struct neighbor *nb,
                __u32 conn_id, __u32 seqno);

extern void send_connect_success(struct control_msg_out *cm,
                struct neighbor *nb, __u32 rcvd_conn_id, __u32 gen_conn_id);

extern void send_connect_nb(struct control_msg_out *cm, struct neighbor *nb,
                __u32 conn_id);

extern void send_conndata(struct control_msg_out *cm, struct neighbor *nb,
                __u32 connid, __u32 seqno, char *data_orig, char *data,
                __u32 datalen);

/* cpacket_parse.c */
extern void parse(struct conn *rconn);

/* snd.c */
extern void retransmit_timerfunc(unsigned long arg);

extern struct sk_buff *create_packet_conn(struct conn *target, int size,
                gfp_t alloc_flags);

extern struct sk_buff *create_packet_kernel(struct neighbor *nb, int size,
                gfp_t alloc_flags);
                
extern void send_conn_flushdata(struct conn *rconn, char *data, __u32 datalen);

extern void send_packet(struct sk_buff *skb, struct neighbor *nb,
                int retransmit);

extern void ack_received(struct neighbor *nb, __u32 conn_id, __u32 seqno);

extern void flush_out(struct conn *rconn);

extern int __init cor_snd_init(void);

/* forward.c */
extern void databuf_pull(struct data_buf *data, char *dst, int len);

extern size_t databuf_pulluser(struct conn *sconn, struct msghdr *msg);

extern void databuf_ack(struct data_buf *buf, __u64 pos);

extern void databuf_ackread(struct data_buf *buf);

extern int databuf_maypush(struct data_buf *buf);

extern void databuf_free(struct data_buf *data);

extern void databuf_init(struct data_buf *data);

extern int receive_userbuf(struct conn *rconn, struct msghdr *msg);

extern void receive_buf(struct conn *rconn, char *buf, int len);

extern int receive_skb(struct conn *rconn, struct sk_buff *skb);

extern void wake_sender(struct conn *rconn);

extern void forward_init(void);



static inline struct skb_procstate *skb_pstate(struct sk_buff *skb)
{
        return (struct skb_procstate *) &(skb->cb[0]);
}

static inline struct sk_buff *skb_from_pstate(struct skb_procstate *ps)
{
        return (struct sk_buff *) (((char *)ps) - offsetof(struct sk_buff,cb));
}


static inline __u32 mss(struct neighbor *nb)
{
        return nb->dev->mtu - LL_RESERVED_SPACE(nb->dev) - 9;
}


static inline void put_u64(char *dst, __u64 value, int convbo)
{
        char *p_value = (char *) &value;
        
        if (convbo)
                value = cpu_to_be64(value);
        
        dst[0] = p_value[0];
        dst[1] = p_value[1];
        dst[2] = p_value[2];
        dst[3] = p_value[3];
        dst[4] = p_value[4];
        dst[5] = p_value[5];
        dst[6] = p_value[6];
        dst[7] = p_value[7];
}

static inline void put_u32(char *dst, __u32 value, int convbo)
{
        char *p_value = (char *) &value;
        
        if (convbo)
                value = cpu_to_be32(value);
        
        dst[0] = p_value[0];
        dst[1] = p_value[1];
        dst[2] = p_value[2];
        dst[3] = p_value[3];
}

static inline void put_u16(char *dst, __u16 value, int convbo)
{
        char *p_value = (char *) &value;
        
        if (convbo)
                value = cpu_to_be16(value);
        
        dst[0] = p_value[0];
        dst[1] = p_value[1];
}

static inline char *cor_pull_skb(struct sk_buff *skb, unsigned int len)
{
        char *ptr = skb_pull(skb, len);

        if(ptr == 0)
                return 0;

        return ptr - len;
}