qos fixes, reset bufferusage on conn reset, conn refcnt fix

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

/*
 *      Connection oriented routing
 *      Copyright (C) 2007-2010 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 <linux/kref.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_PING[1] cookie[4]
 * KP_PONG[1] cookie[4] respdelay[4]
 *
 * This is needed to find out whether the other node is reachable. After a new
 * neighbor is seen, ping requests are sent and the neighbor is only reachable
 * after a few pongs are received. These requests are also used to find out
 * whether a neighber is gone.
 *
 * respdelay:
 * The receiver of a ping may delay the sending of the pong e.g. to create
 * bigger kernel packets. The respdelay is the time in microseconds the packet
 * was delayed.
 */
#define KP_PING 2
#define KP_PONG 3

/* KP_ACK[1] seqno[4] */
#define KP_ACK 4

/*
 * KP_ACK_CONN[1] conn_id[4] seqno[4] window[1]
 * KP_ACK_CONN_OOO[1] conn_id[4] seqno[4] window[1] seqno_ooo[4] length[4]
 *
 * conn_id is the conn_id we use if we sent something through this conn and
 *   *not* the conn_id that the neighbor used to send us the data
 *
 * seqno = the seqno which is expected in the next non-out-of-order packet
 *   seqno_ooo, length = in case
 *
 * window = amount of data which can be sent without receiving the next ack
 *   packets with lower seqno do not overwrite the last window size
 *   note: the other side may also reduce the window size
 *   decode:
 *     0 = 0
 *     1...255 = 64*2^((value-1)/11) end result is rounded down to an integer
 *
 */
#define KP_ACK_CONN 5
#define KP_ACK_CONN_OOO 6

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

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

/*
 * 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] init_seqno[4] window[1]
 */
#define KP_CONNECT_SUCCESS 8

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

/*
 * KP_PING_CONN[1] conn_id[4]
 *
 * This is for querying the status of an open connection. The response is either
 * KP_ACK_CONN or CONNID_UNKNOWN
 */
#define KP_PING_CONN 10

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

/*
 * KP_CONNID_UNKNOWN[1] sent_conn_id[4]
 * We send this, if we receive an invalid conn_id
 */
#define KP_CONNID_UNKNOWN 12

/*
 * KP_PING_ALL_CONNS[1]
 * We send this, if we we lost a conn, but could not send reset_conn and
 * connid_unknown
 */
#define KP_PING_ALL_CONNS 13

/*
 * KP_SET_MAX_CMSG_DELAY[1] delay[4]
 * Sent after connecting and at any change
 * delay in specifies in microsecs
 */
#define KP_SET_MAX_CMSG_DELAY 14

/*
 * KP_SET_CREDITS[1] credits[8] rate_initial[4] rate_earning[4] rate_spending[4]
 */
#define KP_SET_CREDITS 15

/*
 * KP_SET_CONN_CREDITS[1] conn_id[4] credit_rate[4]
 */
#define KP_SET_CONN_CREDITS 16


/*
 * 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

/*
 * CD_SET_(FORWARD|BACKWARD)_TIMEOUT[2] length[4] timeout_ms[4]
 *
 * If there is no successful communication with the previous or neighbor for
 * this period, the connection will be reset. This value must be between
 * NB_STALL_TIME and NB_KILL_TIME. Otherwise it will silently behave as if it
 * was set to exactly one of these limits.
 */
#define CD_SET_FORWARD_TIMEOUT 4
#define CD_SET_BACKWARD_TIMEOUT 5

/*
 * 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
        #define CDR_EXECFAILED_ILLEGAL_COMMAND 33289

/*
 * 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 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 kref_offset;
};

struct resume_block{
        struct list_head lh;
        int in_queue;
};

struct announce_data{
        struct kref ref;

        struct list_head lh;
        struct net_device *dev;
        struct delayed_work announce_work;
        struct announce *ann;
        struct resume_block rb;

        __u32 curr_announce_msg_offset;
        __u64 scheduled_announce_timer;
};

struct ping_cookie{
        unsigned long time;
        __u32 cookie;
        __u8 pongs; /* count of pongs for pings sent after this one */
};

#define NEIGHBOR_STATE_INITIAL 0
#define NEIGHBOR_STATE_ACTIVE 1
#define NEIGHBOR_STATE_STALLED 2
#define NEIGHBOR_STATE_KILLED 3

struct neighbor{
        struct list_head nb_list;

