net/filter.c

   1 /*
   2  * Copyright (c) 2015 FUJITSU LIMITED
   3  * Author: Yang Hongyang <yanghy@cn.fujitsu.com>
   4  *
   5  * This work is licensed under the terms of the GNU GPL, version 2 or
   6  * later.  See the COPYING file in the top-level directory.
   7  */
   8
   9 #include "qemu-common.h"
  10 #include "qapi/qmp/qerror.h"
  11 #include "qemu/error-report.h"
  12
  13 #include "net/filter.h"
  14 #include "net/net.h"
  15 #include "net/vhost_net.h"
  16 #include "qom/object_interfaces.h"
  17
  18 ssize_t qemu_netfilter_receive(NetFilterState *nf,
  19                                NetFilterDirection direction,
  20                                NetClientState *sender,
  21                                unsigned flags,
  22                                const struct iovec *iov,
  23                                int iovcnt,
  24                                NetPacketSent *sent_cb)
  25 {
  26     if (nf->direction == direction ||
  27         nf->direction == NET_FILTER_DIRECTION_ALL) {
  28         return NETFILTER_GET_CLASS(OBJECT(nf))->receive_iov(
  29                                    nf, sender, flags, iov, iovcnt, sent_cb);
  30     }
  31
  32     return 0;
  33 }
  34
  35 static char *netfilter_get_netdev_id(Object *obj, Error **errp)
  36 {
  37     NetFilterState *nf = NETFILTER(obj);
  38
  39     return g_strdup(nf->netdev_id);
  40 }
  41
  42 static void netfilter_set_netdev_id(Object *obj, const char *str, Error **errp)
  43 {
  44     NetFilterState *nf = NETFILTER(obj);
  45
  46     nf->netdev_id = g_strdup(str);
  47 }
  48
  49 static int netfilter_get_direction(Object *obj, Error **errp G_GNUC_UNUSED)
  50 {
  51     NetFilterState *nf = NETFILTER(obj);
  52     return nf->direction;
  53 }
  54
  55 static void netfilter_set_direction(Object *obj, int direction, Error **errp)
  56 {
  57     NetFilterState *nf = NETFILTER(obj);
  58     nf->direction = direction;
  59 }
  60
  61 static void netfilter_init(Object *obj)
  62 {
  63     object_property_add_str(obj, "netdev",
  64                             netfilter_get_netdev_id, netfilter_set_netdev_id,
  65                             NULL);
  66     object_property_add_enum(obj, "queue", "NetFilterDirection",
  67                              NetFilterDirection_lookup,
  68                              netfilter_get_direction, netfilter_set_direction,
  69                              NULL);
  70 }
  71
  72 static void netfilter_complete(UserCreatable *uc, Error **errp)
  73 {
  74     NetFilterState *nf = NETFILTER(uc);
  75     NetClientState *ncs[MAX_QUEUE_NUM];
  76     NetFilterClass *nfc = NETFILTER_GET_CLASS(uc);
  77     int queues;
  78     Error *local_err = NULL;
  79
  80     if (!nf->netdev_id) {
  81         error_setg(errp, "Parameter 'netdev' is required");
  82         return;
  83     }
  84
  85     queues = qemu_find_net_clients_except(nf->netdev_id, ncs,
  86                                           NET_CLIENT_OPTIONS_KIND_NIC,
  87                                           MAX_QUEUE_NUM);
  88     if (queues < 1) {
  89         error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "netdev",
  90                    "a network backend id");
  91         return;
  92     } else if (queues > 1) {
  93         error_setg(errp, "multiqueue is not supported");
  94         return;
  95     }
  96
  97     if (get_vhost_net(ncs[0])) {
  98         error_setg(errp, "Vhost is not supported");
  99         return;
 100     }
 101
 102     nf->netdev = ncs[0];
 103
 104     if (nfc->setup) {
 105         nfc->setup(nf, &local_err);
 106         if (local_err) {
 107             error_propagate(errp, local_err);
 108             return;
 109         }
 110     }
 111     QTAILQ_INSERT_TAIL(&nf->netdev->filters, nf, next);
 112 }
 113
 114 static void netfilter_finalize(Object *obj)
 115 {
 116     NetFilterState *nf = NETFILTER(obj);
 117     NetFilterClass *nfc = NETFILTER_GET_CLASS(obj);
 118
 119     if (nfc->cleanup) {
 120         nfc->cleanup(nf);
 121     }
 122
 123     if (nf->netdev && !QTAILQ_EMPTY(&nf->netdev->filters)) {
 124         QTAILQ_REMOVE(&nf->netdev->filters, nf, next);
 125     }
 126 }
 127
 128 static void netfilter_class_init(ObjectClass *oc, void *data)
 129 {
 130     UserCreatableClass *ucc = USER_CREATABLE_CLASS(oc);
 131
 132     ucc->complete = netfilter_complete;
 133 }
 134
 135 static const TypeInfo netfilter_info = {
 136     .name = TYPE_NETFILTER,
 137     .parent = TYPE_OBJECT,
 138     .abstract = true,
 139     .class_size = sizeof(NetFilterClass),
 140     .class_init = netfilter_class_init,
 141     .instance_size = sizeof(NetFilterState),
 142     .instance_init = netfilter_init,
 143     .instance_finalize = netfilter_finalize,
 144     .interfaces = (InterfaceInfo[]) {
 145         { TYPE_USER_CREATABLE },
 146         { }
 147     }
 148 };
 149
 150 static void register_types(void)
 151 {
 152     type_register_static(&netfilter_info);
 153 }
 154
 155 type_init(register_types);