Merge remote-tracking branch 'remotes/kraxel/tags/usb-20170717-pull-request' into...

[qemu.git] / net / dump.c

diff --git a/net/dump.c b/net/dump.c
index 41197217205092078fa5bd59e87df1469d450750..15df9a4973037459fb8eaa3e21db1a048bbc8349 100644 (file)
--- a/net/dump.c
+++ b/net/dump.c
@@ -22,15 +22,18 @@
  * THE SOFTWARE.
  */
 
  * THE SOFTWARE.
  */
 

+#include "qemu/osdep.h"

 #include "clients.h"
 #include "clients.h"

+#include "qapi/error.h"

 #include "qemu-common.h"
 #include "qemu/error-report.h"
 #include "qemu-common.h"
 #include "qemu/error-report.h"

+#include "qemu/iov.h"

 #include "qemu/log.h"
 #include "qemu/timer.h"
 #include "qemu/log.h"
 #include "qemu/timer.h"

-#include "hub.h"
+#include "qapi/visitor.h"
+#include "net/filter.h"

 
 typedef struct DumpState {
 
 typedef struct DumpState {

-    NetClientState nc;

     int64_t start_ts;
     int fd;
     int pcap_caplen;
     int64_t start_ts;
     int fd;
     int pcap_caplen;


@@ -57,28 +60,33 @@ struct pcap_sf_pkthdr {
     uint32_t len;
 };
 
     uint32_t len;
 };
 

-static ssize_t dump_receive(NetClientState *nc, const uint8_t *buf, size_t size)
+static ssize_t dump_receive_iov(DumpState *s, const struct iovec *iov, int cnt)

 {
 {

-    DumpState *s = DO_UPCAST(DumpState, nc, nc);

     struct pcap_sf_pkthdr hdr;
     int64_t ts;
     int caplen;
     struct pcap_sf_pkthdr hdr;
     int64_t ts;
     int caplen;

+    size_t size = iov_size(iov, cnt);
+    struct iovec dumpiov[cnt + 1];

 
     /* Early return in case of previous error. */
     if (s->fd < 0) {
         return size;
     }
 
 
     /* Early return in case of previous error. */
     if (s->fd < 0) {
         return size;
     }
 

-    ts = muldiv64(qemu_get_clock_ns(vm_clock), 1000000, get_ticks_per_sec());
+    ts = qemu_clock_get_us(QEMU_CLOCK_VIRTUAL);

     caplen = size > s->pcap_caplen ? s->pcap_caplen : size;
 
     hdr.ts.tv_sec = ts / 1000000 + s->start_ts;
     hdr.ts.tv_usec = ts % 1000000;
     hdr.caplen = caplen;
     hdr.len = size;
     caplen = size > s->pcap_caplen ? s->pcap_caplen : size;
 
     hdr.ts.tv_sec = ts / 1000000 + s->start_ts;
     hdr.ts.tv_usec = ts % 1000000;
     hdr.caplen = caplen;
     hdr.len = size;

-    if (write(s->fd, &hdr, sizeof(hdr)) != sizeof(hdr) ||
-        write(s->fd, buf, caplen) != caplen) {
-        qemu_log("-net dump write error - stop dump\n");
+
+    dumpiov[0].iov_base = &hdr;
+    dumpiov[0].iov_len = sizeof(hdr);
+    cnt = iov_copy(&dumpiov[1], cnt, iov, cnt, 0, caplen);
+
+    if (writev(s->fd, dumpiov, cnt + 1) != sizeof(hdr) + caplen) {
+        error_report("network dump write error - stopping dump");

         close(s->fd);
         s->fd = -1;
     }
         close(s->fd);
         s->fd = -1;
     }


@@ -86,32 +94,22 @@ static ssize_t dump_receive(NetClientState *nc, const uint8_t *buf, size_t size)
     return size;
 }
 
     return size;
 }
 

-static void dump_cleanup(NetClientState *nc)
+static void dump_cleanup(DumpState *s)

 {
 {

-    DumpState *s = DO_UPCAST(DumpState, nc, nc);
-

     close(s->fd);
     close(s->fd);

+    s->fd = -1;

 }
 
 }
 

-static NetClientInfo net_dump_info = {
-    .type = NET_CLIENT_OPTIONS_KIND_DUMP,
-    .size = sizeof(DumpState),
-    .receive = dump_receive,
-    .cleanup = dump_cleanup,
-};
-
-static int net_dump_init(NetClientState *peer, const char *device,
-                         const char *name, const char *filename, int len)
+static int net_dump_state_init(DumpState *s, const char *filename,
+                               int len, Error **errp)

 {
     struct pcap_file_hdr hdr;
 {
     struct pcap_file_hdr hdr;

-    NetClientState *nc;
-    DumpState *s;

     struct tm tm;
     int fd;
 
     fd = open(filename, O_CREAT | O_TRUNC | O_WRONLY | O_BINARY, 0644);
     if (fd < 0) {
     struct tm tm;
     int fd;
 
     fd = open(filename, O_CREAT | O_TRUNC | O_WRONLY | O_BINARY, 0644);
     if (fd < 0) {

-        error_report("-net dump: can't open %s", filename);
+        error_setg_errno(errp, errno, "-net dump: can't open %s", filename);

         return -1;
     }
 
         return -1;
     }
 


@@ -124,18 +122,11 @@ static int net_dump_init(NetClientState *peer, const char *device,
     hdr.linktype = 1;
 
     if (write(fd, &hdr, sizeof(hdr)) < sizeof(hdr)) {
     hdr.linktype = 1;
 
     if (write(fd, &hdr, sizeof(hdr)) < sizeof(hdr)) {

-        error_report("-net dump write error: %s", strerror(errno));
+        error_setg_errno(errp, errno, "-net dump write error");

         close(fd);
         return -1;
     }
 
         close(fd);
         return -1;
     }
 

-    nc = qemu_new_net_client(&net_dump_info, peer, device, name);
-
-    snprintf(nc->info_str, sizeof(nc->info_str),
-             "dump to %s (len=%d)", filename, len);
-
-    s = DO_UPCAST(DumpState, nc, nc);
-

     s->fd = fd;
     s->pcap_caplen = len;
 
     s->fd = fd;
     s->pcap_caplen = len;
 


@@ -145,19 +136,67 @@ static int net_dump_init(NetClientState *peer, const char *device,
     return 0;
 }
 
     return 0;
 }
 

-int net_init_dump(const NetClientOptions *opts, const char *name,
-                  NetClientState *peer)
+/* Dumping via VLAN netclient */
+
+struct DumpNetClient {
+    NetClientState nc;
+    DumpState ds;
+};
+typedef struct DumpNetClient DumpNetClient;
+
+static ssize_t dumpclient_receive(NetClientState *nc, const uint8_t *buf,
+                                  size_t size)
+{
+    DumpNetClient *dc = DO_UPCAST(DumpNetClient, nc, nc);
+    struct iovec iov = {
+        .iov_base = (void *)buf,
+        .iov_len = size
+    };
+
+    return dump_receive_iov(&dc->ds, &iov, 1);
+}
+
+static ssize_t dumpclient_receive_iov(NetClientState *nc,
+                                      const struct iovec *iov, int cnt)
+{
+    DumpNetClient *dc = DO_UPCAST(DumpNetClient, nc, nc);
+
+    return dump_receive_iov(&dc->ds, iov, cnt);
+}
+
+static void dumpclient_cleanup(NetClientState *nc)

 {
 {

-    int len;
+    DumpNetClient *dc = DO_UPCAST(DumpNetClient, nc, nc);
+
+    dump_cleanup(&dc->ds);
+}
+
+static NetClientInfo net_dump_info = {
+    .type = NET_CLIENT_DRIVER_DUMP,
+    .size = sizeof(DumpNetClient),
+    .receive = dumpclient_receive,
+    .receive_iov = dumpclient_receive_iov,
+    .cleanup = dumpclient_cleanup,
+};
+
+int net_init_dump(const Netdev *netdev, const char *name,
+                  NetClientState *peer, Error **errp)
+{
+    int len, rc;

     const char *file;
     char def_file[128];
     const NetdevDumpOptions *dump;
     const char *file;
     char def_file[128];
     const NetdevDumpOptions *dump;

+    NetClientState *nc;
+    DumpNetClient *dnc;

 
 

-    assert(opts->kind == NET_CLIENT_OPTIONS_KIND_DUMP);
-    dump = opts->dump;
+    assert(netdev->type == NET_CLIENT_DRIVER_DUMP);
+    dump = &netdev->u.dump;

 
     assert(peer);
 
 
     assert(peer);
 

+    error_report("'-net dump' is deprecated. "
+                 "Please use '-object filter-dump' instead.");
+

     if (dump->has_file) {
         file = dump->file;
     } else {
     if (dump->has_file) {
         file = dump->file;
     } else {


@@ -173,7 +212,7 @@ int net_init_dump(const NetClientOptions *opts, const char *name,
 
     if (dump->has_len) {
         if (dump->len > INT_MAX) {
 
     if (dump->has_len) {
         if (dump->len > INT_MAX) {

-            error_report("invalid length: %"PRIu64, dump->len);
+            error_setg(errp, "invalid length: %"PRIu64, dump->len);

             return -1;
         }
         len = dump->len;
             return -1;
         }
         len = dump->len;


@@ -181,5 +220,148 @@ int net_init_dump(const NetClientOptions *opts, const char *name,
         len = 65536;
     }
 
         len = 65536;
     }
 

-    return net_dump_init(peer, "dump", name, file, len);
+    nc = qemu_new_net_client(&net_dump_info, peer, "dump", name);
+    snprintf(nc->info_str, sizeof(nc->info_str),
+             "dump to %s (len=%d)", file, len);
+
+    dnc = DO_UPCAST(DumpNetClient, nc, nc);
+    rc = net_dump_state_init(&dnc->ds, file, len, errp);
+    if (rc) {
+        qemu_del_net_client(nc);
+    }
+    return rc;
+}
+
+/* Dumping via filter */
+
+#define TYPE_FILTER_DUMP "filter-dump"
+
+#define FILTER_DUMP(obj) \
+    OBJECT_CHECK(NetFilterDumpState, (obj), TYPE_FILTER_DUMP)
+
+struct NetFilterDumpState {
+    NetFilterState nfs;
+    DumpState ds;
+    char *filename;
+    uint32_t maxlen;
+};
+typedef struct NetFilterDumpState NetFilterDumpState;
+
+static ssize_t filter_dump_receive_iov(NetFilterState *nf, NetClientState *sndr,
+                                       unsigned flags, const struct iovec *iov,
+                                       int iovcnt, NetPacketSent *sent_cb)
+{
+    NetFilterDumpState *nfds = FILTER_DUMP(nf);
+
+    dump_receive_iov(&nfds->ds, iov, iovcnt);
+    return 0;
+}
+
+static void filter_dump_cleanup(NetFilterState *nf)
+{
+    NetFilterDumpState *nfds = FILTER_DUMP(nf);
+
+    dump_cleanup(&nfds->ds);
+}
+
+static void filter_dump_setup(NetFilterState *nf, Error **errp)
+{
+    NetFilterDumpState *nfds = FILTER_DUMP(nf);
+
+    if (!nfds->filename) {
+        error_setg(errp, "dump filter needs 'file' property set!");
+        return;
+    }
+
+    net_dump_state_init(&nfds->ds, nfds->filename, nfds->maxlen, errp);
+}
+
+static void filter_dump_get_maxlen(Object *obj, Visitor *v, const char *name,
+                                   void *opaque, Error **errp)
+{
+    NetFilterDumpState *nfds = FILTER_DUMP(obj);
+    uint32_t value = nfds->maxlen;
+
+    visit_type_uint32(v, name, &value, errp);
+}
+
+static void filter_dump_set_maxlen(Object *obj, Visitor *v, const char *name,
+                                   void *opaque, Error **errp)
+{
+    NetFilterDumpState *nfds = FILTER_DUMP(obj);
+    Error *local_err = NULL;
+    uint32_t value;
+
+    visit_type_uint32(v, name, &value, &local_err);
+    if (local_err) {
+        goto out;
+    }
+    if (value == 0) {
+        error_setg(&local_err, "Property '%s.%s' doesn't take value '%u'",
+                   object_get_typename(obj), name, value);
+        goto out;
+    }
+    nfds->maxlen = value;
+
+out:
+    error_propagate(errp, local_err);
+}
+
+static char *file_dump_get_filename(Object *obj, Error **errp)
+{
+    NetFilterDumpState *nfds = FILTER_DUMP(obj);
+
+    return g_strdup(nfds->filename);

 }
 }

+
+static void file_dump_set_filename(Object *obj, const char *value, Error **errp)
+{
+   NetFilterDumpState *nfds = FILTER_DUMP(obj);
+
+    g_free(nfds->filename);
+    nfds->filename = g_strdup(value);
+}
+
+static void filter_dump_instance_init(Object *obj)
+{
+    NetFilterDumpState *nfds = FILTER_DUMP(obj);
+
+    nfds->maxlen = 65536;
+
+    object_property_add(obj, "maxlen", "uint32", filter_dump_get_maxlen,
+                        filter_dump_set_maxlen, NULL, NULL, NULL);
+    object_property_add_str(obj, "file", file_dump_get_filename,
+                            file_dump_set_filename, NULL);
+}
+
+static void filter_dump_instance_finalize(Object *obj)
+{
+    NetFilterDumpState *nfds = FILTER_DUMP(obj);
+
+    g_free(nfds->filename);
+}
+
+static void filter_dump_class_init(ObjectClass *oc, void *data)
+{
+    NetFilterClass *nfc = NETFILTER_CLASS(oc);
+
+    nfc->setup = filter_dump_setup;
+    nfc->cleanup = filter_dump_cleanup;
+    nfc->receive_iov = filter_dump_receive_iov;
+}
+
+static const TypeInfo filter_dump_info = {
+    .name = TYPE_FILTER_DUMP,
+    .parent = TYPE_NETFILTER,
+    .class_init = filter_dump_class_init,
+    .instance_init = filter_dump_instance_init,
+    .instance_finalize = filter_dump_instance_finalize,
+    .instance_size = sizeof(NetFilterDumpState),
+};
+
+static void filter_dump_register_types(void)
+{
+    type_register_static(&filter_dump_info);
+}
+
+type_init(filter_dump_register_types);