        struct kref ref;

        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;
        /**
         * urgent messages; These are sent even if the neighbor state is not
         * active. If the queue gets full, the oldest ones are dropped. It thus
         * may only contain messages which are allowed to be dropped.
         */
        struct list_head ucontrol_msgs_out;
        __u64 timeout;
        __u32 cmlength;
        __u32 ucmlength;

        atomic_t cmcnt; /* size of queue + retransmits */
        atomic_t ucmcnt; /* size of queue only */

        __u8 ping_all_conns;
        __u8 send_credits;
        __u8 max_cmsg_delay_sent;

        /* see snd.c/qos_queue */
        /* protected by cmsg_lock */
        __u8 kp_allmsgs;

        /* procected by queues_lock */
        struct resume_block rb_kp;
        struct resume_block rb_cr;

        struct mutex pingcookie_lock;
        unsigned long last_ping_time;
        __u32 ping_intransit;
        struct ping_cookie cookies[PING_COOKIES_PER_NEIGH];
        __u32 lastcookie;
        atomic_t latency; /* microsecs */
        atomic_t max_remote_cmsg_delay; /* microsecs */

        spinlock_t state_lock;
        union {
                __u64 last_state_change;/* initial state */
                /**
                 * last_roundtrip:
                 * time of the last sent packet which has been acked or
                 * otherwise responded to (e.g. pong)
                 */
                unsigned long last_roundtrip;/* active/stalled state */
        }state_time;
        __u8 state;
        __u16 ping_success;

        struct delayed_work stalltimeout_timer;
        __u8 str_timer_pending;


        atomic_t kpacket_seqno;
        atomic_t ooo_packets;

        spinlock_t credits_lock;
        long jiffies_credit_update;

        /* all cretid rates are in credits/ms */
        __u64 credits; /* how much we can spend */
        __u32 credits_fract;
        __u64 credits_diff; /* diff between the neighbor's and our calc */
        __u32 credits_diff_fract;
        __s32 creditrate_initial;
        __u32 creditrate_earning;
        __u32 creditrate_spending;
        __u32 creditrate_spending_expected;

        __s32 creditrate_spending_diff;

        __u64 debits; /* how much the other side can spend */
        __u32 debits_fract;
        __s32 debitrate_initial;
        __s32 debitrate_initial_adj;
        __u32 debitrate_earning;
        __u32 debitrate_spending;


        /*
         * 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;
        __u32 num_send_conns;

        /*
         * used for ping_all conns, if not zero this is the next conn we need to
         * ping, protected by conn_list_lock
         */
        struct conn *next_ping_conn;
        __u32 ping_conns_remaining;
        __u32 ping_conns_retrans_remaining;
        __u32 pong_conns_expected;
        unsigned long ping_conn_completed; /* jiffies */

        /*
         * 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 delayed_work retrans_timer_conn;
        struct delayed_work retrans_timer;
        __u8 retrans_timer_conn_running;
        __u8 retrans_timer_running;

        struct list_head retrans_list;
        struct list_head retrans_list_conn;

        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;
        __u32 first_offset;

        __u32 totalsize;
        __u32 read_remaining;

        __u16 last_read_offset;

        __u16 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;

};

struct speedtracker{
        __u64 speed;/* bytes*65536/jiffie */
        unsigned long jiffies_last_update;
        __u32 bytes_curr;
};

