xref: /openbmc/qemu/net/filter-mirror.c (revision c39f95dc) 
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 "net/filter.h"
14 #include "net/net.h"
15 #include "qemu-common.h"
16 #include "qapi/error.h"
17 #include "qapi/qmp/qerror.h"
18 #include "qapi-visit.h"
19 #include "qom/object.h"
20 #include "qemu/main-loop.h"
21 #include "qemu/error-report.h"
22 #include "trace.h"
23 #include "chardev/char-fe.h"
24 #include "qemu/iov.h"
25 #include "qemu/sockets.h"
26 
27 #define FILTER_MIRROR(obj) \
28     OBJECT_CHECK(MirrorState, (obj), TYPE_FILTER_MIRROR)
29 
30 #define FILTER_REDIRECTOR(obj) \
31     OBJECT_CHECK(MirrorState, (obj), TYPE_FILTER_REDIRECTOR)
32 
33 #define TYPE_FILTER_MIRROR "filter-mirror"
34 #define TYPE_FILTER_REDIRECTOR "filter-redirector"
35 #define REDIRECTOR_MAX_LEN NET_BUFSIZE
36 
37 typedef struct MirrorState {
38     NetFilterState parent_obj;
39     char *indev;
40     char *outdev;
41     CharBackend chr_in;
42     CharBackend chr_out;
43     SocketReadState rs;
44     bool vnet_hdr;
45 } MirrorState;
46 
47 static int filter_send(MirrorState *s,
48                        const struct iovec *iov,
49                        int iovcnt)
50 {
51     NetFilterState *nf = NETFILTER(s);
52     int ret = 0;
53     ssize_t size = 0;
54     uint32_t len = 0;
55     char *buf;
56 
57     size = iov_size(iov, iovcnt);
58     if (!size) {
59         return 0;
60     }
61 
62     len = htonl(size);
63     ret = qemu_chr_fe_write_all(&s->chr_out, (uint8_t *)&len, sizeof(len));
64     if (ret != sizeof(len)) {
65         goto err;
66     }
67 
68     if (s->vnet_hdr) {
69         /*
70          * If vnet_hdr = on, we send vnet header len to make other
71          * module(like colo-compare) know how to parse net
72          * packet correctly.
73          */
74         ssize_t vnet_hdr_len;
75 
76         vnet_hdr_len = nf->netdev->vnet_hdr_len;
77 
78         len = htonl(vnet_hdr_len);
79         ret = qemu_chr_fe_write_all(&s->chr_out, (uint8_t *)&len, sizeof(len));
80         if (ret != sizeof(len)) {
81             goto err;
82         }
83     }
84 
85     buf = g_malloc(size);
86     iov_to_buf(iov, iovcnt, 0, buf, size);
87     ret = qemu_chr_fe_write_all(&s->chr_out, (uint8_t *)buf, size);
88     g_free(buf);
89     if (ret != size) {
90         goto err;
91     }
92 
93     return 0;
94 
95 err:
96     return ret < 0 ? ret : -EIO;
97 }
98 
99 static void redirector_to_filter(NetFilterState *nf,
100                                  const uint8_t *buf,
101                                  int len)
102 {
103     struct iovec iov = {
104         .iov_base = (void *)buf,
105         .iov_len = len,
106     };
107 
108     if (nf->direction == NET_FILTER_DIRECTION_ALL ||
109         nf->direction == NET_FILTER_DIRECTION_TX) {
110         qemu_netfilter_pass_to_next(nf->netdev, 0, &iov, 1, nf);
111     }
112 
113     if (nf->direction == NET_FILTER_DIRECTION_ALL ||
114         nf->direction == NET_FILTER_DIRECTION_RX) {
115         qemu_netfilter_pass_to_next(nf->netdev->peer, 0, &iov, 1, nf);
116      }
117 }
118 
119 static int redirector_chr_can_read(void *opaque)
120 {
121     return REDIRECTOR_MAX_LEN;
122 }
123 
124 static void redirector_chr_read(void *opaque, const uint8_t *buf, int size)
125 {
126     NetFilterState *nf = opaque;
127     MirrorState *s = FILTER_REDIRECTOR(nf);
128     int ret;
129 
130     ret = net_fill_rstate(&s->rs, buf, size);
131 
132     if (ret == -1) {
133         qemu_chr_fe_set_handlers(&s->chr_in, NULL, NULL, NULL,
134                                  NULL, NULL, NULL, true);
135     }
136 }
137 
138 static void redirector_chr_event(void *opaque, int event)
139 {
140     NetFilterState *nf = opaque;
141     MirrorState *s = FILTER_REDIRECTOR(nf);
142 
143     switch (event) {
144     case CHR_EVENT_CLOSED:
145         qemu_chr_fe_set_handlers(&s->chr_in, NULL, NULL, NULL,
146                                  NULL, NULL, NULL, true);
147         break;
148     default:
149         break;
150     }
151 }
152 
153 static ssize_t filter_mirror_receive_iov(NetFilterState *nf,
154                                          NetClientState *sender,
155                                          unsigned flags,
156                                          const struct iovec *iov,
157                                          int iovcnt,
158                                          NetPacketSent *sent_cb)
159 {
160     MirrorState *s = FILTER_MIRROR(nf);
161     int ret;
162 
163     ret = filter_send(s, iov, iovcnt);
164     if (ret) {
165         error_report("filter mirror send failed(%s)", strerror(-ret));
166     }
167 
168     /*
169      * we don't hope this error interrupt the normal
170      * path of net packet, so we always return zero.
171      */
172     return 0;
173 }
174 
175 static ssize_t filter_redirector_receive_iov(NetFilterState *nf,
176                                              NetClientState *sender,
177                                              unsigned flags,
178                                              const struct iovec *iov,
179                                              int iovcnt,
180                                              NetPacketSent *sent_cb)
181 {
182     MirrorState *s = FILTER_REDIRECTOR(nf);
183     int ret;
184 
185     if (qemu_chr_fe_backend_connected(&s->chr_out)) {
186         ret = filter_send(s, iov, iovcnt);
187         if (ret) {
188             error_report("filter redirector send failed(%s)", strerror(-ret));
189         }
190         return iov_size(iov, iovcnt);
191     } else {
192         return 0;
193     }
194 }
195 
196 static void filter_mirror_cleanup(NetFilterState *nf)
197 {
198     MirrorState *s = FILTER_MIRROR(nf);
199 
200     qemu_chr_fe_deinit(&s->chr_out, false);
201 }
202 
203 static void filter_redirector_cleanup(NetFilterState *nf)
204 {
205     MirrorState *s = FILTER_REDIRECTOR(nf);
206 
207     qemu_chr_fe_deinit(&s->chr_in, false);
208     qemu_chr_fe_deinit(&s->chr_out, false);
209 }
210 
211 static void filter_mirror_setup(NetFilterState *nf, Error **errp)
212 {
213     MirrorState *s = FILTER_MIRROR(nf);
214     Chardev *chr;
215 
216     if (s->outdev == NULL) {
217         error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND, "filter-mirror parameter"\
218                   " 'outdev' cannot be empty");
219         return;
220     }
221 
222     chr = qemu_chr_find(s->outdev);
223     if (chr == NULL) {
224         error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
225                   "Device '%s' not found", s->outdev);
226         return;
227     }
228 
229     qemu_chr_fe_init(&s->chr_out, chr, errp);
230 }
231 
232 static void redirector_rs_finalize(SocketReadState *rs)
233 {
234     MirrorState *s = container_of(rs, MirrorState, rs);
235     NetFilterState *nf = NETFILTER(s);
236 
237     redirector_to_filter(nf, rs->buf, rs->packet_len);
238 }
239 
240 static void filter_redirector_setup(NetFilterState *nf, Error **errp)
241 {
242     MirrorState *s = FILTER_REDIRECTOR(nf);
243     Chardev *chr;
244 
245     if (!s->indev && !s->outdev) {
246         error_setg(errp, "filter redirector needs 'indev' or "
247                    "'outdev' at least one property set");
248         return;
249     } else if (s->indev && s->outdev) {
250         if (!strcmp(s->indev, s->outdev)) {
251             error_setg(errp, "'indev' and 'outdev' could not be same "
252                        "for filter redirector");
253             return;
254         }
255     }
256 
257     net_socket_rs_init(&s->rs, redirector_rs_finalize, s->vnet_hdr);
258 
259     if (s->indev) {
260         chr = qemu_chr_find(s->indev);
261         if (chr == NULL) {
262             error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
263                       "IN Device '%s' not found", s->indev);
264             return;
265         }
266 
267         if (!qemu_chr_fe_init(&s->chr_in, chr, errp)) {
268             return;
269         }
270 
271         qemu_chr_fe_set_handlers(&s->chr_in, redirector_chr_can_read,
272                                  redirector_chr_read, redirector_chr_event,
273                                  NULL, nf, NULL, true);
274     }
275 
276     if (s->outdev) {
277         chr = qemu_chr_find(s->outdev);
278         if (chr == NULL) {
279             error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
280                       "OUT Device '%s' not found", s->outdev);
281             return;
282         }
283         if (!qemu_chr_fe_init(&s->chr_out, chr, errp)) {
284             return;
285         }
286     }
287 }
288 
289 static void filter_mirror_class_init(ObjectClass *oc, void *data)
290 {
291     NetFilterClass *nfc = NETFILTER_CLASS(oc);
292 
293     nfc->setup = filter_mirror_setup;
294     nfc->cleanup = filter_mirror_cleanup;
295     nfc->receive_iov = filter_mirror_receive_iov;
296 }
297 
298 static void filter_redirector_class_init(ObjectClass *oc, void *data)
299 {
300     NetFilterClass *nfc = NETFILTER_CLASS(oc);
301 
302     nfc->setup = filter_redirector_setup;
303     nfc->cleanup = filter_redirector_cleanup;
304     nfc->receive_iov = filter_redirector_receive_iov;
305 }
306 
307 static char *filter_redirector_get_indev(Object *obj, Error **errp)
308 {
309     MirrorState *s = FILTER_REDIRECTOR(obj);
310 
311     return g_strdup(s->indev);
312 }
313 
314 static void filter_redirector_set_indev(Object *obj,
315                                         const char *value,
316                                         Error **errp)
317 {
318     MirrorState *s = FILTER_REDIRECTOR(obj);
319 
320     g_free(s->indev);
321     s->indev = g_strdup(value);
322 }
323 
324 static char *filter_mirror_get_outdev(Object *obj, Error **errp)
325 {
326     MirrorState *s = FILTER_MIRROR(obj);
327 
328     return g_strdup(s->outdev);
329 }
330 
331 static void filter_mirror_set_outdev(Object *obj,
332                                      const char *value,
333                                      Error **errp)
334 {
335     MirrorState *s = FILTER_MIRROR(obj);
336 
337     g_free(s->outdev);
338     s->outdev = g_strdup(value);
339     if (!s->outdev) {
340         error_setg(errp, "filter mirror needs 'outdev' "
341                    "property set");
342         return;
343     }
344 }
345 
346 static bool filter_mirror_get_vnet_hdr(Object *obj, Error **errp)
347 {
348     MirrorState *s = FILTER_MIRROR(obj);
349 
350     return s->vnet_hdr;
351 }
352 
353 static void filter_mirror_set_vnet_hdr(Object *obj, bool value, Error **errp)
354 {
355     MirrorState *s = FILTER_MIRROR(obj);
356 
357     s->vnet_hdr = value;
358 }
359 
360 static char *filter_redirector_get_outdev(Object *obj, Error **errp)
361 {
362     MirrorState *s = FILTER_REDIRECTOR(obj);
363 
364     return g_strdup(s->outdev);
365 }
366 
367 static void filter_redirector_set_outdev(Object *obj,
368                                          const char *value,
369                                          Error **errp)
370 {
371     MirrorState *s = FILTER_REDIRECTOR(obj);
372 
373     g_free(s->outdev);
374     s->outdev = g_strdup(value);
375 }
376 
377 static bool filter_redirector_get_vnet_hdr(Object *obj, Error **errp)
378 {
379     MirrorState *s = FILTER_REDIRECTOR(obj);
380 
381     return s->vnet_hdr;
382 }
383 
384 static void filter_redirector_set_vnet_hdr(Object *obj,
385                                            bool value,
386                                            Error **errp)
387 {
388     MirrorState *s = FILTER_REDIRECTOR(obj);
389 
390     s->vnet_hdr = value;
391 }
392 
393 static void filter_mirror_init(Object *obj)
394 {
395     MirrorState *s = FILTER_MIRROR(obj);
396 
397     object_property_add_str(obj, "outdev", filter_mirror_get_outdev,
398                             filter_mirror_set_outdev, NULL);
399 
400     s->vnet_hdr = false;
401     object_property_add_bool(obj, "vnet_hdr_support",
402                              filter_mirror_get_vnet_hdr,
403                              filter_mirror_set_vnet_hdr, NULL);
404 }
405 
406 static void filter_redirector_init(Object *obj)
407 {
408     MirrorState *s = FILTER_REDIRECTOR(obj);
409 
410     object_property_add_str(obj, "indev", filter_redirector_get_indev,
411                             filter_redirector_set_indev, NULL);
412     object_property_add_str(obj, "outdev", filter_redirector_get_outdev,
413                             filter_redirector_set_outdev, NULL);
414 
415     s->vnet_hdr = false;
416     object_property_add_bool(obj, "vnet_hdr_support",
417                              filter_redirector_get_vnet_hdr,
418                              filter_redirector_set_vnet_hdr, NULL);
419 }
420 
421 static void filter_mirror_fini(Object *obj)
422 {
423     MirrorState *s = FILTER_MIRROR(obj);
424 
425     g_free(s->outdev);
426 }
427 
428 static void filter_redirector_fini(Object *obj)
429 {
430     MirrorState *s = FILTER_REDIRECTOR(obj);
431 
432     g_free(s->indev);
433     g_free(s->outdev);
434 }
435 
436 static const TypeInfo filter_redirector_info = {
437     .name = TYPE_FILTER_REDIRECTOR,
438     .parent = TYPE_NETFILTER,
439     .class_init = filter_redirector_class_init,
440     .instance_init = filter_redirector_init,
441     .instance_finalize = filter_redirector_fini,
442     .instance_size = sizeof(MirrorState),
443 };
444 
445 static const TypeInfo filter_mirror_info = {
446     .name = TYPE_FILTER_MIRROR,
447     .parent = TYPE_NETFILTER,
448     .class_init = filter_mirror_class_init,
449     .instance_init = filter_mirror_init,
450     .instance_finalize = filter_mirror_fini,
451     .instance_size = sizeof(MirrorState),
452 };
453 
454 static void register_types(void)
455 {
456     type_register_static(&filter_mirror_info);
457     type_register_static(&filter_redirector_info);
458 }
459 
460 type_init(register_types);
461