1 /* 2 * Copyright (c) 2016 HUAWEI TECHNOLOGIES CO., LTD. 3 * Copyright (c) 2016 FUJITSU LIMITED 4 * Copyright (c) 2016 Intel Corporation 5 * 6 * Author: Zhang Chen <zhangchen.fnst@cn.fujitsu.com> 7 * 8 * This work is licensed under the terms of the GNU GPL, version 2 or 9 * later. See the COPYING file in the top-level directory. 10 */ 11 12 #include "qemu/osdep.h" 13 #include "trace.h" 14 #include "net/colo.h" 15 #include "net/filter.h" 16 #include "net/net.h" 17 #include "qemu-common.h" 18 #include "qapi/error.h" 19 #include "qapi/qmp/qerror.h" 20 #include "qapi-visit.h" 21 #include "qom/object.h" 22 #include "qemu/main-loop.h" 23 #include "qemu/iov.h" 24 #include "net/checksum.h" 25 26 #define FILTER_COLO_REWRITER(obj) \ 27 OBJECT_CHECK(RewriterState, (obj), TYPE_FILTER_REWRITER) 28 29 #define TYPE_FILTER_REWRITER "filter-rewriter" 30 31 typedef struct RewriterState { 32 NetFilterState parent_obj; 33 NetQueue *incoming_queue; 34 /* hashtable to save connection */ 35 GHashTable *connection_track_table; 36 } RewriterState; 37 38 static void filter_rewriter_flush(NetFilterState *nf) 39 { 40 RewriterState *s = FILTER_COLO_REWRITER(nf); 41 42 if (!qemu_net_queue_flush(s->incoming_queue)) { 43 /* Unable to empty the queue, purge remaining packets */ 44 qemu_net_queue_purge(s->incoming_queue, nf->netdev); 45 } 46 } 47 48 /* 49 * Return 1 on success, if return 0 means the pkt 50 * is not TCP packet 51 */ 52 static int is_tcp_packet(Packet *pkt) 53 { 54 if (!parse_packet_early(pkt) && 55 pkt->ip->ip_p == IPPROTO_TCP) { 56 return 1; 57 } else { 58 return 0; 59 } 60 } 61 62 /* handle tcp packet from primary guest */ 63 static int handle_primary_tcp_pkt(NetFilterState *nf, 64 Connection *conn, 65 Packet *pkt) 66 { 67 struct tcphdr *tcp_pkt; 68 69 tcp_pkt = (struct tcphdr *)pkt->transport_header; 70 if (trace_event_get_state(TRACE_COLO_FILTER_REWRITER_DEBUG)) { 71 char *sdebug, *ddebug; 72 sdebug = strdup(inet_ntoa(pkt->ip->ip_src)); 73 ddebug = strdup(inet_ntoa(pkt->ip->ip_dst)); 74 trace_colo_filter_rewriter_pkt_info(__func__, sdebug, ddebug, 75 ntohl(tcp_pkt->th_seq), ntohl(tcp_pkt->th_ack), 76 tcp_pkt->th_flags); 77 trace_colo_filter_rewriter_conn_offset(conn->offset); 78 g_free(sdebug); 79 g_free(ddebug); 80 } 81 82 if (((tcp_pkt->th_flags & (TH_ACK | TH_SYN)) == TH_SYN)) { 83 /* 84 * we use this flag update offset func 85 * run once in independent tcp connection 86 */ 87 conn->syn_flag = 1; 88 } 89 90 if (((tcp_pkt->th_flags & (TH_ACK | TH_SYN)) == TH_ACK)) { 91 if (conn->syn_flag) { 92 /* 93 * offset = secondary_seq - primary seq 94 * ack packet sent by guest from primary node, 95 * so we use th_ack - 1 get primary_seq 96 */ 97 conn->offset -= (ntohl(tcp_pkt->th_ack) - 1); 98 conn->syn_flag = 0; 99 } 100 /* handle packets to the secondary from the primary */ 101 tcp_pkt->th_ack = htonl(ntohl(tcp_pkt->th_ack) + conn->offset); 102 103 net_checksum_calculate((uint8_t *)pkt->data, pkt->size); 104 } 105 106 return 0; 107 } 108 109 /* handle tcp packet from secondary guest */ 110 static int handle_secondary_tcp_pkt(NetFilterState *nf, 111 Connection *conn, 112 Packet *pkt) 113 { 114 struct tcphdr *tcp_pkt; 115 116 tcp_pkt = (struct tcphdr *)pkt->transport_header; 117 118 if (trace_event_get_state(TRACE_COLO_FILTER_REWRITER_DEBUG)) { 119 char *sdebug, *ddebug; 120 sdebug = strdup(inet_ntoa(pkt->ip->ip_src)); 121 ddebug = strdup(inet_ntoa(pkt->ip->ip_dst)); 122 trace_colo_filter_rewriter_pkt_info(__func__, sdebug, ddebug, 123 ntohl(tcp_pkt->th_seq), ntohl(tcp_pkt->th_ack), 124 tcp_pkt->th_flags); 125 trace_colo_filter_rewriter_conn_offset(conn->offset); 126 g_free(sdebug); 127 g_free(ddebug); 128 } 129 130 if (((tcp_pkt->th_flags & (TH_ACK | TH_SYN)) == (TH_ACK | TH_SYN))) { 131 /* 132 * save offset = secondary_seq and then 133 * in handle_primary_tcp_pkt make offset 134 * = secondary_seq - primary_seq 135 */ 136 conn->offset = ntohl(tcp_pkt->th_seq); 137 } 138 139 if ((tcp_pkt->th_flags & (TH_ACK | TH_SYN)) == TH_ACK) { 140 /* handle packets to the primary from the secondary*/ 141 tcp_pkt->th_seq = htonl(ntohl(tcp_pkt->th_seq) - conn->offset); 142 143 net_checksum_calculate((uint8_t *)pkt->data, pkt->size); 144 } 145 146 return 0; 147 } 148 149 static ssize_t colo_rewriter_receive_iov(NetFilterState *nf, 150 NetClientState *sender, 151 unsigned flags, 152 const struct iovec *iov, 153 int iovcnt, 154 NetPacketSent *sent_cb) 155 { 156 RewriterState *s = FILTER_COLO_REWRITER(nf); 157 Connection *conn; 158 ConnectionKey key; 159 Packet *pkt; 160 ssize_t size = iov_size(iov, iovcnt); 161 char *buf = g_malloc0(size); 162 163 iov_to_buf(iov, iovcnt, 0, buf, size); 164 pkt = packet_new(buf, size); 165 166 /* 167 * if we get tcp packet 168 * we will rewrite it to make secondary guest's 169 * connection established successfully 170 */ 171 if (pkt && is_tcp_packet(pkt)) { 172 173 fill_connection_key(pkt, &key); 174 175 if (sender == nf->netdev) { 176 /* 177 * We need make tcp TX and RX packet 178 * into one connection. 179 */ 180 reverse_connection_key(&key); 181 } 182 conn = connection_get(s->connection_track_table, 183 &key, 184 NULL); 185 186 if (sender == nf->netdev) { 187 /* NET_FILTER_DIRECTION_TX */ 188 if (!handle_primary_tcp_pkt(nf, conn, pkt)) { 189 qemu_net_queue_send(s->incoming_queue, sender, 0, 190 (const uint8_t *)pkt->data, pkt->size, NULL); 191 packet_destroy(pkt, NULL); 192 pkt = NULL; 193 /* 194 * We block the packet here,after rewrite pkt 195 * and will send it 196 */ 197 return 1; 198 } 199 } else { 200 /* NET_FILTER_DIRECTION_RX */ 201 if (!handle_secondary_tcp_pkt(nf, conn, pkt)) { 202 qemu_net_queue_send(s->incoming_queue, sender, 0, 203 (const uint8_t *)pkt->data, pkt->size, NULL); 204 packet_destroy(pkt, NULL); 205 pkt = NULL; 206 /* 207 * We block the packet here,after rewrite pkt 208 * and will send it 209 */ 210 return 1; 211 } 212 } 213 } 214 215 packet_destroy(pkt, NULL); 216 pkt = NULL; 217 return 0; 218 } 219 220 static void colo_rewriter_cleanup(NetFilterState *nf) 221 { 222 RewriterState *s = FILTER_COLO_REWRITER(nf); 223 224 /* flush packets */ 225 if (s->incoming_queue) { 226 filter_rewriter_flush(nf); 227 g_free(s->incoming_queue); 228 } 229 } 230 231 static void colo_rewriter_setup(NetFilterState *nf, Error **errp) 232 { 233 RewriterState *s = FILTER_COLO_REWRITER(nf); 234 235 s->connection_track_table = g_hash_table_new_full(connection_key_hash, 236 connection_key_equal, 237 g_free, 238 connection_destroy); 239 s->incoming_queue = qemu_new_net_queue(qemu_netfilter_pass_to_next, nf); 240 } 241 242 static void colo_rewriter_class_init(ObjectClass *oc, void *data) 243 { 244 NetFilterClass *nfc = NETFILTER_CLASS(oc); 245 246 nfc->setup = colo_rewriter_setup; 247 nfc->cleanup = colo_rewriter_cleanup; 248 nfc->receive_iov = colo_rewriter_receive_iov; 249 } 250 251 static const TypeInfo colo_rewriter_info = { 252 .name = TYPE_FILTER_REWRITER, 253 .parent = TYPE_NETFILTER, 254 .class_init = colo_rewriter_class_init, 255 .instance_size = sizeof(RewriterState), 256 }; 257 258 static void register_types(void) 259 { 260 type_register_static(&colo_rewriter_info); 261 } 262 263 type_init(register_types); 264