qemu/net/filter.c
Markus Armbruster d2623129a7 qom: Drop parameter @errp of object_property_add() & friends
The only way object_property_add() can fail is when a property with
the same name already exists.  Since our property names are all
hardcoded, failure is a programming error, and the appropriate way to
handle it is passing &error_abort.

Same for its variants, except for object_property_add_child(), which
additionally fails when the child already has a parent.  Parentage is
also under program control, so this is a programming error, too.

We have a bit over 500 callers.  Almost half of them pass
&error_abort, slightly fewer ignore errors, one test case handles
errors, and the remaining few callers pass them to their own callers.

The previous few commits demonstrated once again that ignoring
programming errors is a bad idea.

Of the few ones that pass on errors, several violate the Error API.
The Error ** argument must be NULL, &error_abort, &error_fatal, or a
pointer to a variable containing NULL.  Passing an argument of the
latter kind twice without clearing it in between is wrong: if the
first call sets an error, it no longer points to NULL for the second
call.  ich9_pm_add_properties(), sparc32_ledma_realize(),
sparc32_dma_realize(), xilinx_axidma_realize(), xilinx_enet_realize()
are wrong that way.

When the one appropriate choice of argument is &error_abort, letting
users pick the argument is a bad idea.

Drop parameter @errp and assert the preconditions instead.

There's one exception to "duplicate property name is a programming
error": the way object_property_add() implements the magic (and
undocumented) "automatic arrayification".  Don't drop @errp there.
Instead, rename object_property_add() to object_property_try_add(),
and add the obvious wrapper object_property_add().

Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Message-Id: <20200505152926.18877-15-armbru@redhat.com>
[Two semantic rebase conflicts resolved]
2020-05-15 07:07:58 +02:00

378 lines
10 KiB
C

