@@ -39,7 +39,7 @@ softmmu_ss.add(when: 'CONFIG_WIN32', if_true: files('tap-win32.c'))
softmmu_ss.add(when: 'CONFIG_VHOST_NET_VDPA', if_true: files('vhost-vdpa.c'))
vmnet_files = files(
- 'vmnet-common.c',
+ 'vmnet-common.m',
'vmnet-bridged.c',
'vmnet-host.c',
'vmnet-shared.c'
deleted file mode 100644
@@ -1,20 +0,0 @@
-/*
- * vmnet.c - network client wrapper for Apple vmnet.framework
- *
- * Copyright(c) 2021 Vladislav Yaroshchuk <yaroshchuk2000@gmail.com>
- * Copyright(c) 2021 Phillip Tennen <phillip@axleos.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-types-net.h"
-#include "vmnet_int.h"
-#include "clients.h"
-#include "qemu/error-report.h"
-#include "qapi/error.h"
-
-#include <vmnet/vmnet.h>
-
new file mode 100644
@@ -0,0 +1,294 @@
+/*
+ * vmnet.c - network backend based on vmnet.framework
+ *
+ * Copyright(c) 2021 Vladislav Yaroshchuk <yaroshchuk2000@gmail.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 "qemu/main-loop.h"
+#include "qapi-types-net.h"
+#include "vmnet_int.h"
+#include "clients.h"
+#include "qemu/error-report.h"
+#include "qapi/error.h"
+
+#include <vmnet/vmnet.h>
+#include <dispatch/dispatch.h>
+
+typedef struct vmpktdesc vmpktdesc_t;
+typedef struct iovec iovec_t;
+
+static void vmnet_set_send_enabled(VmnetCommonState *s, bool enable)
+{
+ s->send_enabled = enable;
+}
+
+
+static void vmnet_send_completed(NetClientState *nc, ssize_t len)
+{
+ VmnetCommonState *s = DO_UPCAST(VmnetCommonState, nc, nc);
+ vmnet_set_send_enabled(s, true);
+}
+
+
+static void vmnet_send(NetClientState *nc,
+ interface_event_t event_id,
+ xpc_object_t event)
+{
+ assert(event_id == VMNET_INTERFACE_PACKETS_AVAILABLE);
+
+ VmnetCommonState *s;
+ uint64_t packets_available;
+
+ struct iovec *iov;
+ struct vmpktdesc *packets;
+ int pkt_cnt;
+ int i;
+
+ vmnet_return_t if_status;
+ ssize_t size;
+
+ s = DO_UPCAST(VmnetCommonState, nc, nc);
+
+ packets_available = xpc_dictionary_get_uint64(
+ event,
+ vmnet_estimated_packets_available_key
+ );
+
+ pkt_cnt = (packets_available < VMNET_PACKETS_LIMIT) ?
+ packets_available :
+ VMNET_PACKETS_LIMIT;
+
+
+ iov = s->iov_buf;
+ packets = s->packets_buf;
+
+ for (i = 0; i < pkt_cnt; ++i) {
+ packets[i].vm_pkt_size = s->max_packet_size;
+ packets[i].vm_pkt_iovcnt = 1;
+ packets[i].vm_flags = 0;
+ }
+
+ if_status = vmnet_read(s->vmnet_if, packets, &pkt_cnt);
+ if (if_status != VMNET_SUCCESS) {
+ error_printf("vmnet: read failed: %s\n",
+ vmnet_status_map_str(if_status));
+ }
+ qemu_mutex_lock_iothread();
+ for (i = 0; i < pkt_cnt; ++i) {
+ size = qemu_send_packet_async(nc,
+ iov[i].iov_base,
+ packets[i].vm_pkt_size,
+ vmnet_send_completed);
+ if (size == 0) {
+ vmnet_set_send_enabled(s, false);
+ } else if (size < 0) {
+ break;
+ }
+ }
+ qemu_mutex_unlock_iothread();
+
+}
+
+
+static void vmnet_register_event_callback(VmnetCommonState *s)
+{
+ dispatch_queue_t avail_pkt_q = dispatch_queue_create(
+ "org.qemu.vmnet.if_queue",
+ DISPATCH_QUEUE_SERIAL
+ );
+
+ vmnet_interface_set_event_callback(
+ s->vmnet_if,
+ VMNET_INTERFACE_PACKETS_AVAILABLE,
+ avail_pkt_q,
+ ^(interface_event_t event_id, xpc_object_t event) {
+ if (s->send_enabled) {
+ vmnet_send(&s->nc, event_id, event);
+ }
+ });
+}
+
+
+static void vmnet_bufs_init(VmnetCommonState *s)
+{
+ int i;
+ struct vmpktdesc *packets;
+ struct iovec *iov;
+
+ packets = s->packets_buf;
+ iov = s->iov_buf;
+
+ for (i = 0; i < VMNET_PACKETS_LIMIT; ++i) {
+ iov[i].iov_len = s->max_packet_size;
+ iov[i].iov_base = g_malloc0(iov[i].iov_len);
+ packets[i].vm_pkt_iov = iov + i;
+ }
+}
+
+
+const char *vmnet_status_map_str(vmnet_return_t status)
+{
+ switch (status) {
+ case VMNET_SUCCESS:
+ return "success";
+ case VMNET_FAILURE:
+ return "general failure";
+ case VMNET_MEM_FAILURE:
+ return "memory allocation failure";
+ case VMNET_INVALID_ARGUMENT:
+ return "invalid argument specified";
+ case VMNET_SETUP_INCOMPLETE:
+ return "interface setup is not complete";
+ case VMNET_INVALID_ACCESS:
+ return "invalid access, permission denied";
+ case VMNET_PACKET_TOO_BIG:
+ return "packet size is larger than MTU";
+ case VMNET_BUFFER_EXHAUSTED:
+ return "buffers exhausted in kernel";
+ case VMNET_TOO_MANY_PACKETS:
+ return "packet count exceeds limit";
+ default:
+ return "unknown vmnet error";
+ }
+}
+
+
+int vmnet_if_create(NetClientState *nc,
+ xpc_object_t if_desc,
+ Error **errp,
+ void (*completion_callback)(xpc_object_t interface_param))
+{
+ VmnetCommonState *s;
+
+ dispatch_queue_t if_create_q;
+ dispatch_semaphore_t if_created_sem;
+
+ __block vmnet_return_t if_status;
+
+ if_create_q = dispatch_queue_create("org.qemu.vmnet.create",
+ DISPATCH_QUEUE_SERIAL);
+ if_created_sem = dispatch_semaphore_create(0);
+
+ s = DO_UPCAST(VmnetCommonState, nc, nc);
+ s->vmnet_if = vmnet_start_interface(
+ if_desc,
+ if_create_q,
+ ^(vmnet_return_t status, xpc_object_t interface_param) {
+ if_status = status;
+ if (status != VMNET_SUCCESS || !interface_param) {
+ dispatch_semaphore_signal(if_created_sem);
+ return;
+ }
+
+ s->mtu = xpc_dictionary_get_uint64(
+ interface_param,
+ vmnet_mtu_key);
+ s->max_packet_size = xpc_dictionary_get_uint64(
+ interface_param,
+ vmnet_max_packet_size_key);
+
+ if (completion_callback) {
+ completion_callback(interface_param);
+ }
+ dispatch_semaphore_signal(if_created_sem);
+ });
+
+ if (s->vmnet_if == NULL) {
+ error_setg(errp, "unable to create interface with requested params");
+ return -1;
+ }
+
+ dispatch_semaphore_wait(if_created_sem, DISPATCH_TIME_FOREVER);
+ dispatch_release(if_create_q);
+
+ if (if_status != VMNET_SUCCESS) {
+ error_setg(errp,
+ "interface creation error: %s",
+ vmnet_status_map_str(if_status));
+ return -1;
+ }
+
+ vmnet_register_event_callback(s);
+ vmnet_bufs_init(s);
+ vmnet_set_send_enabled(s, true);
+
+ return 0;
+}
+
+
+ssize_t vmnet_receive_common(NetClientState *nc,
+ const uint8_t *buf,
+ size_t size)
+{
+ VmnetCommonState *s;
+ vmpktdesc_t packet;
+ iovec_t iov;
+ int pkt_cnt;
+ vmnet_return_t if_status;
+
+ s = DO_UPCAST(VmnetCommonState, nc, nc);
+
+ if (size > s->max_packet_size) {
+ warn_report("vmnet: packet is too big, %zu > %llu\n",
+ packet.vm_pkt_size,
+ s->max_packet_size);
+ return -1;
+ }
+
+ iov.iov_base = (char *) buf;
+ iov.iov_len = size;
+
+ packet.vm_pkt_iovcnt = 1;
+ packet.vm_flags = 0;
+ packet.vm_pkt_size = size;
+ packet.vm_pkt_iov = &iov;
+
+ pkt_cnt = 1;
+ if_status = vmnet_write(s->vmnet_if, &packet, &pkt_cnt);
+
+ if (if_status != VMNET_SUCCESS) {
+ error_report("vmnet: write error: %s\n",
+ vmnet_status_map_str(if_status));
+ }
+
+ if (if_status == VMNET_SUCCESS && pkt_cnt) {
+ return size;
+ }
+ return 0;
+}
+
+
+void vmnet_cleanup_common(NetClientState *nc)
+{
+ VmnetCommonState *s;
+ dispatch_queue_t if_destroy_q;
+
+ s = DO_UPCAST(VmnetCommonState, nc, nc);
+
+ qemu_purge_queued_packets(nc);
+ vmnet_set_send_enabled(s, false);
+
+ if (s->vmnet_if == NULL) {
+ return;
+ }
+
+ if_destroy_q = dispatch_queue_create(
+ "org.qemu.vmnet.destroy",
+ DISPATCH_QUEUE_SERIAL
+ );
+
+ vmnet_stop_interface(
+ s->vmnet_if,
+ if_destroy_q,
+ ^(vmnet_return_t status) {
+ });
+
+ for (int i = 0; i < VMNET_PACKETS_LIMIT; ++i) {
+ g_free(s->iov_buf[i].iov_base);
+ }
+}
@@ -17,9 +17,78 @@
#include <vmnet/vmnet.h>
+typedef struct VmnetSharedState {
+ VmnetCommonState common;
+
+} VmnetSharedState;
+
+static xpc_object_t create_if_desc(const Netdev *netdev, Error **errp);
+
+static NetClientInfo net_vmnet_shared_info = {
+ .type = NET_CLIENT_DRIVER_VMNET_SHARED,
+ .size = sizeof(VmnetSharedState),
+ .receive = vmnet_receive_common,
+ .cleanup = vmnet_cleanup_common,
+};
+
int net_init_vmnet_shared(const Netdev *netdev, const char *name,
NetClientState *peer, Error **errp)
{
- error_setg(errp, "vmnet-shared is not implemented yet");
- return -1;
+ NetClientState *nc;
+ xpc_object_t if_desc;
+
+ nc = qemu_new_net_client(&net_vmnet_shared_info,
+ peer, "vmnet-shared", name);
+ if_desc = create_if_desc(netdev, errp);
+ return vmnet_if_create(nc, if_desc, errp, NULL);
+}
+
+static xpc_object_t create_if_desc(const Netdev *netdev, Error **errp)
+{
+ const NetdevVmnetSharedOptions *options;
+ xpc_object_t if_desc;
+
+ if_desc = xpc_dictionary_create(NULL, NULL, 0);
+ xpc_dictionary_set_uint64(
+ if_desc,
+ vmnet_operation_mode_key,
+ VMNET_SHARED_MODE
+ );
+
+ xpc_dictionary_set_bool(
+ if_desc,
+ vmnet_allocate_mac_address_key,
+ false
+ );
+
+ options = &(netdev->u.vmnet_shared);
+
+ if (options->has_dhcpstart ||
+ options->has_dhcpend ||
+ options->has_subnetmask) {
+
+ if (options->has_dhcpstart &&
+ options->has_dhcpend &&
+ options->has_subnetmask) {
+
+ xpc_dictionary_set_string(if_desc,
+ vmnet_start_address_key,
+ options->dhcpstart);
+ xpc_dictionary_set_string(if_desc,
+ vmnet_end_address_key,
+ options->dhcpend);
+ xpc_dictionary_set_string(if_desc,
+ vmnet_subnet_mask_key,
+ options->subnetmask);
+ } else {
+ error_setg(
+ errp,
+ "'dhcpstart', 'dhcpend', 'subnetmask' "
+ "must be provided together"
+ );
+ }
+ }
+
+ return if_desc;
}
+
@@ -16,10 +16,33 @@
#include <vmnet/vmnet.h>
+#define VMNET_PACKETS_LIMIT 50
+
typedef struct VmnetCommonState {
NetClientState nc;
+ interface_ref vmnet_if;
+
+ bool send_enabled;
+
+ uint64_t mtu;
+ uint64_t max_packet_size;
+
+ struct vmpktdesc packets_buf[VMNET_PACKETS_LIMIT];
+ struct iovec iov_buf[VMNET_PACKETS_LIMIT];
} VmnetCommonState;
+const char *vmnet_status_map_str(vmnet_return_t status);
+
+int vmnet_if_create(NetClientState *nc,
+ xpc_object_t if_desc,
+ Error **errp,
+ void (*completion_callback)(xpc_object_t interface_param));
+
+ssize_t vmnet_receive_common(NetClientState *nc,
+ const uint8_t *buf,
+ size_t size);
+
+void vmnet_cleanup_common(NetClientState *nc);
#endif /* VMNET_INT_H */
Still not implemented: - port forwarding - ipv6 prefix setting Signed-off-by: Vladislav Yaroshchuk <yaroshchuk2000@gmail.com> --- net/meson.build | 2 +- net/vmnet-common.c | 20 --- net/vmnet-common.m | 294 +++++++++++++++++++++++++++++++++++++++++++++ net/vmnet-shared.c | 73 ++++++++++- net/vmnet_int.h | 23 ++++ 5 files changed, 389 insertions(+), 23 deletions(-) delete mode 100644 net/vmnet-common.c create mode 100644 net/vmnet-common.m