/*
 * 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;

        /*
         * isreset values:
         * 0... connection active
         * 1... connection is about to be reset, target does not need to be
         *      notified
         * 2... connection is reset
         * 3... connection is reset + no pointers to "struct conn *reversedir"
         *      remaining except from this conn
         */
        atomic_t isreset;

        struct list_head queue_list;

        struct kref ref;

        /**
         * locking order:
         * If one side is SOCK or NONE/UNCONNECTED and both directions
         * need to be locked, the direction with TARGET_UNCONNECTED or
         * TARGET_SOCK has to be locked first, the direction with
         * SOURCE_NONE or SOURCE_SOCK afterwards. If one side is TARGET_SOCK
         * and the other is TARGET_UNCONNECTED, TARGET_SOCK needs to be locked
         * first. This is needed for changing source/targettype, credit flow
         * and TARGET_UNCONNECTED generating responses.
         * If data is forwarded, (both sides are IN/OUT), only one direction
         * may be locked.
         */
        struct mutex rcv_lock;

        long jiffies_credit_update;
        /* state */
        __s64 credits;
        __u32 credits_fract;
        /* credit rates, locked by credit_lock (in credit.c) */
        __u32 sender_crate;
        __u32 recp_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;

                        atomic_t pong_awaiting;

                        /* credit rate */
                        __u32 crate_in_raw;

                        __u32 window_seqnolimit_max;
                        __u32 window_seqnolimit_last;

                        struct list_head buffer_list;

                        __u32 buffer_init;
                        __u32 buffer_speed;
                        __u32 buffer_ata;

                        __u32 usage_init;
                        __u32 usage_speed;
                        __u32 usage_ata;
                        __u32 usage_reserve;

                        struct speedtracker st;

                        unsigned long jiffies_last_window_set;
                }in;

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

                        __u32 crate;
                }sock;
        }source;

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

                        __u32 stall_timeout_ms;
                }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;
                        /* protected by nb->retrans_lock, sorted by seqno */
                        struct list_head retrans_list;

                        /* reverse conn_id lookup */
                        struct htab_entry htab_entry;

                        __u32 conn_id;
                        __u32 seqno_nextsend;
                        __u32 seqno_acked;
                        __u32 seqno_windowlimit;
                        __u32 kp_windowsetseqno;

                        struct resume_block rb;

                        __u32 stall_timeout_ms;

                        /* credit rate */
                        __u32 crate_out_raw;
                }out;

                struct{
                        wait_queue_head_t wait;

                        __u8 credituser;
                }sock;
        }target;

        struct data_buf buf;

        struct conn *reversedir;
};

/* inside skb->cb */
struct skb_procstate{
        union{
                struct{
                        struct work_struct work;
                }rcv;

                struct{
                        __u32 offset;
                }announce;

                struct{
                        __u32 seqno;
                }rcv2;
        }funcstate;
};


/* common.c */
extern atomic_t num_conns;

extern __u8 enc_window(__u32 window_bytes);

extern __u32 dec_window(__u8 window);

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

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

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 kref_offset);

extern struct conn *get_conn_reverse(struct neighbor *nb, __u32 conn_id);

extern void insert_reverse_connid(struct conn *rconn);

extern struct conn *get_conn(__u32 conn_id);

extern void free_conn(struct kref *ref);

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_ping(struct conn *rconn);

extern void reset_conn(struct conn *conn);

/* credits.c */
extern int refresh_credits_state(struct neighbor *nb);

extern void check_credit_state(struct neighbor *nb);

extern int debit_adj_needed(struct neighbor *nb);

extern void refresh_conn_credits(struct conn *conn);

extern void set_credits(struct neighbor *nb, __u64 credits,
                __s32 creditrate_initial, __u32 creditrate_earning,
                __u32 creditrate_spending);

extern void set_debitrate_initial(struct neighbor *nb, __u32 debitrate);

extern void set_conn_in_crate(struct conn *rconn, __u32 crate_in);

extern int __init cor_credits_init(void);

/* neighbor.c */
extern void neighbor_free(struct kref *ref);

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 int get_neigh_state(struct neighbor *nb);

extern void ping_resp(struct neighbor *nb, __u32 cookie, __u32 respdelay);

extern __u32 add_ping_req(struct neighbor *nb);

extern void unadd_ping_req(struct neighbor *nb, __u32 cookie);

extern int time_to_send_ping(struct neighbor *nb);

extern int force_ping(struct neighbor *nb);

extern void rcv_announce(struct sk_buff *skb);

extern int send_announce_qos(struct announce_data *ann);

extern void announce_data_free(struct kref *ref);

extern int __init cor_neighbor_init(void);

/* rcv.c */
extern __u32 get_window(struct conn *rconn);

extern void reset_bufferusage(struct conn *conn);

extern void refresh_speedstat(struct conn *rconn, __u32 written);

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;

#define ACM_PRIORITY_LOW 1
#define ACM_PRIORITY_MED 2
#define ACM_PRIORITY_HIGH 3

extern struct control_msg_out *alloc_control_msg(struct neighbor *nb,
                int priority);

extern void free_control_msg(struct control_msg_out *cm);

extern void retransmit_timerfunc(struct work_struct *work);

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

extern int resume_send_messages(struct neighbor *nb);

extern void send_pong(struct neighbor *nb,
                __u32 cookie);

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

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

extern void send_ack_conn(struct control_msg_out *cm, struct conn *rconn,
                __u32 conn_id, __u32 seqno);

extern void send_ack_conn_ooo(struct control_msg_out *cm, struct conn *rconn,
                __u32 conn_id, __u32 seqno, __u32 seqno_ooo, __u32 length);

