[mirror_qemu.git] / net / colo.h

/*
 * COarse-grain LOck-stepping Virtual Machines for Non-stop Service (COLO)
 * (a.k.a. Fault Tolerance or Continuous Replication)
 *
 * Copyright (c) 2016 HUAWEI TECHNOLOGIES CO., LTD.
 * Copyright (c) 2016 FUJITSU LIMITED
 * Copyright (c) 2016 Intel Corporation
 *
 * Author: Zhang Chen <zhangchen.fnst@cn.fujitsu.com>
 *
 * This work is licensed under the terms of the GNU GPL, version 2 or
 * later.  See the COPYING file in the top-level directory.
 */

#ifndef QEMU_COLO_PROXY_H
#define QEMU_COLO_PROXY_H

#include "slirp/slirp.h"
#include "qemu/jhash.h"
#include "qemu/timer.h"

#define HASHTABLE_MAX_SIZE 16384

#ifndef IPPROTO_DCCP
#define IPPROTO_DCCP 33
#endif

#ifndef IPPROTO_SCTP
#define IPPROTO_SCTP 132
#endif

#ifndef IPPROTO_UDPLITE
#define IPPROTO_UDPLITE 136
#endif

typedef struct Packet {
    void *data;
    union {
        uint8_t *network_header;
        struct ip *ip;
    };
    uint8_t *transport_header;
    int size;
    /* Time of packet creation, in wall clock ms */
    int64_t creation_ms;
    /* Get vnet_hdr_len from filter */
    uint32_t vnet_hdr_len;
} Packet;

typedef struct ConnectionKey {
    /* (src, dst) must be grouped, in the same way than in IP header */
    struct in_addr src;
    struct in_addr dst;
    uint16_t src_port;
    uint16_t dst_port;
    uint8_t ip_proto;
} QEMU_PACKED ConnectionKey;

typedef struct Connection {
    /* connection primary send queue: element type: Packet */
    GQueue primary_list;
    /* connection secondary send queue: element type: Packet */
    GQueue secondary_list;
    /* flag to enqueue unprocessed_connections */
    bool processing;
    uint8_t ip_proto;
    /* offset = secondary_seq - primary_seq */
    tcp_seq  offset;
    /*
     * we use this flag update offset func
     * run once in independent tcp connection
     */
    int syn_flag;
} Connection;

uint32_t connection_key_hash(const void *opaque);
int connection_key_equal(const void *opaque1, const void *opaque2);
int parse_packet_early(Packet *pkt);
void fill_connection_key(Packet *pkt, ConnectionKey *key);
void reverse_connection_key(ConnectionKey *key);
Connection *connection_new(ConnectionKey *key);
void connection_destroy(void *opaque);
Connection *connection_get(GHashTable *connection_track_table,
                           ConnectionKey *key,
                           GQueue *conn_list);
void connection_hashtable_reset(GHashTable *connection_track_table);
Packet *packet_new(const void *data, int size, int vnet_hdr_len);
void packet_destroy(void *opaque, void *user_data);

#endif /* QEMU_COLO_PROXY_H */
Commit	Line	Data
59509ec1 ZC	1	/*
	2	* COarse-grain LOck-stepping Virtual Machines for Non-stop Service (COLO)
	3	* (a.k.a. Fault Tolerance or Continuous Replication)
	4	*
	5	* Copyright (c) 2016 HUAWEI TECHNOLOGIES CO., LTD.
	6	* Copyright (c) 2016 FUJITSU LIMITED
	7	* Copyright (c) 2016 Intel Corporation
	8	*
	9	* Author: Zhang Chen <zhangchen.fnst@cn.fujitsu.com>
	10	*
	11	* This work is licensed under the terms of the GNU GPL, version 2 or
	12	* later. See the COPYING file in the top-level directory.
	13	*/
	14
	15	#ifndef QEMU_COLO_PROXY_H
	16	#define QEMU_COLO_PROXY_H
	17
	18	#include "slirp/slirp.h"
ccf0426c	19	#include "qemu/jhash.h"
0682e15b	20	#include "qemu/timer.h"
59509ec1 ZC	21
	22	#define HASHTABLE_MAX_SIZE 16384
	23
b6540d40 ZC	24	#ifndef IPPROTO_DCCP
	25	#define IPPROTO_DCCP 33
	26	#endif
	27
	28	#ifndef IPPROTO_SCTP
	29	#define IPPROTO_SCTP 132
	30	#endif
	31
	32	#ifndef IPPROTO_UDPLITE
	33	#define IPPROTO_UDPLITE 136
	34	#endif
	35
59509ec1 ZC	36	typedef struct Packet {
	37	void *data;
	38	union {
	39	uint8_t *network_header;
	40	struct ip *ip;
	41	};
	42	uint8_t *transport_header;
	43	int size;
0682e15b ZC	44	/* Time of packet creation, in wall clock ms */
0682e15b ZC	45	int64_t creation_ms;
ada1a33f ZC	46	/* Get vnet_hdr_len from filter */
ada1a33f ZC	47	uint32_t vnet_hdr_len;
59509ec1 ZC	48	} Packet;
59509ec1 ZC	49
b6540d40 ZC	50	typedef struct ConnectionKey {
	51	/* (src, dst) must be grouped, in the same way than in IP header */
	52	struct in_addr src;
	53	struct in_addr dst;
	54	uint16_t src_port;
	55	uint16_t dst_port;
	56	uint8_t ip_proto;
	57	} QEMU_PACKED ConnectionKey;
	58
	59	typedef struct Connection {
	60	/* connection primary send queue: element type: Packet */
	61	GQueue primary_list;
	62	/* connection secondary send queue: element type: Packet */
	63	GQueue secondary_list;
	64	/* flag to enqueue unprocessed_connections */
	65	bool processing;
	66	uint8_t ip_proto;
30656b09 ZC	67	/* offset = secondary_seq - primary_seq */
	68	tcp_seq offset;
	69	/*
	70	* we use this flag update offset func
	71	* run once in independent tcp connection
	72	*/
	73	int syn_flag;
b6540d40 ZC	74	} Connection;
	75
	76	uint32_t connection_key_hash(const void *opaque);
	77	int connection_key_equal(const void opaque1, const void opaque2);
59509ec1	78	int parse_packet_early(Packet *pkt);
b6540d40	79	void fill_connection_key(Packet pkt, ConnectionKey key);
afe46124	80	void reverse_connection_key(ConnectionKey *key);
b6540d40 ZC	81	Connection connection_new(ConnectionKey key);
	82	void connection_destroy(void *opaque);
	83	Connection connection_get(GHashTable connection_track_table,
	84	ConnectionKey *key,
	85	GQueue *conn_list);
59509ec1	86	void connection_hashtable_reset(GHashTable *connection_track_table);
ada1a33f	87	Packet packet_new(const void data, int size, int vnet_hdr_len);
59509ec1 ZC	88	void packet_destroy(void opaque, void user_data);
	89
	90	#endif /* QEMU_COLO_PROXY_H */