[patch-axel-45a]

components/Init/src/virtio_con.c

@@ -195,7 +195,7 @@ static void console_handle_irq(void *cookie)
 {
     virtio_con_cookie_t *virtio_cookie = (virtio_con_cookie_t *)cookie;
     if (!virtio_cookie || !virtio_cookie->vm) {
-        ZF_LOGE("NULL virtio cookie given to raw irq handler");
+        ZF_LOGE("invalid cookie given to raw irq handler");
         return;
     }
 

components/Init/src/virtio_net_vswitch.c

@@ -292,5 +292,5 @@ void make_virtio_net_vswitch(vm_t *vm, vmm_pci_space_t *pci, vmm_io_port_list_t
 /* Dummy function used to register irq callback handlers. */
 void make_virtio_net_vswitch_driver_dummy(vm_t *vm, vmm_pci_space_t *pci, vmm_io_port_list_t *io_ports)
 {
-
+    /* nothing here, it's a dummy function */
 }

components/Init/src/virtio_vsock.c

@@ -214,7 +214,7 @@ static void vsock_inject_irq(void *cookie)
 {
     virtio_vsock_cookie_t *virtio_cookie = (virtio_vsock_cookie_t *)cookie;
     if (!virtio_cookie || !virtio_cookie->vm) {
-        ZF_LOGE("NULL virtio cookie given to raw irq handler");
+        ZF_LOGE("invalid cookie given to raw irq handler");
         return;
     }
 

libs/libvirtio/src/virtio_console.c

@@ -25,31 +25,42 @@ typedef struct virtio_con_cookie {
     vm_t *vm;
 } virtio_con_cookie_t;
 
-static void virtio_console_ack(vm_vcpu_t *vcpu, int irq, void *token) {}
+static void virtio_console_ack(vm_vcpu_t *vcpu, int irq, void *token)
+{
+    /* nothing to be done */
+}
 
 static void console_handle_irq(void *cookie)
 {
     virtio_con_cookie_t *virtio_cookie = (virtio_con_cookie_t *)cookie;
     if (!virtio_cookie || !virtio_cookie->vm) {
-        ZF_LOGE("NULL virtio cookie given to raw irq handler");
+        ZF_LOGE("invalid cookie given to raw irq handler");
         return;
     }
     int err = vm_inject_irq(virtio_cookie->vm->vcpus[BOOT_VCPU], VIRTIO_CON_PLAT_INTERRUPT_LINE);
     if (err) {
-        ZF_LOGE("Failed to inject irq");
+        ZF_LOGE("Failed to inject irq (%d)", err);
         return;
     }
 }
 
 virtio_con_t *virtio_console_init(vm_t *vm, console_putchar_fn_t putchar,
                                   vmm_pci_space_t *pci, vmm_io_port_list_t *io_ports)
 {
-
     int err;
     struct virtio_console_passthrough backend;
     virtio_con_cookie_t *console_cookie;
     virtio_con_t *virtio_con;
 
+    err = vm_register_irq(vm->vcpus[BOOT_VCPU], VIRTIO_CON_PLAT_INTERRUPT_LINE, &virtio_console_ack, NULL);
+    if (err) {
+        ZF_LOGE("Failed to register console irq (%d)", err);
+        return NULL;
+    }
+    /* There is no way to unregister an IRQ, so there is not recovery when
+     * anything below fails
+     */
+
     backend.handleIRQ = console_handle_irq;
     backend.backend_putchar = putchar;
 
@@ -58,18 +69,19 @@ virtio_con_t *virtio_console_init(vm_t *vm, console_putchar_fn_t putchar,
         ZF_LOGE("Failed to allocated virtio console cookie");
         return NULL;
     }
+    console_cookie->vm = vm;
 
     backend.console_data = (void *)console_cookie;
     ioport_range_t virtio_port_range = {0, 0, VIRTIO_IOPORT_SIZE};
     virtio_con = common_make_virtio_con(vm, pci, io_ports, virtio_port_range, IOPORT_FREE,
                                         VIRTIO_INTERRUPT_PIN, VIRTIO_CON_PLAT_INTERRUPT_LINE, backend);
-    console_cookie->virtio_con = virtio_con;
-    console_cookie->vm = vm;
-    err =  vm_register_irq(vm->vcpus[BOOT_VCPU], VIRTIO_CON_PLAT_INTERRUPT_LINE, &virtio_console_ack, NULL);
-    if (err) {
-        ZF_LOGE("Failed to register console irq");
-        free(console_cookie);
+    if (!virtio_con) {
+        ZF_LOGE("Failed to initialise virtio con driver");
+        free(virtio_con);
         return NULL;
     }
+
+    console_cookie->virtio_con = virtio_con;
+
     return virtio_con;
 }

libs/libvirtio/src/virtio_net.c

@@ -44,7 +44,7 @@ static void emul_raw_handle_irq(struct eth_driver *driver, int irq)
     }
     int err = vm_inject_irq(virtio_cookie->vm->vcpus[BOOT_VCPU], VIRTIO_NET_PLAT_INTERRUPT_LINE);
     if (err) {
-        ZF_LOGE("Failed to inject irq");
+        ZF_LOGE("Failed to inject irq (%d)", err);
         return;
     }
     if (virtio_cookie->callbacks.irq_callback) {
@@ -103,14 +103,26 @@ static void emul_low_level_init(struct eth_driver *driver, uint8_t *mac, int *mt
     *mtu = MAX_MTU_DATA;
 }
 
-static void virtio_net_ack(vm_vcpu_t *vcpu, int irq, void *token) {}
+static void virtio_net_ack(vm_vcpu_t *vcpu, int irq, void *token)
+{
+    /* nothing to be done */
+}
 
 virtio_net_t *virtio_net_init(vm_t *vm, virtio_net_callbacks_t *callbacks,
                               vmm_pci_space_t *pci, vmm_io_port_list_t *io_ports)
 {
     virtio_net_cookie_t *driver_cookie;
     virtio_net_t *virtio_net;
 
+    int err = vm_register_irq(vm->vcpus[BOOT_VCPU], VIRTIO_NET_PLAT_INTERRUPT_LINE, &virtio_net_ack, NULL);
+    if (err) {
+        ZF_LOGE("Failed to register net irq (%d)", err);
+        return NULL;
+    }
+    /* There is no way to unregister an IRQ, so there is not recovery when
+     * anything below fails
+     */
+
     get_mac_addr_callback = callbacks->get_mac_addr_callback;
 
     struct raw_iface_funcs backend = virtio_net_default_backend();
@@ -123,6 +135,11 @@ virtio_net_t *virtio_net_init(vm_t *vm, virtio_net_callbacks_t *callbacks,
         ZF_LOGE("Failed to allocated virtio iface cookie");
         return NULL;
     }
+    driver_cookie->vm = vm;
+    if (callbacks) {
+        driver_cookie->callbacks.tx_callback = callbacks->tx_callback;
+        driver_cookie->callbacks.irq_callback = callbacks->irq_callback;
+    }
 
     ioport_range_t virtio_port_range = {0, 0, VIRTIO_IOPORT_SIZE};
     virtio_net = common_make_virtio_net(vm, pci, io_ports, virtio_port_range, IOPORT_FREE,
@@ -132,13 +149,8 @@ virtio_net_t *virtio_net_init(vm_t *vm, virtio_net_callbacks_t *callbacks,
         free(driver_cookie);
         return NULL;
     }
-    driver_cookie->virtio_net = virtio_net;
-    driver_cookie->vm = vm;
-    int err =  vm_register_irq(vm->vcpus[BOOT_VCPU], VIRTIO_NET_PLAT_INTERRUPT_LINE, &virtio_net_ack, NULL);
-    if (callbacks) {
-        driver_cookie->callbacks.tx_callback = callbacks->tx_callback;
-        driver_cookie->callbacks.irq_callback = callbacks->irq_callback;
-    }
     virtio_net->emul_driver->eth_data = (void *)driver_cookie;
+    driver_cookie->virtio_net = virtio_net;
+
     return virtio_net;
 }