extern void send_connect_success(struct control_msg_out *cm, __u32 rcvd_conn_id,
                __u32 gen_conn_id, __u32 init_seqno,  struct conn *rconn);

extern void send_connect_nb(struct control_msg_out *cm, __u32 conn_id,
                __u32 init_seqno, struct conn *sconn);

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

extern void send_ping_conn(struct control_msg_out *cm, __u32 conn_id);

extern void send_connid_unknown(struct control_msg_out *cm, __u32 conn_id);

extern void send_ping_all_conns(struct neighbor *nb);

extern void send_credits(struct neighbor *nb);

extern void cor_kgen_init(void);

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

/* snd.c */
extern int destroy_queue(struct net_device *dev);

extern int create_queue(struct net_device *dev);

#define QOS_CALLER_KPACKET 0
#define QOS_CALLER_CONN_RETRANS 1
#define QOS_CALLER_ANNOUNCE 2
#define QOS_CALLER_CONN 3

extern void qos_enqueue(struct net_device *dev, struct resume_block *rb,
                int caller);

extern void qos_enqueue_kpacket(struct neighbor *nb);

extern void qos_remove_conn(struct conn *rconn);

extern void qos_enqueue_conn(struct conn *rconn, int oom);

extern struct sk_buff *create_packet(struct neighbor *nb, int size,
                gfp_t alloc_flags, __u32 conn_id, __u32 seqno);

extern void cancel_retrans(struct conn *rconn);

extern void retransmit_conn_timerfunc(struct work_struct *work);

extern void conn_ack_rcvd(__u32 kpacket_seqno, struct conn *rconn, __u32 seqno,
                __u8 window, __u32 seqno_ooo, __u32 length);

#define RC_FLUSH_CONN_OUT_OK 0
#define RC_FLUSH_CONN_OUT_CONG 1
#define RC_FLUSH_CONN_OUT_CREDITS 2
#define RC_FLUSH_CONN_OUT_OOM 3
extern int 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_unpull(struct data_buf *data, __u32 bytes);

extern void databuf_pullold(struct data_buf *data, __u32 startpos, char *dst,
                int len);

extern void databuf_ack(struct conn *rconn, __u32 pos);

extern void databuf_ackread(struct conn *rconn);

extern int databuf_maypush(struct data_buf *buf);

extern void flush_buf(struct conn *rconn);

extern void reset_seqno(struct data_buf *buf, __u32 initseqno);

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(unlikely(ptr == 0))
                return 0;

        return ptr - len;
}


static inline __u64 mul_saturated(__u64 a, __u64 b)
{
        __u64 res = a*b;
        if (res / a != b)
                return -1;
        return res;
}

static inline int numdigits(__u64 value)
{
        int digits = 0;
        for (;value != 0;value = (value >> 1)) {
                digits++;
        }
        return digits;
}

/* approximate (a*b) / c without overflowing a*b */
static inline __u64 multiply_div(__u64 a, __u64 b, __u64 c)
{
        int alen = numdigits(a);
        int blen = numdigits(b);
        int clen = numdigits(c);

        BUG_ON(alen < 0 || alen > 64);
        BUG_ON(blen < 0 || blen > 64);
        BUG_ON(clen < 0 || clen > 64);

        BUG_ON((a == 0 && alen != 0) || (a != 0 && alen == 0));
        BUG_ON((b == 0 && blen != 0) || (b != 0 && blen == 0));
        BUG_ON((c == 0 && clen != 0) || (c != 0 && clen == 0));

        BUG_ON(a >= b && alen < blen);
        BUG_ON(a >= c && alen < clen);
        BUG_ON(b >= a && blen < alen);
        BUG_ON(b >= c && blen < clen);
        BUG_ON(c >= a && clen < alen);
        BUG_ON(c >= b && clen < blen);

        if (alen == 0 || blen == 0)
                return 0;

        BUG_ON(c == 0);

        if (alen + blen <= 64)
                return (a*b)/c;

        if (a >= b && alen > clen + 16)
                return mul_saturated(a/c, b);
        else if (a < b && blen > clen + 16)
                return mul_saturated(b/c, a);

        while (alen + blen > 64) {
                if (alen > blen || (alen == blen && a > b)) {
                        alen--;
                        a = (a >> 1);
                } else {
                        blen--;
                        b = (b >> 1);
                }
                clen--;
                c = (c >> 1);
        }

        return (a*b)/c;
}