#include "qemu/main-loop.h"
#include "qemu/error-report.h"
#include "trace.h"
-#include "sysemu/char.h"
+#include "chardev/char-fe.h"
#include "qemu/iov.h"
#include "qemu/sockets.h"
NetFilterState parent_obj;
char *indev;
char *outdev;
- CharDriverState *chr_in;
- CharDriverState *chr_out;
+ CharBackend chr_in;
+ CharBackend chr_out;
SocketReadState rs;
+ bool vnet_hdr;
} MirrorState;
-static int filter_mirror_send(CharDriverState *chr_out,
- const struct iovec *iov,
- int iovcnt)
+static int filter_send(MirrorState *s,
+ const struct iovec *iov,
+ int iovcnt)
{
+ NetFilterState *nf = NETFILTER(s);
int ret = 0;
ssize_t size = 0;
- uint32_t len = 0;
+ uint32_t len = 0;
char *buf;
size = iov_size(iov, iovcnt);
}
len = htonl(size);
- ret = qemu_chr_fe_write_all(chr_out, (uint8_t *)&len, sizeof(len));
+ ret = qemu_chr_fe_write_all(&s->chr_out, (uint8_t *)&len, sizeof(len));
if (ret != sizeof(len)) {
goto err;
}
+ if (s->vnet_hdr) {
+ /*
+ * If vnet_hdr = on, we send vnet header len to make other
+ * module(like colo-compare) know how to parse net
+ * packet correctly.
+ */
+ ssize_t vnet_hdr_len;
+
+ vnet_hdr_len = nf->netdev->vnet_hdr_len;
+
+ len = htonl(vnet_hdr_len);
+ ret = qemu_chr_fe_write_all(&s->chr_out, (uint8_t *)&len, sizeof(len));
+ if (ret != sizeof(len)) {
+ goto err;
+ }
+ }
+
buf = g_malloc(size);
iov_to_buf(iov, iovcnt, 0, buf, size);
- ret = qemu_chr_fe_write_all(chr_out, (uint8_t *)buf, size);
+ ret = qemu_chr_fe_write_all(&s->chr_out, (uint8_t *)buf, size);
g_free(buf);
if (ret != size) {
goto err;
return ret < 0 ? ret : -EIO;
}
-static void
-redirector_to_filter(NetFilterState *nf, const uint8_t *buf, int len)
+static void redirector_to_filter(NetFilterState *nf,
+ const uint8_t *buf,
+ int len)
{
struct iovec iov = {
.iov_base = (void *)buf,
ret = net_fill_rstate(&s->rs, buf, size);
if (ret == -1) {
- qemu_chr_add_handlers(s->chr_in, NULL, NULL, NULL, NULL);
+ qemu_chr_fe_set_handlers(&s->chr_in, NULL, NULL, NULL,
+ NULL, NULL, NULL, true);
}
}
switch (event) {
case CHR_EVENT_CLOSED:
- qemu_chr_add_handlers(s->chr_in, NULL, NULL, NULL, NULL);
+ qemu_chr_fe_set_handlers(&s->chr_in, NULL, NULL, NULL,
+ NULL, NULL, NULL, true);
break;
default:
break;
MirrorState *s = FILTER_MIRROR(nf);
int ret;
- ret = filter_mirror_send(s->chr_out, iov, iovcnt);
+ ret = filter_send(s, iov, iovcnt);
if (ret) {
- error_report("filter_mirror_send failed(%s)", strerror(-ret));
+ error_report("filter mirror send failed(%s)", strerror(-ret));
}
/*
MirrorState *s = FILTER_REDIRECTOR(nf);
int ret;
- if (s->chr_out) {
- ret = filter_mirror_send(s->chr_out, iov, iovcnt);
+ if (qemu_chr_fe_backend_connected(&s->chr_out)) {
+ ret = filter_send(s, iov, iovcnt);
if (ret) {
- error_report("filter_mirror_send failed(%s)", strerror(-ret));
+ error_report("filter redirector send failed(%s)", strerror(-ret));
}
return iov_size(iov, iovcnt);
} else {
{
MirrorState *s = FILTER_MIRROR(nf);
- if (s->chr_out) {
- qemu_chr_fe_release(s->chr_out);
- }
+ qemu_chr_fe_deinit(&s->chr_out, false);
}
static void filter_redirector_cleanup(NetFilterState *nf)
{
MirrorState *s = FILTER_REDIRECTOR(nf);
- if (s->chr_in) {
- qemu_chr_add_handlers(s->chr_in, NULL, NULL, NULL, NULL);
- qemu_chr_fe_release(s->chr_in);
- }
- if (s->chr_out) {
- qemu_chr_fe_release(s->chr_out);
- }
+ qemu_chr_fe_deinit(&s->chr_in, false);
+ qemu_chr_fe_deinit(&s->chr_out, false);
}
static void filter_mirror_setup(NetFilterState *nf, Error **errp)
{
MirrorState *s = FILTER_MIRROR(nf);
+ Chardev *chr;
- if (!s->outdev) {
- error_setg(errp, "filter filter mirror needs 'outdev' "
- "property set");
+ if (s->outdev == NULL) {
+ error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND, "filter-mirror parameter"\
+ " 'outdev' cannot be empty");
return;
}
- s->chr_out = qemu_chr_find(s->outdev);
- if (s->chr_out == NULL) {
+ chr = qemu_chr_find(s->outdev);
+ if (chr == NULL) {
error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
"Device '%s' not found", s->outdev);
return;
}
- if (qemu_chr_fe_claim(s->chr_out) != 0) {
- error_setg(errp, QERR_DEVICE_IN_USE, s->outdev);
- return;
- }
+ qemu_chr_fe_init(&s->chr_out, chr, errp);
}
static void redirector_rs_finalize(SocketReadState *rs)
static void filter_redirector_setup(NetFilterState *nf, Error **errp)
{
MirrorState *s = FILTER_REDIRECTOR(nf);
+ Chardev *chr;
if (!s->indev && !s->outdev) {
error_setg(errp, "filter redirector needs 'indev' or "
}
}
- net_socket_rs_init(&s->rs, redirector_rs_finalize);
+ net_socket_rs_init(&s->rs, redirector_rs_finalize, s->vnet_hdr);
if (s->indev) {
- s->chr_in = qemu_chr_find(s->indev);
- if (s->chr_in == NULL) {
+ chr = qemu_chr_find(s->indev);
+ if (chr == NULL) {
error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
"IN Device '%s' not found", s->indev);
return;
}
- qemu_chr_fe_claim_no_fail(s->chr_in);
- qemu_chr_add_handlers(s->chr_in, redirector_chr_can_read,
- redirector_chr_read, redirector_chr_event, nf);
+ if (!qemu_chr_fe_init(&s->chr_in, chr, errp)) {
+ return;
+ }
+
+ qemu_chr_fe_set_handlers(&s->chr_in, redirector_chr_can_read,
+ redirector_chr_read, redirector_chr_event,
+ NULL, nf, NULL, true);
}
if (s->outdev) {
- s->chr_out = qemu_chr_find(s->outdev);
- if (s->chr_out == NULL) {
+ chr = qemu_chr_find(s->outdev);
+ if (chr == NULL) {
error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
"OUT Device '%s' not found", s->outdev);
return;
}
- qemu_chr_fe_claim_no_fail(s->chr_out);
+ if (!qemu_chr_fe_init(&s->chr_out, chr, errp)) {
+ return;
+ }
}
}
return g_strdup(s->indev);
}
-static void
-filter_redirector_set_indev(Object *obj, const char *value, Error **errp)
+static void filter_redirector_set_indev(Object *obj,
+ const char *value,
+ Error **errp)
{
MirrorState *s = FILTER_REDIRECTOR(obj);
return g_strdup(s->outdev);
}
-static void
-filter_mirror_set_outdev(Object *obj, const char *value, Error **errp)
+static void filter_mirror_set_outdev(Object *obj,
+ const char *value,
+ Error **errp)
{
MirrorState *s = FILTER_MIRROR(obj);
g_free(s->outdev);
s->outdev = g_strdup(value);
if (!s->outdev) {
- error_setg(errp, "filter filter mirror needs 'outdev' "
+ error_setg(errp, "filter mirror needs 'outdev' "
"property set");
return;
}
}
+static bool filter_mirror_get_vnet_hdr(Object *obj, Error **errp)
+{
+ MirrorState *s = FILTER_MIRROR(obj);
+
+ return s->vnet_hdr;
+}
+
+static void filter_mirror_set_vnet_hdr(Object *obj, bool value, Error **errp)
+{
+ MirrorState *s = FILTER_MIRROR(obj);
+
+ s->vnet_hdr = value;
+}
+
static char *filter_redirector_get_outdev(Object *obj, Error **errp)
{
MirrorState *s = FILTER_REDIRECTOR(obj);
return g_strdup(s->outdev);
}
-static void
-filter_redirector_set_outdev(Object *obj, const char *value, Error **errp)
+static void filter_redirector_set_outdev(Object *obj,
+ const char *value,
+ Error **errp)
{
MirrorState *s = FILTER_REDIRECTOR(obj);
s->outdev = g_strdup(value);
}
+static bool filter_redirector_get_vnet_hdr(Object *obj, Error **errp)
+{
+ MirrorState *s = FILTER_REDIRECTOR(obj);
+
+ return s->vnet_hdr;
+}
+
+static void filter_redirector_set_vnet_hdr(Object *obj,
+ bool value,
+ Error **errp)
+{
+ MirrorState *s = FILTER_REDIRECTOR(obj);
+
+ s->vnet_hdr = value;
+}
+
static void filter_mirror_init(Object *obj)
{
+ MirrorState *s = FILTER_MIRROR(obj);
+
object_property_add_str(obj, "outdev", filter_mirror_get_outdev,
filter_mirror_set_outdev, NULL);
+
+ s->vnet_hdr = false;
+ object_property_add_bool(obj, "vnet_hdr_support",
+ filter_mirror_get_vnet_hdr,
+ filter_mirror_set_vnet_hdr, NULL);
}
static void filter_redirector_init(Object *obj)
{
+ MirrorState *s = FILTER_REDIRECTOR(obj);
+
object_property_add_str(obj, "indev", filter_redirector_get_indev,
filter_redirector_set_indev, NULL);
object_property_add_str(obj, "outdev", filter_redirector_get_outdev,
filter_redirector_set_outdev, NULL);
+
+ s->vnet_hdr = false;
+ object_property_add_bool(obj, "vnet_hdr_support",
+ filter_redirector_get_vnet_hdr,
+ filter_redirector_set_vnet_hdr, NULL);
}
static void filter_mirror_fini(Object *obj)
projects / qemu.git / blobdiff