/*
* Copyright (c) 2015 FUJITSU LIMITED
* Author: Yang Hongyang <yanghy@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.
*/
#include "qemu/osdep.h"
#include "qapi/error.h"
#include "qapi/qmp/qerror.h"
#include "qemu/error-report.h"
#include "net/filter.h"
#include "net/net.h"
#include "net/vhost_net.h"
#include "qom/object_interfaces.h"
#include "qemu/iov.h"
#include "qemu/module.h"
#include "net/colo.h"
#include "migration/colo.h"
static inline bool qemu_can_skip_netfilter(NetFilterState *nf)
{
return !nf->on;
}
ssize_t qemu_netfilter_receive(NetFilterState *nf,
NetFilterDirection direction,
NetClientState *sender,
unsigned flags,
const struct iovec *iov,
int iovcnt,
NetPacketSent *sent_cb)
{
if (qemu_can_skip_netfilter(nf)) {
return 0;
}
if (nf->direction == direction ||
nf->direction == NET_FILTER_DIRECTION_ALL) {
return NETFILTER_GET_CLASS(OBJECT(nf))->receive_iov(
nf, sender, flags, iov, iovcnt, sent_cb);
}
return 0;
}
static NetFilterState *netfilter_next(NetFilterState *nf,
NetFilterDirection dir)
{
NetFilterState *next;
if (dir == NET_FILTER_DIRECTION_TX) {
/* forward walk through filters */
next = QTAILQ_NEXT(nf, next);
} else {
/* reverse order */
next = QTAILQ_PREV(nf, next);
}
return next;
}
ssize_t qemu_netfilter_pass_to_next(NetClientState *sender,
unsigned flags,
const struct iovec *iov,
int iovcnt,
void *opaque)
{
int ret = 0;
int direction;
NetFilterState *nf = opaque;
NetFilterState *next = NULL;
if (!sender || !sender->peer) {
/* no receiver, or sender been deleted, no need to pass it further */
goto out;
}
if (nf->direction == NET_FILTER_DIRECTION_ALL) {
if (sender == nf->netdev) {
/* This packet is sent by netdev itself */
direction = NET_FILTER_DIRECTION_TX;
} else {
direction = NET_FILTER_DIRECTION_RX;
}
} else {
direction = nf->direction;
}
next = netfilter_next(nf, direction);
while (next) {
/*
* if qemu_netfilter_pass_to_next been called, means that
* the packet has been hold by filter and has already retured size
* to the sender, so sent_cb shouldn't be called later, just
* pass NULL to next.
*/
ret = qemu_netfilter_receive(next, direction, sender, flags, iov,
iovcnt, NULL);
if (ret) {
return ret;
}
next = netfilter_next(next, direction);
}
/*
* We have gone through all filters, pass it to receiver.
* Do the valid check again incase sender or receiver been
* deleted while we go through filters.
*/
if (sender && sender->peer) {
qemu_net_queue_send_iov(sender->peer->incoming_queue,
sender, flags, iov, iovcnt, NULL);
}
out:
/* no receiver, or sender been deleted */
return iov_size(iov, iovcnt);
}
static char *netfilter_get_netdev_id(Object *obj, Error **errp)
{
NetFilterState *nf = NETFILTER(obj);
return g_strdup(nf->netdev_id);
}
static void netfilter_set_netdev_id(Object *obj, const char *str, Error **errp)
{
NetFilterState *nf = NETFILTER(obj);
nf->netdev_id = g_strdup(str);
}
static int netfilter_get_direction(Object *obj, Error **errp G_GNUC_UNUSED)
{
NetFilterState *nf = NETFILTER(obj);
return nf->direction;
}
static void netfilter_set_direction(Object *obj, int direction, Error **errp)
{
NetFilterState *nf = NETFILTER(obj);
nf->direction = direction;
}
static char *netfilter_get_status(Object *obj, Error **errp)
{
NetFilterState *nf = NETFILTER(obj);
return nf->on ? g_strdup("on") : g_strdup("off");
}
static void netfilter_set_status(Object *obj, const char *str, Error **errp)
{
NetFilterState *nf = NETFILTER(obj);
NetFilterClass *nfc = NETFILTER_GET_CLASS(obj);
if (strcmp(str, "on") && strcmp(str, "off")) {
error_setg(errp, "Invalid value for netfilter status, "
"should be 'on' or 'off'");
return;
}
if (nf->on == !strcmp(str, "on")) {
return;
}
nf->on = !nf->on;
if (nf->netdev && nfc->status_changed) {
nfc->status_changed(nf, errp);
}
}
static char *netfilter_get_position(Object *obj, Error **errp)
{
NetFilterState *nf = NETFILTER(obj);
return g_strdup(nf->position);
}
static void netfilter_set_position(Object *obj, const char *str, Error **errp)
{
NetFilterState *nf = NETFILTER(obj);
nf->position = g_strdup(str);
}
static char *netfilter_get_insert(Object *obj, Error **errp)
{
NetFilterState *nf = NETFILTER(obj);
return nf->insert_before_flag ? g_strdup("before") : g_strdup("behind");
}
static void netfilter_set_insert(Object *obj, const char *str, Error **errp)
{
NetFilterState *nf = NETFILTER(obj);
if (strcmp(str, "before") && strcmp(str, "behind")) {
error_setg(errp, "Invalid value for netfilter insert, "
"should be 'before' or 'behind'");
return;
}
nf->insert_before_flag = !strcmp(str, "before");
}
static void netfilter_init(Object *obj)
{
NetFilterState *nf = NETFILTER(obj);
nf->on = true;
nf->insert_before_flag = false;
nf->position = g_strdup("tail");
object_property_add_str(obj, "netdev",
netfilter_get_netdev_id, netfilter_set_netdev_id);
object_property_add_enum(obj, "queue", "NetFilterDirection",
&NetFilterDirection_lookup,
netfilter_get_direction, netfilter_set_direction);
object_property_add_str(obj, "status",
netfilter_get_status, netfilter_set_status);
object_property_add_str(obj, "position",
netfilter_get_position, netfilter_set_position);
object_property_add_str(obj, "insert",
netfilter_get_insert, netfilter_set_insert);
}
static void netfilter_complete(UserCreatable *uc, Error **errp)
{
NetFilterState *nf = NETFILTER(uc);
NetFilterState *position = NULL;
NetClientState *ncs[MAX_QUEUE_NUM];
NetFilterClass *nfc = NETFILTER_GET_CLASS(uc);
int queues;
Error *local_err = NULL;
if (!nf->netdev_id) {
error_setg(errp, "Parameter 'netdev' is required");
return;
}
queues = qemu_find_net_clients_except(nf->netdev_id, ncs,
NET_CLIENT_DRIVER_NIC,
MAX_QUEUE_NUM);
if (queues < 1) {
error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "netdev",
"a network backend id");
return;
} else if (queues > 1) {
error_setg(errp, "multiqueue is not supported");
return;
}
if (get_vhost_net(ncs[0])) {
error_setg(errp, "Vhost is not supported");
return;
}
if (strcmp(nf->position, "head") && strcmp(nf->position, "tail")) {
Object *container;
Object *obj;
char *position_id;
if (!g_str_has_prefix(nf->position, "id=")) {
error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "position",
"'head', 'tail' or 'id=<id>'");
return;
}
/* get the id from the string */
position_id = g_strndup(nf->position + 3, strlen(nf->position) - 3);
/* Search for the position to insert before/behind */
container = object_get_objects_root();
obj = object_resolve_path_component(container, position_id);
if (!obj) {
error_setg(errp, "filter '%s' not found", position_id);
g_free(position_id);
return;
}
position = NETFILTER(obj);
if (position->netdev != ncs[0]) {
error_setg(errp, "filter '%s' belongs to a different netdev",
position_id);
g_free(position_id);
return;
}
g_free(position_id);
}
nf->netdev = ncs[0];
if (nfc->setup) {
nfc->setup(nf, &local_err);
if (local_err) {
error_propagate(errp, local_err);
return;
}
}
if (position) {
if (nf->insert_before_flag) {
QTAILQ_INSERT_BEFORE(position, nf, next);
} else {
QTAILQ_INSERT_AFTER(&nf->netdev->filters, position, nf, next);
}
} else if (!strcmp(nf->position, "head")) {
QTAILQ_INSERT_HEAD(&nf->netdev->filters, nf, next);
} else if (!strcmp(nf->position, "tail")) {
QTAILQ_INSERT_TAIL(&nf->netdev->filters, nf, next);
}
}
static void netfilter_finalize(Object *obj)
{
NetFilterState *nf = NETFILTER(obj);
NetFilterClass *nfc = NETFILTER_GET_CLASS(obj);
if (nfc->cleanup) {
nfc->cleanup(nf);
}
if (nf->netdev && !QTAILQ_EMPTY(&nf->netdev->filters) &&
QTAILQ_IN_USE(nf, next)) {
QTAILQ_REMOVE(&nf->netdev->filters, nf, next);
}
g_free(nf->netdev_id);
g_free(nf->position);
}
static void default_handle_event(NetFilterState *nf, int event, Error **errp)
{
switch (event) {
case COLO_EVENT_CHECKPOINT:
break;
case COLO_EVENT_FAILOVER:
object_property_set_str(OBJECT(nf), "off", "status", errp);
break;
default:
break;
}
}
static void netfilter_class_init(ObjectClass *oc, void *data)
{
UserCreatableClass *ucc = USER_CREATABLE_CLASS(oc);
NetFilterClass *nfc = NETFILTER_CLASS(oc);
ucc->complete = netfilter_complete;
nfc->handle_event = default_handle_event;
}
static const TypeInfo netfilter_info = {
.name = TYPE_NETFILTER,
.parent = TYPE_OBJECT,
.abstract = true,
.class_size = sizeof(NetFilterClass),
.class_init = netfilter_class_init,
.instance_size = sizeof(NetFilterState),
.instance_init = netfilter_init,
.instance_finalize = netfilter_finalize,
.interfaces = (InterfaceInfo[]) {
{ TYPE_USER_CREATABLE },
{ }
}
};
static void register_types(void)
{
type_register_static(&netfilter_info);
}
type_init(register_types);